tf.Tensor:\\n if wintype == 'vorbis':\\n window = tf.signal.vorbis_window(block_samples, dtype=tf.float32)\\n elif wintype == 'kaiser-bessel-derived':\\n window = tf.signal.kaiser_bessel_derived_window(block_samples,\\n dtype=tf.float32)\\n elif wintype == 'rectangular':\\n window = 1.0/tf.sqrt(2.0) * tf.ones((block_samples,))\\n else:\\n raise ValueError(f'Window type {wintype} unknown.')\\n return window\",\n \"def handle_input(self, proxy, event_type, event, refcon):\\n self.update_timeval()\\n self.events = []\\n\\n if event_type in (1, 2, 3, 4, 25, 26, 27):\\n self.handle_button(event, event_type)\\n\\n if event_type == 22:\\n self.handle_scrollwheel(event)\\n\\n # Add in the absolute position of the mouse cursor\\n self.handle_absolute(event)\\n\\n # Add in the relative position of the mouse cursor\\n self.handle_relative(event)\\n\\n # End with a sync marker\\n self.events.append(self.sync_marker(self.timeval))\\n\\n # We are done\\n self.write_to_pipe(self.events)\",\n \"def keyboardInterface(event):\\r\\n global rect\\r\\n if event.key == \\\"right\\\":\\r\\n # Make the rectangle wider\\r\\n w0 = rect.get_width()\\r\\n rect.set_width(w0 + 1)\\r\\n elif event.key == \\\"left\\\":\\r\\n # Make the rectangle narrower\\r\\n w0 = rect.get_width()\\r\\n rect.set_width(w0 - 1)\\r\\n elif event.key == \\\"up\\\":\\r\\n # Make the rectangle shorter\\r\\n h0 = rect.get_height()\\r\\n rect.set_height(h0 - 1)\\r\\n elif event.key == \\\"down\\\":\\r\\n # Make the rectangle taller\\r\\n h0 = rect.get_height()\\r\\n rect.set_height(h0 + 1)\\r\\n################################################################################\\r\\n# The functions below here will need to be changed for use on Windows!\\r\\n elif event.key == \\\"ctrl+right\\\":\\r\\n # Make the rectangle wider - faster\\r\\n w0 = rect.get_width()\\r\\n rect.set_width(w0 + 10)\\r\\n elif event.key == \\\"ctrl+left\\\":\\r\\n # Make the rectangle narrower - faster\\r\\n w0 = rect.get_width()\\r\\n rect.set_width(w0 - 10)\\r\\n elif event.key == \\\"ctrl+up\\\":\\r\\n # Make the rectangle shorter - faster\\r\\n h0 = rect.get_height()\\r\\n rect.set_height(h0 - 10)\\r\\n elif event.key == \\\"ctrl+down\\\":\\r\\n # Make the rectangle taller - faster\\r\\n h0 = rect.get_height()\\r\\n rect.set_height(h0 + 10)\\r\\n\\r\\n rect.figure.canvas.draw()# update the plot window\\r\",\n \"def __init__(self, data_rate: Union[int, float], processing_window: int = None):\\n super().__init__()\\n self.data_rate = data_rate\\n self.processing_window = processing_window if processing_window else data_rate\\n self.raw_data_buffer = []\\n self.processed_data_buffer = []\\n self._is_one = None\",\n \"def movingWindow(rawData, n):\\n data = np.array([rawData[i:i+n] for i in range(rawData.shape[0] - (n-1))])\\n return data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6172538","0.5824715","0.579524","0.5777404","0.5741833","0.56970376","0.5631466","0.5602177","0.555027","0.55155164","0.5480653","0.5460816","0.54408014","0.53961843","0.53608793","0.53503096","0.53198206","0.5311485","0.53044426","0.52996355","0.5267582","0.52645785","0.5262367","0.5257529","0.5244089","0.5187804","0.5186202","0.5158812","0.5144501","0.5143662","0.5140392","0.51399237","0.5132024","0.51284486","0.5119443","0.5118096","0.51157564","0.5090038","0.5090038","0.5086997","0.5081694","0.50655085","0.50603247","0.50577176","0.50567365","0.5055423","0.5043202","0.5036098","0.50350773","0.50217754","0.49979776","0.49946624","0.4979826","0.49715972","0.4970019","0.49685666","0.49683678","0.49602675","0.49579227","0.49467847","0.49388936","0.49379218","0.49355918","0.49350458","0.4931625","0.49269745","0.49163425","0.4912451","0.4906011","0.49032423","0.4902494","0.49011186","0.4892999","0.48910752","0.4890886","0.48893544","0.4879516","0.4874929","0.48728216","0.4869864","0.48697305","0.48478806","0.48475707","0.48454478","0.4844739","0.4842427","0.48369256","0.4829155","0.4828845","0.48273453","0.48223612","0.48212537","0.48203722","0.48165348","0.48146296","0.4810573","0.48064116","0.48035663","0.480333","0.48020375","0.47983864"],"string":"[\n \"0.6172538\",\n \"0.5824715\",\n \"0.579524\",\n \"0.5777404\",\n \"0.5741833\",\n \"0.56970376\",\n \"0.5631466\",\n \"0.5602177\",\n \"0.555027\",\n \"0.55155164\",\n \"0.5480653\",\n \"0.5460816\",\n \"0.54408014\",\n \"0.53961843\",\n \"0.53608793\",\n \"0.53503096\",\n \"0.53198206\",\n \"0.5311485\",\n \"0.53044426\",\n \"0.52996355\",\n \"0.5267582\",\n \"0.52645785\",\n \"0.5262367\",\n \"0.5257529\",\n \"0.5244089\",\n \"0.5187804\",\n \"0.5186202\",\n \"0.5158812\",\n \"0.5144501\",\n \"0.5143662\",\n \"0.5140392\",\n \"0.51399237\",\n \"0.5132024\",\n \"0.51284486\",\n \"0.5119443\",\n \"0.5118096\",\n \"0.51157564\",\n \"0.5090038\",\n \"0.5090038\",\n \"0.5086997\",\n \"0.5081694\",\n \"0.50655085\",\n \"0.50603247\",\n \"0.50577176\",\n \"0.50567365\",\n \"0.5055423\",\n \"0.5043202\",\n \"0.5036098\",\n \"0.50350773\",\n \"0.50217754\",\n \"0.49979776\",\n \"0.49946624\",\n \"0.4979826\",\n \"0.49715972\",\n \"0.4970019\",\n \"0.49685666\",\n \"0.49683678\",\n \"0.49602675\",\n \"0.49579227\",\n \"0.49467847\",\n \"0.49388936\",\n \"0.49379218\",\n \"0.49355918\",\n \"0.49350458\",\n \"0.4931625\",\n \"0.49269745\",\n \"0.49163425\",\n \"0.4912451\",\n \"0.4906011\",\n \"0.49032423\",\n \"0.4902494\",\n \"0.49011186\",\n \"0.4892999\",\n \"0.48910752\",\n \"0.4890886\",\n \"0.48893544\",\n \"0.4879516\",\n \"0.4874929\",\n \"0.48728216\",\n \"0.4869864\",\n \"0.48697305\",\n \"0.48478806\",\n \"0.48475707\",\n \"0.48454478\",\n \"0.4844739\",\n \"0.4842427\",\n \"0.48369256\",\n \"0.4829155\",\n \"0.4828845\",\n \"0.48273453\",\n \"0.48223612\",\n \"0.48212537\",\n \"0.48203722\",\n \"0.48165348\",\n \"0.48146296\",\n \"0.4810573\",\n \"0.48064116\",\n \"0.48035663\",\n \"0.480333\",\n \"0.48020375\",\n \"0.47983864\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84570,"cells":{"query":{"kind":"string","value":"Class for stochastic sampling of data points. It is most useful for feeding examples for the the training ops of `ReverseHG` or `ForwardHG`. Most notably, if the number of epochs is specified, the class takes track of the examples per minibatches which is important for the backward pass of `ReverseHG` method."},"document":{"kind":"string","value":"def __init__(self, dataset, batch_size, epochs=None, rnd=None):\n self.dataset = dataset\n self.batch_size = batch_size\n self.epochs = epochs\n self.T = int(np.ceil(dataset.num_examples / batch_size))\n if self.epochs:\n self.T *= self.epochs\n\n self.rnd = get_rand_state(rnd)\n\n self.training_schedule = None\n self.iter_per_epoch = int(dataset.num_examples / batch_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 generate_samples(self, n_samples):","def generate_samples(self, n_samples):","def _sample_mini_dataset(dataset, num_classes, num_shots):\n shuffled = list(dataset)\n random.shuffle(shuffled)\n for class_idx, class_obj in enumerate(shuffled[:num_classes]):\n for sample in class_obj.sample(num_shots):\n yield (sample, class_idx)","def sample(self):\r\n raise NotImplementedError","def sampling_algorithm(self, X, y):\r\n n_to_sample = self.det_n_to_sample(self.proportion)\r\n\r\n if n_to_sample == 0:\r\n return self.return_copies(X, y, \"Sampling is not needed\")\r\n\r\n X_min = X[y == self.min_label]\r\n X_maj = X[y == self.maj_label]\r\n\r\n # fitting nearest neighbors model to find closest majority points to\r\n # minority samples\r\n nn_params = {**self.nn_params}\r\n nn_params['metric_tensor'] = \\\r\n self.metric_tensor_from_nn_params(nn_params, X, y)\r\n\r\n density = self.calculate_density(X_min, X_maj, nn_params)\r\n\r\n # fitting nearest neighbors model to minority samples to run\r\n # SMOTE-like sampling\r\n n_neighbors = min([len(X_min), self.n_neighbors+1])\r\n nnmt = NearestNeighborsWithMetricTensor(n_neighbors=n_neighbors,\r\n n_jobs=self.n_jobs,\r\n **nn_params)\r\n nnmt.fit(X_min)\r\n ind = nnmt.kneighbors(X_min, return_distance=False)\r\n\r\n samples = self.sample_simplex(X=X_min,\r\n indices=ind,\r\n n_to_sample=n_to_sample,\r\n base_weights=density)\r\n\r\n # do the sampling\r\n #samples = []\r\n #while len(samples) < n_to_sample:\r\n # idx = self.random_state.choice(np.arange(len(density)), p=density)\r\n # random_neighbor_idx = self.random_state.choice(ind[idx][1:])\r\n # X_a = X_min[idx]\r\n # X_b = X_min[random_neighbor_idx]\r\n # samples.append(self.sample_between_points(X_a, X_b))\r\n\r\n return (np.vstack([X, samples]),\r\n np.hstack([y, np.repeat(self.min_label, len(samples))]))","def sample(self):\n raise NotImplementedError","def sample(self):\n raise NotImplementedError","def sample(self, num_samples, **kwargs):\n pass","def sample(self, batchsize, *args, **kwargs):\n raise NotImplementedError","def test_sampling(self):\n dim = Fidelity(\"epoch\", 1, 2)\n assert dim.sample() == [2]\n dim = Fidelity(\"epoch\", 1, 5)\n assert dim.sample() == [5]\n dim = Fidelity(\"epoch\", 1, 5)\n assert dim.sample(4) == [5] * 4","def sampling_algorithm(self, X, y):\r\n\r\n n_to_sample = self.det_n_to_sample(self.proportion)\r\n\r\n if n_to_sample == 0:\r\n return self.return_copies(X, y, \"Sampling is not needed.\")\r\n\r\n # standardization is needed to make the range of the propensity scores\r\n # similar to that of the features\r\n mms = MinMaxScaler()\r\n X_trans = mms.fit_transform(X) # pylint: disable=invalid-name\r\n\r\n X_min = X_trans[y == self.min_label]\r\n\r\n # adding propensity scores as a new feature\r\n X_new = np.column_stack([X_trans, self.propensity_scores(X_trans, y)])\r\n X_min_new = X_new[y == self.min_label] # pylint: disable=invalid-name\r\n\r\n # finding nearest neighbors of minority samples\r\n n_neighbors = min([len(X_new), self.n_neighbors+1])\r\n\r\n ind = self.neighborhood_structure(X_new, y, n_neighbors, X_min_new)\r\n\r\n # noise removal\r\n t_hat = np.sum(y[ind[:, 1:]] == self.min_label, axis=1)\r\n to_remove = np.where(t_hat < self.t * n_neighbors)[0]\r\n\r\n if len(to_remove) >= len(X_min) - 1:\r\n return self.return_copies(X, y,\r\n \"most minority samples indentified as noise\")\r\n\r\n n_to_sample = n_to_sample + to_remove.shape[0]\r\n\r\n samples = self.generate_samples(X_min=X_min,\r\n to_remove=to_remove,\r\n X_trans=X_trans,\r\n y=y,\r\n ind=ind,\r\n n_to_sample=n_to_sample)\r\n\r\n X_min = np.delete(X_min, to_remove, axis=0)\r\n\r\n # do the sampling\r\n #samples = []\r\n #while len(samples) < n_to_sample:\r\n # idx = self.random_state.randint(len(X_min))\r\n # # finding the number of minority neighbors\r\n # t_hat = np.sum(y[ind[idx][1:]] == self.min_label)\r\n # if t_hat < self.t*n_neighbors:\r\n # # removing the minority point if the number of minority\r\n # # neighbors is less then the threshold\r\n # # to_remove indexes X_min\r\n # if idx not in to_remove:\r\n # to_remove.append(idx)\r\n # # compensating the removal of the minority point\r\n # n_to_sample = n_to_sample + 1\r\n #\r\n # if len(to_remove) == len(X_min):\r\n # _logger.warning(self.__class__.__name__ + \": \" +\r\n # \"all minority samples identified as noise\")\r\n # return X.copy(), y.copy()\r\n # else:\r\n # # otherwise do the sampling\r\n # X_b = X_trans[self.random_state.choice(ind[idx][1:])]\r\n # samples.append(self.sample_between_points(X_min[idx], X_b))\r\n\r\n return (mms.inverse_transform(np.vstack([X_trans[y == self.maj_label],\r\n X_min,\r\n samples])),\r\n np.hstack([np.repeat(self.maj_label,\r\n np.sum(y == self.maj_label)),\r\n np.repeat(self.min_label, len(X_min)),\r\n np.repeat(self.min_label, len(samples))]))","def sampler(self) -> Generator[int, None, None]:\n remaining = self.num_samples\n if self.shuffled:\n while remaining > 0:\n n = min(remaining, len(self.data_source))\n for idx in torch.randperm(len(self.data_source))[0:n]:\n yield int(idx)\n remaining -= n\n else:\n current_idx = None\n while remaining > 0:\n if current_idx is None or current_idx >= len(self.data_source):\n current_idx = 0\n yield current_idx\n current_idx += 1\n remaining -= 1","def _generate(self, **kwargs):\n N = self.parameter_schema['N']\n parameter_count = len(self._parameter_names)\n common_override_kwargs = {}\n override_kwargs = self._sampler_overrides(common_override_kwargs)\n if kwargs:\n kwargs.update(override_kwargs)\n else:\n kwargs = override_kwargs\n __import__(\"SALib.sample\", fromlist=[self.sampler_class])\n sampler = getattr(SALib.sample, self.sampler_class)\n problem = self.parameter_schema[\"problem\"]\n self._samples = sampler.sample(problem, N, **kwargs)\n self._samples = numpy.unique(self._samples, axis=0)\n super()._generate()","def sample(self,p0=None,nsamp=None): \r\n raise NotImplementedError('Need to implement sample function')","def sample(self, n=1):\n raise NotImplementedError","def get_samples(self, min_samples):\n raise NotImplementedError","def _sample_synthetic(self, X):\n n_samples = X.shape[0]\n self.y = np.concatenate((np.ones(n_samples), np.zeros(n_samples)))\n \n random_state = _forest.check_random_state(self.random_state) \n\n X_synth = np.asarray([np.apply_along_axis(random_state.choice, 0, X) for _ in range(n_samples)])\n self.X = np.concatenate((X, X_synth))\n\n return self.X, self.y","def sample(self, batch_size):\n raise NotImplementedError","def sample(self, processor, batch_size=None):\n pass","def sample(self, seed=None):\n raise NotImplementedError()","def generate_sampler(dataset, sampler_option='random', step=1):\n\n df = dataset.df\n min_age = np.min(df.age)\n max_age = np.max(df.age)\n\n if (max_age - min_age) % step == 0:\n max_age += step\n\n bins = np.arange(min_age, max_age, step)\n count = np.zeros(len(bins))\n for idx in df.index:\n age = df.loc[idx, \"age\"]\n key = np.argmax(np.logical_and(age - step < bins, age >= bins)).astype(int)\n count[key] += 1\n\n # weight_per_class = (1 / np.array(count)) if count.any() != 0 else 0.\n weight_per_class = np.zeros_like(count).astype(float)\n np.divide(1., count, out=weight_per_class, where=count != 0)\n weights = [0] * len(df)\n\n for idx, age in enumerate(df.age.values):\n key = np.argmax(np.logical_and(age - 5 <= bins, age > bins)).astype(int)\n weights[idx] = weight_per_class[key]\n\n weights = torch.FloatTensor(weights)\n\n if sampler_option == 'random':\n s = sampler.RandomSampler(dataset, replacement=False)\n elif sampler_option == 'weighted':\n s = sampler.WeightedRandomSampler(weights, len(weights))\n else:\n raise NotImplementedError(\"The option %s for sampler is not implemented\" % sampler_option)\n\n return s","def sample_generator(self, sess):\n\n to_return = {\n 'g_sample': self.G_sample_test,\n }\n return sess.run(to_return)","def _sample_mini_dataset_mil(dataset, num_classes, num_shots):\n shuffled = list(dataset)\n random.shuffle(shuffled)\n for class_idx, class_obj in enumerate(shuffled[:num_classes]):\n gifs, states, actions = class_obj.sample(num_shots)\n for shot_idx in range(num_shots):\n start_idx, end_idx = shot_idx*class_obj.T, (shot_idx + 1)*class_obj.T\n g, s, a = gifs[start_idx:end_idx], states[start_idx:end_idx], actions[start_idx:end_idx]\n yield (g, s, a)","def sample(self, size=1):\n raise NotImplementedError","def sample(self, size=1):\n raise NotImplementedError","def sample(self, size=1):\n raise NotImplementedError","def sample(self, size=1):\n raise NotImplementedError","def easy_sample(self, num, **kwargs):\n return self.preprocess(self.sample(num, **kwargs), **kwargs)","def sample_from_prior(self):\n raise NotImplementedError","def samples(self):\n pass","def sample(self, num, **kwargs):\n raise NotImplementedError(f'Should be implemented in derived class!')","def sample(self, size=1):\n pass","def data_source():\n dataset = [0.1, 0.2, 0.3, 0.4, 0.5]\n while True:\n time.sleep(2)\n yield random.choice(dataset)","def samples(self, gp):\r\n raise NotImplementedError","def sample(self, state, model_args, model_kwargs):\n raise NotImplementedError","def test_sampling1 ():\n cpus = list(range(C.N_PARALLEL))\n affinity = dict(cuda_idx=C.CUDA_IDX, workers_cpus=cpus)\n agent_ = findOptimalAgent(reward=None)\n agent = CategoricalPgAgent(AcrobotNet, \n initial_model_state_dict=agent_.state_dict())\n s0 = np.array([1, 0, 1/np.sqrt(2), 1/np.sqrt(2), 4, 2], dtype=np.float)\n sampler = SerialSampler(\n EnvCls=rlpyt_make,\n env_kwargs=dict(id=C.ENV, reward=None, internalStateFn=C.INTERNAL_STATE_FN, s0=s0),\n batch_T=500,\n batch_B=16,\n max_decorrelation_steps=0,\n )\n sampler.initialize(\n agent=agent,\n affinity=affinity,\n seed=0\n )\n _, traj_info = sampler.obtain_samples(0)\n print(np.mean([t['DiscountedReturn'] for t in traj_info]))","def generate_samples(self, nsamples):\n assert self.trained, \"Model must first be fitted to some data.\"\n logger.debug(f'Generate synthetic dataset of size {nsamples}')\n synthetic_data, _ = self.gm.sample(nsamples)\n return synthetic_data","def sample(self, data, chains=2, iter=1024, warmup=None, **kwargs):\n\n kwds = self._validate_stan_inputs(\n data=data, chains=chains, iter=iter, warmup=warmup, **kwargs)\n return self._model.sampling(**kwds)","def run_sample_example():\n\n opt = edo.DataOptimiser(\n sample_fitness,\n size=100,\n row_limits=[50, 100],\n col_limits=[1, 3],\n families=[edo.Family(Uniform)],\n max_iter=10,\n )\n\n state = np.random.RandomState(0)\n _, fit_history = opt.run(processes=4, random_state=state)\n return fit_history","def generate_samples(self):\n self.analytic_probability()","def sample(self, n):\n raise NotImplementedError","def _graph_fn_sample_stochastic(distribution):\n return distribution.sample()","def score_samples(self, x):\n raise NotImplementedError","def __init__(self, precision=0, random_generator=random.Random(), minimum_stochastic_distance=0):\n super(StochasticRound, self).__init__(precision=precision)\n self.random_generator = random_generator\n self.minimum_stochastic_distance = minimum_stochastic_distance","def generate_samples(obj, N=None, checkpoint=None, **kwards):\n gen_sample, gen_sample_raw = obj.generate(\n N=N, checkpoint=checkpoint, **kwards)\n gen_sample = np.squeeze(gen_sample)\n gen_sample_raw = np.squeeze(gen_sample_raw)\n return gen_sample, gen_sample_raw","def _sample_schechter(x0, alpha, x_min, size=100, max_iter=1000):\n out = []\n n = 0\n num_iter = 0\n while (n<size) & (num_iter<max_iter):\n x = np.random.gamma(scale=x0, shape=alpha+2, size=size)\n x = x[x>x_min]\n u = np.random.uniform(size=x.size)\n x = x[u<x_min/x]\n out.append(x)\n n+=x.size\n num_iter += 1\n\n if num_iter >= max_iter:\n msg = (\"The maximum number of iterations reached.\",\n \"Random variates may not be representitive.\",\n \"Try increasing `max_iter`.\")\n print(msg)\n\n return np.concatenate(out)[:size]","def _sampling_concrete(self, args):\n return sampling_concrete(args, (None, self.latent_disc_dim))","def sampling(self, args):\n\n z_mean, z_log = args\n batch = K.shape(z_mean)[0] # batch size\n dim = K.int_shape(z_mean)[1] # latent dimension\n epsilon = K.random_normal(shape=(batch, dim)) # mean=0, std=1.0\n\n return z_mean + K.exp(0.5 * z_log) * epsilon","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 sampling(args: tuple):\n\n # unpack the input tuple\n z_mean, z_log_var = args\n\n # mini-batch size\n mb_size = K.shape(z_mean)[0]\n\n # latent space size\n dim = K.int_shape(z_mean)[1]\n\n # random normal vector with mean=0 and std=1.0\n epsilon = K.random_normal(shape=(mb_size, dim))\n\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def __call__(self, samples_number):\n self.sampler.sample(samples_number)","def _sample(self, points: Iterable[float]) -> np.array:\n pass","def sampling(args):\n t_mean, t_log_var = args\n # YOUR CODE HERE\n epsilon = K.random_normal(t_mean.shape)\n z = epsilon * K.exp(0.5 * t_log_var) + t_mean\n return z","def sample(self):\n raise NotImplementedError(\"Override me!\")","def sample(self, nsamples):\n return self.dist.sample(nsamples)","def test_generated_sample_distribution(\n jax_dist, sp_dist, params, N_sample=100_000, key=random.PRNGKey(11)\n):\n\n if jax_dist not in [dist.Gumbel]:\n pytest.skip(\n \"{} sampling method taken from upstream, no need to\"\n \"test generated samples.\".format(jax_dist.__name__)\n )\n\n jax_dist = jax_dist(*params)\n if sp_dist and not jax_dist.event_shape and not jax_dist.batch_shape:\n our_samples = jax_dist.sample(key, (N_sample,))\n ks_result = osp.kstest(our_samples, sp_dist(*params).cdf)\n assert ks_result.pvalue > 0.05","def __init__(self, samples):\n self.samples = samples","def sample(self, point, n_samples=1):\n raise NotImplementedError(\"The sample method is not yet implemented.\")","def next_frame_sampling_stochastic():\n hparams = basic_deterministic_params.next_frame_sampling()\n hparams.stochastic_model = True\n hparams.add_hparam(\"latent_channels\", 1)\n hparams.add_hparam(\"latent_std_min\", -5.0)\n hparams.add_hparam(\"num_iterations_1st_stage\", 15000)\n hparams.add_hparam(\"num_iterations_2nd_stage\", 15000)\n hparams.add_hparam(\"latent_loss_multiplier\", 1e-3)\n hparams.add_hparam(\"latent_loss_multiplier_dynamic\", False)\n hparams.add_hparam(\"latent_loss_multiplier_alpha\", 1e-5)\n hparams.add_hparam(\"latent_loss_multiplier_epsilon\", 1.0)\n hparams.add_hparam(\"latent_loss_multiplier_schedule\", \"constant\")\n hparams.add_hparam(\"latent_num_frames\", 0) # 0 means use all frames.\n hparams.add_hparam(\"anneal_end\", 40000)\n hparams.add_hparam(\"information_capacity\", 0.0)\n return hparams","def sample(self, x):","def __call__(self, **kwargs):\n # Fix the seed so we get a deterministic objective per iteration.\n seed = samplers.sanitize_seed(\n [100, 2] if self.seed is None else self.seed, salt='qucb')\n\n samples = self.predictive_distribution.sample(\n self.num_samples, seed=seed, **kwargs)\n\n # This parameterization differs from [1] in that we don't assume that\n # samples come from a Normal distribution with a rescaled covariance. This\n # effectively reparameterizes the exploration parameter by a factor of\n # sqrt(pi / 2).\n if self._transform_fn is not None:\n samples = self._transform_fn(samples)\n mean = tf.math.reduce_mean(samples, axis=0)\n else:\n mean = self.predictive_distribution.mean(**kwargs)\n\n qucb = mean + self.exploration * tf.math.abs(samples - mean)\n return tf.reduce_mean(tf.reduce_max(qucb, axis=-1), axis=0)","def sample_from_prior(self, n_samples):\n pass","def _choose_sample(self):\n\n \t #periodically generate a new reconstruction for the purposes of sampling","def __init__(self, size = 1000, discard_sample = False, method = 'first'):\r\n super(SampleNode, self).__init__()\r\n self.size = size\r\n self.discard_sample = discard_sample\r\n self.method = method\r\n # random nodes need a stack to hold intermediate records\r\n if method == \"random\":\r\n self.stack = Stack(size)\r\n else:\r\n self.stack = None\r\n if method == \"percent\" and ((size>100) or (size<0)):\r\n raise ValueError, \"Sample size must be between 0 and 100 with 'percent' method.\"","def sampling(args):\n\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.shape(z_mean)[1]\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def __init__(self, x_benchmark, x_trial, K=5, n_perm=100):\n self.x_benchmark = x_benchmark\n self.x_trial = x_trial\n self.K = K\n self.n_perm = n_perm\n \n # Number of points in the samples\n self.NB = self.x_benchmark.shape[0]\n self.NT = self.x_trial.shape[0]\n \n # Dimensionality of points\n self.D = self.x_benchmark.shape[1]","def sample(timesteps):\n\n k = 32\n # pow_alpha = -0.7\n # pow_beta = -0.5\n \n # # P(i) = (1 / rank(i)) ^ alpha / sum((1 / rank(i)) ^ alpha)\n # pdf = [x ** pow_alpha for x in range(1, k+1)]\n # pdf_sum = math.fsum(pdf)\n # distribution = [x / pdf_sum for x in pdf]\n \n # # The expected value with stochastic updates depends on the behavior\n # # distribution to be the same as the updates. Since we are introducing\n # # bias with prioritized sweeps, we need to do introduce importance\n # # sampling.\n\n # # https://arxiv.org/pdf/1511.05952.pdf\n # # Importance sampling weight \n # # w_i = (N * P(i))^-B) / max(w_j)\n # importance = [(len(timesteps) * pi) ** pow_beta for pi in distribution]\n # max_importance = max(importance)\n # importance = [i / max_importance for i in importance]\n \n # # Sample timesteps\n # # timesteps.sort(key=lambda t: t.abs_error, reverse=True)\n # samples = []\n # b = 0\n # for start, stop in batch_indexes(len(timesteps), math.floor(len(timesteps) / k)):\n # if b == k: break\n # sample = np.random.choice(timesteps[start:stop])\n # sample.adjusted_target = sample.target * importance[b]\n # samples.append(sample)\n # b += 1\n \n for t in timesteps:\n t.adjusted_target = t.target\n random.shuffle(timesteps)\n return timesteps[:k]","def sample(self, data=None, chains=4, iter=2000, warmup=None, \n recompile=False, overwrite=False, **kwargs):\n\n self._load_model(recompile=recompile, overwrite=overwrite, **kwargs)\n\n kwds = self._validate_stan_inputs(\n data=data, chains=chains, iter=iter, warmup=warmup, **kwargs)\n\n self._fit = self.model.sampling(**kwds)\n return self._fit","def sample_from_prior(self, *args, **kwargs):\n pass","def __init__(self, num_features=NUM_FEATURES, num_samp=NUM_SAMP):\n num_samp = NUM_SAMP\n sigma = 0.1\n np.random.seed(31415)\n\n # We're going to learn these paramters\n self.w = np.random.randint(low=0, high=5, size=(num_features, 1))\n self.b = 2\n\n self.index = np.arange(num_samp)\n self.x = np.random.uniform(size=(num_samp, num_features))\n self.y = self.x @ self.w + self.b + sigma * np.random.normal()","def sampling(args):\r\n z_mean,z_log_var = args\r\n batch = K.shape(z_mean)[0]\r\n dim = K.shape(z_mean)[1]\r\n epsilon = K.random_normal(shape=(batch,dim),\r\n mean=0.0,stddev=1.0)\r\n std_epsilon = 1e-4\r\n return z_mean + (z_log_var + std_epsilon) * epsilon","def subsampling(dataset, class_column_index, class_max_count, class_dict):\n out = []\n for row in dataset:\n cls = row[class_column_index]\n rInt = np.random.randint(0, class_dict[cls])\n if rInt <= class_max_count:\n out.append(row)\n ss_data = np.array(out)\n\n return ss_data","def sampling(self, args):\n self.z_mean, self.z_log_var = args\n batch = K.shape(self.z_mean)[0]\n dim = K.int_shape(self.z_mean)[1]\n epsilon = K.random_uniform(shape=(batch, dim))\n \n return self.z_mean + K.exp(0.5 * self.z_log_var) * epsilon","def _sample_internal(self, opts, num):\n noise = utils.generate_noise(opts, num)\n sample = self._run_batch(\n opts, self._generated, self._noise_ph, noise,\n self._is_training_ph, False)\n return sample","def __init__(self, data_source, batch_size):\n self.batch_size = batch_size\n self.samples_per_row = ceil(len(data_source) / batch_size)\n self.num_samples = self.samples_per_row * batch_size","def sample(self):\n return self(np.random.randn(self.num_xi)).reshape(self.X.shape)","def __init__(self, min_dist=0.1, n_neighbors=15, max_samples=2000,\n shuffle=False, **kwargs):\n super().__init__(min_dist=min_dist, n_neighbors=n_neighbors,\n max_samples=max_samples, shuffle=shuffle, **kwargs)\n self.max_samples = max_samples\n self.shuffle = shuffle\n self.min_dist = min_dist\n self.n_neighbors = n_neighbors","def sample(self, n_samples: int) -> torch.Tensor:\n return self.dist.sample((n_samples,))","def get_data(self):\n if self.random_seeds: \n self._validate_random_seeds()\n seed_iter = list(map(iter,self.random_seeds))\n nsamples = len(self.random_seeds[0])\n else:\n seed_iter = None\n nsamples = self.numsamples\n self._set_meta_features()\n for _ in tqdm(range(nsamples)):\n self._update_meta_features(seed_iter)\n self._sample()\n yield self._extract_features()","def mksampler(x):\n if hasattr(x, \"__call__\"):\n return x\n elif type(x) is list:\n # NB: disjoint ranges can be given as nested lists, e.g. [(1,2), (4,5)]\n if len(x) == 2 and type(x[0]) in (int,float) and type(x[1]) in (int,float):\n #print \"MKSAMPLER: Casting %s to UniformSampler\" % str(x)\n return UniformSampler(*x)\n elif len(x) > 2 or (len(x) > 0 and type(x[0]) not in (int,float)):\n #print \"MKSAMPLER: Casting %s to DisjointUniformSampler\" % str(x)\n return DisjointUniformSampler(x)\n if len(x) < 2:\n raise Exception(\"Supplied list could not be converted to a continuous sampler\")\n elif type(x) is tuple:\n #print \"MKSAMPLER: Casting %s to CyclicSeqSampler\" % str(x)\n return CyclicSeqSampler(*x)\n elif type(x) is set:\n #print \"MKSAMPLER: Casting %s to RandomSeqSampler\" % str(x)\n return RandomSeqSampler(*x)\n else:\n #print \"MKSAMPLER: Casting %s to ConstSampler\" % str(x)\n return ConstSampler(x)","def DataSample(*args, **kw):\n return cnexxT.DataSample.make_shared(cnexxT.DataSample(*args, **kw))","def sample_prior(size):\n return torch.randn(size)","def simple_sampler(fun, start, sigma, iterations, verbose=False):\n mean = np.zeros(len(start))\n cov = np.eye(len(start)) * sigma\n\n if isinstance(start, np.ndarray):\n previous = start\n else:\n previous = np.array(start)\n\n f_previous = fun(previous)\n\n samples = np.zeros((iterations, len(start)))\n acceptance = 0\n for i in range(iterations):\n proposal = previous + np.random.multivariate_normal(mean=mean, cov=cov)\n f_proposal = fun(proposal)\n fun(previous)\n if (np.log(np.random.rand())) < (f_proposal - f_previous):\n previous = proposal\n acceptance += 1\n samples[i] = np.array(previous)\n\n if verbose:\n print('sampler acceptance = {0:.3f}'.format(acceptance / iterations))\n\n return samples","def pseudo_sample(self):\n return (torch.zeros(1, 1, 28, 28), None)","def take_samples(self, num_samples: int) -> List:\n if num_samples > len(self.samples):\n return random.sample(self.samples, len(self.samples))\n return random.sample(self.samples, num_samples)","def _sample_seed(self):\n raise Exception(\" not implemented in base model\")","def init(self, start_sample, fhat, budget):\n self.proposed_points = start_sample\n self.fhat = fhat\n self.n0 = start_sample.shape[0]\n for i in range(self.nstrats):\n self.sampling_strategies[i].init(self.proposed_points, fhat, budget)","def create_samples(self, initial_point: Dict) -> Tuple[List[Dict], List[float]]:\n burnin = self.sampling_params['burnin']\n thin = self.sampling_params['thin']\n proposal_distribution = self.sampling_params['proposal_distribution']\n \n samples = []\n logprobs = []\n curr_point = initial_point.copy()\n sampling_user = self.user_model.copy()\n sampling_user.params = curr_point\n curr_logprob = self.logprior(curr_point) + sampling_user.loglikelihood_dataset(self.dataset)\n samples.append(curr_point)\n logprobs.append(curr_logprob)\n for _ in range(burnin + thin * self.num_samples - 1):\n next_point = proposal_distribution(curr_point)\n sampling_user.params = next_point\n next_logprob = self.logprior(next_point) + sampling_user.loglikelihood_dataset(self.dataset)\n if np.log(np.random.rand()) < next_logprob - curr_logprob:\n curr_point = next_point.copy()\n curr_logprob = next_logprob\n samples.append(curr_point)\n logprobs.append(curr_logprob)\n self.samples, self.logprobs = samples[burnin::thin], logprobs[burnin::thin]","def sampling(train_set, train_meta, klass, label, n_samples_pos, rate_neg, fold, path_idxs):\n\tprint('-- SAMPLING TRAINNING')\n\tdirectory_idxs = path_idxs+fold+'/'+str(int(klass))+'/'\n\tif(os.path.isdir(directory_idxs)):\n\t\tprint('loading indexes...')\n\t\tidxs_class_pos = np.loadtxt(directory_idxs+'idxs_pos_train.txt', dtype=int)\n\t\tidxs_class_neg = np.loadtxt(directory_idxs+'idxs_neg_train.txt', dtype=int)\n\telse:\n\t\tidxs_class_pos = (train_meta[ : , label] == klass).nonzero()[0]\n\t\tidxs_class_neg = (train_meta[ : , label] != klass).nonzero()[0]\n\t\tif(n_samples_pos < len(idxs_class_pos)):\n\t\t\tidxs_class_pos = np.random.choice(idxs_class_pos, n_samples_pos)\n\t\tidxs_class_neg = np.random.choice(idxs_class_neg, int(n_samples_pos*rate_neg))\n\t\tprint('saving indexes...')\n\t\tos.makedirs(directory_idxs)\n\t\tnp.savetxt(directory_idxs+'idxs_pos_train.txt', idxs_class_pos, fmt='%d')\n\t\tnp.savetxt(directory_idxs+'idxs_neg_train.txt', idxs_class_neg, fmt='%d')\n\n\ttrain_set = np.vstack((train_set[idxs_class_pos], train_set[idxs_class_neg]))\n\ttrain_meta = np.vstack((train_meta[idxs_class_pos], train_meta[idxs_class_neg]))\n\ttrain_meta[:, label] = 1\n\ttrain_meta[len(idxs_class_pos):, label] = -1\n\treturn [train_set, train_meta]","def sample(self, batch_size):\n # get the sum of priorities\n priority_sum = self.sum_tree.get_sum_priority()\n # sample priorities \n priorities_to_sample = np.random.uniform(0, priority_sum, batch_size)\n # get the indexes of replays\n sample_idxes = [self.sum_tree.get(x) for x in priorities_to_sample]\n # fetch the transitions and prepare the batch for training\n random_sample = [self.queue[x] for x in sample_idxes]\n # zip\n zipped = [ torch.from_numpy( np.asarray(arr).astype(np.float32) ).float() for arr in zip(*random_sample) ]\n sample = Transition( zipped[0], zipped[1].unsqueeze_(-1).long(), zipped[2].unsqueeze_(-1), zipped[3], zipped[4].unsqueeze_(-1).byte() )\n return sample, sample_idxes","def train_samples_for_cls(self, cls):\n train = [t for t in self.get_train_files() if t[2] == cls]\n all_samples = ({'cls': t[2], **_read_mat_data(t[3])} for t in train)\n return (sample for sample in all_samples if sample['signals'] is not None), len(train)","def generate_samples(self, latent_vec=None, num=None):\n num = self.batch_size if num is None else num\n latent_vec = self.noise_fn(num) if latent_vec is None else latent_vec\n with torch.no_grad():\n samples = self.generator(latent_vec)\n samples = samples.cpu() # move images to cpu\n return samples","def sampling(args):\r\n\r\n z_mean, z_log_var = args\r\n batch = K.shape(z_mean)[0]\r\n dim = K.int_shape(z_mean)[1]\r\n # by default, random_normal has mean=0 and std=1.0\r\n epsilon = K.random_normal(shape=(batch, dim))\r\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","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 sampling(args):\n\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.int_shape(z_mean)[1]\n # by default, random_normal has mean = 0 and std = 1.0\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def generate(self):\n # --------------------------------\n # Initializing Variables\n # --------------------------------\n\n # Set NumPy Random Seed\n np.random.seed(self._seed)\n\n # Create Active List\n active = []\n\n # Clear previously generated examples\n if len(self._samples) > 0:\n self._clear_previous_samples()\n\n # --------------------------------\n # Begin Generating Samples\n # --------------------------------\n\n # Create the first sample\n self._samples.append(np.random.uniform(low=np.zeros(shape=(self._dim,)),\n high=self._extent, size=(self._dim,)))\n active.append(self._samples[0])\n self._grid[self._get_grid_coord(self._samples[0])] = 0\n\n while active:\n # Choose Random Active Sample\n idx = np.random.choice(len(active))\n\n # Make new point & confirm it is valid\n new_point = self._make_point(active[idx])\n if new_point is None:\n active.pop(idx)\n else:\n # Add sample to listings and store in grid for neighboring locations.\n self._samples.append(new_point)\n active.append(new_point)\n self._grid[self._get_grid_coord(new_point)] = len(self._samples) - 1\n\n # Return samples as numpy array\n self._samples = np.array(self._samples)\n return self._samples","def build_sampler(self, params):\n\n def sampler(logits_1, logits_2, key):\n q_kwargs = dict(transpose=True) if self.use_transpose else {}\n x = self.model.bind(params).sample(logits_1, key)\n y = self.model.bind(params).sample(logits_2, key, **q_kwargs)\n return jnp.zeros([10, 10]).at[x, y].set(1.)\n\n return sampler","def __init__(self, k, p, sample_p=1):\n # Maximum sample size\n self.k = k\n\n # A dictionary containing the sampled elements\n # The dictionary key is the key of the element\n # The value is a tuple (seed, count)\n self.elements = {}\n\n # The function of the frequencies that the sketch estimates\n # For now it's the p-th frequency moment, but in the future we may\n # support other functions (passed as a parameter)\n self.func_of_freq = lambda x: x**p\n\n # The power of values used for the sampling weights\n self.sample_p = sample_p","def data_feeder_2():\n return random.sample(range(100), 10)","def sampling(args):\n\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.int_shape(z_mean)[1]\n # by default, random_normal has mean=0 and std=1.0\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon"],"string":"[\n \"def generate_samples(self, n_samples):\",\n \"def generate_samples(self, n_samples):\",\n \"def _sample_mini_dataset(dataset, num_classes, num_shots):\\n shuffled = list(dataset)\\n random.shuffle(shuffled)\\n for class_idx, class_obj in enumerate(shuffled[:num_classes]):\\n for sample in class_obj.sample(num_shots):\\n yield (sample, class_idx)\",\n \"def sample(self):\\r\\n raise NotImplementedError\",\n \"def sampling_algorithm(self, X, y):\\r\\n n_to_sample = self.det_n_to_sample(self.proportion)\\r\\n\\r\\n if n_to_sample == 0:\\r\\n return self.return_copies(X, y, \\\"Sampling is not needed\\\")\\r\\n\\r\\n X_min = X[y == self.min_label]\\r\\n X_maj = X[y == self.maj_label]\\r\\n\\r\\n # fitting nearest neighbors model to find closest majority points to\\r\\n # minority samples\\r\\n nn_params = {**self.nn_params}\\r\\n nn_params['metric_tensor'] = \\\\\\r\\n self.metric_tensor_from_nn_params(nn_params, X, y)\\r\\n\\r\\n density = self.calculate_density(X_min, X_maj, nn_params)\\r\\n\\r\\n # fitting nearest neighbors model to minority samples to run\\r\\n # SMOTE-like sampling\\r\\n n_neighbors = min([len(X_min), self.n_neighbors+1])\\r\\n nnmt = NearestNeighborsWithMetricTensor(n_neighbors=n_neighbors,\\r\\n n_jobs=self.n_jobs,\\r\\n **nn_params)\\r\\n nnmt.fit(X_min)\\r\\n ind = nnmt.kneighbors(X_min, return_distance=False)\\r\\n\\r\\n samples = self.sample_simplex(X=X_min,\\r\\n indices=ind,\\r\\n n_to_sample=n_to_sample,\\r\\n base_weights=density)\\r\\n\\r\\n # do the sampling\\r\\n #samples = []\\r\\n #while len(samples) < n_to_sample:\\r\\n # idx = self.random_state.choice(np.arange(len(density)), p=density)\\r\\n # random_neighbor_idx = self.random_state.choice(ind[idx][1:])\\r\\n # X_a = X_min[idx]\\r\\n # X_b = X_min[random_neighbor_idx]\\r\\n # samples.append(self.sample_between_points(X_a, X_b))\\r\\n\\r\\n return (np.vstack([X, samples]),\\r\\n np.hstack([y, np.repeat(self.min_label, len(samples))]))\",\n \"def sample(self):\\n raise NotImplementedError\",\n \"def sample(self):\\n raise NotImplementedError\",\n \"def sample(self, num_samples, **kwargs):\\n pass\",\n \"def sample(self, batchsize, *args, **kwargs):\\n raise NotImplementedError\",\n \"def test_sampling(self):\\n dim = Fidelity(\\\"epoch\\\", 1, 2)\\n assert dim.sample() == [2]\\n dim = Fidelity(\\\"epoch\\\", 1, 5)\\n assert dim.sample() == [5]\\n dim = Fidelity(\\\"epoch\\\", 1, 5)\\n assert dim.sample(4) == [5] * 4\",\n \"def sampling_algorithm(self, X, y):\\r\\n\\r\\n n_to_sample = self.det_n_to_sample(self.proportion)\\r\\n\\r\\n if n_to_sample == 0:\\r\\n return self.return_copies(X, y, \\\"Sampling is not needed.\\\")\\r\\n\\r\\n # standardization is needed to make the range of the propensity scores\\r\\n # similar to that of the features\\r\\n mms = MinMaxScaler()\\r\\n X_trans = mms.fit_transform(X) # pylint: disable=invalid-name\\r\\n\\r\\n X_min = X_trans[y == self.min_label]\\r\\n\\r\\n # adding propensity scores as a new feature\\r\\n X_new = np.column_stack([X_trans, self.propensity_scores(X_trans, y)])\\r\\n X_min_new = X_new[y == self.min_label] # pylint: disable=invalid-name\\r\\n\\r\\n # finding nearest neighbors of minority samples\\r\\n n_neighbors = min([len(X_new), self.n_neighbors+1])\\r\\n\\r\\n ind = self.neighborhood_structure(X_new, y, n_neighbors, X_min_new)\\r\\n\\r\\n # noise removal\\r\\n t_hat = np.sum(y[ind[:, 1:]] == self.min_label, axis=1)\\r\\n to_remove = np.where(t_hat < self.t * n_neighbors)[0]\\r\\n\\r\\n if len(to_remove) >= len(X_min) - 1:\\r\\n return self.return_copies(X, y,\\r\\n \\\"most minority samples indentified as noise\\\")\\r\\n\\r\\n n_to_sample = n_to_sample + to_remove.shape[0]\\r\\n\\r\\n samples = self.generate_samples(X_min=X_min,\\r\\n to_remove=to_remove,\\r\\n X_trans=X_trans,\\r\\n y=y,\\r\\n ind=ind,\\r\\n n_to_sample=n_to_sample)\\r\\n\\r\\n X_min = np.delete(X_min, to_remove, axis=0)\\r\\n\\r\\n # do the sampling\\r\\n #samples = []\\r\\n #while len(samples) < n_to_sample:\\r\\n # idx = self.random_state.randint(len(X_min))\\r\\n # # finding the number of minority neighbors\\r\\n # t_hat = np.sum(y[ind[idx][1:]] == self.min_label)\\r\\n # if t_hat < self.t*n_neighbors:\\r\\n # # removing the minority point if the number of minority\\r\\n # # neighbors is less then the threshold\\r\\n # # to_remove indexes X_min\\r\\n # if idx not in to_remove:\\r\\n # to_remove.append(idx)\\r\\n # # compensating the removal of the minority point\\r\\n # n_to_sample = n_to_sample + 1\\r\\n #\\r\\n # if len(to_remove) == len(X_min):\\r\\n # _logger.warning(self.__class__.__name__ + \\\": \\\" +\\r\\n # \\\"all minority samples identified as noise\\\")\\r\\n # return X.copy(), y.copy()\\r\\n # else:\\r\\n # # otherwise do the sampling\\r\\n # X_b = X_trans[self.random_state.choice(ind[idx][1:])]\\r\\n # samples.append(self.sample_between_points(X_min[idx], X_b))\\r\\n\\r\\n return (mms.inverse_transform(np.vstack([X_trans[y == self.maj_label],\\r\\n X_min,\\r\\n samples])),\\r\\n np.hstack([np.repeat(self.maj_label,\\r\\n np.sum(y == self.maj_label)),\\r\\n np.repeat(self.min_label, len(X_min)),\\r\\n np.repeat(self.min_label, len(samples))]))\",\n \"def sampler(self) -> Generator[int, None, None]:\\n remaining = self.num_samples\\n if self.shuffled:\\n while remaining > 0:\\n n = min(remaining, len(self.data_source))\\n for idx in torch.randperm(len(self.data_source))[0:n]:\\n yield int(idx)\\n remaining -= n\\n else:\\n current_idx = None\\n while remaining > 0:\\n if current_idx is None or current_idx >= len(self.data_source):\\n current_idx = 0\\n yield current_idx\\n current_idx += 1\\n remaining -= 1\",\n \"def _generate(self, **kwargs):\\n N = self.parameter_schema['N']\\n parameter_count = len(self._parameter_names)\\n common_override_kwargs = {}\\n override_kwargs = self._sampler_overrides(common_override_kwargs)\\n if kwargs:\\n kwargs.update(override_kwargs)\\n else:\\n kwargs = override_kwargs\\n __import__(\\\"SALib.sample\\\", fromlist=[self.sampler_class])\\n sampler = getattr(SALib.sample, self.sampler_class)\\n problem = self.parameter_schema[\\\"problem\\\"]\\n self._samples = sampler.sample(problem, N, **kwargs)\\n self._samples = numpy.unique(self._samples, axis=0)\\n super()._generate()\",\n \"def sample(self,p0=None,nsamp=None): \\r\\n raise NotImplementedError('Need to implement sample function')\",\n \"def sample(self, n=1):\\n raise NotImplementedError\",\n \"def get_samples(self, min_samples):\\n raise NotImplementedError\",\n \"def _sample_synthetic(self, X):\\n n_samples = X.shape[0]\\n self.y = np.concatenate((np.ones(n_samples), np.zeros(n_samples)))\\n \\n random_state = _forest.check_random_state(self.random_state) \\n\\n X_synth = np.asarray([np.apply_along_axis(random_state.choice, 0, X) for _ in range(n_samples)])\\n self.X = np.concatenate((X, X_synth))\\n\\n return self.X, self.y\",\n \"def sample(self, batch_size):\\n raise NotImplementedError\",\n \"def sample(self, processor, batch_size=None):\\n pass\",\n \"def sample(self, seed=None):\\n raise NotImplementedError()\",\n \"def generate_sampler(dataset, sampler_option='random', step=1):\\n\\n df = dataset.df\\n min_age = np.min(df.age)\\n max_age = np.max(df.age)\\n\\n if (max_age - min_age) % step == 0:\\n max_age += step\\n\\n bins = np.arange(min_age, max_age, step)\\n count = np.zeros(len(bins))\\n for idx in df.index:\\n age = df.loc[idx, \\\"age\\\"]\\n key = np.argmax(np.logical_and(age - step < bins, age >= bins)).astype(int)\\n count[key] += 1\\n\\n # weight_per_class = (1 / np.array(count)) if count.any() != 0 else 0.\\n weight_per_class = np.zeros_like(count).astype(float)\\n np.divide(1., count, out=weight_per_class, where=count != 0)\\n weights = [0] * len(df)\\n\\n for idx, age in enumerate(df.age.values):\\n key = np.argmax(np.logical_and(age - 5 <= bins, age > bins)).astype(int)\\n weights[idx] = weight_per_class[key]\\n\\n weights = torch.FloatTensor(weights)\\n\\n if sampler_option == 'random':\\n s = sampler.RandomSampler(dataset, replacement=False)\\n elif sampler_option == 'weighted':\\n s = sampler.WeightedRandomSampler(weights, len(weights))\\n else:\\n raise NotImplementedError(\\\"The option %s for sampler is not implemented\\\" % sampler_option)\\n\\n return s\",\n \"def sample_generator(self, sess):\\n\\n to_return = {\\n 'g_sample': self.G_sample_test,\\n }\\n return sess.run(to_return)\",\n \"def _sample_mini_dataset_mil(dataset, num_classes, num_shots):\\n shuffled = list(dataset)\\n random.shuffle(shuffled)\\n for class_idx, class_obj in enumerate(shuffled[:num_classes]):\\n gifs, states, actions = class_obj.sample(num_shots)\\n for shot_idx in range(num_shots):\\n start_idx, end_idx = shot_idx*class_obj.T, (shot_idx + 1)*class_obj.T\\n g, s, a = gifs[start_idx:end_idx], states[start_idx:end_idx], actions[start_idx:end_idx]\\n yield (g, s, a)\",\n \"def sample(self, size=1):\\n raise NotImplementedError\",\n \"def sample(self, size=1):\\n raise NotImplementedError\",\n \"def sample(self, size=1):\\n raise NotImplementedError\",\n \"def sample(self, size=1):\\n raise NotImplementedError\",\n \"def easy_sample(self, num, **kwargs):\\n return self.preprocess(self.sample(num, **kwargs), **kwargs)\",\n \"def sample_from_prior(self):\\n raise NotImplementedError\",\n \"def samples(self):\\n pass\",\n \"def sample(self, num, **kwargs):\\n raise NotImplementedError(f'Should be implemented in derived class!')\",\n \"def sample(self, size=1):\\n pass\",\n \"def data_source():\\n dataset = [0.1, 0.2, 0.3, 0.4, 0.5]\\n while True:\\n time.sleep(2)\\n yield random.choice(dataset)\",\n \"def samples(self, gp):\\r\\n raise NotImplementedError\",\n \"def sample(self, state, model_args, model_kwargs):\\n raise NotImplementedError\",\n \"def test_sampling1 ():\\n cpus = list(range(C.N_PARALLEL))\\n affinity = dict(cuda_idx=C.CUDA_IDX, workers_cpus=cpus)\\n agent_ = findOptimalAgent(reward=None)\\n agent = CategoricalPgAgent(AcrobotNet, \\n initial_model_state_dict=agent_.state_dict())\\n s0 = np.array([1, 0, 1/np.sqrt(2), 1/np.sqrt(2), 4, 2], dtype=np.float)\\n sampler = SerialSampler(\\n EnvCls=rlpyt_make,\\n env_kwargs=dict(id=C.ENV, reward=None, internalStateFn=C.INTERNAL_STATE_FN, s0=s0),\\n batch_T=500,\\n batch_B=16,\\n max_decorrelation_steps=0,\\n )\\n sampler.initialize(\\n agent=agent,\\n affinity=affinity,\\n seed=0\\n )\\n _, traj_info = sampler.obtain_samples(0)\\n print(np.mean([t['DiscountedReturn'] for t in traj_info]))\",\n \"def generate_samples(self, nsamples):\\n assert self.trained, \\\"Model must first be fitted to some data.\\\"\\n logger.debug(f'Generate synthetic dataset of size {nsamples}')\\n synthetic_data, _ = self.gm.sample(nsamples)\\n return synthetic_data\",\n \"def sample(self, data, chains=2, iter=1024, warmup=None, **kwargs):\\n\\n kwds = self._validate_stan_inputs(\\n data=data, chains=chains, iter=iter, warmup=warmup, **kwargs)\\n return self._model.sampling(**kwds)\",\n \"def run_sample_example():\\n\\n opt = edo.DataOptimiser(\\n sample_fitness,\\n size=100,\\n row_limits=[50, 100],\\n col_limits=[1, 3],\\n families=[edo.Family(Uniform)],\\n max_iter=10,\\n )\\n\\n state = np.random.RandomState(0)\\n _, fit_history = opt.run(processes=4, random_state=state)\\n return fit_history\",\n \"def generate_samples(self):\\n self.analytic_probability()\",\n \"def sample(self, n):\\n raise NotImplementedError\",\n \"def _graph_fn_sample_stochastic(distribution):\\n return distribution.sample()\",\n \"def score_samples(self, x):\\n raise NotImplementedError\",\n \"def __init__(self, precision=0, random_generator=random.Random(), minimum_stochastic_distance=0):\\n super(StochasticRound, self).__init__(precision=precision)\\n self.random_generator = random_generator\\n self.minimum_stochastic_distance = minimum_stochastic_distance\",\n \"def generate_samples(obj, N=None, checkpoint=None, **kwards):\\n gen_sample, gen_sample_raw = obj.generate(\\n N=N, checkpoint=checkpoint, **kwards)\\n gen_sample = np.squeeze(gen_sample)\\n gen_sample_raw = np.squeeze(gen_sample_raw)\\n return gen_sample, gen_sample_raw\",\n \"def _sample_schechter(x0, alpha, x_min, size=100, max_iter=1000):\\n out = []\\n n = 0\\n num_iter = 0\\n while (n<size) & (num_iter<max_iter):\\n x = np.random.gamma(scale=x0, shape=alpha+2, size=size)\\n x = x[x>x_min]\\n u = np.random.uniform(size=x.size)\\n x = x[u<x_min/x]\\n out.append(x)\\n n+=x.size\\n num_iter += 1\\n\\n if num_iter >= max_iter:\\n msg = (\\\"The maximum number of iterations reached.\\\",\\n \\\"Random variates may not be representitive.\\\",\\n \\\"Try increasing `max_iter`.\\\")\\n print(msg)\\n\\n return np.concatenate(out)[:size]\",\n \"def _sampling_concrete(self, args):\\n return sampling_concrete(args, (None, self.latent_disc_dim))\",\n \"def sampling(self, args):\\n\\n z_mean, z_log = args\\n batch = K.shape(z_mean)[0] # batch size\\n dim = K.int_shape(z_mean)[1] # latent dimension\\n epsilon = K.random_normal(shape=(batch, dim)) # mean=0, std=1.0\\n\\n return z_mean + K.exp(0.5 * z_log) * epsilon\",\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 sampling(args: tuple):\\n\\n # unpack the input tuple\\n z_mean, z_log_var = args\\n\\n # mini-batch size\\n mb_size = K.shape(z_mean)[0]\\n\\n # latent space size\\n dim = K.int_shape(z_mean)[1]\\n\\n # random normal vector with mean=0 and std=1.0\\n epsilon = K.random_normal(shape=(mb_size, dim))\\n\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def __call__(self, samples_number):\\n self.sampler.sample(samples_number)\",\n \"def _sample(self, points: Iterable[float]) -> np.array:\\n pass\",\n \"def sampling(args):\\n t_mean, t_log_var = args\\n # YOUR CODE HERE\\n epsilon = K.random_normal(t_mean.shape)\\n z = epsilon * K.exp(0.5 * t_log_var) + t_mean\\n return z\",\n \"def sample(self):\\n raise NotImplementedError(\\\"Override me!\\\")\",\n \"def sample(self, nsamples):\\n return self.dist.sample(nsamples)\",\n \"def test_generated_sample_distribution(\\n jax_dist, sp_dist, params, N_sample=100_000, key=random.PRNGKey(11)\\n):\\n\\n if jax_dist not in [dist.Gumbel]:\\n pytest.skip(\\n \\\"{} sampling method taken from upstream, no need to\\\"\\n \\\"test generated samples.\\\".format(jax_dist.__name__)\\n )\\n\\n jax_dist = jax_dist(*params)\\n if sp_dist and not jax_dist.event_shape and not jax_dist.batch_shape:\\n our_samples = jax_dist.sample(key, (N_sample,))\\n ks_result = osp.kstest(our_samples, sp_dist(*params).cdf)\\n assert ks_result.pvalue > 0.05\",\n \"def __init__(self, samples):\\n self.samples = samples\",\n \"def sample(self, point, n_samples=1):\\n raise NotImplementedError(\\\"The sample method is not yet implemented.\\\")\",\n \"def next_frame_sampling_stochastic():\\n hparams = basic_deterministic_params.next_frame_sampling()\\n hparams.stochastic_model = True\\n hparams.add_hparam(\\\"latent_channels\\\", 1)\\n hparams.add_hparam(\\\"latent_std_min\\\", -5.0)\\n hparams.add_hparam(\\\"num_iterations_1st_stage\\\", 15000)\\n hparams.add_hparam(\\\"num_iterations_2nd_stage\\\", 15000)\\n hparams.add_hparam(\\\"latent_loss_multiplier\\\", 1e-3)\\n hparams.add_hparam(\\\"latent_loss_multiplier_dynamic\\\", False)\\n hparams.add_hparam(\\\"latent_loss_multiplier_alpha\\\", 1e-5)\\n hparams.add_hparam(\\\"latent_loss_multiplier_epsilon\\\", 1.0)\\n hparams.add_hparam(\\\"latent_loss_multiplier_schedule\\\", \\\"constant\\\")\\n hparams.add_hparam(\\\"latent_num_frames\\\", 0) # 0 means use all frames.\\n hparams.add_hparam(\\\"anneal_end\\\", 40000)\\n hparams.add_hparam(\\\"information_capacity\\\", 0.0)\\n return hparams\",\n \"def sample(self, x):\",\n \"def __call__(self, **kwargs):\\n # Fix the seed so we get a deterministic objective per iteration.\\n seed = samplers.sanitize_seed(\\n [100, 2] if self.seed is None else self.seed, salt='qucb')\\n\\n samples = self.predictive_distribution.sample(\\n self.num_samples, seed=seed, **kwargs)\\n\\n # This parameterization differs from [1] in that we don't assume that\\n # samples come from a Normal distribution with a rescaled covariance. This\\n # effectively reparameterizes the exploration parameter by a factor of\\n # sqrt(pi / 2).\\n if self._transform_fn is not None:\\n samples = self._transform_fn(samples)\\n mean = tf.math.reduce_mean(samples, axis=0)\\n else:\\n mean = self.predictive_distribution.mean(**kwargs)\\n\\n qucb = mean + self.exploration * tf.math.abs(samples - mean)\\n return tf.reduce_mean(tf.reduce_max(qucb, axis=-1), axis=0)\",\n \"def sample_from_prior(self, n_samples):\\n pass\",\n \"def _choose_sample(self):\\n\\n \\t #periodically generate a new reconstruction for the purposes of sampling\",\n \"def __init__(self, size = 1000, discard_sample = False, method = 'first'):\\r\\n super(SampleNode, self).__init__()\\r\\n self.size = size\\r\\n self.discard_sample = discard_sample\\r\\n self.method = method\\r\\n # random nodes need a stack to hold intermediate records\\r\\n if method == \\\"random\\\":\\r\\n self.stack = Stack(size)\\r\\n else:\\r\\n self.stack = None\\r\\n if method == \\\"percent\\\" and ((size>100) or (size<0)):\\r\\n raise ValueError, \\\"Sample size must be between 0 and 100 with 'percent' method.\\\"\",\n \"def sampling(args):\\n\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.shape(z_mean)[1]\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def __init__(self, x_benchmark, x_trial, K=5, n_perm=100):\\n self.x_benchmark = x_benchmark\\n self.x_trial = x_trial\\n self.K = K\\n self.n_perm = n_perm\\n \\n # Number of points in the samples\\n self.NB = self.x_benchmark.shape[0]\\n self.NT = self.x_trial.shape[0]\\n \\n # Dimensionality of points\\n self.D = self.x_benchmark.shape[1]\",\n \"def sample(timesteps):\\n\\n k = 32\\n # pow_alpha = -0.7\\n # pow_beta = -0.5\\n \\n # # P(i) = (1 / rank(i)) ^ alpha / sum((1 / rank(i)) ^ alpha)\\n # pdf = [x ** pow_alpha for x in range(1, k+1)]\\n # pdf_sum = math.fsum(pdf)\\n # distribution = [x / pdf_sum for x in pdf]\\n \\n # # The expected value with stochastic updates depends on the behavior\\n # # distribution to be the same as the updates. Since we are introducing\\n # # bias with prioritized sweeps, we need to do introduce importance\\n # # sampling.\\n\\n # # https://arxiv.org/pdf/1511.05952.pdf\\n # # Importance sampling weight \\n # # w_i = (N * P(i))^-B) / max(w_j)\\n # importance = [(len(timesteps) * pi) ** pow_beta for pi in distribution]\\n # max_importance = max(importance)\\n # importance = [i / max_importance for i in importance]\\n \\n # # Sample timesteps\\n # # timesteps.sort(key=lambda t: t.abs_error, reverse=True)\\n # samples = []\\n # b = 0\\n # for start, stop in batch_indexes(len(timesteps), math.floor(len(timesteps) / k)):\\n # if b == k: break\\n # sample = np.random.choice(timesteps[start:stop])\\n # sample.adjusted_target = sample.target * importance[b]\\n # samples.append(sample)\\n # b += 1\\n \\n for t in timesteps:\\n t.adjusted_target = t.target\\n random.shuffle(timesteps)\\n return timesteps[:k]\",\n \"def sample(self, data=None, chains=4, iter=2000, warmup=None, \\n recompile=False, overwrite=False, **kwargs):\\n\\n self._load_model(recompile=recompile, overwrite=overwrite, **kwargs)\\n\\n kwds = self._validate_stan_inputs(\\n data=data, chains=chains, iter=iter, warmup=warmup, **kwargs)\\n\\n self._fit = self.model.sampling(**kwds)\\n return self._fit\",\n \"def sample_from_prior(self, *args, **kwargs):\\n pass\",\n \"def __init__(self, num_features=NUM_FEATURES, num_samp=NUM_SAMP):\\n num_samp = NUM_SAMP\\n sigma = 0.1\\n np.random.seed(31415)\\n\\n # We're going to learn these paramters\\n self.w = np.random.randint(low=0, high=5, size=(num_features, 1))\\n self.b = 2\\n\\n self.index = np.arange(num_samp)\\n self.x = np.random.uniform(size=(num_samp, num_features))\\n self.y = self.x @ self.w + self.b + sigma * np.random.normal()\",\n \"def sampling(args):\\r\\n z_mean,z_log_var = args\\r\\n batch = K.shape(z_mean)[0]\\r\\n dim = K.shape(z_mean)[1]\\r\\n epsilon = K.random_normal(shape=(batch,dim),\\r\\n mean=0.0,stddev=1.0)\\r\\n std_epsilon = 1e-4\\r\\n return z_mean + (z_log_var + std_epsilon) * epsilon\",\n \"def subsampling(dataset, class_column_index, class_max_count, class_dict):\\n out = []\\n for row in dataset:\\n cls = row[class_column_index]\\n rInt = np.random.randint(0, class_dict[cls])\\n if rInt <= class_max_count:\\n out.append(row)\\n ss_data = np.array(out)\\n\\n return ss_data\",\n \"def sampling(self, args):\\n self.z_mean, self.z_log_var = args\\n batch = K.shape(self.z_mean)[0]\\n dim = K.int_shape(self.z_mean)[1]\\n epsilon = K.random_uniform(shape=(batch, dim))\\n \\n return self.z_mean + K.exp(0.5 * self.z_log_var) * epsilon\",\n \"def _sample_internal(self, opts, num):\\n noise = utils.generate_noise(opts, num)\\n sample = self._run_batch(\\n opts, self._generated, self._noise_ph, noise,\\n self._is_training_ph, False)\\n return sample\",\n \"def __init__(self, data_source, batch_size):\\n self.batch_size = batch_size\\n self.samples_per_row = ceil(len(data_source) / batch_size)\\n self.num_samples = self.samples_per_row * batch_size\",\n \"def sample(self):\\n return self(np.random.randn(self.num_xi)).reshape(self.X.shape)\",\n \"def __init__(self, min_dist=0.1, n_neighbors=15, max_samples=2000,\\n shuffle=False, **kwargs):\\n super().__init__(min_dist=min_dist, n_neighbors=n_neighbors,\\n max_samples=max_samples, shuffle=shuffle, **kwargs)\\n self.max_samples = max_samples\\n self.shuffle = shuffle\\n self.min_dist = min_dist\\n self.n_neighbors = n_neighbors\",\n \"def sample(self, n_samples: int) -> torch.Tensor:\\n return self.dist.sample((n_samples,))\",\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 mksampler(x):\\n if hasattr(x, \\\"__call__\\\"):\\n return x\\n elif type(x) is list:\\n # NB: disjoint ranges can be given as nested lists, e.g. [(1,2), (4,5)]\\n if len(x) == 2 and type(x[0]) in (int,float) and type(x[1]) in (int,float):\\n #print \\\"MKSAMPLER: Casting %s to UniformSampler\\\" % str(x)\\n return UniformSampler(*x)\\n elif len(x) > 2 or (len(x) > 0 and type(x[0]) not in (int,float)):\\n #print \\\"MKSAMPLER: Casting %s to DisjointUniformSampler\\\" % str(x)\\n return DisjointUniformSampler(x)\\n if len(x) < 2:\\n raise Exception(\\\"Supplied list could not be converted to a continuous sampler\\\")\\n elif type(x) is tuple:\\n #print \\\"MKSAMPLER: Casting %s to CyclicSeqSampler\\\" % str(x)\\n return CyclicSeqSampler(*x)\\n elif type(x) is set:\\n #print \\\"MKSAMPLER: Casting %s to RandomSeqSampler\\\" % str(x)\\n return RandomSeqSampler(*x)\\n else:\\n #print \\\"MKSAMPLER: Casting %s to ConstSampler\\\" % str(x)\\n return ConstSampler(x)\",\n \"def DataSample(*args, **kw):\\n return cnexxT.DataSample.make_shared(cnexxT.DataSample(*args, **kw))\",\n \"def sample_prior(size):\\n return torch.randn(size)\",\n \"def simple_sampler(fun, start, sigma, iterations, verbose=False):\\n mean = np.zeros(len(start))\\n cov = np.eye(len(start)) * sigma\\n\\n if isinstance(start, np.ndarray):\\n previous = start\\n else:\\n previous = np.array(start)\\n\\n f_previous = fun(previous)\\n\\n samples = np.zeros((iterations, len(start)))\\n acceptance = 0\\n for i in range(iterations):\\n proposal = previous + np.random.multivariate_normal(mean=mean, cov=cov)\\n f_proposal = fun(proposal)\\n fun(previous)\\n if (np.log(np.random.rand())) < (f_proposal - f_previous):\\n previous = proposal\\n acceptance += 1\\n samples[i] = np.array(previous)\\n\\n if verbose:\\n print('sampler acceptance = {0:.3f}'.format(acceptance / iterations))\\n\\n return samples\",\n \"def pseudo_sample(self):\\n return (torch.zeros(1, 1, 28, 28), None)\",\n \"def take_samples(self, num_samples: int) -> List:\\n if num_samples > len(self.samples):\\n return random.sample(self.samples, len(self.samples))\\n return random.sample(self.samples, num_samples)\",\n \"def _sample_seed(self):\\n raise Exception(\\\" not implemented in base model\\\")\",\n \"def init(self, start_sample, fhat, budget):\\n self.proposed_points = start_sample\\n self.fhat = fhat\\n self.n0 = start_sample.shape[0]\\n for i in range(self.nstrats):\\n self.sampling_strategies[i].init(self.proposed_points, fhat, budget)\",\n \"def create_samples(self, initial_point: Dict) -> Tuple[List[Dict], List[float]]:\\n burnin = self.sampling_params['burnin']\\n thin = self.sampling_params['thin']\\n proposal_distribution = self.sampling_params['proposal_distribution']\\n \\n samples = []\\n logprobs = []\\n curr_point = initial_point.copy()\\n sampling_user = self.user_model.copy()\\n sampling_user.params = curr_point\\n curr_logprob = self.logprior(curr_point) + sampling_user.loglikelihood_dataset(self.dataset)\\n samples.append(curr_point)\\n logprobs.append(curr_logprob)\\n for _ in range(burnin + thin * self.num_samples - 1):\\n next_point = proposal_distribution(curr_point)\\n sampling_user.params = next_point\\n next_logprob = self.logprior(next_point) + sampling_user.loglikelihood_dataset(self.dataset)\\n if np.log(np.random.rand()) < next_logprob - curr_logprob:\\n curr_point = next_point.copy()\\n curr_logprob = next_logprob\\n samples.append(curr_point)\\n logprobs.append(curr_logprob)\\n self.samples, self.logprobs = samples[burnin::thin], logprobs[burnin::thin]\",\n \"def sampling(train_set, train_meta, klass, label, n_samples_pos, rate_neg, fold, path_idxs):\\n\\tprint('-- SAMPLING TRAINNING')\\n\\tdirectory_idxs = path_idxs+fold+'/'+str(int(klass))+'/'\\n\\tif(os.path.isdir(directory_idxs)):\\n\\t\\tprint('loading indexes...')\\n\\t\\tidxs_class_pos = np.loadtxt(directory_idxs+'idxs_pos_train.txt', dtype=int)\\n\\t\\tidxs_class_neg = np.loadtxt(directory_idxs+'idxs_neg_train.txt', dtype=int)\\n\\telse:\\n\\t\\tidxs_class_pos = (train_meta[ : , label] == klass).nonzero()[0]\\n\\t\\tidxs_class_neg = (train_meta[ : , label] != klass).nonzero()[0]\\n\\t\\tif(n_samples_pos < len(idxs_class_pos)):\\n\\t\\t\\tidxs_class_pos = np.random.choice(idxs_class_pos, n_samples_pos)\\n\\t\\tidxs_class_neg = np.random.choice(idxs_class_neg, int(n_samples_pos*rate_neg))\\n\\t\\tprint('saving indexes...')\\n\\t\\tos.makedirs(directory_idxs)\\n\\t\\tnp.savetxt(directory_idxs+'idxs_pos_train.txt', idxs_class_pos, fmt='%d')\\n\\t\\tnp.savetxt(directory_idxs+'idxs_neg_train.txt', idxs_class_neg, fmt='%d')\\n\\n\\ttrain_set = np.vstack((train_set[idxs_class_pos], train_set[idxs_class_neg]))\\n\\ttrain_meta = np.vstack((train_meta[idxs_class_pos], train_meta[idxs_class_neg]))\\n\\ttrain_meta[:, label] = 1\\n\\ttrain_meta[len(idxs_class_pos):, label] = -1\\n\\treturn [train_set, train_meta]\",\n \"def sample(self, batch_size):\\n # get the sum of priorities\\n priority_sum = self.sum_tree.get_sum_priority()\\n # sample priorities \\n priorities_to_sample = np.random.uniform(0, priority_sum, batch_size)\\n # get the indexes of replays\\n sample_idxes = [self.sum_tree.get(x) for x in priorities_to_sample]\\n # fetch the transitions and prepare the batch for training\\n random_sample = [self.queue[x] for x in sample_idxes]\\n # zip\\n zipped = [ torch.from_numpy( np.asarray(arr).astype(np.float32) ).float() for arr in zip(*random_sample) ]\\n sample = Transition( zipped[0], zipped[1].unsqueeze_(-1).long(), zipped[2].unsqueeze_(-1), zipped[3], zipped[4].unsqueeze_(-1).byte() )\\n return sample, sample_idxes\",\n \"def train_samples_for_cls(self, cls):\\n train = [t for t in self.get_train_files() if t[2] == cls]\\n all_samples = ({'cls': t[2], **_read_mat_data(t[3])} for t in train)\\n return (sample for sample in all_samples if sample['signals'] is not None), len(train)\",\n \"def generate_samples(self, latent_vec=None, num=None):\\n num = self.batch_size if num is None else num\\n latent_vec = self.noise_fn(num) if latent_vec is None else latent_vec\\n with torch.no_grad():\\n samples = self.generator(latent_vec)\\n samples = samples.cpu() # move images to cpu\\n return samples\",\n \"def sampling(args):\\r\\n\\r\\n z_mean, z_log_var = args\\r\\n batch = K.shape(z_mean)[0]\\r\\n dim = K.int_shape(z_mean)[1]\\r\\n # by default, random_normal has mean=0 and std=1.0\\r\\n epsilon = K.random_normal(shape=(batch, dim))\\r\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\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 sampling(args):\\n\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.int_shape(z_mean)[1]\\n # by default, random_normal has mean = 0 and std = 1.0\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def generate(self):\\n # --------------------------------\\n # Initializing Variables\\n # --------------------------------\\n\\n # Set NumPy Random Seed\\n np.random.seed(self._seed)\\n\\n # Create Active List\\n active = []\\n\\n # Clear previously generated examples\\n if len(self._samples) > 0:\\n self._clear_previous_samples()\\n\\n # --------------------------------\\n # Begin Generating Samples\\n # --------------------------------\\n\\n # Create the first sample\\n self._samples.append(np.random.uniform(low=np.zeros(shape=(self._dim,)),\\n high=self._extent, size=(self._dim,)))\\n active.append(self._samples[0])\\n self._grid[self._get_grid_coord(self._samples[0])] = 0\\n\\n while active:\\n # Choose Random Active Sample\\n idx = np.random.choice(len(active))\\n\\n # Make new point & confirm it is valid\\n new_point = self._make_point(active[idx])\\n if new_point is None:\\n active.pop(idx)\\n else:\\n # Add sample to listings and store in grid for neighboring locations.\\n self._samples.append(new_point)\\n active.append(new_point)\\n self._grid[self._get_grid_coord(new_point)] = len(self._samples) - 1\\n\\n # Return samples as numpy array\\n self._samples = np.array(self._samples)\\n return self._samples\",\n \"def build_sampler(self, params):\\n\\n def sampler(logits_1, logits_2, key):\\n q_kwargs = dict(transpose=True) if self.use_transpose else {}\\n x = self.model.bind(params).sample(logits_1, key)\\n y = self.model.bind(params).sample(logits_2, key, **q_kwargs)\\n return jnp.zeros([10, 10]).at[x, y].set(1.)\\n\\n return sampler\",\n \"def __init__(self, k, p, sample_p=1):\\n # Maximum sample size\\n self.k = k\\n\\n # A dictionary containing the sampled elements\\n # The dictionary key is the key of the element\\n # The value is a tuple (seed, count)\\n self.elements = {}\\n\\n # The function of the frequencies that the sketch estimates\\n # For now it's the p-th frequency moment, but in the future we may\\n # support other functions (passed as a parameter)\\n self.func_of_freq = lambda x: x**p\\n\\n # The power of values used for the sampling weights\\n self.sample_p = sample_p\",\n \"def data_feeder_2():\\n return random.sample(range(100), 10)\",\n \"def sampling(args):\\n\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.int_shape(z_mean)[1]\\n # by default, random_normal has mean=0 and std=1.0\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65095025","0.65095025","0.62867826","0.61317563","0.61276025","0.610246","0.610246","0.6065455","0.6057883","0.60466325","0.60249513","0.6012527","0.5995907","0.59938455","0.59754515","0.5971747","0.59705216","0.5960324","0.5956033","0.59375805","0.59256035","0.59098893","0.589455","0.5894196","0.5894196","0.5894196","0.5894196","0.58925223","0.5891034","0.5884782","0.5884095","0.5870258","0.584934","0.5848578","0.5846827","0.58292913","0.58289367","0.58180463","0.5801805","0.57909","0.5774549","0.57717794","0.5758428","0.5755195","0.5754683","0.5750951","0.5750107","0.5747852","0.57367295","0.5720837","0.57178146","0.5708704","0.570174","0.56991637","0.56990916","0.56854445","0.56792665","0.56792647","0.5678967","0.567864","0.5670302","0.5669147","0.5652561","0.56490046","0.56464076","0.56417483","0.5641428","0.56373096","0.56325567","0.5632497","0.5631366","0.5630575","0.5626073","0.56224906","0.5613321","0.5610801","0.56065226","0.55927074","0.558772","0.5586269","0.55806786","0.5579888","0.55798167","0.5577665","0.5572919","0.5572788","0.5563654","0.55553323","0.55550843","0.5551622","0.5550569","0.55441993","0.55440533","0.5539935","0.5538057","0.5537252","0.5533687","0.55324894","0.55299157","0.5520561"],"string":"[\n \"0.65095025\",\n \"0.65095025\",\n \"0.62867826\",\n \"0.61317563\",\n \"0.61276025\",\n \"0.610246\",\n \"0.610246\",\n \"0.6065455\",\n \"0.6057883\",\n \"0.60466325\",\n \"0.60249513\",\n \"0.6012527\",\n \"0.5995907\",\n \"0.59938455\",\n \"0.59754515\",\n \"0.5971747\",\n \"0.59705216\",\n \"0.5960324\",\n \"0.5956033\",\n \"0.59375805\",\n \"0.59256035\",\n \"0.59098893\",\n \"0.589455\",\n \"0.5894196\",\n \"0.5894196\",\n \"0.5894196\",\n \"0.5894196\",\n \"0.58925223\",\n \"0.5891034\",\n \"0.5884782\",\n \"0.5884095\",\n \"0.5870258\",\n \"0.584934\",\n \"0.5848578\",\n \"0.5846827\",\n \"0.58292913\",\n \"0.58289367\",\n \"0.58180463\",\n \"0.5801805\",\n \"0.57909\",\n \"0.5774549\",\n \"0.57717794\",\n \"0.5758428\",\n \"0.5755195\",\n \"0.5754683\",\n \"0.5750951\",\n \"0.5750107\",\n \"0.5747852\",\n \"0.57367295\",\n \"0.5720837\",\n \"0.57178146\",\n \"0.5708704\",\n \"0.570174\",\n \"0.56991637\",\n \"0.56990916\",\n \"0.56854445\",\n \"0.56792665\",\n \"0.56792647\",\n \"0.5678967\",\n \"0.567864\",\n \"0.5670302\",\n \"0.5669147\",\n \"0.5652561\",\n \"0.56490046\",\n \"0.56464076\",\n \"0.56417483\",\n \"0.5641428\",\n \"0.56373096\",\n \"0.56325567\",\n \"0.5632497\",\n \"0.5631366\",\n \"0.5630575\",\n \"0.5626073\",\n \"0.56224906\",\n \"0.5613321\",\n \"0.5610801\",\n \"0.56065226\",\n \"0.55927074\",\n \"0.558772\",\n \"0.5586269\",\n \"0.55806786\",\n \"0.5579888\",\n \"0.55798167\",\n \"0.5577665\",\n \"0.5572919\",\n \"0.5572788\",\n \"0.5563654\",\n \"0.55553323\",\n \"0.55550843\",\n \"0.5551622\",\n \"0.5550569\",\n \"0.55441993\",\n \"0.55440533\",\n \"0.5539935\",\n \"0.5538057\",\n \"0.5537252\",\n \"0.5533687\",\n \"0.55324894\",\n \"0.55299157\",\n \"0.5520561\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5782709"},"document_rank":{"kind":"string","value":"40"}}},{"rowIdx":84571,"cells":{"query":{"kind":"string","value":"Generates and stores example visiting scheme, as a numpy array of integers."},"document":{"kind":"string","value":"def generate_visiting_scheme(self):\n\n def all_indices_shuffled():\n _res = list(range(self.dataset.num_examples))\n self.rnd.shuffle(_res)\n return _res\n\n # noinspection PyUnusedLocal\n _tmp_ts = np.concatenate(\n [all_indices_shuffled() for _ in range(self.epochs or 1)]\n )\n self.training_schedule = (\n _tmp_ts\n if self.training_schedule is None\n else np.concatenate([self.training_schedule, _tmp_ts])\n ) # do not discard previous schedule,\n # this should allow backward passes of arbitrary length\n\n return self"},"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 originalData(self): \n self.__exampleIndices = array(list(range(0, self.__numExamples)))","def data_gen(size, p):\n #print(np.random.get_state()[1][0])\n random_table = np.random.binomial(size = size, p = p, n = 1)\n test_array = np.zeros((size, 2), dtype = int)\n for i in range(size):\n test_array[i,0] = i\n test_array[i,1] = random_table[i]\n return test_array","def create_array( n ):","def get_example_data():\n nnz = np.random.randint(FLAGS.min_nnz, FLAGS.max_nnz)\n nz_idx = np.random.randint(FLAGS.dense_size, size=nnz)\n nz_idx = np.unique(nz_idx)\n nz_values = np.random.uniform(10, size=nz_idx.size)\n label = np.random.randint(FLAGS.num_classes)\n return nz_idx, nz_values, label","def generate_data(example_size):\n\n\n # A placeholder for data.\n x = np.zeros((example_size, 2))\n\n # Randomly selects one of two classes for each example.\n class_id = np.random.randint(2, size=example_size)\n\n # Generates data for the class 0.\n class_0_idx = np.where(class_id == 0)\n mean0 = [0.0, 1.0]\n cov0 = [[0.4, 0.0], [0.0, 1.0]]\n x[class_0_idx[0], :] = np.random.multivariate_normal(\n mean0, cov0, class_0_idx[0].shape[0])\n\n # Generates data for the class 0.\n class_1_idx = np.where(class_id == 1)\n mean1 = [1.0, 2.0]\n cov1 = [[1.0, 0.0], [0.0, 0.4]]\n x[class_1_idx[0], :] = np.random.multivariate_normal(\n mean1, cov1, class_1_idx[0].shape[0])\n\n return (x, class_id)","def array(self):","def test_30_test_init_array(self, persons_gi):\n example = Example(groups=7, origins=5)\n\n example.init_array('param_g', 7)\n assert example.param_g.shape == (7, )","def _create_counterexamples(self, x_concept):\n n = x_concept.shape[0]\n height = x_concept.shape[1]\n width = x_concept.shape[2]\n channels = x_concept.shape[3]\n counterexamples = []\n for i in range(0, n):\n counterexamples.append(\n np.rint(np.random.rand(height, width, channels) * 255)\n )\n return np.array(counterexamples)","def gen_num_seq(nums):\n X = np.zeros([nums, 10, 20], dtype=float)\n y = np.zeros([nums, 10, 20], dtype=float)\n for i in range(nums):\n start = np.random.randint(0, 10)\n num_seq = np.arange(start, start + 10)\n X[i] = to_categorical(num_seq, n_col=20)\n y[i] = np.roll(X[i], -1, axis=0)\n y[:, -1, 1] = 1 # Mark endpoint as 1\n return X, y","def basic_array_creation():\n print('From normal creation')\n arr: pa.Array = pa.array([1, 2, 3, 4, 5], type=pa.int8())\n print(arr)\n\n print('From pandas series')\n arr: pa.Array = pa.Array.from_pandas(pd.Series([1, 2, 3, 4, 5]))\n print(arr)","def generate(\n self,\n num_nodes: int,\n num_edges: int,\n is_directed: bool,\n *args,\n return_node_ids: bool = False,\n **kwargs,\n ) -> np.ndarray:\n raise NotImplementedError()","def convert_to_array(self): \n self.reads = np.asarray(self.reads, dtype=\"int64\")\n self.sampling=True","def _get_rand_array(self):\n pass","def num_54():\n frmt = \"\"\"\n :{}\n :Generate Data that conform to a uniform distribution.\n :\n :Class values: {}\n :Population size: {}\n :Results:\n : values:\n {}\n : table:\n {}\n : histogram: (class, frequency)\n {}\n :Then use NumPyArrayToTable to get your table.\n \"\"\"\n # import numpy as np\n st = 1\n end = 7\n vals = np.arange(st,end)\n reps = 10\n z = np.repeat(vals,reps)\n np.random.shuffle(z)\n ID = np.arange(len(z))\n tbl = np.array(list(zip(ID, z)), \n dtype = [('ID', 'int'), ('Class', 'int')])\n h = np.histogram(z, np.arange(st, end+1))\n h = np.array(list(zip(h[1], h[0])))\n pad = \" \"\n args =[num_54.__doc__, vals, reps*len(vals),\n indent(str(z.reshape(3,20)), pad),\n indent(str(tbl), pad), indent(str(h), pad)]\n print(dedent(frmt).format(*args))","def test_ford_fulkerson_algo() -> np.ndarray:\r\n res = ford_fulkerson_algorithm(np.array(ex_sample_graph), 0, 10)\r\n print(\"Result: \")\r\n print(res)\r\n return res","def example_to_data(self, example):\n raise NotImplementedError","def gen_graph(self):","def get_image_array_from_example(example):\n features = example.features.feature\n img = features['image/encoded'].bytes_list.value[0]\n shape = features['image/shape'].int64_list.value[0:3]\n return np.frombuffer(img, np.uint8).reshape(shape)","def generate_fake_samples(generator_model : Model, dataset : np.ndarray, patch_shape : int) -> np.ndarray:\n X = generator_model.predict(dataset)\n y = generate_patch_labels(len(X), patch_shape, label=0)\n return X, y","def __init__(self):\n self.arr = array(\"i\")","def gcode_interpreter(file_gcode):\n\tgcode_raw = read_gcode(file_gcode)\n\n\tdim = (11, 11)\n\tarray = convert_gcode_to_array(gcode_raw, dim)\n\n\tprint array","def __array__(self):\n return pa.column(\"dummy\", self.data).to_pandas().values","def gen_numpy(path,smilist):\n import numpy as np\n from get_metadata import get_metadata\n from descriptor import Morgan2D\n nb = 1024\n trainlen = len(smilist)\n train_XY = np.zeros((trainlen, nb + 5))\n local_X = np.zeros((nb + 5))\n for num, smi in enumerate(smilist):\n \n etot, dipole, quadrapole, solv, mp = get_metadata(path,smi)\n ecfp = Morgan2D(smi,2,nb)\n local_X[0:nb] = ecfp\n local_X[-5] = etot\n local_X[-4] = dipole\n local_X[-3] = quadrapole\n local_X[-2] = solv\n local_X[-1] = mp \n train_XY[num, :] = local_X\n \n return train_XY","def create_array(uri: str):\n dim1 = tiledb.Dim(\"d1\", domain=(1, 5))\n dim2 = tiledb.Dim(\"d2\", domain=(1, 5))\n dom = tiledb.Domain(dim1, dim2)\n att = tiledb.Attr(\"a1\", dtype=np.int64)\n dim_labels = {\n 0: {\"l1\": dim1.create_label_schema(\"decreasing\", np.int64)},\n 1: {\n \"l2\": dim2.create_label_schema(\"increasing\", np.int64),\n \"l3\": dim2.create_label_schema(\"increasing\", np.float64),\n },\n }\n schema = tiledb.ArraySchema(domain=dom, attrs=(att,), dim_labels=dim_labels)\n tiledb.Array.create(uri, schema)","def __data_generation(self, list_IDs_temp):\n # Initialization\n if self.mirror:\n X = np.empty(\n (self.batch_size, *self.dim_in, self.n_channels_in),\n dtype=\"uint8\",\n ) \n else:\n X = np.empty(\n (self.batch_size * len(self.camnames[0]), *self.dim_in, self.n_channels_in),\n dtype=\"uint8\",\n )\n\n # We'll need to transpose this later such that channels are last,\n # but initializaing the array this ways gives us\n # more flexibility in terms of user-defined array sizes\\\n if self.labelmode == \"prob\":\n y = np.empty(\n (\n self.batch_size * len(self.camnames[0]),\n self.n_channels_out,\n *self.dim_out,\n ),\n dtype=\"float32\",\n )\n else:\n # Just return the targets, without making a meshgrid later\n y = np.empty(\n (\n self.batch_size * len(self.camnames[0]),\n self.n_channels_out,\n len(self.dim_out),\n ),\n dtype=\"float32\",\n )\n\n # Generate data\n cnt = 0\n for i, ID in enumerate(list_IDs_temp):\n if \"_\" in ID:\n experimentID = int(ID.split(\"_\")[0])\n else:\n # Then we only have one experiment\n experimentID = 0\n for _ci, camname in enumerate(self.camnames[experimentID]):\n # Store sample\n # TODO(Refactor): This section is tricky to read\n\n if not self.mirror or _ci == 0:\n if self.immode == \"video\":\n X[cnt] = self.load_vid_frame(\n self.labels[ID][\"frames\"][camname],\n camname,\n self.preload,\n self.extension,\n )[\n self.crop_height[0] : self.crop_height[1],\n self.crop_width[0] : self.crop_width[1],\n ]\n elif self.immode == \"tif\":\n X[cnt] = self.load_tif_frame(\n self.labels[ID][\"frames\"][camname], camname\n )[\n self.crop_height[0] : self.crop_height[1],\n self.crop_width[0] : self.crop_width[1],\n ]\n else:\n raise Exception(\"Not a valid image reading mode\")\n\n # Labels will now be the pixel positions of each joint.\n # Here, we convert them to\n # probability maps with a numpy meshgrid operation\n this_y = np.round(self.labels[ID][\"data\"][camname])\n if self.immode == \"video\":\n this_y[0, :] = this_y[0, :] - self.crop_width[0]\n this_y[1, :] = this_y[1, :] - self.crop_height[0]\n else:\n raise Exception(\n \"Unsupported image format. Needs to be video files.\"\n )\n\n # For 2D, this_y should be size (2, 20)\n if this_y.shape[1] != self.n_channels_out:\n # TODO(shape_exception):This should probably be its own\n # class that inherits from base exception\n raise Exception(_EXEP_MSG)\n\n if self.labelmode == \"prob\":\n # Only do this if we actually need the labels --\n # this is too slow otherwise\n (x_coord, y_coord) = np.meshgrid(\n np.arange(self.dim_out[1]), np.arange(self.dim_out[0])\n )\n for j in range(self.n_channels_out):\n # I tested a version of this with numpy broadcasting,\n # and looping was ~100ms seconds faster for making\n # 20 maps\n # In the future, a shortcut might be to \"stamp\" a\n # truncated Gaussian pdf onto the images, centered\n # at the peak\n y[cnt, j] = np.exp(\n -(\n (y_coord - this_y[1, j]) ** 2\n + (x_coord - this_y[0, j]) ** 2\n )\n / (2 * self.out_scale ** 2)\n )\n else:\n y[cnt] = this_y.T\n\n cnt = cnt + 1\n\n # Move channels last\n if self.labelmode == \"prob\":\n y = np.transpose(y, [0, 2, 3, 1])\n\n if self.mirror:\n # separate the batches from the cameras, and use the cameras as the numebr of channels \n # to make a single-shot multi-target prediction from a single image\n y = np.reshape(y, (self.batch_size, len(self.camnames[0]), y.shape[1], y.shape[2]))\n y = np.transpose(y, [0, 2, 3, 1])\n else:\n # One less dimension when not training with probability map targets\n y = np.transpose(y, [0, 2, 1])\n\n if self.downsample > 1:\n X = processing.downsample_batch(X, fac=self.downsample, method=self.dsmode)\n if self.labelmode == \"prob\":\n y = processing.downsample_batch(\n y, fac=self.downsample, method=self.dsmode\n )\n y /= np.max(np.max(y, axis=1), axis=1)[:, np.newaxis, np.newaxis, :]\n\n if self.mono and self.n_channels_in == 3:\n # Go from 3 to 1 channel using RGB conversion. This will also\n # work fine if there are just 3 channel grayscale\n X = X[:, :, :, 0]*0.2125 + \\\n X[:, :, :, 1]*0.7154 + \\\n X[:, :, :, 2]*0.0721\n\n X = X[:, :, :, np.newaxis]\n\n if self.mono:\n # Just subtract the mean imagent BGR value, which is as close as we\n # get to vgg19 normalization\n X -= 114.67\n else:\n X = pp_vgg19(X)\n return X, y","def int2array(line, train=True):\n example = np.zeros((15, 15, 3), dtype=np.float32)\n for channel in range(2):\n intstr = str(bin(int(line[channel]))[2:].zfill(225))\n tmp = np.fromstring(intstr[::-1], np.int8) - 48\n tmp = tmp.reshape((15, 15))\n example[:, :, channel] = tmp.T\n if train:\n example[axis(int(line[3]))[0], axis(int(line[3]))[1], 2] = 1.0\n else:\n example[:, :, 2] = int(line[2])\n return example\n\n examples = []\n policies = []\n values = []\n\n for k in range(4):\n tmp = np.zeros((15, 15, 3), dtype=np.float32)\n tmp[:] = np.rot90(example, k, (0, 1))\n rx, ry = axis(np.argmax(tmp[:, :, 2].T))\n policy = toind(rx, ry)\n tmp[:, :, 2] = int(line[2])\n examples.append(tmp)\n policies.append(policy)\n values.append(float(line[4]))\n\n rev_example = example[::-1, :, :]\n for k in range(4):\n tmp = np.zeros((15, 15, 3), dtype=np.float32)\n tmp[:] = np.rot90(rev_example, k, (0, 1))\n rx, ry = axis(np.argmax(tmp[:, :, 2].T))\n policy = toind(rx, ry)\n tmp[:, :, 2] = int(line[2])\n examples.append(tmp)\n policies.append(policy)\n values.append(float(line[4]))\n return examples, policies, values","def generate_array(hdulist, features, targets):\n \"\"\"\n #To do:\n -get targets and features via .conf file\n -> use field_names = hdulist_test[1].columns.names\n \"\"\"\n\n '''extract data'''\n astro_data = hdulist[1].data\n\n '''get all float like and feature matching data'''\n data_float = np.squeeze(np.array([astro_data.field(0)]))\n for x in range(0, len(astro_data[0])):\n if isinstance(astro_data.field(x)[1], (int, float, complex)) is True\\\n and x not in targets and x in features:\n data_float = np.vstack((data_float, np.squeeze(np.array([astro_data.field(x)]))))\n '''get all and target matching data'''\n targets_float = np.squeeze(np.array(astro_data.field(targets[0])))\n for x in range(len(targets)):\n targets_float = np.vstack((targets_float, np.squeeze(np.array(astro_data.field(targets[x])))))\n print('Selected Feature: ' + hdulist_test[1].columns.names[targets[x]])\n '''return'''\n return data_float, targets_float","def _create_example(self):\n source = np.random.randn(self.batch_size, self.max_decode_length,\n self.input_depth)\n source_len = np.random.randint(0, self.max_decode_length, [self.batch_size])\n target_len = np.random.randint(0, self.max_decode_length * 2,\n [self.batch_size])\n target = np.random.randn(self.batch_size,\n np.max(target_len), self.input_depth)\n labels = np.random.randint(0, self.vocab_size,\n [self.batch_size, np.max(target_len) - 1])\n\n example_ = namedtuple(\n \"Example\", [\"source\", \"source_len\", \"target\", \"target_len\", \"labels\"])\n return example_(source, source_len, target, target_len, labels)","def _img_array_feature(value):\n return tf.train.Feature(int64_list=tf.train.Int64List(value=value.ravel()))","def _img_array_feature(value):\n return tf.train.Feature(int64_list=tf.train.Int64List(value=value.ravel()))","def _transformEx(self,example):\n x = []\n x.extend(example) \n x.append(1)\n return x,example.label","def generate_converted():\n for example in generate_examples(data_path):\n input_ids, label_ids = encode_fn(\n example['tokens'], example['labels'])\n\n yield {\n 'input_ids': input_ids,\n 'label_ids': label_ids\n }","def gen_data(self):\n\n # 1，read the source text\n inputs, labels = self.read_data()\n print(\"read finished\")\n\n # 2. word label index\n word_to_index, label_to_index = self.gen_word_label_index()\n # print(\"word_to_index\",word_to_index)\n # print(\"label_to_index\",label_to_index)\n print(\"vocab process finished\")\n #\n # 3，input to index\n inputs_idx = self.trans_to_index(inputs, word_to_index)\n # print((inputs_idx))\n print(\"index transform finished\")\n #\n # 4, padding\n inputs_idx = self.padding(inputs_idx, self._sequence_length)\n # print(inputs_idx)\n print(\"padding finished\")\n\n # 6，label to index\n labels_idx = self.trans_label_to_index(labels, label_to_index)\n print(\"label index transform finished\")\n\n return np.array(inputs_idx), np.array(labels_idx)","def load_test_data():\n # X has dim (USER_COUNT x ITEM_COUNT)\n USER_COUNT = 10000\n ITEM_COUNT = 1000\n\n ratings = load_ratings_from_file_path(get_test_file_path())\n\n X = np.zeros([USER_COUNT, ITEM_COUNT])\n for (row, col, rating) in ratings:\n X[row, col] = rating\n return X","def test_id_array(self):\n arr = vtk.vtkIdTypeArray()\n arr.SetNumberOfTuples(10)\n for i in range(10):\n arr.SetValue(i, i)\n\n np = array_handler.vtk2array(arr)\n self.assertEqual(numpy.all(np == range(10)), True)","def generate_samples(self, n_samples):","def generate_samples(self, n_samples):","def generate_dataset(output_dim=14, num_examples=10000):\n def int2vec(x, dim=output_dim):\n out = np.zeros(dim)\n binrep = np.array(list(np.binary_repr(x))).astype('int')\n out[-len(binrep):] = binrep\n return out\n\n x_left_int = (np.random.rand(num_examples) * 2 ** (output_dim - 1)).astype('int')\n x_right_int = (np.random.rand(num_examples) * 2 ** (output_dim - 1)).astype('int')\n y_int = x_left_int + x_right_int\n\n x = list()\n for i in range(len(x_left_int)):\n x.append(np.concatenate((int2vec(x_left_int[i]), int2vec(x_right_int[i]))))\n\n y = list()\n for i in range(len(y_int)):\n y.append(int2vec(y_int[i]))\n\n x = np.array(x)\n y = np.array(y)\n return x, y","def _generate_examples(self, filepath):\n # Simultaneously iterating through the different data sets in the hdf5\n # file is >100x slower and the data set is small (26.7MB). Hence, we first\n # load everything into memory before yielding the samples.\n with tfds.core.lazy_imports.h5py.File(filepath, \"r\") as h5dataset:\n image_array = np.array(h5dataset[\"imgs\"])\n class_array = np.array(h5dataset[\"latents\"][\"classes\"])\n values_array = np.array(h5dataset[\"latents\"][\"values\"])\n\n for i, (image, classes, values) in enumerate(moves.zip(\n image_array, class_array, values_array)):\n record = dict(\n image=np.expand_dims(image, -1),\n label_shape=classes[1],\n label_scale=classes[2],\n label_orientation=classes[3],\n label_x_position=classes[4],\n label_y_position=classes[5],\n value_shape=values[1],\n value_scale=values[2],\n value_orientation=values[3],\n value_x_position=values[4],\n value_y_position=values[5])\n if self.version > \"2.0.0\":\n record[\"id\"] = \"{:06d}\".format(i)\n yield i, record","def easydatagen():\n\n # Reading in the training file\n data = pd.read_json('train.json')\n\n # The set of different cuisines\n cuisines = data.cuisine.unique()\n\n # To find the different ingredients, we need to clean them up a little.\n def clean(string) :\n s = string.replace('-',' ') # read low-fat the same as low fat\n s = string.replace('&', 'and') # read & and and as the same\n s = re.sub('\\((.*?)\\)', '', s) # remove everythin g in brackets\n s = re.sub('\\d{1,2}\\%', '', s) # remove things of the form d% or dd%, where d is a digit\n s = ' '.join(s.split()) # remove extra white spaces\n\n return s\n\n ing_list = data.ingredients.values.tolist()\n raw_ingredients = [clean(x) for ing in ing_list for x in ing]\n\n ingredients = sorted(set(raw_ingredients))\n\n # build a dictionary that to each ingredient assigns its index\n ingredient_index = {}\n for i in range(0,len(ingredients)) :\n ingredient_index[ingredients[i]] = i\n\n # the same for cuisines\n cuisine_index = {}\n for i in range(0, len(cuisines)) :\n cuisine_index[cuisines[i]] = i\n\n def ingredients_to_vector(ings) :\n vect = np.zeros(len(ingredients))\n for ing in ings :\n vect[ingredient_index[clean(ing)]] = 1\n\n return vect\n\n def cuisine_to_vector(cus) :\n vect = np.zeros(20)\n vect[cuisine_index[cus]] = 1\n return vect\n\n vect_list = [ingredients_to_vector(ing) for ing in ing_list]\n target_list = [cuisine_to_vector(cus) for cus in data.cuisine.values.tolist()]\n\n # Define training data\n X = np.c_[vect_list]\n Y = np.c_[target_list]\n\n Y_num = np.zeros((Y.shape[0]))\n for i in range(Y.shape[0]):\n Y_num[i] = np.argmax(Y[i])\n\n x_train, x_test, y_train, y_test = train_test_split(X, Y_num, test_size = 0.2)\n\n return x_train, x_test, y_train, y_test","def _int64_array_feature(value):\n return tf.train.Feature(int64_list=tf.train.Int64List(value=value))","def persons_gi(request):\n arr = np.array([[100, 0, 200],\n [0, 250, 50]])\n return arr","def _build(self):\n ary = np.zeros( (3,3,3), float )\n ary[0,0,0] = ary[1,1,1] = ary[0,1,2] = ary[1,0,2] = 1.\n ary[0,2,0] = ary[0,2,2] = ary[2,0,0] = ary[2,0,2] = 0.5\n ary[1,2,1] = ary[1,2,2] = ary[2,1,1] = ary[2,1,2] = 0.5\n ary[2,2,0] = ary[2,2,1] = 0.25\n ary[2,2,2] = 0.5\n return ary","def createIndivitual(self) -> Dict[str, Any]:\n ind = {\n \"genome\": {\n key: numpy.random.randint(0, len(value), size=self.ref_count[key]) for (\n key, value) in self.grammar.items()\n },\n \"fitness\": None,\n \"fenotype\": None,\n }\n return ind","def gen_values(self):","def _buildArray(self):\n if len(self.synth_spec.components) == 0:\n self.array = np.zeros(len(self.synth_spec.x))\n else:\n y = []\n for comp in self.synth_spec.components:\n y += [[comp.function(x) for x in self.synth_spec.x]]\n self.array = np.array(y)","def numbers_identity() -> np.array:\r\n # Temporary dataframe to compare numbers for item pairs\r\n identity = pd.DataFrame()\r\n # Look up values by respective row indexes\r\n identity['item_1'] = data.iloc[pairs['idx_1'], :]['title'].values\r\n identity['item_2'] = data.iloc[pairs['idx_2'], :]['title'].values\r\n # Extract numbers and convert them to space-delimited string\r\n identity['nums_1'] = identity['item_1'].apply(lambda x: ' '.join(re.findall(r'\\d+', x)))\r\n identity['nums_2'] = identity['item_2'].apply(lambda x: ' '.join(re.findall(r'\\d+', x)))\r\n # Binary column signifying match or mismatch\r\n identity['match'] = (identity['nums_1'] == identity['nums_2']).astype('int')\r\n return identity['match'].values","def __data_generation(self, list_ids_temp):\r\n # 'Generates data containing batch_size samples' # X : (n_samples, *dim, n_channels)\r\n # Initialization\r\n X = np.empty((self.batch_size, *self.dim, self.n_channels))\r\n y = np.empty(self.batch_size, dtype = int)\r\n\r\n # Get data from .mat files\r\n for i, ID in enumerate(list_ids_temp):\r\n with h5py.File(ID) as file:\r\n _data = list(file['sequences'])\r\n\r\n # Convert to .mat structure to numpy array\r\n _npData = np.array(_data)\r\n _allSequences = np.transpose(_npData)\r\n\r\n # Reshape the numpy array to size : ( # of sequences, # of rows, # of columns, # of channels)\r\n X[i,] = np.reshape(_allSequences, (15, 16, 3200, 1)) # sequences\r\n\r\n # Store class\r\n y[i] = self.labels[ID]\r\n\r\n return X, tf.keras.utils.to_categorical(y, num_classes = self.n_classes)","def generate_real_samples(dataset : np.ndarray, patch_shape : int) -> np.ndarray:\n y = generate_patch_labels(len(dataset), patch_shape, label=1)\n return dataset, y","def convert_int_data(lines):\n tagdict = load('help/tagsets/upenn_tagset.pickle')\n list_tags = list(tagdict.keys()) # Get the list of all the tags.\n X, Y = [], [] # Creation of the array\n for j in range(len(lines)):\n line = lines[j]\n if len(line) >= 5: # We want the word in the middle of five words\n index = np.random.random_integers(low=2, high=len(line) - 3) # Take the index of the word to be choosen\n neighbours_words = [line[i] for i in (index - 2, index - 1, index + 1, index + 2)] # Extract the words\n Y.append(one_hot_encoding(lines[j][index], list_tags)) # Append the target to the array\n sample = []\n for word in neighbours_words:\n sample.append(one_hot_encoding(word, list_tags).tolist())\n X.append(sample) # Append the 4 neighbouring words\n\n return np.array(X), np.array(Y)","def test_array(self):\n htype = h5t.py_create(('f',(2,2)))\n self.assertIsInstance(htype, h5t.TypeArrayID)\n self.assertEqual(htype.get_array_dims(), (2,2))","def generate_data(groups):\n # get path list for the intended classification problem\n input_paths = generate_input_list(groups) \n X_lst = []\n y = []\n for p in input_paths:\n dp = pd.read_csv(p, sep = '\\t') #datapoint\n # Normalization \n # norm = lambda x: (x - x.mean()) / x.std()\n # dp = dp.apply(norm)\n # Min-Max scaling \n #dp_norm = (dp - dp.min()) / (dp.max() - dp.min())\n #dp = dp_norm.values\n if dp.isnull().sum().sum()>0:\n# print(p, dp.isnull().sum().sum())\n continue\n dp = dp.drop(['time'], axis = 1) \n dp = dp.iloc[:1600:4]\n\n if dp.isnull().sum().sum()>0:\n# print('after norm',p, dp.isnull().sum().sum())\n continue\n dp = dp.values\n\n X_lst.append(dp)\n sample_y = get_target(p, text= True)\n y.append(sample_y)\n X = np.stack(X_lst, axis=0)\n \n # convert y into int 0 and 1\n encoder = LabelEncoder()\n encoder.fit(y)\n y = encoder.transform(y)\n y_dummy = y\n # convert y into one-hot encoding\n if len(groups)>2:\n y_dummy = pd.get_dummies(y)\n y_dummy = y_dummy.values\n return X, y , y_dummy","def create_label_array(files_list):\n lab_array = np.array([np.array(turn_age_into_vector(find_age(file))) for file in files_list])\n return lab_array","def samples(self, gp):\r\n orig_shape = gp.shape\r\n gp = gp.flatten()\r\n ns = np.ones_like(gp, dtype=int)\r\n Ysim = np.random.binomial(ns, self.gp_link.transf(gp))\r\n return Ysim.reshape(orig_shape)","def import_data(path, num_examples):\n data = np.empty((num_examples, 5), dtype=\"float128\")\n y = np.empty((num_examples, 1), dtype=\"float128\")\n\n with open(path, 'r') as f:\n i = 0\n for line in f:\n example = []\n terms = line.strip().split(',')\n for j in range(len(terms)):\n if j == 4:\n y[i] = 2 * float(terms[j]) - 1\n else:\n example.append(float(terms[j]))\n data[i, 1:] = example\n data[i, 0] = 1\n i += 1\n\n data = normalize(np.asmatrix(data), axis=0)\n return [data, np.asmatrix(y)]","def example_generator(self, mode: str):\n raise NotImplementedError","def load_examples(filename):\r\n data = np.load(filename)\r\n return data['examples'], int(data['srate'])","def load_examples(filename):\r\n data = np.load(filename)\r\n return data['examples'], int(data['srate'])","def var_array_generator(array):\n vars = []\n for cen in array:\n iteration_var = np.var(np.array(cen))\n vars.append(iteration_var)\n\n vars = np.array(vars)\n return vars","def example():\n sampler = DoomSampler()\n # Current architecture works on batches of 32 levels\n # Noise shape is (batch_size, 100)\n noise_shape = [32, 100]\n # Input Feature vector shape is (batch_size, 7) - Refer to DoomLevelsGAN/network_architecture.py\n feat_shape = [32, 7]\n\n # Generating random noise and input features as example\n noise = np.random.random(size=noise_shape)\n input_features = np.random.random(size=feat_shape)\n out_features = sampler.get_features_of(noise, input_features)\n\n # Retrieving samples\n levels = sampler.last_generated_samples\n\n # Printing feature values\n for f_name, f_list in out_features.items():\n print(\"Feature: {} \\n {}\".format(f_name, f_list))","def generateNumbersArr(mines, num_rows, num_cols):\n minesIn2D = [convertFrom1Dto2D(mine, num_cols) for mine in mines] \n minesSet = set(minesIn2D) #set of tuples\n\n #initialize a 2D array\n #newArr = new Array(rows).fill(0).map(() => new Array(cols).fill(0));\n newArr = np.zeros(shape=(num_rows, num_cols))\n for i in range(num_rows):\n for j in range(num_cols):\n if ((i, j) in minesSet):\n newArr[i][j]=9\n else:\n newArr[i][j]=numNeighbors(minesSet, i, j, num_cols, num_rows)\n return newArr","def np_ints(self):\n # A numpy-array packaging of the integer input parameters\n return np.array([self.mode, self.n_freqs], dtype=np.int32)","def _generate_examples(self, filepath):\n logger.info(\"generating examples from = %s\", filepath)\n with open(filepath, encoding=\"utf-8\") as f:\n qasper = json.load(f)\n for id_ in qasper:\n qasper[id_][\"id\"] = id_\n yield id_, qasper[id_]","def load_values(demo):\r\n if demo:\r\n return Matrix(5, 5, [Node(i, v) for i, v in enumerate([\r\n 131, 673, 234, 103, 18,\r\n 201, 96, 342, 965, 150,\r\n 630, 803, 746, 422, 111,\r\n 537, 699, 497, 121, 956,\r\n 805, 732, 524, 37, 331])])\r\n else:\r\n with open(_MATRIX, 'r') as flr:\r\n digits = flr.read()\r\n digits = [int(i.strip()) for i in digits.strip().\r\n replace('\\n', ' ').replace(',', ' ').split(' ')]\r\n\r\n return Matrix(80, 80, [Node(i, v) for i, v in enumerate(digits)])","def generate_inference_dataset(self, inference_directory: str) -> (List[str], List[np.ndarray]):\n example_paths = [os.path.join(inference_directory, file_name) for file_name in\n os.listdir(inference_directory) if file_name.endswith('.npy')]\n examples = []\n for example_path in example_paths:\n lightcurve = np.load(example_path)\n lightcurve = self.preprocess_and_augment_lightcurve(lightcurve)\n examples.append(lightcurve.astype(np.float32))\n return example_paths, examples","def create_data(data_size,heme, nucleotide, control, steroid,data_total,path_to_data):\n\n os.chdir(path_to_data)\n\n x_array = np.zeros(shape = (data_size,14,32,32,32))\n\n y_array = np.zeros(shape = data_size)\n\n print(\"data size = \", data_size)\n\n #training set :\n\n file_count = 0\n\n for file in data_total:\n\n y_array[file_count]= find_class(str(file), heme, nucleotide, control, steroid)\n\n x_array[file_count] = np.load(str(file+\".npy\"))\n\n file_count+=1\n\n\n return (x_array, y_array)","def alt_allele_indices_from_example(example):\n features = example.features.feature\n val = features['alt_allele_indices/encoded'].bytes_list.value[0]\n # Extract the encoded proto into unsigned integers and convert to regular ints\n mapped = [int(x) for x in np.frombuffer(val, dtype=np.uint8)]\n # Format is [<field id + type>, <number of elements in array>, ...<array>].\n # Extract the array only, leaving out the metadata.\n return mapped[2:]","def build_input_data(sentences, vocabulary):\n index_list = []\n for word in sentences:\n tmp = vocabulary[word]\n index_list.append(tmp)\n x = np.array(index_list)\n return x","def inputs(self) -> Sequence[jnp.ndarray]:\n pass","def i(self):\n return np.array(self._sequence)","def instantiate_examples(self, examples : [dict]) -> [dict]:\n raise NotImplementedError()","def gen_instances(positive_flows: list, negative_flows: list, simulate: bool = False, char_wb: bool = False,\n add_taint: bool = False) -> (\n list, [[float]], np.array, np.array):\n logger.info('lenPos: %d', len(positive_flows))\n logger.info('lenNeg: %d', len(negative_flows))\n docs = Analyzer.gen_docs(positive_flows, char_wb, add_taint=add_taint)\n docs = docs + (Analyzer.gen_docs(negative_flows, char_wb, add_taint=add_taint))\n if simulate and len(negative_flows) == 0:\n docs = docs + Learner.simulate_flows(len(positive_flows), 0)\n samples = []\n samples_num = []\n labels = []\n real_labels = []\n for doc in docs:\n samples.append(doc.doc)\n numeric_fea_val = []\n for x in doc.numeric_features:\n if isinstance(x, list):\n for val in x:\n if val == '?':\n logger.warning('Unknown value appeared in stats feature!')\n val = 0.0\n numeric_fea_val.append(float(val))\n else:\n numeric_fea_val.append(float(x))\n samples_num.append(numeric_fea_val)\n labels.append(doc.label)\n real_labels.append(doc.real_label)\n logger.debug(str(doc.label) + \": \" + doc.doc)\n\n return samples, samples_num, np.array(labels), np.array(real_labels)","def data():\n return RaggedArray(\n [[0, 1], [1, 2, 3, 4], [], [-1, -2], []]*20, dtype='float64')","def get_count_train(datagen):\n y_train = np.array([])\n\n for i in range(len(datagen)):\n y_train = np.append(y_train, datagen[i][1])\n \n age_train, count_train = np.unique(y_train, return_counts=True)\n \n return count_train","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 fake_data_as_array(self, time_steps=10000, currencies_num=4, rand_seed=101):\n np.random.seed(rand_seed)\n data = np.zeros((time_steps, currencies_num, 4))\n time_scale = np.arange(0, time_steps, 1)\n ones_array = np.ones(time_steps)\n labels = {}\n for idx in range(currencies_num):\n labels[idx] = \"fake_\"+str(idx)\n base_data = np.sin(time_scale/200)*np.sin(time_scale/20) + 1.1*ones_array + np.random.rand(1)*ones_array\n for olhc in range(4):\n data[:, idx, olhc] = base_data + olhc/4*ones_array\n\n return data, labels","def arrays(self, select_output):\n pass","def init_output_mat(self, y_list):","def test_get_nsamples_array():\n test_file = os.path.join(DATA_PATH, \"paper_test_file.uvh5\")\n test_uv = UVData()\n test_uv.read(test_file)\n\n baseline_array = np.array(list(set(test_uv.baseline_array)))\n nsample_array = utils.get_nsample_array(test_uv, reds=baseline_array)\n\n test_samples = np.zeros(\n (test_uv.Npols, test_uv.Nbls, test_uv.Ntimes, test_uv.Nfreqs),\n dtype=np.float32,\n )\n\n pol_array = uvutils.polnum2str(test_uv.polarization_array)\n for pol_cnt, pol in enumerate(pol_array):\n for cnt, baseline in enumerate(list(set(test_uv.baseline_array))):\n ant_1, ant_2 = test_uv.baseline_to_antnums(baseline)\n test_samples[pol_cnt, cnt] = test_uv.get_nsamples(ant_1, ant_2)\n\n test_samples = np.squeeze(test_samples, axis=0)\n assert np.all(test_samples == nsample_array)","def __data_generation(self, list_IDs_temp):\n\n # Initialization\n X = np.empty((self.batch_size, self.grid_dim, self.grid_dim, self.grid_dim, self.n_channels))\n y = np.empty(self.batch_size, dtype=int)\n\n # Generate data\n for i, ID in enumerate(list_IDs_temp):\n # Store sample\n X[i], y[i] = pro_lig_reader_sample(ID[0], ID[1], self.grid_size, self.n_channels, self.grid_resolution)\n return X, keras.utils.to_categorical(y, num_classes=self.n_classes)","def get_initial_array(events, slots, seed=None):\n if seed is not None:\n np.random.seed(seed)\n\n m = len(events)\n n = len(slots)\n X = np.zeros((m, n))\n for i, row in enumerate(X):\n X[i, i] = 1\n np.random.shuffle(X)\n return X","def construct(frequency_array):\n tree = [0] * (len(frequency_array) + 1)\n for index, frequency in enumerate(frequency_array):\n updatebit(tree, index, frequency)\n print tree\n return tree","def init_expected_outputs(data, no_labels=26):\n expected_outputs = np.zeros((data.shape[0], no_labels))\n \n for i in range(0,data.shape[0]): \n expected_outputs[i, data[i].astype(int)]=1\n\n return expected_outputs","def get_train_inputs(self, example):\n return example","def generate():","def generate(inputFilename, outputFilename = defaultFileName, \n sizeOfReducedSample = DEFSIZEOFREDUCEDSAMPLE, \n centerEta = DEFCENTERETA, centerPhi = DEFCENTERPHI): \n listOfSignals = convert(inputFilename)\n arrayOfSignals = np.array(listOfSignals)\n arrayOfSignals.shape\n np.save(outputFilename, arrayOfSignals, allow_pickle=False)\n print(\"npy array name: \",outputFilename)","def _generate_examples(self, images_path, annotations_path):\n caption_file = '/captions_val2014.json'\n with tf.io.gfile.GFile(annotations_path + caption_file) as f:\n data = json.load(f)\n path_head = images_path + '/COCO_val2014_'\n ann = data['annotations'] # Contains annotations\n \n img_names = [path_head + '%012d.jpg' % i['image_id'] for i in ann] \n captions = ['<start> ' + i['caption'] + ' <end>' for i in ann]\n ids = [i['id'] for i in ann]\n \n # The above lines create the captions (start and end tokens), the \n # image names (which consist of the path head and a 12 digit number,\n # right-aligned with the id), and the id to distinguish each unique image.\n\n for (i, name) in enumerate(img_names):\n yield ids[i], {\n 'image': name,\n 'caption': captions[i]\n }","def __data_generation(self, list_IDs_temp):\n X = np.empty((self.batch_size, self.dim))\n Y = np.empty((self.batch_size, self.word_length, self.hot_enc_len))\n\n # Generate data\n for i, ID in enumerate(list_IDs_temp): # The enumerate() function adds a counter to an iterable.\n word = self.labels.index2word[ID]\n # Store sample\n X[i, ] = self.labels[word]\n # Store class\n char_hot_enc_pad = self.word_2_seq_hot_enc_sample(word)\n Y[i] = char_hot_enc_pad\n return X.reshape(self.batch_size, self.dim), Y","def _samples(self):\n finite_types = \\\n [QuiverMutationType(t) for t in [['A', 1], ['A', 5], ['B', 2], ['B', 5],\n ['C', 3], ['C', 5], ['D', 2], ['D', 5],\n [\"E\", 6], [\"E\", 7], [\"E\", 8], [\"F\", 4],\n [\"G\", 2]]]\n affine_types = \\\n [QuiverMutationType(t) for t in [['A', [1,1], 1], ['A', [4,5], 1], ['D', 4, 1], ['BB', 5, 1]]]\n elliptic_types = \\\n [QuiverMutationType(t) for t in [['E', 6, [1,1]], ['E', 7, [1,1]]]]\n mutation_finite_types = \\\n [QuiverMutationType(t) for t in [['R2',(1,5)], ['R2',(3,5)]]]\n mutation_infinite_types = \\\n [QuiverMutationType(t) for t in [['E',10], ['BE',5], ['GR',(3,10)], ['T',(3,3,4)]]]\n\n return finite_types + affine_types + elliptic_types + mutation_finite_types + mutation_infinite_types","def __init__(self):\n self.size = 0\n self.array = []\n self.val2i = {}","def _generate_examples(\n self, mode: str) -> Generator[ProcessedExample, None, None]:\n if mode not in self._json_dict:\n self._json_dict[mode] = collections.defaultdict(list)\n generator = self.builder_config.example_generator(mode)\n for example in generator:\n img_id, processed_example = self._convert_raw_example(\n self._json_dict[mode], example)\n yield img_id, processed_example","def _instantiate_vars(labels: np.ndarray):\n n = len(labels)\n if len(set(labels)) == n:\n index_seed = np.arange(n)\n index_remain = np.arange(n)\n else:\n index_seed = np.argwhere(labels >= 0).ravel()\n index_remain = np.argwhere(labels < 0).ravel()\n labels = labels[index_seed]\n return index_seed.astype(np.int32), index_remain.astype(np.int32), labels.astype(np.int32)","def GetEdgeArray(self, p_int):\n ...","def _default_sample_ids(path: PathType) -> ArrayLike:\n with bgen_file(path) as bgen:\n if bgen.contain_samples:\n return bgen.read_samples()\n else:\n return np.char.add(b\"sample_\", np.arange(bgen.nsamples).astype(\"S\"))","def __data_generation(self, list_IDs_temp):\n X1 = np.empty((len(list_IDs_temp), *self.dim, self.n_channels))\n X2 = np.empty((len(list_IDs_temp), *self.dim, self.n_channels))\n X3 = np.empty((len(list_IDs_temp), *self.dim, self.n_channels))\n X4 = np.empty((len(list_IDs_temp), *self.dim, self.n_channels))\n y = np.empty(len(list_IDs_temp), dtype=int)\n\n for i, ID_instance in enumerate(list_IDs_temp):\n\n with (self.path_instances / ID_instance).open('rb') as input:\n instance = pickle.load(input)\n\n frames = instance['frames']\n\n label = instance['crossing']\n\n #Normalización de los frames\n if self.normalized:\n frames = frames * 1 / 255\n\n X1[i, ] = frames[0]\n X2[i, ] = frames[1]\n X3[i, ] = frames[2]\n X4[i, ] = frames[3]\n y[i] = label\n\n return [X1, X2, X3, X4], to_categorical(y, num_classes=self.n_classes)","def process(self, example):\n self.get_counter(\"examples-total\").inc()\n label = example_util.get_bytes_feature(example, _LABEL_COLUMN)[0]\n self.get_counter(\"examples-{}\".format(label)).inc()\n yield example","def dev_sample_generator(self, fi):\n for line in fi:\n line_list = line.split(\" \")\n label = int(line_list[-1])\n sequence = np.array(line_list[:-1], dtype=np.intp)\n yield sequence, sequence.shape[0], np.unique(sequence).shape[0], label","def construct_dataset(tri2index, num_examples=100, qap_path=\"./dataset/qa_pairs.dump\",\n label_path=\"./dataset/labels.dump\"):\n Xpair = []\n Y = []\n with open(DATA_PATH) as f:\n lines = csv.reader(f, delimiter=\"\\t\")\n i = 0\n for line in lines:\n q_processed = char_trigram_creator(preprocess(line[3]))\n a_processed = char_trigram_creator(preprocess(line[4]))\n # get the index of the array\n q_index = [tri2index[qp] for qp in q_processed]\n a_index = [tri2index[ap] for ap in a_processed]\n # append dataset\n Xpair.append((q_index, a_index)) # list of tuples\n Y.append(line[5].replace(\"\\n\", \"\"))\n # if i >= num_examples : break\n i += 1\n f.close()\n # shuffle the dataset\n Xs = np.asarray(Xpair[1:]) # discard the header\n Ys = np.asarray(Y[1:])\n perm = np.random.permutation(len(Xs))\n Xs = Xs[perm]\n Ys = Ys[perm]\n pickle.dump(Xs, open(qap_path, \"wb\"))\n pickle.dump(Ys, open(label_path, \"wb\"))","def get_data(generator, random, bench_id):\n x_train, y_train, x_test, y_test = generator(random, bench_id)\n x_train = np.c_[np.ones(len(x_train)), x_train]\n x_test = np.c_[np.ones(len(x_test)), x_test]\n return x_train, y_train, x_test, y_test","def _random_encoding(examples):\n return np.random.normal(size=(len(examples), 7))"],"string":"[\n \"def originalData(self): \\n self.__exampleIndices = array(list(range(0, self.__numExamples)))\",\n \"def data_gen(size, p):\\n #print(np.random.get_state()[1][0])\\n random_table = np.random.binomial(size = size, p = p, n = 1)\\n test_array = np.zeros((size, 2), dtype = int)\\n for i in range(size):\\n test_array[i,0] = i\\n test_array[i,1] = random_table[i]\\n return test_array\",\n \"def create_array( n ):\",\n \"def get_example_data():\\n nnz = np.random.randint(FLAGS.min_nnz, FLAGS.max_nnz)\\n nz_idx = np.random.randint(FLAGS.dense_size, size=nnz)\\n nz_idx = np.unique(nz_idx)\\n nz_values = np.random.uniform(10, size=nz_idx.size)\\n label = np.random.randint(FLAGS.num_classes)\\n return nz_idx, nz_values, label\",\n \"def generate_data(example_size):\\n\\n\\n # A placeholder for data.\\n x = np.zeros((example_size, 2))\\n\\n # Randomly selects one of two classes for each example.\\n class_id = np.random.randint(2, size=example_size)\\n\\n # Generates data for the class 0.\\n class_0_idx = np.where(class_id == 0)\\n mean0 = [0.0, 1.0]\\n cov0 = [[0.4, 0.0], [0.0, 1.0]]\\n x[class_0_idx[0], :] = np.random.multivariate_normal(\\n mean0, cov0, class_0_idx[0].shape[0])\\n\\n # Generates data for the class 0.\\n class_1_idx = np.where(class_id == 1)\\n mean1 = [1.0, 2.0]\\n cov1 = [[1.0, 0.0], [0.0, 0.4]]\\n x[class_1_idx[0], :] = np.random.multivariate_normal(\\n mean1, cov1, class_1_idx[0].shape[0])\\n\\n return (x, class_id)\",\n \"def array(self):\",\n \"def test_30_test_init_array(self, persons_gi):\\n example = Example(groups=7, origins=5)\\n\\n example.init_array('param_g', 7)\\n assert example.param_g.shape == (7, )\",\n \"def _create_counterexamples(self, x_concept):\\n n = x_concept.shape[0]\\n height = x_concept.shape[1]\\n width = x_concept.shape[2]\\n channels = x_concept.shape[3]\\n counterexamples = []\\n for i in range(0, n):\\n counterexamples.append(\\n np.rint(np.random.rand(height, width, channels) * 255)\\n )\\n return np.array(counterexamples)\",\n \"def gen_num_seq(nums):\\n X = np.zeros([nums, 10, 20], dtype=float)\\n y = np.zeros([nums, 10, 20], dtype=float)\\n for i in range(nums):\\n start = np.random.randint(0, 10)\\n num_seq = np.arange(start, start + 10)\\n X[i] = to_categorical(num_seq, n_col=20)\\n y[i] = np.roll(X[i], -1, axis=0)\\n y[:, -1, 1] = 1 # Mark endpoint as 1\\n return X, y\",\n \"def basic_array_creation():\\n print('From normal creation')\\n arr: pa.Array = pa.array([1, 2, 3, 4, 5], type=pa.int8())\\n print(arr)\\n\\n print('From pandas series')\\n arr: pa.Array = pa.Array.from_pandas(pd.Series([1, 2, 3, 4, 5]))\\n print(arr)\",\n \"def generate(\\n self,\\n num_nodes: int,\\n num_edges: int,\\n is_directed: bool,\\n *args,\\n return_node_ids: bool = False,\\n **kwargs,\\n ) -> np.ndarray:\\n raise NotImplementedError()\",\n \"def convert_to_array(self): \\n self.reads = np.asarray(self.reads, dtype=\\\"int64\\\")\\n self.sampling=True\",\n \"def _get_rand_array(self):\\n pass\",\n \"def num_54():\\n frmt = \\\"\\\"\\\"\\n :{}\\n :Generate Data that conform to a uniform distribution.\\n :\\n :Class values: {}\\n :Population size: {}\\n :Results:\\n : values:\\n {}\\n : table:\\n {}\\n : histogram: (class, frequency)\\n {}\\n :Then use NumPyArrayToTable to get your table.\\n \\\"\\\"\\\"\\n # import numpy as np\\n st = 1\\n end = 7\\n vals = np.arange(st,end)\\n reps = 10\\n z = np.repeat(vals,reps)\\n np.random.shuffle(z)\\n ID = np.arange(len(z))\\n tbl = np.array(list(zip(ID, z)), \\n dtype = [('ID', 'int'), ('Class', 'int')])\\n h = np.histogram(z, np.arange(st, end+1))\\n h = np.array(list(zip(h[1], h[0])))\\n pad = \\\" \\\"\\n args =[num_54.__doc__, vals, reps*len(vals),\\n indent(str(z.reshape(3,20)), pad),\\n indent(str(tbl), pad), indent(str(h), pad)]\\n print(dedent(frmt).format(*args))\",\n \"def test_ford_fulkerson_algo() -> np.ndarray:\\r\\n res = ford_fulkerson_algorithm(np.array(ex_sample_graph), 0, 10)\\r\\n print(\\\"Result: \\\")\\r\\n print(res)\\r\\n return res\",\n \"def example_to_data(self, example):\\n raise NotImplementedError\",\n \"def gen_graph(self):\",\n \"def get_image_array_from_example(example):\\n features = example.features.feature\\n img = features['image/encoded'].bytes_list.value[0]\\n shape = features['image/shape'].int64_list.value[0:3]\\n return np.frombuffer(img, np.uint8).reshape(shape)\",\n \"def generate_fake_samples(generator_model : Model, dataset : np.ndarray, patch_shape : int) -> np.ndarray:\\n X = generator_model.predict(dataset)\\n y = generate_patch_labels(len(X), patch_shape, label=0)\\n return X, y\",\n \"def __init__(self):\\n self.arr = array(\\\"i\\\")\",\n \"def gcode_interpreter(file_gcode):\\n\\tgcode_raw = read_gcode(file_gcode)\\n\\n\\tdim = (11, 11)\\n\\tarray = convert_gcode_to_array(gcode_raw, dim)\\n\\n\\tprint array\",\n \"def __array__(self):\\n return pa.column(\\\"dummy\\\", self.data).to_pandas().values\",\n \"def gen_numpy(path,smilist):\\n import numpy as np\\n from get_metadata import get_metadata\\n from descriptor import Morgan2D\\n nb = 1024\\n trainlen = len(smilist)\\n train_XY = np.zeros((trainlen, nb + 5))\\n local_X = np.zeros((nb + 5))\\n for num, smi in enumerate(smilist):\\n \\n etot, dipole, quadrapole, solv, mp = get_metadata(path,smi)\\n ecfp = Morgan2D(smi,2,nb)\\n local_X[0:nb] = ecfp\\n local_X[-5] = etot\\n local_X[-4] = dipole\\n local_X[-3] = quadrapole\\n local_X[-2] = solv\\n local_X[-1] = mp \\n train_XY[num, :] = local_X\\n \\n return train_XY\",\n \"def create_array(uri: str):\\n dim1 = tiledb.Dim(\\\"d1\\\", domain=(1, 5))\\n dim2 = tiledb.Dim(\\\"d2\\\", domain=(1, 5))\\n dom = tiledb.Domain(dim1, dim2)\\n att = tiledb.Attr(\\\"a1\\\", dtype=np.int64)\\n dim_labels = {\\n 0: {\\\"l1\\\": dim1.create_label_schema(\\\"decreasing\\\", np.int64)},\\n 1: {\\n \\\"l2\\\": dim2.create_label_schema(\\\"increasing\\\", np.int64),\\n \\\"l3\\\": dim2.create_label_schema(\\\"increasing\\\", np.float64),\\n },\\n }\\n schema = tiledb.ArraySchema(domain=dom, attrs=(att,), dim_labels=dim_labels)\\n tiledb.Array.create(uri, schema)\",\n \"def __data_generation(self, list_IDs_temp):\\n # Initialization\\n if self.mirror:\\n X = np.empty(\\n (self.batch_size, *self.dim_in, self.n_channels_in),\\n dtype=\\\"uint8\\\",\\n ) \\n else:\\n X = np.empty(\\n (self.batch_size * len(self.camnames[0]), *self.dim_in, self.n_channels_in),\\n dtype=\\\"uint8\\\",\\n )\\n\\n # We'll need to transpose this later such that channels are last,\\n # but initializaing the array this ways gives us\\n # more flexibility in terms of user-defined array sizes\\\\\\n if self.labelmode == \\\"prob\\\":\\n y = np.empty(\\n (\\n self.batch_size * len(self.camnames[0]),\\n self.n_channels_out,\\n *self.dim_out,\\n ),\\n dtype=\\\"float32\\\",\\n )\\n else:\\n # Just return the targets, without making a meshgrid later\\n y = np.empty(\\n (\\n self.batch_size * len(self.camnames[0]),\\n self.n_channels_out,\\n len(self.dim_out),\\n ),\\n dtype=\\\"float32\\\",\\n )\\n\\n # Generate data\\n cnt = 0\\n for i, ID in enumerate(list_IDs_temp):\\n if \\\"_\\\" in ID:\\n experimentID = int(ID.split(\\\"_\\\")[0])\\n else:\\n # Then we only have one experiment\\n experimentID = 0\\n for _ci, camname in enumerate(self.camnames[experimentID]):\\n # Store sample\\n # TODO(Refactor): This section is tricky to read\\n\\n if not self.mirror or _ci == 0:\\n if self.immode == \\\"video\\\":\\n X[cnt] = self.load_vid_frame(\\n self.labels[ID][\\\"frames\\\"][camname],\\n camname,\\n self.preload,\\n self.extension,\\n )[\\n self.crop_height[0] : self.crop_height[1],\\n self.crop_width[0] : self.crop_width[1],\\n ]\\n elif self.immode == \\\"tif\\\":\\n X[cnt] = self.load_tif_frame(\\n self.labels[ID][\\\"frames\\\"][camname], camname\\n )[\\n self.crop_height[0] : self.crop_height[1],\\n self.crop_width[0] : self.crop_width[1],\\n ]\\n else:\\n raise Exception(\\\"Not a valid image reading mode\\\")\\n\\n # Labels will now be the pixel positions of each joint.\\n # Here, we convert them to\\n # probability maps with a numpy meshgrid operation\\n this_y = np.round(self.labels[ID][\\\"data\\\"][camname])\\n if self.immode == \\\"video\\\":\\n this_y[0, :] = this_y[0, :] - self.crop_width[0]\\n this_y[1, :] = this_y[1, :] - self.crop_height[0]\\n else:\\n raise Exception(\\n \\\"Unsupported image format. Needs to be video files.\\\"\\n )\\n\\n # For 2D, this_y should be size (2, 20)\\n if this_y.shape[1] != self.n_channels_out:\\n # TODO(shape_exception):This should probably be its own\\n # class that inherits from base exception\\n raise Exception(_EXEP_MSG)\\n\\n if self.labelmode == \\\"prob\\\":\\n # Only do this if we actually need the labels --\\n # this is too slow otherwise\\n (x_coord, y_coord) = np.meshgrid(\\n np.arange(self.dim_out[1]), np.arange(self.dim_out[0])\\n )\\n for j in range(self.n_channels_out):\\n # I tested a version of this with numpy broadcasting,\\n # and looping was ~100ms seconds faster for making\\n # 20 maps\\n # In the future, a shortcut might be to \\\"stamp\\\" a\\n # truncated Gaussian pdf onto the images, centered\\n # at the peak\\n y[cnt, j] = np.exp(\\n -(\\n (y_coord - this_y[1, j]) ** 2\\n + (x_coord - this_y[0, j]) ** 2\\n )\\n / (2 * self.out_scale ** 2)\\n )\\n else:\\n y[cnt] = this_y.T\\n\\n cnt = cnt + 1\\n\\n # Move channels last\\n if self.labelmode == \\\"prob\\\":\\n y = np.transpose(y, [0, 2, 3, 1])\\n\\n if self.mirror:\\n # separate the batches from the cameras, and use the cameras as the numebr of channels \\n # to make a single-shot multi-target prediction from a single image\\n y = np.reshape(y, (self.batch_size, len(self.camnames[0]), y.shape[1], y.shape[2]))\\n y = np.transpose(y, [0, 2, 3, 1])\\n else:\\n # One less dimension when not training with probability map targets\\n y = np.transpose(y, [0, 2, 1])\\n\\n if self.downsample > 1:\\n X = processing.downsample_batch(X, fac=self.downsample, method=self.dsmode)\\n if self.labelmode == \\\"prob\\\":\\n y = processing.downsample_batch(\\n y, fac=self.downsample, method=self.dsmode\\n )\\n y /= np.max(np.max(y, axis=1), axis=1)[:, np.newaxis, np.newaxis, :]\\n\\n if self.mono and self.n_channels_in == 3:\\n # Go from 3 to 1 channel using RGB conversion. This will also\\n # work fine if there are just 3 channel grayscale\\n X = X[:, :, :, 0]*0.2125 + \\\\\\n X[:, :, :, 1]*0.7154 + \\\\\\n X[:, :, :, 2]*0.0721\\n\\n X = X[:, :, :, np.newaxis]\\n\\n if self.mono:\\n # Just subtract the mean imagent BGR value, which is as close as we\\n # get to vgg19 normalization\\n X -= 114.67\\n else:\\n X = pp_vgg19(X)\\n return X, y\",\n \"def int2array(line, train=True):\\n example = np.zeros((15, 15, 3), dtype=np.float32)\\n for channel in range(2):\\n intstr = str(bin(int(line[channel]))[2:].zfill(225))\\n tmp = np.fromstring(intstr[::-1], np.int8) - 48\\n tmp = tmp.reshape((15, 15))\\n example[:, :, channel] = tmp.T\\n if train:\\n example[axis(int(line[3]))[0], axis(int(line[3]))[1], 2] = 1.0\\n else:\\n example[:, :, 2] = int(line[2])\\n return example\\n\\n examples = []\\n policies = []\\n values = []\\n\\n for k in range(4):\\n tmp = np.zeros((15, 15, 3), dtype=np.float32)\\n tmp[:] = np.rot90(example, k, (0, 1))\\n rx, ry = axis(np.argmax(tmp[:, :, 2].T))\\n policy = toind(rx, ry)\\n tmp[:, :, 2] = int(line[2])\\n examples.append(tmp)\\n policies.append(policy)\\n values.append(float(line[4]))\\n\\n rev_example = example[::-1, :, :]\\n for k in range(4):\\n tmp = np.zeros((15, 15, 3), dtype=np.float32)\\n tmp[:] = np.rot90(rev_example, k, (0, 1))\\n rx, ry = axis(np.argmax(tmp[:, :, 2].T))\\n policy = toind(rx, ry)\\n tmp[:, :, 2] = int(line[2])\\n examples.append(tmp)\\n policies.append(policy)\\n values.append(float(line[4]))\\n return examples, policies, values\",\n \"def generate_array(hdulist, features, targets):\\n \\\"\\\"\\\"\\n #To do:\\n -get targets and features via .conf file\\n -> use field_names = hdulist_test[1].columns.names\\n \\\"\\\"\\\"\\n\\n '''extract data'''\\n astro_data = hdulist[1].data\\n\\n '''get all float like and feature matching data'''\\n data_float = np.squeeze(np.array([astro_data.field(0)]))\\n for x in range(0, len(astro_data[0])):\\n if isinstance(astro_data.field(x)[1], (int, float, complex)) is True\\\\\\n and x not in targets and x in features:\\n data_float = np.vstack((data_float, np.squeeze(np.array([astro_data.field(x)]))))\\n '''get all and target matching data'''\\n targets_float = np.squeeze(np.array(astro_data.field(targets[0])))\\n for x in range(len(targets)):\\n targets_float = np.vstack((targets_float, np.squeeze(np.array(astro_data.field(targets[x])))))\\n print('Selected Feature: ' + hdulist_test[1].columns.names[targets[x]])\\n '''return'''\\n return data_float, targets_float\",\n \"def _create_example(self):\\n source = np.random.randn(self.batch_size, self.max_decode_length,\\n self.input_depth)\\n source_len = np.random.randint(0, self.max_decode_length, [self.batch_size])\\n target_len = np.random.randint(0, self.max_decode_length * 2,\\n [self.batch_size])\\n target = np.random.randn(self.batch_size,\\n np.max(target_len), self.input_depth)\\n labels = np.random.randint(0, self.vocab_size,\\n [self.batch_size, np.max(target_len) - 1])\\n\\n example_ = namedtuple(\\n \\\"Example\\\", [\\\"source\\\", \\\"source_len\\\", \\\"target\\\", \\\"target_len\\\", \\\"labels\\\"])\\n return example_(source, source_len, target, target_len, labels)\",\n \"def _img_array_feature(value):\\n return tf.train.Feature(int64_list=tf.train.Int64List(value=value.ravel()))\",\n \"def _img_array_feature(value):\\n return tf.train.Feature(int64_list=tf.train.Int64List(value=value.ravel()))\",\n \"def _transformEx(self,example):\\n x = []\\n x.extend(example) \\n x.append(1)\\n return x,example.label\",\n \"def generate_converted():\\n for example in generate_examples(data_path):\\n input_ids, label_ids = encode_fn(\\n example['tokens'], example['labels'])\\n\\n yield {\\n 'input_ids': input_ids,\\n 'label_ids': label_ids\\n }\",\n \"def gen_data(self):\\n\\n # 1，read the source text\\n inputs, labels = self.read_data()\\n print(\\\"read finished\\\")\\n\\n # 2. word label index\\n word_to_index, label_to_index = self.gen_word_label_index()\\n # print(\\\"word_to_index\\\",word_to_index)\\n # print(\\\"label_to_index\\\",label_to_index)\\n print(\\\"vocab process finished\\\")\\n #\\n # 3，input to index\\n inputs_idx = self.trans_to_index(inputs, word_to_index)\\n # print((inputs_idx))\\n print(\\\"index transform finished\\\")\\n #\\n # 4, padding\\n inputs_idx = self.padding(inputs_idx, self._sequence_length)\\n # print(inputs_idx)\\n print(\\\"padding finished\\\")\\n\\n # 6，label to index\\n labels_idx = self.trans_label_to_index(labels, label_to_index)\\n print(\\\"label index transform finished\\\")\\n\\n return np.array(inputs_idx), np.array(labels_idx)\",\n \"def load_test_data():\\n # X has dim (USER_COUNT x ITEM_COUNT)\\n USER_COUNT = 10000\\n ITEM_COUNT = 1000\\n\\n ratings = load_ratings_from_file_path(get_test_file_path())\\n\\n X = np.zeros([USER_COUNT, ITEM_COUNT])\\n for (row, col, rating) in ratings:\\n X[row, col] = rating\\n return X\",\n \"def test_id_array(self):\\n arr = vtk.vtkIdTypeArray()\\n arr.SetNumberOfTuples(10)\\n for i in range(10):\\n arr.SetValue(i, i)\\n\\n np = array_handler.vtk2array(arr)\\n self.assertEqual(numpy.all(np == range(10)), True)\",\n \"def generate_samples(self, n_samples):\",\n \"def generate_samples(self, n_samples):\",\n \"def generate_dataset(output_dim=14, num_examples=10000):\\n def int2vec(x, dim=output_dim):\\n out = np.zeros(dim)\\n binrep = np.array(list(np.binary_repr(x))).astype('int')\\n out[-len(binrep):] = binrep\\n return out\\n\\n x_left_int = (np.random.rand(num_examples) * 2 ** (output_dim - 1)).astype('int')\\n x_right_int = (np.random.rand(num_examples) * 2 ** (output_dim - 1)).astype('int')\\n y_int = x_left_int + x_right_int\\n\\n x = list()\\n for i in range(len(x_left_int)):\\n x.append(np.concatenate((int2vec(x_left_int[i]), int2vec(x_right_int[i]))))\\n\\n y = list()\\n for i in range(len(y_int)):\\n y.append(int2vec(y_int[i]))\\n\\n x = np.array(x)\\n y = np.array(y)\\n return x, y\",\n \"def _generate_examples(self, filepath):\\n # Simultaneously iterating through the different data sets in the hdf5\\n # file is >100x slower and the data set is small (26.7MB). Hence, we first\\n # load everything into memory before yielding the samples.\\n with tfds.core.lazy_imports.h5py.File(filepath, \\\"r\\\") as h5dataset:\\n image_array = np.array(h5dataset[\\\"imgs\\\"])\\n class_array = np.array(h5dataset[\\\"latents\\\"][\\\"classes\\\"])\\n values_array = np.array(h5dataset[\\\"latents\\\"][\\\"values\\\"])\\n\\n for i, (image, classes, values) in enumerate(moves.zip(\\n image_array, class_array, values_array)):\\n record = dict(\\n image=np.expand_dims(image, -1),\\n label_shape=classes[1],\\n label_scale=classes[2],\\n label_orientation=classes[3],\\n label_x_position=classes[4],\\n label_y_position=classes[5],\\n value_shape=values[1],\\n value_scale=values[2],\\n value_orientation=values[3],\\n value_x_position=values[4],\\n value_y_position=values[5])\\n if self.version > \\\"2.0.0\\\":\\n record[\\\"id\\\"] = \\\"{:06d}\\\".format(i)\\n yield i, record\",\n \"def easydatagen():\\n\\n # Reading in the training file\\n data = pd.read_json('train.json')\\n\\n # The set of different cuisines\\n cuisines = data.cuisine.unique()\\n\\n # To find the different ingredients, we need to clean them up a little.\\n def clean(string) :\\n s = string.replace('-',' ') # read low-fat the same as low fat\\n s = string.replace('&', 'and') # read & and and as the same\\n s = re.sub('\\\\((.*?)\\\\)', '', s) # remove everythin g in brackets\\n s = re.sub('\\\\d{1,2}\\\\%', '', s) # remove things of the form d% or dd%, where d is a digit\\n s = ' '.join(s.split()) # remove extra white spaces\\n\\n return s\\n\\n ing_list = data.ingredients.values.tolist()\\n raw_ingredients = [clean(x) for ing in ing_list for x in ing]\\n\\n ingredients = sorted(set(raw_ingredients))\\n\\n # build a dictionary that to each ingredient assigns its index\\n ingredient_index = {}\\n for i in range(0,len(ingredients)) :\\n ingredient_index[ingredients[i]] = i\\n\\n # the same for cuisines\\n cuisine_index = {}\\n for i in range(0, len(cuisines)) :\\n cuisine_index[cuisines[i]] = i\\n\\n def ingredients_to_vector(ings) :\\n vect = np.zeros(len(ingredients))\\n for ing in ings :\\n vect[ingredient_index[clean(ing)]] = 1\\n\\n return vect\\n\\n def cuisine_to_vector(cus) :\\n vect = np.zeros(20)\\n vect[cuisine_index[cus]] = 1\\n return vect\\n\\n vect_list = [ingredients_to_vector(ing) for ing in ing_list]\\n target_list = [cuisine_to_vector(cus) for cus in data.cuisine.values.tolist()]\\n\\n # Define training data\\n X = np.c_[vect_list]\\n Y = np.c_[target_list]\\n\\n Y_num = np.zeros((Y.shape[0]))\\n for i in range(Y.shape[0]):\\n Y_num[i] = np.argmax(Y[i])\\n\\n x_train, x_test, y_train, y_test = train_test_split(X, Y_num, test_size = 0.2)\\n\\n return x_train, x_test, y_train, y_test\",\n \"def _int64_array_feature(value):\\n return tf.train.Feature(int64_list=tf.train.Int64List(value=value))\",\n \"def persons_gi(request):\\n arr = np.array([[100, 0, 200],\\n [0, 250, 50]])\\n return arr\",\n \"def _build(self):\\n ary = np.zeros( (3,3,3), float )\\n ary[0,0,0] = ary[1,1,1] = ary[0,1,2] = ary[1,0,2] = 1.\\n ary[0,2,0] = ary[0,2,2] = ary[2,0,0] = ary[2,0,2] = 0.5\\n ary[1,2,1] = ary[1,2,2] = ary[2,1,1] = ary[2,1,2] = 0.5\\n ary[2,2,0] = ary[2,2,1] = 0.25\\n ary[2,2,2] = 0.5\\n return ary\",\n \"def createIndivitual(self) -> Dict[str, Any]:\\n ind = {\\n \\\"genome\\\": {\\n key: numpy.random.randint(0, len(value), size=self.ref_count[key]) for (\\n key, value) in self.grammar.items()\\n },\\n \\\"fitness\\\": None,\\n \\\"fenotype\\\": None,\\n }\\n return ind\",\n \"def gen_values(self):\",\n \"def _buildArray(self):\\n if len(self.synth_spec.components) == 0:\\n self.array = np.zeros(len(self.synth_spec.x))\\n else:\\n y = []\\n for comp in self.synth_spec.components:\\n y += [[comp.function(x) for x in self.synth_spec.x]]\\n self.array = np.array(y)\",\n \"def numbers_identity() -> np.array:\\r\\n # Temporary dataframe to compare numbers for item pairs\\r\\n identity = pd.DataFrame()\\r\\n # Look up values by respective row indexes\\r\\n identity['item_1'] = data.iloc[pairs['idx_1'], :]['title'].values\\r\\n identity['item_2'] = data.iloc[pairs['idx_2'], :]['title'].values\\r\\n # Extract numbers and convert them to space-delimited string\\r\\n identity['nums_1'] = identity['item_1'].apply(lambda x: ' '.join(re.findall(r'\\\\d+', x)))\\r\\n identity['nums_2'] = identity['item_2'].apply(lambda x: ' '.join(re.findall(r'\\\\d+', x)))\\r\\n # Binary column signifying match or mismatch\\r\\n identity['match'] = (identity['nums_1'] == identity['nums_2']).astype('int')\\r\\n return identity['match'].values\",\n \"def __data_generation(self, list_ids_temp):\\r\\n # 'Generates data containing batch_size samples' # X : (n_samples, *dim, n_channels)\\r\\n # Initialization\\r\\n X = np.empty((self.batch_size, *self.dim, self.n_channels))\\r\\n y = np.empty(self.batch_size, dtype = int)\\r\\n\\r\\n # Get data from .mat files\\r\\n for i, ID in enumerate(list_ids_temp):\\r\\n with h5py.File(ID) as file:\\r\\n _data = list(file['sequences'])\\r\\n\\r\\n # Convert to .mat structure to numpy array\\r\\n _npData = np.array(_data)\\r\\n _allSequences = np.transpose(_npData)\\r\\n\\r\\n # Reshape the numpy array to size : ( # of sequences, # of rows, # of columns, # of channels)\\r\\n X[i,] = np.reshape(_allSequences, (15, 16, 3200, 1)) # sequences\\r\\n\\r\\n # Store class\\r\\n y[i] = self.labels[ID]\\r\\n\\r\\n return X, tf.keras.utils.to_categorical(y, num_classes = self.n_classes)\",\n \"def generate_real_samples(dataset : np.ndarray, patch_shape : int) -> np.ndarray:\\n y = generate_patch_labels(len(dataset), patch_shape, label=1)\\n return dataset, y\",\n \"def convert_int_data(lines):\\n tagdict = load('help/tagsets/upenn_tagset.pickle')\\n list_tags = list(tagdict.keys()) # Get the list of all the tags.\\n X, Y = [], [] # Creation of the array\\n for j in range(len(lines)):\\n line = lines[j]\\n if len(line) >= 5: # We want the word in the middle of five words\\n index = np.random.random_integers(low=2, high=len(line) - 3) # Take the index of the word to be choosen\\n neighbours_words = [line[i] for i in (index - 2, index - 1, index + 1, index + 2)] # Extract the words\\n Y.append(one_hot_encoding(lines[j][index], list_tags)) # Append the target to the array\\n sample = []\\n for word in neighbours_words:\\n sample.append(one_hot_encoding(word, list_tags).tolist())\\n X.append(sample) # Append the 4 neighbouring words\\n\\n return np.array(X), np.array(Y)\",\n \"def test_array(self):\\n htype = h5t.py_create(('f',(2,2)))\\n self.assertIsInstance(htype, h5t.TypeArrayID)\\n self.assertEqual(htype.get_array_dims(), (2,2))\",\n \"def generate_data(groups):\\n # get path list for the intended classification problem\\n input_paths = generate_input_list(groups) \\n X_lst = []\\n y = []\\n for p in input_paths:\\n dp = pd.read_csv(p, sep = '\\\\t') #datapoint\\n # Normalization \\n # norm = lambda x: (x - x.mean()) / x.std()\\n # dp = dp.apply(norm)\\n # Min-Max scaling \\n #dp_norm = (dp - dp.min()) / (dp.max() - dp.min())\\n #dp = dp_norm.values\\n if dp.isnull().sum().sum()>0:\\n# print(p, dp.isnull().sum().sum())\\n continue\\n dp = dp.drop(['time'], axis = 1) \\n dp = dp.iloc[:1600:4]\\n\\n if dp.isnull().sum().sum()>0:\\n# print('after norm',p, dp.isnull().sum().sum())\\n continue\\n dp = dp.values\\n\\n X_lst.append(dp)\\n sample_y = get_target(p, text= True)\\n y.append(sample_y)\\n X = np.stack(X_lst, axis=0)\\n \\n # convert y into int 0 and 1\\n encoder = LabelEncoder()\\n encoder.fit(y)\\n y = encoder.transform(y)\\n y_dummy = y\\n # convert y into one-hot encoding\\n if len(groups)>2:\\n y_dummy = pd.get_dummies(y)\\n y_dummy = y_dummy.values\\n return X, y , y_dummy\",\n \"def create_label_array(files_list):\\n lab_array = np.array([np.array(turn_age_into_vector(find_age(file))) for file in files_list])\\n return lab_array\",\n \"def samples(self, gp):\\r\\n orig_shape = gp.shape\\r\\n gp = gp.flatten()\\r\\n ns = np.ones_like(gp, dtype=int)\\r\\n Ysim = np.random.binomial(ns, self.gp_link.transf(gp))\\r\\n return Ysim.reshape(orig_shape)\",\n \"def import_data(path, num_examples):\\n data = np.empty((num_examples, 5), dtype=\\\"float128\\\")\\n y = np.empty((num_examples, 1), dtype=\\\"float128\\\")\\n\\n with open(path, 'r') as f:\\n i = 0\\n for line in f:\\n example = []\\n terms = line.strip().split(',')\\n for j in range(len(terms)):\\n if j == 4:\\n y[i] = 2 * float(terms[j]) - 1\\n else:\\n example.append(float(terms[j]))\\n data[i, 1:] = example\\n data[i, 0] = 1\\n i += 1\\n\\n data = normalize(np.asmatrix(data), axis=0)\\n return [data, np.asmatrix(y)]\",\n \"def example_generator(self, mode: str):\\n raise NotImplementedError\",\n \"def load_examples(filename):\\r\\n data = np.load(filename)\\r\\n return data['examples'], int(data['srate'])\",\n \"def load_examples(filename):\\r\\n data = np.load(filename)\\r\\n return data['examples'], int(data['srate'])\",\n \"def var_array_generator(array):\\n vars = []\\n for cen in array:\\n iteration_var = np.var(np.array(cen))\\n vars.append(iteration_var)\\n\\n vars = np.array(vars)\\n return vars\",\n \"def example():\\n sampler = DoomSampler()\\n # Current architecture works on batches of 32 levels\\n # Noise shape is (batch_size, 100)\\n noise_shape = [32, 100]\\n # Input Feature vector shape is (batch_size, 7) - Refer to DoomLevelsGAN/network_architecture.py\\n feat_shape = [32, 7]\\n\\n # Generating random noise and input features as example\\n noise = np.random.random(size=noise_shape)\\n input_features = np.random.random(size=feat_shape)\\n out_features = sampler.get_features_of(noise, input_features)\\n\\n # Retrieving samples\\n levels = sampler.last_generated_samples\\n\\n # Printing feature values\\n for f_name, f_list in out_features.items():\\n print(\\\"Feature: {} \\\\n {}\\\".format(f_name, f_list))\",\n \"def generateNumbersArr(mines, num_rows, num_cols):\\n minesIn2D = [convertFrom1Dto2D(mine, num_cols) for mine in mines] \\n minesSet = set(minesIn2D) #set of tuples\\n\\n #initialize a 2D array\\n #newArr = new Array(rows).fill(0).map(() => new Array(cols).fill(0));\\n newArr = np.zeros(shape=(num_rows, num_cols))\\n for i in range(num_rows):\\n for j in range(num_cols):\\n if ((i, j) in minesSet):\\n newArr[i][j]=9\\n else:\\n newArr[i][j]=numNeighbors(minesSet, i, j, num_cols, num_rows)\\n return newArr\",\n \"def np_ints(self):\\n # A numpy-array packaging of the integer input parameters\\n return np.array([self.mode, self.n_freqs], dtype=np.int32)\",\n \"def _generate_examples(self, filepath):\\n logger.info(\\\"generating examples from = %s\\\", filepath)\\n with open(filepath, encoding=\\\"utf-8\\\") as f:\\n qasper = json.load(f)\\n for id_ in qasper:\\n qasper[id_][\\\"id\\\"] = id_\\n yield id_, qasper[id_]\",\n \"def load_values(demo):\\r\\n if demo:\\r\\n return Matrix(5, 5, [Node(i, v) for i, v in enumerate([\\r\\n 131, 673, 234, 103, 18,\\r\\n 201, 96, 342, 965, 150,\\r\\n 630, 803, 746, 422, 111,\\r\\n 537, 699, 497, 121, 956,\\r\\n 805, 732, 524, 37, 331])])\\r\\n else:\\r\\n with open(_MATRIX, 'r') as flr:\\r\\n digits = flr.read()\\r\\n digits = [int(i.strip()) for i in digits.strip().\\r\\n replace('\\\\n', ' ').replace(',', ' ').split(' ')]\\r\\n\\r\\n return Matrix(80, 80, [Node(i, v) for i, v in enumerate(digits)])\",\n \"def generate_inference_dataset(self, inference_directory: str) -> (List[str], List[np.ndarray]):\\n example_paths = [os.path.join(inference_directory, file_name) for file_name in\\n os.listdir(inference_directory) if file_name.endswith('.npy')]\\n examples = []\\n for example_path in example_paths:\\n lightcurve = np.load(example_path)\\n lightcurve = self.preprocess_and_augment_lightcurve(lightcurve)\\n examples.append(lightcurve.astype(np.float32))\\n return example_paths, examples\",\n \"def create_data(data_size,heme, nucleotide, control, steroid,data_total,path_to_data):\\n\\n os.chdir(path_to_data)\\n\\n x_array = np.zeros(shape = (data_size,14,32,32,32))\\n\\n y_array = np.zeros(shape = data_size)\\n\\n print(\\\"data size = \\\", data_size)\\n\\n #training set :\\n\\n file_count = 0\\n\\n for file in data_total:\\n\\n y_array[file_count]= find_class(str(file), heme, nucleotide, control, steroid)\\n\\n x_array[file_count] = np.load(str(file+\\\".npy\\\"))\\n\\n file_count+=1\\n\\n\\n return (x_array, y_array)\",\n \"def alt_allele_indices_from_example(example):\\n features = example.features.feature\\n val = features['alt_allele_indices/encoded'].bytes_list.value[0]\\n # Extract the encoded proto into unsigned integers and convert to regular ints\\n mapped = [int(x) for x in np.frombuffer(val, dtype=np.uint8)]\\n # Format is [<field id + type>, <number of elements in array>, ...<array>].\\n # Extract the array only, leaving out the metadata.\\n return mapped[2:]\",\n \"def build_input_data(sentences, vocabulary):\\n index_list = []\\n for word in sentences:\\n tmp = vocabulary[word]\\n index_list.append(tmp)\\n x = np.array(index_list)\\n return x\",\n \"def inputs(self) -> Sequence[jnp.ndarray]:\\n pass\",\n \"def i(self):\\n return np.array(self._sequence)\",\n \"def instantiate_examples(self, examples : [dict]) -> [dict]:\\n raise NotImplementedError()\",\n \"def gen_instances(positive_flows: list, negative_flows: list, simulate: bool = False, char_wb: bool = False,\\n add_taint: bool = False) -> (\\n list, [[float]], np.array, np.array):\\n logger.info('lenPos: %d', len(positive_flows))\\n logger.info('lenNeg: %d', len(negative_flows))\\n docs = Analyzer.gen_docs(positive_flows, char_wb, add_taint=add_taint)\\n docs = docs + (Analyzer.gen_docs(negative_flows, char_wb, add_taint=add_taint))\\n if simulate and len(negative_flows) == 0:\\n docs = docs + Learner.simulate_flows(len(positive_flows), 0)\\n samples = []\\n samples_num = []\\n labels = []\\n real_labels = []\\n for doc in docs:\\n samples.append(doc.doc)\\n numeric_fea_val = []\\n for x in doc.numeric_features:\\n if isinstance(x, list):\\n for val in x:\\n if val == '?':\\n logger.warning('Unknown value appeared in stats feature!')\\n val = 0.0\\n numeric_fea_val.append(float(val))\\n else:\\n numeric_fea_val.append(float(x))\\n samples_num.append(numeric_fea_val)\\n labels.append(doc.label)\\n real_labels.append(doc.real_label)\\n logger.debug(str(doc.label) + \\\": \\\" + doc.doc)\\n\\n return samples, samples_num, np.array(labels), np.array(real_labels)\",\n \"def data():\\n return RaggedArray(\\n [[0, 1], [1, 2, 3, 4], [], [-1, -2], []]*20, dtype='float64')\",\n \"def get_count_train(datagen):\\n y_train = np.array([])\\n\\n for i in range(len(datagen)):\\n y_train = np.append(y_train, datagen[i][1])\\n \\n age_train, count_train = np.unique(y_train, return_counts=True)\\n \\n return count_train\",\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 fake_data_as_array(self, time_steps=10000, currencies_num=4, rand_seed=101):\\n np.random.seed(rand_seed)\\n data = np.zeros((time_steps, currencies_num, 4))\\n time_scale = np.arange(0, time_steps, 1)\\n ones_array = np.ones(time_steps)\\n labels = {}\\n for idx in range(currencies_num):\\n labels[idx] = \\\"fake_\\\"+str(idx)\\n base_data = np.sin(time_scale/200)*np.sin(time_scale/20) + 1.1*ones_array + np.random.rand(1)*ones_array\\n for olhc in range(4):\\n data[:, idx, olhc] = base_data + olhc/4*ones_array\\n\\n return data, labels\",\n \"def arrays(self, select_output):\\n pass\",\n \"def init_output_mat(self, y_list):\",\n \"def test_get_nsamples_array():\\n test_file = os.path.join(DATA_PATH, \\\"paper_test_file.uvh5\\\")\\n test_uv = UVData()\\n test_uv.read(test_file)\\n\\n baseline_array = np.array(list(set(test_uv.baseline_array)))\\n nsample_array = utils.get_nsample_array(test_uv, reds=baseline_array)\\n\\n test_samples = np.zeros(\\n (test_uv.Npols, test_uv.Nbls, test_uv.Ntimes, test_uv.Nfreqs),\\n dtype=np.float32,\\n )\\n\\n pol_array = uvutils.polnum2str(test_uv.polarization_array)\\n for pol_cnt, pol in enumerate(pol_array):\\n for cnt, baseline in enumerate(list(set(test_uv.baseline_array))):\\n ant_1, ant_2 = test_uv.baseline_to_antnums(baseline)\\n test_samples[pol_cnt, cnt] = test_uv.get_nsamples(ant_1, ant_2)\\n\\n test_samples = np.squeeze(test_samples, axis=0)\\n assert np.all(test_samples == nsample_array)\",\n \"def __data_generation(self, list_IDs_temp):\\n\\n # Initialization\\n X = np.empty((self.batch_size, self.grid_dim, self.grid_dim, self.grid_dim, self.n_channels))\\n y = np.empty(self.batch_size, dtype=int)\\n\\n # Generate data\\n for i, ID in enumerate(list_IDs_temp):\\n # Store sample\\n X[i], y[i] = pro_lig_reader_sample(ID[0], ID[1], self.grid_size, self.n_channels, self.grid_resolution)\\n return X, keras.utils.to_categorical(y, num_classes=self.n_classes)\",\n \"def get_initial_array(events, slots, seed=None):\\n if seed is not None:\\n np.random.seed(seed)\\n\\n m = len(events)\\n n = len(slots)\\n X = np.zeros((m, n))\\n for i, row in enumerate(X):\\n X[i, i] = 1\\n np.random.shuffle(X)\\n return X\",\n \"def construct(frequency_array):\\n tree = [0] * (len(frequency_array) + 1)\\n for index, frequency in enumerate(frequency_array):\\n updatebit(tree, index, frequency)\\n print tree\\n return tree\",\n \"def init_expected_outputs(data, no_labels=26):\\n expected_outputs = np.zeros((data.shape[0], no_labels))\\n \\n for i in range(0,data.shape[0]): \\n expected_outputs[i, data[i].astype(int)]=1\\n\\n return expected_outputs\",\n \"def get_train_inputs(self, example):\\n return example\",\n \"def generate():\",\n \"def generate(inputFilename, outputFilename = defaultFileName, \\n sizeOfReducedSample = DEFSIZEOFREDUCEDSAMPLE, \\n centerEta = DEFCENTERETA, centerPhi = DEFCENTERPHI): \\n listOfSignals = convert(inputFilename)\\n arrayOfSignals = np.array(listOfSignals)\\n arrayOfSignals.shape\\n np.save(outputFilename, arrayOfSignals, allow_pickle=False)\\n print(\\\"npy array name: \\\",outputFilename)\",\n \"def _generate_examples(self, images_path, annotations_path):\\n caption_file = '/captions_val2014.json'\\n with tf.io.gfile.GFile(annotations_path + caption_file) as f:\\n data = json.load(f)\\n path_head = images_path + '/COCO_val2014_'\\n ann = data['annotations'] # Contains annotations\\n \\n img_names = [path_head + '%012d.jpg' % i['image_id'] for i in ann] \\n captions = ['<start> ' + i['caption'] + ' <end>' for i in ann]\\n ids = [i['id'] for i in ann]\\n \\n # The above lines create the captions (start and end tokens), the \\n # image names (which consist of the path head and a 12 digit number,\\n # right-aligned with the id), and the id to distinguish each unique image.\\n\\n for (i, name) in enumerate(img_names):\\n yield ids[i], {\\n 'image': name,\\n 'caption': captions[i]\\n }\",\n \"def __data_generation(self, list_IDs_temp):\\n X = np.empty((self.batch_size, self.dim))\\n Y = np.empty((self.batch_size, self.word_length, self.hot_enc_len))\\n\\n # Generate data\\n for i, ID in enumerate(list_IDs_temp): # The enumerate() function adds a counter to an iterable.\\n word = self.labels.index2word[ID]\\n # Store sample\\n X[i, ] = self.labels[word]\\n # Store class\\n char_hot_enc_pad = self.word_2_seq_hot_enc_sample(word)\\n Y[i] = char_hot_enc_pad\\n return X.reshape(self.batch_size, self.dim), Y\",\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 __init__(self):\\n self.size = 0\\n self.array = []\\n self.val2i = {}\",\n \"def _generate_examples(\\n self, mode: str) -> Generator[ProcessedExample, None, None]:\\n if mode not in self._json_dict:\\n self._json_dict[mode] = collections.defaultdict(list)\\n generator = self.builder_config.example_generator(mode)\\n for example in generator:\\n img_id, processed_example = self._convert_raw_example(\\n self._json_dict[mode], example)\\n yield img_id, processed_example\",\n \"def _instantiate_vars(labels: np.ndarray):\\n n = len(labels)\\n if len(set(labels)) == n:\\n index_seed = np.arange(n)\\n index_remain = np.arange(n)\\n else:\\n index_seed = np.argwhere(labels >= 0).ravel()\\n index_remain = np.argwhere(labels < 0).ravel()\\n labels = labels[index_seed]\\n return index_seed.astype(np.int32), index_remain.astype(np.int32), labels.astype(np.int32)\",\n \"def GetEdgeArray(self, p_int):\\n ...\",\n \"def _default_sample_ids(path: PathType) -> ArrayLike:\\n with bgen_file(path) as bgen:\\n if bgen.contain_samples:\\n return bgen.read_samples()\\n else:\\n return np.char.add(b\\\"sample_\\\", np.arange(bgen.nsamples).astype(\\\"S\\\"))\",\n \"def __data_generation(self, list_IDs_temp):\\n X1 = np.empty((len(list_IDs_temp), *self.dim, self.n_channels))\\n X2 = np.empty((len(list_IDs_temp), *self.dim, self.n_channels))\\n X3 = np.empty((len(list_IDs_temp), *self.dim, self.n_channels))\\n X4 = np.empty((len(list_IDs_temp), *self.dim, self.n_channels))\\n y = np.empty(len(list_IDs_temp), dtype=int)\\n\\n for i, ID_instance in enumerate(list_IDs_temp):\\n\\n with (self.path_instances / ID_instance).open('rb') as input:\\n instance = pickle.load(input)\\n\\n frames = instance['frames']\\n\\n label = instance['crossing']\\n\\n #Normalización de los frames\\n if self.normalized:\\n frames = frames * 1 / 255\\n\\n X1[i, ] = frames[0]\\n X2[i, ] = frames[1]\\n X3[i, ] = frames[2]\\n X4[i, ] = frames[3]\\n y[i] = label\\n\\n return [X1, X2, X3, X4], to_categorical(y, num_classes=self.n_classes)\",\n \"def process(self, example):\\n self.get_counter(\\\"examples-total\\\").inc()\\n label = example_util.get_bytes_feature(example, _LABEL_COLUMN)[0]\\n self.get_counter(\\\"examples-{}\\\".format(label)).inc()\\n yield example\",\n \"def dev_sample_generator(self, fi):\\n for line in fi:\\n line_list = line.split(\\\" \\\")\\n label = int(line_list[-1])\\n sequence = np.array(line_list[:-1], dtype=np.intp)\\n yield sequence, sequence.shape[0], np.unique(sequence).shape[0], label\",\n \"def construct_dataset(tri2index, num_examples=100, qap_path=\\\"./dataset/qa_pairs.dump\\\",\\n label_path=\\\"./dataset/labels.dump\\\"):\\n Xpair = []\\n Y = []\\n with open(DATA_PATH) as f:\\n lines = csv.reader(f, delimiter=\\\"\\\\t\\\")\\n i = 0\\n for line in lines:\\n q_processed = char_trigram_creator(preprocess(line[3]))\\n a_processed = char_trigram_creator(preprocess(line[4]))\\n # get the index of the array\\n q_index = [tri2index[qp] for qp in q_processed]\\n a_index = [tri2index[ap] for ap in a_processed]\\n # append dataset\\n Xpair.append((q_index, a_index)) # list of tuples\\n Y.append(line[5].replace(\\\"\\\\n\\\", \\\"\\\"))\\n # if i >= num_examples : break\\n i += 1\\n f.close()\\n # shuffle the dataset\\n Xs = np.asarray(Xpair[1:]) # discard the header\\n Ys = np.asarray(Y[1:])\\n perm = np.random.permutation(len(Xs))\\n Xs = Xs[perm]\\n Ys = Ys[perm]\\n pickle.dump(Xs, open(qap_path, \\\"wb\\\"))\\n pickle.dump(Ys, open(label_path, \\\"wb\\\"))\",\n \"def get_data(generator, random, bench_id):\\n x_train, y_train, x_test, y_test = generator(random, bench_id)\\n x_train = np.c_[np.ones(len(x_train)), x_train]\\n x_test = np.c_[np.ones(len(x_test)), x_test]\\n return x_train, y_train, x_test, y_test\",\n \"def _random_encoding(examples):\\n return np.random.normal(size=(len(examples), 7))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5792245","0.57152265","0.5646653","0.56107265","0.54559135","0.53339714","0.5332648","0.53321683","0.5320349","0.5287736","0.5264665","0.5232722","0.5185454","0.5129824","0.5108268","0.50851935","0.5042504","0.5032581","0.50246435","0.50160766","0.5007008","0.49815613","0.49720874","0.49706554","0.4963362","0.49558538","0.4951139","0.49258298","0.49253562","0.49253562","0.4924429","0.4923001","0.49131325","0.49085116","0.49069896","0.4906855","0.4906855","0.49061117","0.4897096","0.48851663","0.4865665","0.48613375","0.4861249","0.4851934","0.485032","0.48466563","0.4846635","0.483562","0.48346248","0.48311368","0.4822032","0.48215285","0.4815744","0.48143876","0.48054025","0.48033193","0.47996378","0.47996378","0.4796634","0.47927982","0.47927943","0.47927353","0.47821012","0.47722566","0.4772099","0.47651622","0.47647002","0.47485593","0.4747199","0.47382727","0.47381836","0.47377703","0.47373343","0.47292352","0.47228327","0.47211567","0.4714789","0.47145146","0.4713613","0.47056925","0.4698364","0.46973944","0.4696683","0.46955287","0.4692007","0.46828905","0.46828732","0.46790743","0.46790212","0.46763793","0.46748996","0.46685934","0.46684128","0.46567512","0.46556762","0.46536824","0.465278","0.46456432","0.4643527","0.46429172"],"string":"[\n \"0.5792245\",\n \"0.57152265\",\n \"0.5646653\",\n \"0.56107265\",\n \"0.54559135\",\n \"0.53339714\",\n \"0.5332648\",\n \"0.53321683\",\n \"0.5320349\",\n \"0.5287736\",\n \"0.5264665\",\n \"0.5232722\",\n \"0.5185454\",\n \"0.5129824\",\n \"0.5108268\",\n \"0.50851935\",\n \"0.5042504\",\n \"0.5032581\",\n \"0.50246435\",\n \"0.50160766\",\n \"0.5007008\",\n \"0.49815613\",\n \"0.49720874\",\n \"0.49706554\",\n \"0.4963362\",\n \"0.49558538\",\n \"0.4951139\",\n \"0.49258298\",\n \"0.49253562\",\n \"0.49253562\",\n \"0.4924429\",\n \"0.4923001\",\n \"0.49131325\",\n \"0.49085116\",\n \"0.49069896\",\n \"0.4906855\",\n \"0.4906855\",\n \"0.49061117\",\n \"0.4897096\",\n \"0.48851663\",\n \"0.4865665\",\n \"0.48613375\",\n \"0.4861249\",\n \"0.4851934\",\n \"0.485032\",\n \"0.48466563\",\n \"0.4846635\",\n \"0.483562\",\n \"0.48346248\",\n \"0.48311368\",\n \"0.4822032\",\n \"0.48215285\",\n \"0.4815744\",\n \"0.48143876\",\n \"0.48054025\",\n \"0.48033193\",\n \"0.47996378\",\n \"0.47996378\",\n \"0.4796634\",\n \"0.47927982\",\n \"0.47927943\",\n \"0.47927353\",\n \"0.47821012\",\n \"0.47722566\",\n \"0.4772099\",\n \"0.47651622\",\n \"0.47647002\",\n \"0.47485593\",\n \"0.4747199\",\n \"0.47382727\",\n \"0.47381836\",\n \"0.47377703\",\n \"0.47373343\",\n \"0.47292352\",\n \"0.47228327\",\n \"0.47211567\",\n \"0.4714789\",\n \"0.47145146\",\n \"0.4713613\",\n \"0.47056925\",\n \"0.4698364\",\n \"0.46973944\",\n \"0.4696683\",\n \"0.46955287\",\n \"0.4692007\",\n \"0.46828905\",\n \"0.46828732\",\n \"0.46790743\",\n \"0.46790212\",\n \"0.46763793\",\n \"0.46748996\",\n \"0.46685934\",\n \"0.46684128\",\n \"0.46567512\",\n \"0.46556762\",\n \"0.46536824\",\n \"0.465278\",\n \"0.46456432\",\n \"0.4643527\",\n \"0.46429172\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.4968345"},"document_rank":{"kind":"string","value":"24"}}},{"rowIdx":84572,"cells":{"query":{"kind":"string","value":"Tender Qualification Documents List"},"document":{"kind":"string","value":"def collection_get(self):\n if self.request.params.get(\"all\", \"\"):\n collection_data = [i.serialize(\"view\") for i in self.context.documents]\n else:\n collection_data = sorted(\n dict([(i.id, i.serialize(\"view\")) for i in self.context.documents]).values(),\n key=lambda i: i[\"dateModified\"],\n )\n return {\"data\": collection_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 documents(pmid_23982599, civic_aid6_document):\n return [pmid_23982599, civic_aid6_document]","def getDocuments(self):\n return self.objectValues('Multifile')","def get_documents():\n documents = []\n for category in movie_reviews.categories():\n for fileid in movie_reviews.fileids(category):\n documents.append((list(movie_reviews.words(fileid)), category))\n \n return documents","def documents(self, **kw):\r\n \r\n doc_reader = self.doc_reader\r\n return (doc_reader[docnum] for docnum in self.document_numbers(**kw))","def getDocsList(self):\n return self.docs_list","def items(self):\n return self.docs.items()","def get_documents(self, subtypes=None, refresh=False):\n search = ScopusSearch('au-id({})'.format(self.identifier), refresh)\n if subtypes:\n return [p for p in search.results if p.subtype in subtypes]\n else:\n return search.results","def documentlist_sponsor():\n # get the current user id\n user_id = current_user.id\n\n # Document objects list which includes editors for all objects\n # this logic will only work if document_objects.count() = editor_objects.count()\n # get document objects filtered by the current user\n # attach autodocs based upon revision helper table\n document_objects=db.session.query(Retention.sponsor_id,User.id,Retention.editor_id,Retention.document_id,User.name,Document.document_name,Document.document_body,Autodoc.autodoc_body).\\\n join(Retention, User.id==Retention.editor_id).\\\n join(Document, Document.id==Retention.document_id).\\\n order_by(Retention.sponsor_id).\\\n filter(Retention.sponsor_id == user_id).\\\n join(Revision,Revision.document_id==Document.id).\\\n join(Autodoc,Autodoc.id==Revision.autodoc_id)\n\n # get a count of the document objects\n document_count = document_objects.count()\n\n # blank list to append to for documents and editors\n document_list=[]\n\n # loop through document objects\n for counter in range(0,document_count):\n document_list.append(document_objects[counter])\n\n # show list of document names\n documents = document_list\n\n return render_template(\n 'documentlist_sponsor.jinja2',\n documents=documents,\n )","def list_qualifications() -> Dict[str, Any]:\n qualifications_schema = QualificationSchema(many=True)\n qualifications = Qualification.query.all()\n return cast(Dict[str, Any], jsonify(qualifications_schema.dump(qualifications)))","def get_qualification_list(self):\n try:\n qualifications = self.db_handler.get_qualifications_list()\n self.logger.write_to_log('qualifications got', 'model')\n return qualifications\n except Exception as err:\n method_name = sys._getframe().f_code.co_name\n\n self.logger.write_to_log('exception', 'model')\n self.logger.write_to_err_log(f'exception in method {method_name} - {err}', 'model')","def listFeaturableContentTypes():","def get_qualities_with_expert_knowledge(self) -> List[str]:\n return sorted(list(set([q for _, q in self.expert_knowledge])))","def docs():","def speakersVocabulary(context):\n ct = getToolByName(context,'portal_catalog')\n dictSearch = {'portal_type':'apyb.papers.speaker','sort_on':'sortable_title'}\n speakers = ct.searchResults(**dictSearch)\n speakers = [SimpleTerm(b.UID,b.UID,b.Title) for b in speakers]\n return SimpleVocabulary(speakers)","def documentlist_editor():\n # get the current user id\n user_id = current_user.id\n\n # Document objects and list, as well as Editor objects and list\n # this logic will only work if document_objects.count() = editor_objects.count()\n # get document objects filtered by the current user\n document_objects=db.session.query(Retention.sponsor_id,User.id,Retention.editor_id,Retention.document_id,User.name,Document.document_name,Document.document_body,Autodoc.autodoc_body).\\\n join(Retention, User.id==Retention.editor_id).\\\n join(Document, Document.id==Retention.document_id).\\\n order_by(Retention.sponsor_id).\\\n filter(Retention.editor_id == user_id).\\\n join(Revision,Revision.document_id==Document.id).\\\n join(Autodoc,Autodoc.id==Revision.autodoc_id)\n\n # get a count of the document objects\n document_count = document_objects.count()\n\n # blank list to append to for documents and editors\n document_list=[]\n\n # loop through document objects\n for counter in range(0,document_count):\n document_list.append(document_objects[counter])\n\n # show list of document names\n documents = document_list\n\n\n return render_template(\n 'documentlist_editor.jinja2',\n documents=documents,\n )","def get_documents(doc_type):\n doc_type = 1 if doc_type == 'registration' else 2\n return Documents.query.filter_by(type=doc_type).all()","def Documents(self, default=[{}]):\n tmp = self.data.get('metadata', {}).get('documents', default)\n return [HEP.DocumentObject(i) for i in tmp]","def documents(self) -> list[str]:\n return self._documents","def get_labelled_documents_queryset(self):\n from ..models import LabelledDocument\n\n return LabelledDocument.objects\\\n .filter(model_name=self.get_name())","def documents(self):\r\n return doc.Documents(self)","def test_client_document_list(self):\n pass","def get_documents(self, value, key='name'):\n documents = []\n for doc in value:\n if doc.endswith('.json'):\n key = 'filename'\n documents.append([x for x in self.vocab if x[key] == doc])\n return documents","def __get_lucene_contents(self, doc_id, en_list):\n contents = [{'field_name': Lucene.FIELDNAME_ID, 'field_value': doc_id, 'field_type': Lucene.FIELDTYPE_ID}]\n for en_id in en_list:\n contents.append({'field_name': \"content\", 'field_value': en_id, 'field_type': Lucene.FIELDTYPE_ID_TV})\n return contents","def retrieveDocuments(self):\n documents = {}\n for reuter in self.REUTERS_FILES:\n print(reuter)\n reuter_stream = open(self.BASEPATH + reuter, encoding=\"latin-1\")\n reuter_content = reuter_stream.read()\n soup = BeautifulSoup(reuter_content, \"html.parser\")\n articles = soup.find_all('reuters')\n for article in articles:\n body = \"\"\n title = \"\"\n words = \"\"\n newid = article['newid']\n if not article.title is None:\n title = article.title.string\n if not article.body is None:\n body = article.body.string\n words = title + \" \" + body\n documents[newid] = words\n print(f\"Retrieval Complete! - Total Documents: {len(documents)}\")\n return documents","def document(self, **kw):\r\n \r\n for p in self.documents(**kw):\r\n return p","def all_tone_qualities():\n\n tone_qualities = crud.get_tone_qualities()\n\n return render_template('all_tone_qualities.html', tone_qualities=tone_qualities)","def list_documents(self, engine_name, current=1, size=20):\n data = { 'page': { 'current': current, 'size': size } }\n return self.swiftype_session.request('get', \"engines/{}/documents/list\".format(engine_name), json=data)","def get_expert_knowledge_for_qualities(self, qualities: List[str]) -> List[str]:\n expert_knowledge = reduce(\n lambda res, q: res | set(p for p, _q in self.expert_knowledge if _q == q),\n qualities,\n set()\n )\n return sorted(list(expert_knowledge))","def registered_docs(self):\n return [t for t in self.registered if isinstance(t, dexy.doc.Doc)]","def topics(self):\r\n return contents.Topics(self)","def snippetList(requeset, format = None):","def merge_docs(self):","def get_documents() -> list[Document]:\n g.ledger.changed()\n return [e for e in g.filtered.entries if isinstance(e, Document)]","def test_all_documents(self):","def prefiltered_docs(self):\n relevant_docs = set()\n for term in self.query_terms:\n try:\n for entry in self.inv_idx.idx[term]:\n relevant_docs.add(entry.doc_id)\n except KeyError:\n pass\n return relevant_docs","def get_questions(self, obj):\n queryset = Question.objects.filter(sheet=obj)\n questions = []\n for q in queryset:\n questions.append(q.text)\n return questions","def get_test_doclist(doctype, name=None):\n\timport os\n\tfrom frappe import conf\n\tfrom frappe.modules.utils import peval_doclist\n\tfrom frappe.modules import scrub\n\n\tdoctype = scrub(doctype)\n\tdoctype_path = os.path.join(os.path.dirname(os.path.abspath(conf.__file__)),\n\t\tconf.test_data_path, doctype)\n\n\tif name:\n\t\twith open(os.path.join(doctype_path, scrub(name) + \".json\"), 'r') as txtfile:\n\t\t\tdoclist = peval_doclist(txtfile.read())\n\n\t\treturn doclist\n\n\telse:\n\t\tall_doclists = []\n\t\tfor fname in filter(lambda n: n.endswith(\".json\"), os.listdir(doctype_path)):\n\t\t\twith open(os.path.join(doctype_path, scrub(fname)), 'r') as txtfile:\n\t\t\t\tall_doclists.append(peval_doclist(txtfile.read()))\n\n\t\treturn all_doclists","def iter_documents(self):\n raise NotImplementedError","def test_client_verification_document_list(self):\n pass","def _get_documents(self) -> Iterable[dict]:\n\n return self._db[\"documents\"]","def get_queryset(self):\n return PubFulltext.objects.order_by('-pmid')","def filter(self, results):\r\n \r\n docs = self.docs & results.docs\r\n self.scored_list = [docnum for docnum in self.scored_list if docnum in docs]\r\n self.docs = docs","def getMaintainerList(self):\n return self.getDocumentedObject().getMaintainerList()","def get_documents(self):\n documents = self.tree.execute(\"$.documents\")\n for doc in documents:\n sentences = {s['@id']: s['text'] for s in doc.get('sentences', [])}\n self.document_dict[doc['@id']] = {'sentences': sentences,\n 'location': doc['location']}\n return","def test_3_listautor(self): \n [i for i in self.app._listarAutores()]\n self.app.getAutores()","def gather_documents(self):\n self.document_gatherer.gather_and_save_everything(Constants.path_cord, \n Constants.path_metadata, \n Constants.path_linked_documents,\n Constants.path_unlinked_documents,\n Constants.path_parsed_documents,\n Constants.path_all_documents)\n \n print(\"Done gathering documents.\")","def trackVocabulary(context):\n ct = getToolByName(context,'portal_catalog')\n tracks = ct.searchResults(portal_type='apyb.papers.track', sort_on='getObjPositionInParent')\n items = [SimpleTerm(b.UID,b.UID,b.Title) for b in tracks]\n return SimpleVocabulary(items)","def inspect_doc(self, file, terms):\n # populate with studies in loop\n reports = []\n\n # extract text and do the search\n for i, chunk in enumerate(file.content_chunks()):\n\n study = self.inspect_text(chunk, terms)\n\n for entry in study:\n # only populate if there is a match\n # otherwise it will be a bunch of\n # empty studies\n\n # supplement with page\n entry['page'] = i + 1\n\n reports.append(entry)\n\n return reports","def get_queryset(self):\n samples = AudioSample.objects.distinct()\n if samples:\n return samples.filter(\n pub_date__lte=timezone.now()\n ).order_by('-pub_date')\n else:\n return []","def docs(self, searcher, exclude_docs=None):\r\n\r\n try:\r\n return self.matcher(searcher, exclude_docs=exclude_docs).all_ids()\r\n except TermNotFound:\r\n return []","def read_queryset(self, using=None):\n return self.index_queryset(using=using)","def test_list_note_occurrences(self):\n pass","def docs2ids(self):\n self.docs = [ [self.vocab[word] for word in doc] for doc in self.docs]","def get_auto_anno_PUBMED_batch_list(request):\n\n json_resp = {}\n usecase = request.GET.get('usecase')\n # print(usecase)\n languages = ['English', 'english']\n use_obj = UseCase.objects.get(name=usecase)\n json_resp['batch_list'] = []\n batch = Report.objects.filter(name=use_obj,language__in = languages,institute = 'PUBMED').values('batch')\n for el in batch:\n if el['batch'] not in json_resp['batch_list']:\n json_resp['batch_list'].append( el['batch'])\n # print(json_resp['batch_list'])\n json_resp['batch_list'] = sorted(json_resp['batch_list'])\n # print(json_resp)\n return JsonResponse(json_resp)","def get_queryset(self):\n acc = self.kwargs['accession'].lstrip('MGYA')\n job_query = Q(pk=acc)\n\n if self.analysis_job_filters:\n job_query &= self.analysis_job_filters\n\n job = get_object_or_404(emg_models.AnalysisJob, job_query)\n\n analysis = None\n try:\n analysis = self.annotation_model.objects \\\n .get(analysis_id=str(job.job_id))\n except self.annotation_model.DoesNotExist:\n # Return an empty EmbeddedDocumentList, the entity exists\n # but it doesn't have annotations\n return EmbeddedDocumentList([], self.annotation_model, self.annotation_model_property)\n\n if hasattr(self, \"annotation_model_property_resolver\"):\n return self.annotation_model_property_resolver(analysis)\n\n return getattr(analysis, self.annotation_model_property)","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 get_designs(self):","def get_docs(self):\n return self.retrieve_docstring()","def get_docs(self):\n return self.retrieve_docstring()","def get_docs(self):\n return self.retrieve_docstring()","def getCatalogs():","def relevant_docs_from_posting(self, query):\n relevant_docs = {}\n # postingLists = [self.FindPostingByTerm(term) for term in query] #list of posting file -->[idx,tweet id,tfi]\n for term in query:\n post = self.FindPostingByTerm_Binary(term)\n for p in post:\n tweet_id = p[1]\n if tweet_id not in relevant_docs.keys():\n relevant_docs[tweet_id] = {}\n relevant_docs[tweet_id][term] = p[2] * self.inverted_index[term][1] # wiq\n return relevant_docs","def find_records():\r\n\r\n print(\"begin find records\")\r\n\r\n study_list = retrieve_ref('study_list')\r\n sensor_list = retrieve_ref('sensor_list')\r\n # sensor_unit_list = retrieve_ref('sensor_unit_list')\r\n\r\n for study in study_list:\r\n # print('study = ' + str(study))\r\n source_path = os.path.join(study, 'source')\r\n # print('source_path = ' + str(source_path))\r\n\r\n source_folders = os.listdir(source_path)\r\n # print(str(study) + ' source_folders = ')\r\n # print(source_folders)\r\n\r\n df_meta = pd.DataFrame()\r\n df_meta['source_path'] = source_folders\r\n save_meta(study, df_meta)\r\n record_to_summary(study, 'Records found', str(len(source_folders)))\r\n\r\n print(\"completed find records\")","def get_auto_anno_batch_list(request):\n\n json_resp = {}\n usecase = request.GET.get('usecase')\n # print(usecase)\n use_obj = UseCase.objects.get(name=usecase)\n json_resp['batch_list'] = []\n languages = ['English','english']\n batch = Report.objects.filter(name=use_obj,language__in = languages).exclude(institute = 'PUBMED').values('batch')\n for el in batch:\n if el['batch'] not in json_resp['batch_list']:\n json_resp['batch_list'].append( el['batch'])\n # print(json_resp['batch_list'])\n json_resp['batch_list'] = sorted(json_resp['batch_list'])\n # print(json_resp)\n return JsonResponse(json_resp)","def _collection_samples(collection_query, limit, config):\n just_cid = lambda obj : obj.get('meta', {}).get('concept-id')\n found_collections = scom.search_by_page(\"collections\",\n query=collection_query,\n filters=just_cid,\n page_state=scom.create_page_state(limit=limit),\n config=config)\n return found_collections[:limit]","def triple_quote_docs():\n return","def query(self, words: list) -> list:\r\n relevant_documents = self.word_to_docs_mapping[words[0]]\r\n if len(words) > 1:\r\n for word in words:\r\n relevant_documents = relevant_documents & self.word_to_docs_mapping[word]\r\n return list(relevant_documents)","def collecte_docs(self, chercheur, overwrite=False): # self,\n init = overwrite # If True, data persistence is lost when references are updated\n docs = hal.find_publications(chercheur[\"halId_s\"], \"authIdHal_s\")\n\n progress_recorder = ProgressRecorder(self)\n progress_recorder.set_progress(0, len(docs), description=\"récupération des données HAL\")\n # Insert documents collection\n for num, doc in enumerate(docs):\n doc[\"country_colaboration\"] = location_docs.generate_countrys_fields(doc)\n doc = doi_enrichissement.docs_enrichissement_doi(doc)\n if \"fr_abstract_s\" in doc.keys():\n if isinstance(doc[\"fr_abstract_s\"], list):\n doc[\"fr_abstract_s\"] = \"/n\".join(doc[\"fr_abstract_s\"])\n if len(doc[\"fr_abstract_s\"]) > 100:\n doc[\"fr_entites\"] = keyword_enrichissement.return_entities(\n doc[\"fr_abstract_s\"], \"fr\"\n )\n doc[\"fr_teeft_keywords\"] = keyword_enrichissement.keyword_from_teeft(\n doc[\"fr_abstract_s\"], \"fr\"\n )\n if \"en_abstract_s\" in doc.keys():\n if isinstance(doc[\"en_abstract_s\"], list):\n doc[\"en_abstract_s\"] = \"/n\".join(doc[\"en_abstract_s\"])\n if len(doc[\"en_abstract_s\"]) > 100:\n doc[\"en_entites\"] = keyword_enrichissement.return_entities(\n doc[\"en_abstract_s\"], \"en\"\n )\n doc[\"en_teeft_keywords\"] = keyword_enrichissement.keyword_from_teeft(\n doc[\"en_abstract_s\"], \"en\"\n )\n\n doc[\"_id\"] = doc[\"docid\"]\n doc[\"validated\"] = True\n\n doc[\"harvested_from\"] = \"researcher\"\n\n doc[\"harvested_from_ids\"] = []\n doc[\"harvested_from_label\"] = []\n\n #\n #\n # print(doc[\"authorship\"], doc ['authLastName_s'])\n\n if len(doc[\"authIdHal_s\"]) != len(doc[\"authLastName_s\"]):\n # print (\"elastichal.py : test d'autorat no good\")\n # test sur le nom complet...\n nom = [\n truc\n for truc in doc[\"authLastName_s\"]\n if chercheur[\"lastName\"].lower() in truc.lower()\n ] # pour les récemment mariés qui auraient un nom composé...\n # Après si 'lun des co-auteur porte le même nom...\n if len(nom) > 0:\n nom = nom[0].title()\n try:\n if doc[\"authLastName_s\"].index(nom) == 0: # premier\n doc[\"authorship\"] = [\n {\"authorship\": \"firstAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n elif (\n doc[\"authLastName_s\"].index(nom) == len(doc[\"authLastName_s\"]) - 1\n ): # dernier\n doc[\"authorship\"] = [\n {\"authorship\": \"lastAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n except ValueError:\n doc[\"authorship\"] = []\n else:\n doc[\"authorship\"] = []\n elif chercheur[\"halId_s\"] in doc[\"authIdHal_s\"]:\n if doc[\"authIdHal_s\"].index(chercheur[\"halId_s\"]) == 0:\n doc[\"authorship\"] = [\n {\"authorship\": \"firstAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n elif (\n doc[\"authIdHal_s\"].index(chercheur[\"halId_s\"]) == len(doc[\"authIdHal_s\"]) - 1\n ): # dernier\n doc[\"authorship\"] = [\n {\"authorship\": \"lastAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n else:\n doc[\"authorship\"] = []\n else:\n doc[\"authorship\"] = []\n\n doc[\"harvested_from_ids\"].append(chercheur[\"halId_s\"])\n\n # historique d'appartenance du docId\n # pour attribuer les bons docs aux chercheurs\n # harvet_history.append({'docid': doc['docid'], 'from': row['halId_s']})\n #\n # for h in harvet_history:\n # if h['docid'] == doc['docid']:\n # if h['from'] not in doc[\"harvested_from_ids\"]:\n # doc[\"harvested_from_ids\"].append(h['from'])\n\n doc[\"records\"] = []\n\n doc[\"MDS\"] = utils.calculate_mds(doc)\n\n try:\n should_be_open = utils.should_be_open(doc)\n if should_be_open == 1:\n doc[\"should_be_open\"] = True\n if should_be_open == -1:\n doc[\"should_be_open\"] = False\n\n if should_be_open == 1 or should_be_open == 2:\n doc[\"isOaExtra\"] = True\n elif should_be_open == -1:\n doc[\"isOaExtra\"] = False\n except IndexError:\n print(\"publicationDate_tdate error ?\")\n doc[\"Created\"] = datetime.datetime.now().isoformat()\n\n if not init: # récupération de l'existant pour ne pas écraser\n field = \"_id\"\n doc_param = esActions.scope_p(field, doc[\"_id\"])\n\n if not es.indices.exists(\n index=chercheur[\"structSirene\"]\n + \"-\"\n + chercheur[\"labHalId\"]\n + \"-researchers-\"\n + chercheur[\"ldapId\"]\n + \"-documents\"\n ): # -researchers\" + row[\"ldapId\"] + \"-documents\n print(\"exception \", chercheur[\"labHalId\"], chercheur[\"ldapId\"])\n\n res = es.search(\n index=chercheur[\"structSirene\"]\n + \"-\"\n + chercheur[\"labHalId\"]\n + \"-researchers-\"\n + chercheur[\"ldapId\"]\n + \"-documents\",\n body=doc_param,\n ) # -researchers\" + row[\"ldapId\"] + \"-documents\n\n if len(res[\"hits\"][\"hits\"]) > 0:\n doc[\"validated\"] = res[\"hits\"][\"hits\"][0][\"_source\"][\"validated\"]\n if \"authorship\" in res[\"hits\"][\"hits\"][0][\"_source\"]:\n doc[\"authorship\"] = res[\"hits\"][\"hits\"][0][\"_source\"][\"authorship\"]\n\n if (\n res[\"hits\"][\"hits\"][0][\"_source\"][\"modifiedDate_tdate\"]\n != doc[\"modifiedDate_tdate\"]\n ):\n doc[\"records\"].append(\n {\n \"beforeModifiedDate_tdate\": doc[\"modifiedDate_tdate\"],\n \"MDS\": res[\"hits\"][\"hits\"][0][\"_source\"][\"MDS\"],\n }\n )\n\n else:\n doc[\"validated\"] = True\n progress_recorder.set_progress(num, len(docs), description=\"(récolte)\")\n progress_recorder.set_progress(num, len(docs), description=\"(indexation)\")\n helpers.bulk(\n es,\n docs,\n index=chercheur[\"structSirene\"]\n + \"-\"\n + chercheur[\"labHalId\"]\n + \"-researchers-\"\n + chercheur[\"ldapId\"]\n + \"-documents\",\n refresh=\"wait_for\",\n )\n\n return chercheur # au cas où","def test_document_listing(self, flag_is_active):\n flag_is_active.return_value = True\n\n # Create a topic and product\n t = topic(save=True)\n p = product(save=True)\n\n # Create 3 documents with the topic and product and one without\n for i in range(3):\n doc = revision(is_approved=True, save=True).document\n doc.topics.add(t)\n doc.products.add(p)\n doc = revision(is_approved=True, save=True).document\n\n self.refresh()\n\n # GET the page and verify the content\n url = reverse('products.documents', args=[p.slug, t.slug])\n r = self.client.get(url, follow=True)\n eq_(200, r.status_code)\n doc = pq(r.content)\n eq_(3, len(doc('#document-list li')))","def list_documents(self, report_type: Type, key: str = None) -> List[str]:\n documents = []\n collection = self.client.collection(f'{report_type}').list_documents()\n for document in collection:\n if key:\n if document.id == key:\n for _document in document.get().to_dict():\n documents.append(_document)\n else:\n documents.append(document.id)\n\n return documents","def readDocuments(docs, prefix):\n\n fmap = open(\"mapping.txt\", \"w\")\n\n\n i = -1\n for folder in pressrelease_folders_txt:\n i += 1\n fullpath = path.join(prefix, folder)\n totFilesInFolder = len(fnmatch.filter(os.listdir(fullpath),\n '*.txt'))\n countFiles = 0\n for f in listdir(path.join(prefix, folder)):\n fmap.write(\"{0}\\t {1:5d}\\n\".format(f, countFiles))\n countFiles += 1\n fullname = fullpath + f\n # text = open(fullname).readlines()\n ff = open(fullname)\n docs.append(ff.read())\n\n print(\"{0:5d}/{1:5d} :: Reading file {2:10s} \".format(countFiles,\n totFilesInFolder, f))\n\n # if countFiles > 4:\n # return\n\n\n fmap.close()","def get_required_docs(doc_type):\n doc_type = 1 if doc_type == 'registration' else 2\n return Documents.query.filter_by(type=doc_type, required=True).all()","def get_recommendations(self):\n endpoints = '/user/recs'\n return self.get_request(endpoints)","def get_queryset(self, request):\n qs = super().get_queryset(request)\n qs = qs.prefetch_related('writerinwork_set')\n qs = qs.prefetch_related('writers')\n qs = qs.prefetch_related('library_release__library')\n qs = qs.annotate(models.Count('cwr_exports', distinct=True))\n qs = qs.annotate(models.Count('recordings', distinct=True))\n return qs","def _relevant_docs_from_posting(self, all_terms, posting):\n if len(all_terms) == 0: #if empty\n return {}\n\n all_terms_in_same_file = []\n relevant_docs = {}\n\n for term in all_terms.keys():\n relevant_docs[term] = posting[term]['tf']\n\n return relevant_docs","def get_xqa_json(self):\n line = []\n for count, document in enumerate(self.documents):\n json_item = {\"id\": [self.id, count],\n \"question\": self.question,\n \"document\": document,\n \"document_id\": self.document_ids[count]}\n line.append(json_item)\n return line","def set_documents(cls, input_list_text: List[str]) -> None:\n cls.documents = input_list_text","def list_quickstreams():\n quickstreams = read_quickstreams()\n print()\n if quickstreams == {}:\n print(\"No Quickstream bookmarks found.\")\n else:\n print(json.dumps(quickstreams, indent=4))","def docs_from_many_clinical_records(\n base_path: Path, nlp: Language = spacy.blank(\"en\"), merge_docs: bool = True\n) -> List[Doc]:\n all_docs = []\n concept_paths = sorted((base_path / \"concepts\").glob(\"*.txt.con\"))\n document_paths = sorted((base_path / \"docs\").glob(\"*.txt\"))\n\n for con_path, doc_path in zip(concept_paths, document_paths):\n annotations = con_path.open().read().splitlines()\n lines = doc_path.open().read().splitlines()\n\n docs = docs_from_clinical_record(lines, annotations, nlp, merge_docs=merge_docs)\n all_docs += docs\n\n return all_docs","def get_publishers(self):","def content_list(self):\n return self.face.FACES.files.find({})","def get_relevant_documents(self, n_top_hits: Optional[int] = 10) -> List[str]:\n search_string_clean = [self.clean_document(self.search_string)]\n q_vec = self.vectorizer.transform(search_string_clean).toarray().reshape(self.df_tdm.shape[0], )\n sim = {} # Calculate the similarity\n for i in range(n_top_hits):\n print(i)\n sim[i] = np.dot(self.df_tdm.loc[:, i].values, q_vec) / np.linalg.norm(\n self.df_tdm.loc[:, i]) * np.linalg.norm(q_vec)\n # Sort the values\n sim_sorted = sorted(sim.items(), key=lambda item: item[1],\n reverse=True) # Print the articles and their similarity values\n for k, v in sim_sorted:\n if v != 0.0:\n self.search_results.append(self.documents_names[k])\n # print(docs[k])\n return self.search_results","def search_doc(ix, to_search):\n with ix.searcher() as searcher:\n results = searcher.more_like(None, 'code', text=return_unicode(to_search), top=DOCS_TO_FIND)\n info = []\n for res in results:\n q_id = res.fields()['question_id']\n score = res.score\n code = res.fields()['code']\n info += [(q_id, res, code)]\n return info","def _serialize_submitted_documents(self, item):\n if not item.has_proposal:\n return []\n\n docs = IContentListing(item.proposal.resolve_submitted_documents())\n return [doc.render_link() for doc in docs]","def get_docs(self):\n return get_view_description(self.callback)","def get_documents(path_to_dir, qn_id):\n files_to_question = []\n directory = os.path.join(path_to_dir, str(qn_id))\n filenames = os.listdir(directory)\n filenames.sort(key=int)\n\n for filename in filenames:\n doc_name, _ = os.path.splitext(filename)\n document_filepath = os.path.join(directory, filename)\n with open(document_filepath, 'rb') as subfile:\n subfile_data = subfile.readlines()\n\n # Use tried-and-tested tokenizer code from P1...\n tokenized_sentences = string_to_tokens(subfile_data)\n if not tokenized_sentences:\n continue\n\n doc = Document(doc_id=int(doc_name), qn_id=qn_id, content=tokenized_sentences)\n files_to_question.append(doc)\n\n return files_to_question","def test_documents_detailed_search_endpoint(self):\n\n # Search for documents using more specific criterias, like presidential names.\n presidential_documents = self.federal_client.documents(\n presidents=['donald-trump']\n )\n\n # Make sure we have a response.\n self.assertIsNotNone(presidential_documents)\n\n # And make sure we have some results.\n self.assertGreaterEqual(presidential_documents['count'], 10)","def get_document_eids(self, *args, **kwds):\n search = ScopusSearch('au-id({})'.format(self.identifier),\n *args, **kwds)\n return search.get_eids()","def get_documents(self, engine_name, document_ids):\n endpoint = \"engines/{}/documents\".format(engine_name)\n data = json.dumps(document_ids)\n return self.swiftype_session.request('get', endpoint, data=data)","def get_queryset(self):\n queryset = self.queryset\n project_id = self.request.query_params.get('project', None)\n if project_id:\n queryset = self.queryset.filter(document__project_id=project_id)\n id_value = self.request.query_params.get('id', None)\n if id_value:\n id_list = id_value.split(',')\n queryset = self.queryset.filter(id__in=id_list)\n return queryset","def RApps(self):\n\t\treturn self.acad.ActiveDocument.RegisteredApplications","def getSongTextInfo():\n sids = []\n documents = []\n sFile = open('../txt/two__Lastfm_song_Docs.txt')\n lines = sFile.readlines()\n index = 0\n for line in lines:\n line.strip('\\n')\n line.strip('\\r\\n')\n items = line.split('>>')\n sid = int(items[0])\n text = items[1]\n documents.append(text)\n sids.append(sid)\n sFile.close()\n print 'len = ',len(sids)\n print 'len = ',len(documents)\n return sids,documents","def get_queryset(self):\r\n return Keyword.objects.all()","def _build_experiment_embedded_list():\n pass","def extend(self, results):\r\n \r\n docs = self.docs\r\n self.scored_list.extend(docnum for docnum in results.scored_list\r\n if docnum not in docs)\r\n self.docs = docs | results.docs\r\n \r\n # TODO: merge the query terms?\r","def qalist(self):\n return self._palist.qalist","def get_queryset(self):\n qs = super(DocsItaliaProjectViewSet, self).get_queryset()\n tags = self.request.query_params.get('tags', None)\n if tags:\n tags = tags.split(',')\n qs = qs.filter(tags__slug__in=tags).distinct()\n publisher = self.request.query_params.get('publisher', None)\n if publisher:\n qs = qs.filter(publisherproject__publisher__slug=publisher)\n project = self.request.query_params.get('project', None)\n if project:\n qs = qs.filter(publisherproject__slug=project)\n return qs","def get_verified_documents(self, document_set):\n\n q = \"\"\"\n SELECT distinct(document.id) AS document_id, document.name as document_name\n FROM crowdataapp_documentsetfieldentry field_entry\n\n LEFT OUTER JOIN crowdataapp_canonicalfieldentrylabel canonical_label ON canonical_label.id = field_entry.canonical_label_id\n INNER JOIN crowdataapp_documentsetformentry form_entry ON form_entry.id = field_entry.entry_id\n INNER JOIN crowdataapp_document document ON document.id = form_entry.document_id\n\n WHERE document.document_set_id = %d\n AND field_entry.verified = TRUE\n AND canonical_label.id = %d\n \"\"\" % (document_set.id, self.id)\n\n cursor = connection.cursor()\n cursor.execute(q)\n return cursor.fetchall()","def get_queryset(self, request):\n qs = super().get_queryset(request)\n qs = qs.prefetch_related('work__writers')\n qs = qs.prefetch_related('artist')\n qs = qs.prefetch_related('record_label')\n return qs","def retrieve_documents(s, db):\n terms = ['\"%s\"' %stem(term) for term in tokenize(s)]\n \n conn = sqlite3.connect(db)\n c = conn.cursor()\n c.execute('''SELECT docs, tfs FROM inv_index \n WHERE term IN (%s)''' %(','.join(terms)))\n res = c.fetchall()\n\n if not res:\n return None\n \n # if only one result, get the doc(s) with highest tf\n if len(res) == 1:\n doc_ids = str_to_int_vect(res[0][0])\n tfs = str_to_int_vect(res[0][1])\n doc_ids = [doc_ids[i] for i in get_max_indexes(tfs)]\n else:\n # multiple results, get the intersection of doc ids\n sets = [set(str_to_int_vect(d)) for d, _ in res]\n doc_ids = list(set.intersection(*sets))\n\n # if no intersection, then return the documents with highest tf-idf\n if len(doc_ids) == 0:\n c.execute('SELECT id FROM docs')\n n = len(c.fetchall())\n for d, t in res:\n tf_idf = tfidf(n, len(str_to_int_vect(d)), str_to_int_vect(t))\n doc_ids += get_max_indexes(tf_idf)\n \n doc_ids = [str(i) for i in doc_ids]\n c.execute('''SELECT doc FROM docs WHERE id IN (%s)''' %(','.join(doc_ids)))\n return [res[0] for res in c.fetchall()]","def get_doc_ids(self):\n cursor = self.connection.cursor()\n cursor.execute(\"SELECT id FROM documents\")\n results = [r[0] for r in cursor.fetchall()]\n cursor.close()\n return results"],"string":"[\n \"def documents(pmid_23982599, civic_aid6_document):\\n return [pmid_23982599, civic_aid6_document]\",\n \"def getDocuments(self):\\n return self.objectValues('Multifile')\",\n \"def get_documents():\\n documents = []\\n for category in movie_reviews.categories():\\n for fileid in movie_reviews.fileids(category):\\n documents.append((list(movie_reviews.words(fileid)), category))\\n \\n return documents\",\n \"def documents(self, **kw):\\r\\n \\r\\n doc_reader = self.doc_reader\\r\\n return (doc_reader[docnum] for docnum in self.document_numbers(**kw))\",\n \"def getDocsList(self):\\n return self.docs_list\",\n \"def items(self):\\n return self.docs.items()\",\n \"def get_documents(self, subtypes=None, refresh=False):\\n search = ScopusSearch('au-id({})'.format(self.identifier), refresh)\\n if subtypes:\\n return [p for p in search.results if p.subtype in subtypes]\\n else:\\n return search.results\",\n \"def documentlist_sponsor():\\n # get the current user id\\n user_id = current_user.id\\n\\n # Document objects list which includes editors for all objects\\n # this logic will only work if document_objects.count() = editor_objects.count()\\n # get document objects filtered by the current user\\n # attach autodocs based upon revision helper table\\n document_objects=db.session.query(Retention.sponsor_id,User.id,Retention.editor_id,Retention.document_id,User.name,Document.document_name,Document.document_body,Autodoc.autodoc_body).\\\\\\n join(Retention, User.id==Retention.editor_id).\\\\\\n join(Document, Document.id==Retention.document_id).\\\\\\n order_by(Retention.sponsor_id).\\\\\\n filter(Retention.sponsor_id == user_id).\\\\\\n join(Revision,Revision.document_id==Document.id).\\\\\\n join(Autodoc,Autodoc.id==Revision.autodoc_id)\\n\\n # get a count of the document objects\\n document_count = document_objects.count()\\n\\n # blank list to append to for documents and editors\\n document_list=[]\\n\\n # loop through document objects\\n for counter in range(0,document_count):\\n document_list.append(document_objects[counter])\\n\\n # show list of document names\\n documents = document_list\\n\\n return render_template(\\n 'documentlist_sponsor.jinja2',\\n documents=documents,\\n )\",\n \"def list_qualifications() -> Dict[str, Any]:\\n qualifications_schema = QualificationSchema(many=True)\\n qualifications = Qualification.query.all()\\n return cast(Dict[str, Any], jsonify(qualifications_schema.dump(qualifications)))\",\n \"def get_qualification_list(self):\\n try:\\n qualifications = self.db_handler.get_qualifications_list()\\n self.logger.write_to_log('qualifications got', 'model')\\n return qualifications\\n except Exception as err:\\n method_name = sys._getframe().f_code.co_name\\n\\n self.logger.write_to_log('exception', 'model')\\n self.logger.write_to_err_log(f'exception in method {method_name} - {err}', 'model')\",\n \"def listFeaturableContentTypes():\",\n \"def get_qualities_with_expert_knowledge(self) -> List[str]:\\n return sorted(list(set([q for _, q in self.expert_knowledge])))\",\n \"def docs():\",\n \"def speakersVocabulary(context):\\n ct = getToolByName(context,'portal_catalog')\\n dictSearch = {'portal_type':'apyb.papers.speaker','sort_on':'sortable_title'}\\n speakers = ct.searchResults(**dictSearch)\\n speakers = [SimpleTerm(b.UID,b.UID,b.Title) for b in speakers]\\n return SimpleVocabulary(speakers)\",\n \"def documentlist_editor():\\n # get the current user id\\n user_id = current_user.id\\n\\n # Document objects and list, as well as Editor objects and list\\n # this logic will only work if document_objects.count() = editor_objects.count()\\n # get document objects filtered by the current user\\n document_objects=db.session.query(Retention.sponsor_id,User.id,Retention.editor_id,Retention.document_id,User.name,Document.document_name,Document.document_body,Autodoc.autodoc_body).\\\\\\n join(Retention, User.id==Retention.editor_id).\\\\\\n join(Document, Document.id==Retention.document_id).\\\\\\n order_by(Retention.sponsor_id).\\\\\\n filter(Retention.editor_id == user_id).\\\\\\n join(Revision,Revision.document_id==Document.id).\\\\\\n join(Autodoc,Autodoc.id==Revision.autodoc_id)\\n\\n # get a count of the document objects\\n document_count = document_objects.count()\\n\\n # blank list to append to for documents and editors\\n document_list=[]\\n\\n # loop through document objects\\n for counter in range(0,document_count):\\n document_list.append(document_objects[counter])\\n\\n # show list of document names\\n documents = document_list\\n\\n\\n return render_template(\\n 'documentlist_editor.jinja2',\\n documents=documents,\\n )\",\n \"def get_documents(doc_type):\\n doc_type = 1 if doc_type == 'registration' else 2\\n return Documents.query.filter_by(type=doc_type).all()\",\n \"def Documents(self, default=[{}]):\\n tmp = self.data.get('metadata', {}).get('documents', default)\\n return [HEP.DocumentObject(i) for i in tmp]\",\n \"def documents(self) -> list[str]:\\n return self._documents\",\n \"def get_labelled_documents_queryset(self):\\n from ..models import LabelledDocument\\n\\n return LabelledDocument.objects\\\\\\n .filter(model_name=self.get_name())\",\n \"def documents(self):\\r\\n return doc.Documents(self)\",\n \"def test_client_document_list(self):\\n pass\",\n \"def get_documents(self, value, key='name'):\\n documents = []\\n for doc in value:\\n if doc.endswith('.json'):\\n key = 'filename'\\n documents.append([x for x in self.vocab if x[key] == doc])\\n return documents\",\n \"def __get_lucene_contents(self, doc_id, en_list):\\n contents = [{'field_name': Lucene.FIELDNAME_ID, 'field_value': doc_id, 'field_type': Lucene.FIELDTYPE_ID}]\\n for en_id in en_list:\\n contents.append({'field_name': \\\"content\\\", 'field_value': en_id, 'field_type': Lucene.FIELDTYPE_ID_TV})\\n return contents\",\n \"def retrieveDocuments(self):\\n documents = {}\\n for reuter in self.REUTERS_FILES:\\n print(reuter)\\n reuter_stream = open(self.BASEPATH + reuter, encoding=\\\"latin-1\\\")\\n reuter_content = reuter_stream.read()\\n soup = BeautifulSoup(reuter_content, \\\"html.parser\\\")\\n articles = soup.find_all('reuters')\\n for article in articles:\\n body = \\\"\\\"\\n title = \\\"\\\"\\n words = \\\"\\\"\\n newid = article['newid']\\n if not article.title is None:\\n title = article.title.string\\n if not article.body is None:\\n body = article.body.string\\n words = title + \\\" \\\" + body\\n documents[newid] = words\\n print(f\\\"Retrieval Complete! - Total Documents: {len(documents)}\\\")\\n return documents\",\n \"def document(self, **kw):\\r\\n \\r\\n for p in self.documents(**kw):\\r\\n return p\",\n \"def all_tone_qualities():\\n\\n tone_qualities = crud.get_tone_qualities()\\n\\n return render_template('all_tone_qualities.html', tone_qualities=tone_qualities)\",\n \"def list_documents(self, engine_name, current=1, size=20):\\n data = { 'page': { 'current': current, 'size': size } }\\n return self.swiftype_session.request('get', \\\"engines/{}/documents/list\\\".format(engine_name), json=data)\",\n \"def get_expert_knowledge_for_qualities(self, qualities: List[str]) -> List[str]:\\n expert_knowledge = reduce(\\n lambda res, q: res | set(p for p, _q in self.expert_knowledge if _q == q),\\n qualities,\\n set()\\n )\\n return sorted(list(expert_knowledge))\",\n \"def registered_docs(self):\\n return [t for t in self.registered if isinstance(t, dexy.doc.Doc)]\",\n \"def topics(self):\\r\\n return contents.Topics(self)\",\n \"def snippetList(requeset, format = None):\",\n \"def merge_docs(self):\",\n \"def get_documents() -> list[Document]:\\n g.ledger.changed()\\n return [e for e in g.filtered.entries if isinstance(e, Document)]\",\n \"def test_all_documents(self):\",\n \"def prefiltered_docs(self):\\n relevant_docs = set()\\n for term in self.query_terms:\\n try:\\n for entry in self.inv_idx.idx[term]:\\n relevant_docs.add(entry.doc_id)\\n except KeyError:\\n pass\\n return relevant_docs\",\n \"def get_questions(self, obj):\\n queryset = Question.objects.filter(sheet=obj)\\n questions = []\\n for q in queryset:\\n questions.append(q.text)\\n return questions\",\n \"def get_test_doclist(doctype, name=None):\\n\\timport os\\n\\tfrom frappe import conf\\n\\tfrom frappe.modules.utils import peval_doclist\\n\\tfrom frappe.modules import scrub\\n\\n\\tdoctype = scrub(doctype)\\n\\tdoctype_path = os.path.join(os.path.dirname(os.path.abspath(conf.__file__)),\\n\\t\\tconf.test_data_path, doctype)\\n\\n\\tif name:\\n\\t\\twith open(os.path.join(doctype_path, scrub(name) + \\\".json\\\"), 'r') as txtfile:\\n\\t\\t\\tdoclist = peval_doclist(txtfile.read())\\n\\n\\t\\treturn doclist\\n\\n\\telse:\\n\\t\\tall_doclists = []\\n\\t\\tfor fname in filter(lambda n: n.endswith(\\\".json\\\"), os.listdir(doctype_path)):\\n\\t\\t\\twith open(os.path.join(doctype_path, scrub(fname)), 'r') as txtfile:\\n\\t\\t\\t\\tall_doclists.append(peval_doclist(txtfile.read()))\\n\\n\\t\\treturn all_doclists\",\n \"def iter_documents(self):\\n raise NotImplementedError\",\n \"def test_client_verification_document_list(self):\\n pass\",\n \"def _get_documents(self) -> Iterable[dict]:\\n\\n return self._db[\\\"documents\\\"]\",\n \"def get_queryset(self):\\n return PubFulltext.objects.order_by('-pmid')\",\n \"def filter(self, results):\\r\\n \\r\\n docs = self.docs & results.docs\\r\\n self.scored_list = [docnum for docnum in self.scored_list if docnum in docs]\\r\\n self.docs = docs\",\n \"def getMaintainerList(self):\\n return self.getDocumentedObject().getMaintainerList()\",\n \"def get_documents(self):\\n documents = self.tree.execute(\\\"$.documents\\\")\\n for doc in documents:\\n sentences = {s['@id']: s['text'] for s in doc.get('sentences', [])}\\n self.document_dict[doc['@id']] = {'sentences': sentences,\\n 'location': doc['location']}\\n return\",\n \"def test_3_listautor(self): \\n [i for i in self.app._listarAutores()]\\n self.app.getAutores()\",\n \"def gather_documents(self):\\n self.document_gatherer.gather_and_save_everything(Constants.path_cord, \\n Constants.path_metadata, \\n Constants.path_linked_documents,\\n Constants.path_unlinked_documents,\\n Constants.path_parsed_documents,\\n Constants.path_all_documents)\\n \\n print(\\\"Done gathering documents.\\\")\",\n \"def trackVocabulary(context):\\n ct = getToolByName(context,'portal_catalog')\\n tracks = ct.searchResults(portal_type='apyb.papers.track', sort_on='getObjPositionInParent')\\n items = [SimpleTerm(b.UID,b.UID,b.Title) for b in tracks]\\n return SimpleVocabulary(items)\",\n \"def inspect_doc(self, file, terms):\\n # populate with studies in loop\\n reports = []\\n\\n # extract text and do the search\\n for i, chunk in enumerate(file.content_chunks()):\\n\\n study = self.inspect_text(chunk, terms)\\n\\n for entry in study:\\n # only populate if there is a match\\n # otherwise it will be a bunch of\\n # empty studies\\n\\n # supplement with page\\n entry['page'] = i + 1\\n\\n reports.append(entry)\\n\\n return reports\",\n \"def get_queryset(self):\\n samples = AudioSample.objects.distinct()\\n if samples:\\n return samples.filter(\\n pub_date__lte=timezone.now()\\n ).order_by('-pub_date')\\n else:\\n return []\",\n \"def docs(self, searcher, exclude_docs=None):\\r\\n\\r\\n try:\\r\\n return self.matcher(searcher, exclude_docs=exclude_docs).all_ids()\\r\\n except TermNotFound:\\r\\n return []\",\n \"def read_queryset(self, using=None):\\n return self.index_queryset(using=using)\",\n \"def test_list_note_occurrences(self):\\n pass\",\n \"def docs2ids(self):\\n self.docs = [ [self.vocab[word] for word in doc] for doc in self.docs]\",\n \"def get_auto_anno_PUBMED_batch_list(request):\\n\\n json_resp = {}\\n usecase = request.GET.get('usecase')\\n # print(usecase)\\n languages = ['English', 'english']\\n use_obj = UseCase.objects.get(name=usecase)\\n json_resp['batch_list'] = []\\n batch = Report.objects.filter(name=use_obj,language__in = languages,institute = 'PUBMED').values('batch')\\n for el in batch:\\n if el['batch'] not in json_resp['batch_list']:\\n json_resp['batch_list'].append( el['batch'])\\n # print(json_resp['batch_list'])\\n json_resp['batch_list'] = sorted(json_resp['batch_list'])\\n # print(json_resp)\\n return JsonResponse(json_resp)\",\n \"def get_queryset(self):\\n acc = self.kwargs['accession'].lstrip('MGYA')\\n job_query = Q(pk=acc)\\n\\n if self.analysis_job_filters:\\n job_query &= self.analysis_job_filters\\n\\n job = get_object_or_404(emg_models.AnalysisJob, job_query)\\n\\n analysis = None\\n try:\\n analysis = self.annotation_model.objects \\\\\\n .get(analysis_id=str(job.job_id))\\n except self.annotation_model.DoesNotExist:\\n # Return an empty EmbeddedDocumentList, the entity exists\\n # but it doesn't have annotations\\n return EmbeddedDocumentList([], self.annotation_model, self.annotation_model_property)\\n\\n if hasattr(self, \\\"annotation_model_property_resolver\\\"):\\n return self.annotation_model_property_resolver(analysis)\\n\\n return getattr(analysis, self.annotation_model_property)\",\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 get_designs(self):\",\n \"def get_docs(self):\\n return self.retrieve_docstring()\",\n \"def get_docs(self):\\n return self.retrieve_docstring()\",\n \"def get_docs(self):\\n return self.retrieve_docstring()\",\n \"def getCatalogs():\",\n \"def relevant_docs_from_posting(self, query):\\n relevant_docs = {}\\n # postingLists = [self.FindPostingByTerm(term) for term in query] #list of posting file -->[idx,tweet id,tfi]\\n for term in query:\\n post = self.FindPostingByTerm_Binary(term)\\n for p in post:\\n tweet_id = p[1]\\n if tweet_id not in relevant_docs.keys():\\n relevant_docs[tweet_id] = {}\\n relevant_docs[tweet_id][term] = p[2] * self.inverted_index[term][1] # wiq\\n return relevant_docs\",\n \"def find_records():\\r\\n\\r\\n print(\\\"begin find records\\\")\\r\\n\\r\\n study_list = retrieve_ref('study_list')\\r\\n sensor_list = retrieve_ref('sensor_list')\\r\\n # sensor_unit_list = retrieve_ref('sensor_unit_list')\\r\\n\\r\\n for study in study_list:\\r\\n # print('study = ' + str(study))\\r\\n source_path = os.path.join(study, 'source')\\r\\n # print('source_path = ' + str(source_path))\\r\\n\\r\\n source_folders = os.listdir(source_path)\\r\\n # print(str(study) + ' source_folders = ')\\r\\n # print(source_folders)\\r\\n\\r\\n df_meta = pd.DataFrame()\\r\\n df_meta['source_path'] = source_folders\\r\\n save_meta(study, df_meta)\\r\\n record_to_summary(study, 'Records found', str(len(source_folders)))\\r\\n\\r\\n print(\\\"completed find records\\\")\",\n \"def get_auto_anno_batch_list(request):\\n\\n json_resp = {}\\n usecase = request.GET.get('usecase')\\n # print(usecase)\\n use_obj = UseCase.objects.get(name=usecase)\\n json_resp['batch_list'] = []\\n languages = ['English','english']\\n batch = Report.objects.filter(name=use_obj,language__in = languages).exclude(institute = 'PUBMED').values('batch')\\n for el in batch:\\n if el['batch'] not in json_resp['batch_list']:\\n json_resp['batch_list'].append( el['batch'])\\n # print(json_resp['batch_list'])\\n json_resp['batch_list'] = sorted(json_resp['batch_list'])\\n # print(json_resp)\\n return JsonResponse(json_resp)\",\n \"def _collection_samples(collection_query, limit, config):\\n just_cid = lambda obj : obj.get('meta', {}).get('concept-id')\\n found_collections = scom.search_by_page(\\\"collections\\\",\\n query=collection_query,\\n filters=just_cid,\\n page_state=scom.create_page_state(limit=limit),\\n config=config)\\n return found_collections[:limit]\",\n \"def triple_quote_docs():\\n return\",\n \"def query(self, words: list) -> list:\\r\\n relevant_documents = self.word_to_docs_mapping[words[0]]\\r\\n if len(words) > 1:\\r\\n for word in words:\\r\\n relevant_documents = relevant_documents & self.word_to_docs_mapping[word]\\r\\n return list(relevant_documents)\",\n \"def collecte_docs(self, chercheur, overwrite=False): # self,\\n init = overwrite # If True, data persistence is lost when references are updated\\n docs = hal.find_publications(chercheur[\\\"halId_s\\\"], \\\"authIdHal_s\\\")\\n\\n progress_recorder = ProgressRecorder(self)\\n progress_recorder.set_progress(0, len(docs), description=\\\"récupération des données HAL\\\")\\n # Insert documents collection\\n for num, doc in enumerate(docs):\\n doc[\\\"country_colaboration\\\"] = location_docs.generate_countrys_fields(doc)\\n doc = doi_enrichissement.docs_enrichissement_doi(doc)\\n if \\\"fr_abstract_s\\\" in doc.keys():\\n if isinstance(doc[\\\"fr_abstract_s\\\"], list):\\n doc[\\\"fr_abstract_s\\\"] = \\\"/n\\\".join(doc[\\\"fr_abstract_s\\\"])\\n if len(doc[\\\"fr_abstract_s\\\"]) > 100:\\n doc[\\\"fr_entites\\\"] = keyword_enrichissement.return_entities(\\n doc[\\\"fr_abstract_s\\\"], \\\"fr\\\"\\n )\\n doc[\\\"fr_teeft_keywords\\\"] = keyword_enrichissement.keyword_from_teeft(\\n doc[\\\"fr_abstract_s\\\"], \\\"fr\\\"\\n )\\n if \\\"en_abstract_s\\\" in doc.keys():\\n if isinstance(doc[\\\"en_abstract_s\\\"], list):\\n doc[\\\"en_abstract_s\\\"] = \\\"/n\\\".join(doc[\\\"en_abstract_s\\\"])\\n if len(doc[\\\"en_abstract_s\\\"]) > 100:\\n doc[\\\"en_entites\\\"] = keyword_enrichissement.return_entities(\\n doc[\\\"en_abstract_s\\\"], \\\"en\\\"\\n )\\n doc[\\\"en_teeft_keywords\\\"] = keyword_enrichissement.keyword_from_teeft(\\n doc[\\\"en_abstract_s\\\"], \\\"en\\\"\\n )\\n\\n doc[\\\"_id\\\"] = doc[\\\"docid\\\"]\\n doc[\\\"validated\\\"] = True\\n\\n doc[\\\"harvested_from\\\"] = \\\"researcher\\\"\\n\\n doc[\\\"harvested_from_ids\\\"] = []\\n doc[\\\"harvested_from_label\\\"] = []\\n\\n #\\n #\\n # print(doc[\\\"authorship\\\"], doc ['authLastName_s'])\\n\\n if len(doc[\\\"authIdHal_s\\\"]) != len(doc[\\\"authLastName_s\\\"]):\\n # print (\\\"elastichal.py : test d'autorat no good\\\")\\n # test sur le nom complet...\\n nom = [\\n truc\\n for truc in doc[\\\"authLastName_s\\\"]\\n if chercheur[\\\"lastName\\\"].lower() in truc.lower()\\n ] # pour les récemment mariés qui auraient un nom composé...\\n # Après si 'lun des co-auteur porte le même nom...\\n if len(nom) > 0:\\n nom = nom[0].title()\\n try:\\n if doc[\\\"authLastName_s\\\"].index(nom) == 0: # premier\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"firstAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n elif (\\n doc[\\\"authLastName_s\\\"].index(nom) == len(doc[\\\"authLastName_s\\\"]) - 1\\n ): # dernier\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"lastAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n except ValueError:\\n doc[\\\"authorship\\\"] = []\\n else:\\n doc[\\\"authorship\\\"] = []\\n elif chercheur[\\\"halId_s\\\"] in doc[\\\"authIdHal_s\\\"]:\\n if doc[\\\"authIdHal_s\\\"].index(chercheur[\\\"halId_s\\\"]) == 0:\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"firstAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n elif (\\n doc[\\\"authIdHal_s\\\"].index(chercheur[\\\"halId_s\\\"]) == len(doc[\\\"authIdHal_s\\\"]) - 1\\n ): # dernier\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"lastAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n else:\\n doc[\\\"authorship\\\"] = []\\n else:\\n doc[\\\"authorship\\\"] = []\\n\\n doc[\\\"harvested_from_ids\\\"].append(chercheur[\\\"halId_s\\\"])\\n\\n # historique d'appartenance du docId\\n # pour attribuer les bons docs aux chercheurs\\n # harvet_history.append({'docid': doc['docid'], 'from': row['halId_s']})\\n #\\n # for h in harvet_history:\\n # if h['docid'] == doc['docid']:\\n # if h['from'] not in doc[\\\"harvested_from_ids\\\"]:\\n # doc[\\\"harvested_from_ids\\\"].append(h['from'])\\n\\n doc[\\\"records\\\"] = []\\n\\n doc[\\\"MDS\\\"] = utils.calculate_mds(doc)\\n\\n try:\\n should_be_open = utils.should_be_open(doc)\\n if should_be_open == 1:\\n doc[\\\"should_be_open\\\"] = True\\n if should_be_open == -1:\\n doc[\\\"should_be_open\\\"] = False\\n\\n if should_be_open == 1 or should_be_open == 2:\\n doc[\\\"isOaExtra\\\"] = True\\n elif should_be_open == -1:\\n doc[\\\"isOaExtra\\\"] = False\\n except IndexError:\\n print(\\\"publicationDate_tdate error ?\\\")\\n doc[\\\"Created\\\"] = datetime.datetime.now().isoformat()\\n\\n if not init: # récupération de l'existant pour ne pas écraser\\n field = \\\"_id\\\"\\n doc_param = esActions.scope_p(field, doc[\\\"_id\\\"])\\n\\n if not es.indices.exists(\\n index=chercheur[\\\"structSirene\\\"]\\n + \\\"-\\\"\\n + chercheur[\\\"labHalId\\\"]\\n + \\\"-researchers-\\\"\\n + chercheur[\\\"ldapId\\\"]\\n + \\\"-documents\\\"\\n ): # -researchers\\\" + row[\\\"ldapId\\\"] + \\\"-documents\\n print(\\\"exception \\\", chercheur[\\\"labHalId\\\"], chercheur[\\\"ldapId\\\"])\\n\\n res = es.search(\\n index=chercheur[\\\"structSirene\\\"]\\n + \\\"-\\\"\\n + chercheur[\\\"labHalId\\\"]\\n + \\\"-researchers-\\\"\\n + chercheur[\\\"ldapId\\\"]\\n + \\\"-documents\\\",\\n body=doc_param,\\n ) # -researchers\\\" + row[\\\"ldapId\\\"] + \\\"-documents\\n\\n if len(res[\\\"hits\\\"][\\\"hits\\\"]) > 0:\\n doc[\\\"validated\\\"] = res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"validated\\\"]\\n if \\\"authorship\\\" in res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"]:\\n doc[\\\"authorship\\\"] = res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"authorship\\\"]\\n\\n if (\\n res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"modifiedDate_tdate\\\"]\\n != doc[\\\"modifiedDate_tdate\\\"]\\n ):\\n doc[\\\"records\\\"].append(\\n {\\n \\\"beforeModifiedDate_tdate\\\": doc[\\\"modifiedDate_tdate\\\"],\\n \\\"MDS\\\": res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"MDS\\\"],\\n }\\n )\\n\\n else:\\n doc[\\\"validated\\\"] = True\\n progress_recorder.set_progress(num, len(docs), description=\\\"(récolte)\\\")\\n progress_recorder.set_progress(num, len(docs), description=\\\"(indexation)\\\")\\n helpers.bulk(\\n es,\\n docs,\\n index=chercheur[\\\"structSirene\\\"]\\n + \\\"-\\\"\\n + chercheur[\\\"labHalId\\\"]\\n + \\\"-researchers-\\\"\\n + chercheur[\\\"ldapId\\\"]\\n + \\\"-documents\\\",\\n refresh=\\\"wait_for\\\",\\n )\\n\\n return chercheur # au cas où\",\n \"def test_document_listing(self, flag_is_active):\\n flag_is_active.return_value = True\\n\\n # Create a topic and product\\n t = topic(save=True)\\n p = product(save=True)\\n\\n # Create 3 documents with the topic and product and one without\\n for i in range(3):\\n doc = revision(is_approved=True, save=True).document\\n doc.topics.add(t)\\n doc.products.add(p)\\n doc = revision(is_approved=True, save=True).document\\n\\n self.refresh()\\n\\n # GET the page and verify the content\\n url = reverse('products.documents', args=[p.slug, t.slug])\\n r = self.client.get(url, follow=True)\\n eq_(200, r.status_code)\\n doc = pq(r.content)\\n eq_(3, len(doc('#document-list li')))\",\n \"def list_documents(self, report_type: Type, key: str = None) -> List[str]:\\n documents = []\\n collection = self.client.collection(f'{report_type}').list_documents()\\n for document in collection:\\n if key:\\n if document.id == key:\\n for _document in document.get().to_dict():\\n documents.append(_document)\\n else:\\n documents.append(document.id)\\n\\n return documents\",\n \"def readDocuments(docs, prefix):\\n\\n fmap = open(\\\"mapping.txt\\\", \\\"w\\\")\\n\\n\\n i = -1\\n for folder in pressrelease_folders_txt:\\n i += 1\\n fullpath = path.join(prefix, folder)\\n totFilesInFolder = len(fnmatch.filter(os.listdir(fullpath),\\n '*.txt'))\\n countFiles = 0\\n for f in listdir(path.join(prefix, folder)):\\n fmap.write(\\\"{0}\\\\t {1:5d}\\\\n\\\".format(f, countFiles))\\n countFiles += 1\\n fullname = fullpath + f\\n # text = open(fullname).readlines()\\n ff = open(fullname)\\n docs.append(ff.read())\\n\\n print(\\\"{0:5d}/{1:5d} :: Reading file {2:10s} \\\".format(countFiles,\\n totFilesInFolder, f))\\n\\n # if countFiles > 4:\\n # return\\n\\n\\n fmap.close()\",\n \"def get_required_docs(doc_type):\\n doc_type = 1 if doc_type == 'registration' else 2\\n return Documents.query.filter_by(type=doc_type, required=True).all()\",\n \"def get_recommendations(self):\\n endpoints = '/user/recs'\\n return self.get_request(endpoints)\",\n \"def get_queryset(self, request):\\n qs = super().get_queryset(request)\\n qs = qs.prefetch_related('writerinwork_set')\\n qs = qs.prefetch_related('writers')\\n qs = qs.prefetch_related('library_release__library')\\n qs = qs.annotate(models.Count('cwr_exports', distinct=True))\\n qs = qs.annotate(models.Count('recordings', distinct=True))\\n return qs\",\n \"def _relevant_docs_from_posting(self, all_terms, posting):\\n if len(all_terms) == 0: #if empty\\n return {}\\n\\n all_terms_in_same_file = []\\n relevant_docs = {}\\n\\n for term in all_terms.keys():\\n relevant_docs[term] = posting[term]['tf']\\n\\n return relevant_docs\",\n \"def get_xqa_json(self):\\n line = []\\n for count, document in enumerate(self.documents):\\n json_item = {\\\"id\\\": [self.id, count],\\n \\\"question\\\": self.question,\\n \\\"document\\\": document,\\n \\\"document_id\\\": self.document_ids[count]}\\n line.append(json_item)\\n return line\",\n \"def set_documents(cls, input_list_text: List[str]) -> None:\\n cls.documents = input_list_text\",\n \"def list_quickstreams():\\n quickstreams = read_quickstreams()\\n print()\\n if quickstreams == {}:\\n print(\\\"No Quickstream bookmarks found.\\\")\\n else:\\n print(json.dumps(quickstreams, indent=4))\",\n \"def docs_from_many_clinical_records(\\n base_path: Path, nlp: Language = spacy.blank(\\\"en\\\"), merge_docs: bool = True\\n) -> List[Doc]:\\n all_docs = []\\n concept_paths = sorted((base_path / \\\"concepts\\\").glob(\\\"*.txt.con\\\"))\\n document_paths = sorted((base_path / \\\"docs\\\").glob(\\\"*.txt\\\"))\\n\\n for con_path, doc_path in zip(concept_paths, document_paths):\\n annotations = con_path.open().read().splitlines()\\n lines = doc_path.open().read().splitlines()\\n\\n docs = docs_from_clinical_record(lines, annotations, nlp, merge_docs=merge_docs)\\n all_docs += docs\\n\\n return all_docs\",\n \"def get_publishers(self):\",\n \"def content_list(self):\\n return self.face.FACES.files.find({})\",\n \"def get_relevant_documents(self, n_top_hits: Optional[int] = 10) -> List[str]:\\n search_string_clean = [self.clean_document(self.search_string)]\\n q_vec = self.vectorizer.transform(search_string_clean).toarray().reshape(self.df_tdm.shape[0], )\\n sim = {} # Calculate the similarity\\n for i in range(n_top_hits):\\n print(i)\\n sim[i] = np.dot(self.df_tdm.loc[:, i].values, q_vec) / np.linalg.norm(\\n self.df_tdm.loc[:, i]) * np.linalg.norm(q_vec)\\n # Sort the values\\n sim_sorted = sorted(sim.items(), key=lambda item: item[1],\\n reverse=True) # Print the articles and their similarity values\\n for k, v in sim_sorted:\\n if v != 0.0:\\n self.search_results.append(self.documents_names[k])\\n # print(docs[k])\\n return self.search_results\",\n \"def search_doc(ix, to_search):\\n with ix.searcher() as searcher:\\n results = searcher.more_like(None, 'code', text=return_unicode(to_search), top=DOCS_TO_FIND)\\n info = []\\n for res in results:\\n q_id = res.fields()['question_id']\\n score = res.score\\n code = res.fields()['code']\\n info += [(q_id, res, code)]\\n return info\",\n \"def _serialize_submitted_documents(self, item):\\n if not item.has_proposal:\\n return []\\n\\n docs = IContentListing(item.proposal.resolve_submitted_documents())\\n return [doc.render_link() for doc in docs]\",\n \"def get_docs(self):\\n return get_view_description(self.callback)\",\n \"def get_documents(path_to_dir, qn_id):\\n files_to_question = []\\n directory = os.path.join(path_to_dir, str(qn_id))\\n filenames = os.listdir(directory)\\n filenames.sort(key=int)\\n\\n for filename in filenames:\\n doc_name, _ = os.path.splitext(filename)\\n document_filepath = os.path.join(directory, filename)\\n with open(document_filepath, 'rb') as subfile:\\n subfile_data = subfile.readlines()\\n\\n # Use tried-and-tested tokenizer code from P1...\\n tokenized_sentences = string_to_tokens(subfile_data)\\n if not tokenized_sentences:\\n continue\\n\\n doc = Document(doc_id=int(doc_name), qn_id=qn_id, content=tokenized_sentences)\\n files_to_question.append(doc)\\n\\n return files_to_question\",\n \"def test_documents_detailed_search_endpoint(self):\\n\\n # Search for documents using more specific criterias, like presidential names.\\n presidential_documents = self.federal_client.documents(\\n presidents=['donald-trump']\\n )\\n\\n # Make sure we have a response.\\n self.assertIsNotNone(presidential_documents)\\n\\n # And make sure we have some results.\\n self.assertGreaterEqual(presidential_documents['count'], 10)\",\n \"def get_document_eids(self, *args, **kwds):\\n search = ScopusSearch('au-id({})'.format(self.identifier),\\n *args, **kwds)\\n return search.get_eids()\",\n \"def get_documents(self, engine_name, document_ids):\\n endpoint = \\\"engines/{}/documents\\\".format(engine_name)\\n data = json.dumps(document_ids)\\n return self.swiftype_session.request('get', endpoint, data=data)\",\n \"def get_queryset(self):\\n queryset = self.queryset\\n project_id = self.request.query_params.get('project', None)\\n if project_id:\\n queryset = self.queryset.filter(document__project_id=project_id)\\n id_value = self.request.query_params.get('id', None)\\n if id_value:\\n id_list = id_value.split(',')\\n queryset = self.queryset.filter(id__in=id_list)\\n return queryset\",\n \"def RApps(self):\\n\\t\\treturn self.acad.ActiveDocument.RegisteredApplications\",\n \"def getSongTextInfo():\\n sids = []\\n documents = []\\n sFile = open('../txt/two__Lastfm_song_Docs.txt')\\n lines = sFile.readlines()\\n index = 0\\n for line in lines:\\n line.strip('\\\\n')\\n line.strip('\\\\r\\\\n')\\n items = line.split('>>')\\n sid = int(items[0])\\n text = items[1]\\n documents.append(text)\\n sids.append(sid)\\n sFile.close()\\n print 'len = ',len(sids)\\n print 'len = ',len(documents)\\n return sids,documents\",\n \"def get_queryset(self):\\r\\n return Keyword.objects.all()\",\n \"def _build_experiment_embedded_list():\\n pass\",\n \"def extend(self, results):\\r\\n \\r\\n docs = self.docs\\r\\n self.scored_list.extend(docnum for docnum in results.scored_list\\r\\n if docnum not in docs)\\r\\n self.docs = docs | results.docs\\r\\n \\r\\n # TODO: merge the query terms?\\r\",\n \"def qalist(self):\\n return self._palist.qalist\",\n \"def get_queryset(self):\\n qs = super(DocsItaliaProjectViewSet, self).get_queryset()\\n tags = self.request.query_params.get('tags', None)\\n if tags:\\n tags = tags.split(',')\\n qs = qs.filter(tags__slug__in=tags).distinct()\\n publisher = self.request.query_params.get('publisher', None)\\n if publisher:\\n qs = qs.filter(publisherproject__publisher__slug=publisher)\\n project = self.request.query_params.get('project', None)\\n if project:\\n qs = qs.filter(publisherproject__slug=project)\\n return qs\",\n \"def get_verified_documents(self, document_set):\\n\\n q = \\\"\\\"\\\"\\n SELECT distinct(document.id) AS document_id, document.name as document_name\\n FROM crowdataapp_documentsetfieldentry field_entry\\n\\n LEFT OUTER JOIN crowdataapp_canonicalfieldentrylabel canonical_label ON canonical_label.id = field_entry.canonical_label_id\\n INNER JOIN crowdataapp_documentsetformentry form_entry ON form_entry.id = field_entry.entry_id\\n INNER JOIN crowdataapp_document document ON document.id = form_entry.document_id\\n\\n WHERE document.document_set_id = %d\\n AND field_entry.verified = TRUE\\n AND canonical_label.id = %d\\n \\\"\\\"\\\" % (document_set.id, self.id)\\n\\n cursor = connection.cursor()\\n cursor.execute(q)\\n return cursor.fetchall()\",\n \"def get_queryset(self, request):\\n qs = super().get_queryset(request)\\n qs = qs.prefetch_related('work__writers')\\n qs = qs.prefetch_related('artist')\\n qs = qs.prefetch_related('record_label')\\n return qs\",\n \"def retrieve_documents(s, db):\\n terms = ['\\\"%s\\\"' %stem(term) for term in tokenize(s)]\\n \\n conn = sqlite3.connect(db)\\n c = conn.cursor()\\n c.execute('''SELECT docs, tfs FROM inv_index \\n WHERE term IN (%s)''' %(','.join(terms)))\\n res = c.fetchall()\\n\\n if not res:\\n return None\\n \\n # if only one result, get the doc(s) with highest tf\\n if len(res) == 1:\\n doc_ids = str_to_int_vect(res[0][0])\\n tfs = str_to_int_vect(res[0][1])\\n doc_ids = [doc_ids[i] for i in get_max_indexes(tfs)]\\n else:\\n # multiple results, get the intersection of doc ids\\n sets = [set(str_to_int_vect(d)) for d, _ in res]\\n doc_ids = list(set.intersection(*sets))\\n\\n # if no intersection, then return the documents with highest tf-idf\\n if len(doc_ids) == 0:\\n c.execute('SELECT id FROM docs')\\n n = len(c.fetchall())\\n for d, t in res:\\n tf_idf = tfidf(n, len(str_to_int_vect(d)), str_to_int_vect(t))\\n doc_ids += get_max_indexes(tf_idf)\\n \\n doc_ids = [str(i) for i in doc_ids]\\n c.execute('''SELECT doc FROM docs WHERE id IN (%s)''' %(','.join(doc_ids)))\\n return [res[0] for res in c.fetchall()]\",\n \"def get_doc_ids(self):\\n cursor = self.connection.cursor()\\n cursor.execute(\\\"SELECT id FROM documents\\\")\\n results = [r[0] for r in cursor.fetchall()]\\n cursor.close()\\n return results\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6024513","0.58850753","0.58229226","0.57380384","0.57273","0.5612921","0.56083256","0.5542388","0.55306774","0.5491607","0.546858","0.54549557","0.54500514","0.5425209","0.54043716","0.53956443","0.53795594","0.53604776","0.5360414","0.53452253","0.5339323","0.5330064","0.53211504","0.5321125","0.5270035","0.5242988","0.5225808","0.5210862","0.520977","0.5201975","0.5195406","0.5188093","0.51701933","0.51541024","0.51478404","0.5117442","0.51121193","0.51069355","0.50918627","0.50829756","0.5076904","0.50710815","0.5062576","0.50617397","0.50483805","0.5043149","0.50428075","0.50362813","0.50174314","0.50107104","0.5009073","0.49997985","0.49965504","0.49956113","0.4991272","0.49904466","0.49901748","0.49889487","0.49889487","0.49889487","0.498685","0.4982754","0.49798834","0.49770653","0.49757093","0.496536","0.49591267","0.4952846","0.49433964","0.49433184","0.49425846","0.4931982","0.49276742","0.49267295","0.49200502","0.49196243","0.491674","0.49157125","0.49115154","0.49094516","0.4909303","0.4904908","0.49040005","0.49039486","0.49014428","0.49000344","0.48990437","0.48972768","0.48946464","0.48818323","0.48757714","0.4874257","0.48692372","0.4868093","0.48606893","0.4856357","0.4855837","0.48555547","0.48546073","0.48477325","0.48441887"],"string":"[\n \"0.6024513\",\n \"0.58850753\",\n \"0.58229226\",\n \"0.57380384\",\n \"0.57273\",\n \"0.5612921\",\n \"0.56083256\",\n \"0.5542388\",\n \"0.55306774\",\n \"0.5491607\",\n \"0.546858\",\n \"0.54549557\",\n \"0.54500514\",\n \"0.5425209\",\n \"0.54043716\",\n \"0.53956443\",\n \"0.53795594\",\n \"0.53604776\",\n \"0.5360414\",\n \"0.53452253\",\n \"0.5339323\",\n \"0.5330064\",\n \"0.53211504\",\n \"0.5321125\",\n \"0.5270035\",\n \"0.5242988\",\n \"0.5225808\",\n \"0.5210862\",\n \"0.520977\",\n \"0.5201975\",\n \"0.5195406\",\n \"0.5188093\",\n \"0.51701933\",\n \"0.51541024\",\n \"0.51478404\",\n \"0.5117442\",\n \"0.51121193\",\n \"0.51069355\",\n \"0.50918627\",\n \"0.50829756\",\n \"0.5076904\",\n \"0.50710815\",\n \"0.5062576\",\n \"0.50617397\",\n \"0.50483805\",\n \"0.5043149\",\n \"0.50428075\",\n \"0.50362813\",\n \"0.50174314\",\n \"0.50107104\",\n \"0.5009073\",\n \"0.49997985\",\n \"0.49965504\",\n \"0.49956113\",\n \"0.4991272\",\n \"0.49904466\",\n \"0.49901748\",\n \"0.49889487\",\n \"0.49889487\",\n \"0.49889487\",\n \"0.498685\",\n \"0.4982754\",\n \"0.49798834\",\n \"0.49770653\",\n \"0.49757093\",\n \"0.496536\",\n \"0.49591267\",\n \"0.4952846\",\n \"0.49433964\",\n \"0.49433184\",\n \"0.49425846\",\n \"0.4931982\",\n \"0.49276742\",\n \"0.49267295\",\n \"0.49200502\",\n \"0.49196243\",\n \"0.491674\",\n \"0.49157125\",\n \"0.49115154\",\n \"0.49094516\",\n \"0.4909303\",\n \"0.4904908\",\n \"0.49040005\",\n \"0.49039486\",\n \"0.49014428\",\n \"0.49000344\",\n \"0.48990437\",\n \"0.48972768\",\n \"0.48946464\",\n \"0.48818323\",\n \"0.48757714\",\n \"0.4874257\",\n \"0.48692372\",\n \"0.4868093\",\n \"0.48606893\",\n \"0.4856357\",\n \"0.4855837\",\n \"0.48555547\",\n \"0.48546073\",\n \"0.48477325\",\n \"0.48441887\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84573,"cells":{"query":{"kind":"string","value":"Tender Qualification Document Upload"},"document":{"kind":"string","value":"def collection_post(self):\n document = upload_file(self.request)\n document.author = self.request.authenticated_role\n self.context.documents.append(document)\n if save_tender(self.request):\n self.LOGGER.info(\n \"Created tender qualification document {}\".format(document.id),\n extra=context_unpack(\n self.request, {\"MESSAGE_ID\": \"tender_qualification_document_create\"}, {\"document_id\": document.id}\n ),\n )\n self.request.response.status = 201\n document_route = self.request.matched_route.name.replace(\"collection_\", \"\")\n self.request.response.headers[\"Location\"] = self.request.current_route_url(\n _route_name=document_route, document_id=document.id, _query={}\n )\n return {\"data\": document.serialize(\"view\")}"},"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 put(self):\n document = upload_file(self.request)\n self.request.validated[\"qualification\"].documents.append(document)\n if save_tender(self.request):\n self.LOGGER.info(\n \"Updated tender qualification document {}\".format(self.request.context.id),\n extra=context_unpack(self.request, {\"MESSAGE_ID\": \"tender_qualification_document_put\"}),\n )\n return {\"data\": document.serialize(\"view\")}","def upload_doc():\n file = request.files[\"file\"]\n meta_data = {\"name\": request.form[\"name\"].lower()}\n file_id = save_file(meta_data, file)\n print('file-id: ' + file_id)\n index_after_uploading(file_id)\n return jsonify({\"file_id\": file_id})","def test_create_document(self):\n self.client.force_login(user=Customer.objects.get(id=self.dummy.customer[0]).user)\n url = reverse('document-list')\n\n data = {\n 'file':open('Murphy.txt'),\n 'type':2,\n 'res':self.res_id,\n 'obsolete': True,\n 'description':'Sth',\n }\n response = self.client.post(url,data,format='multipart')\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n document = Document.objects.get(id=json.loads(response.content)['id'])\n self.assertEqual(document.res_id,self.res_id)\n self.client.logout()","def document_upload():\n form = SourceTextForm()\n if form.validate_on_submit():\n user = current_user\n\n doc = {}\n doc[\"file\"] = form.filename.data\n doc[\"author\"] = form.author.data\n doc[\"title\"] = form.title.data\n doc[\"language\"] = form.language.data\n\n params = {}\n params[\"email\"] = user.email\n params[\"new_page\"] = current_app.config[\"DOCUMENT_UPLOAD\"][\"PAGE_LIMIT\"]\n params[\"line_size\"] = current_app.config[\"DOCUMENT_UPLOAD\"][\"LINE_SIZE\"]\n params[\"early_cutoff\"] = current_app.config[\"DOCUMENT_UPLOAD\"][\"EARLY_CUTOFF\"]\n params[\"batch_size\"] = current_app.config[\"DOCUMENT_UPLOAD\"][\"BATCH_SIZE\"]\n params[\"tokenizer\"] = current_app.config[\"TOKENIZER\"].select(doc[\"language\"])\n params[\"resource\"] = create_book\n doc_uploader = DocumentUploader(params)\n \n could_upload = True\n try:\n doc_uploader.upload(doc)\n except Exception as e:\n traceback.print_exc()\n could_upload = False\n error_msg = \"Error uploading document. Please try again.\"\n flash(error_msg)\n\n if could_upload:\n success_msg = \"Document successfully uploaded.\"\n flash(success_msg)\n\n return render_template('content_management/document_upload.html', form=form)","def upload(self, upload_request):\n raise NotImplementedError","def upload_corpus(self, name, directory, replace=False):\n logging.info('Not uploading corpus because no Filestore.')","def handle_upload(f, attrs):\n\n # chunked = False\n dest_folder = os.path.join(app.config['UPLOAD_DIRECTORY'], attrs['qquuid'])\n dest = os.path.join(dest_folder, attrs['qqfilename'])\n save_upload(f, dest)","def get_upload(arn=None):\n pass","def upload(self, cr, ads_manager):\n if self.data['order']['articles']:\n res = super(ads_sales_order, self).upload(cr, ads_manager)\n if self.browse_record and self.file_name:\n self.browse_record.write({'ads_file_name': self.file_name})\n return res\n else:\n return False","def put(self):\n if 'file' not in self.request.POST:\n self.request.errors.add('body', 'file', 'Not Found')\n self.request.errors.status = 404\n return\n tender = TenderDocument.load(self.db, self.tender_id)\n if not tender:\n self.request.errors.add('url', 'tender_id', 'Not Found')\n self.request.errors.status = 404\n return\n data = self.request.POST['file']\n bids = [i for i in tender.bids if i.id == self.bid_id]\n if not bids:\n self.request.errors.add('url', 'bid_id', 'Not Found')\n self.request.errors.status = 404\n return\n bid = bids[0]\n documents = [i for i in bid.documents if i.id == self.request.matchdict['id']]\n if not documents:\n self.request.errors.add('url', 'id', 'Not Found')\n self.request.errors.status = 404\n return\n src = tender.serialize(\"plain\")\n document = Document()\n document.id = self.request.matchdict['id']\n document.title = data.filename\n document.format = data.type\n document.datePublished = documents[0].datePublished\n key = uuid4().hex\n document.url = self.request.route_url('Tender Bid Documents', tender_id=self.tender_id, bid_id=self.bid_id, id=document.id, _query={'download': key})\n bid.documents.append(document)\n filename = \"{}_{}\".format(document.id, key)\n tender['_attachments'][filename] = {\n \"content_type\": data.type,\n \"data\": b64encode(data.file.read())\n }\n patch = make_patch(tender.serialize(\"plain\"), src).patch\n tender.revisions.append(revision({'changes': patch}))\n try:\n tender.store(self.db)\n except Exception, e:\n return self.request.errors.add('body', 'data', str(e))\n return {'data': document.serialize(\"view\")}","def click_upload_document_button(self):\n self.click_element(self.upload_document_button_locator, True, True)","def configure_ext_uploads(app):\n configure_uploads(app, [documents])","def initiate_multipart_upload(self):\n request = self.s3.create_request(\"OBJECT_POST\", uri = self.uri, headers = self.headers_baseline, extra = \"?uploads\")\n response = self.s3.send_request(request)\n data = response[\"data\"]\n self.upload_id = getTextFromXml(data, \"UploadId\")\n return self.upload_id","def client_upload_to_doc_service(self, doc_to_upload):\n return self.doc_service_client.upload(file_name, create_file(doc_to_upload), 'application/yaml',\n headers={'X-Client-Request-ID': doc_to_upload[\"meta\"][\"id\"]})","def UploadUnconvertedFileSample():\n client = CreateClient()\n doc = gdata.docs.data.Resource(type='document', title='My Sample Raw Doc')\n path = _GetDataFilePath('test.0.doc')\n media = gdata.data.MediaSource()\n media.SetFileHandle(path, 'application/msword')\n # Pass the convert=false parameter\n create_uri = gdata.docs.client.RESOURCE_UPLOAD_URI + '?convert=false'\n doc = client.CreateResource(doc, create_uri=create_uri, media=media)\n print 'Created, and uploaded:', doc.title.text, doc.resource_id.text","def upload_question(self, request, suffix=''):\n log.info(\"upload_question called\")\n qupload = request.params['qassignment'] \n sha1 = _get_sha1(qupload.file)\n question = {\n \"sha1\": sha1,\n \"filename\": qupload.file.name,\n \"mimetype\": mimetypes.guess_type(qupload.file.name)[0]\n }\n\n self.raw_question = question\n\n path = self._question_storage_path(sha1, qupload.file.name)\n\n \n filepathexists=os.path.join(IMAGEDIFF_ROOT, path)\n file_exists=os.path.exists(filepathexists)\n if not file_exists:\n save_file(path, File(qupload.file))\n file_exists=True\n log.info(\"File uploaded locally\")\n\n\n try:\n storage.store_data(str(self.course_id), \"question\", str(self.location.block_id), file(IMAGEDIFF_ROOT + path))\n log.info(\"upload through storage api successful\")\n except PersonValueError:\n log.info(\"storage api upload failed:\")\n log.info(\"peson argument cant be an empty string\")\n except DepartmentValueError:\n log.info(\"storage api upload failed:\")\n log.info(\"department argument cant be an empty string\")\n except QualifierValueError:\n log.info(\"storage api upload failed:\")\n log.info(\"qualifier argument cant be an empty string\")\n except BucketValueError:\n log.info(\"storage api upload failed:\")\n log.info(\"invalid bucket key argument\")\n except S3ValueError:\n log.info(\"storage api upload failed:\")\n log.info(\"invalid S3 credentials\")\n except SocketValueError:\n log.info(\"storage api upload failed:\")\n log.info(\"invalid host\")\n\n\n \n self.save()\n \n return Response(json_body=self.studio_state())","def handle_upload(f, attrs):\n\n # chunked = False\n print 'UPLOAD DIRECTORY:', UPLOAD_DIRECTORY\n dest_folder = os.path.join(UPLOAD_DIRECTORY, attrs['qquuid'])\n dest = os.path.join(dest_folder, attrs['qqfilename'])\n save_upload(f, dest)","def prepare_quick_upload(self, req):\n\t\tresult, filename = self.handle_upload(req, self.get_selected_root(req))\n\t\tfile_url = self.selected_root['url_callback'](req, filename)\n\t\t\n\t\tself.content = [str(tags.script(type=\"text/javascript\")[\n\t\t\t\t\t\t\"window.parent.OnUploadCompleted(%s, '%s', '%s', '');\\n\" % (result, file_url, filename)\n\t\t\t\t\t\t])]","def collection_post(self):\n if 'file' not in self.request.POST:\n self.request.errors.add('body', 'file', 'Not Found')\n self.request.errors.status = 404\n return\n tender = TenderDocument.load(self.db, self.tender_id)\n if not tender:\n self.request.errors.add('url', 'tender_id', 'Not Found')\n self.request.errors.status = 404\n return\n src = tender.serialize(\"plain\")\n bids = [i for i in tender.bids if i.id == self.bid_id]\n if not bids:\n self.request.errors.add('url', 'bid_id', 'Not Found')\n self.request.errors.status = 404\n return\n bid = bids[0]\n data = self.request.POST['file']\n document = Document()\n document.id = uuid4().hex\n document.title = data.filename\n document.format = data.type\n key = uuid4().hex\n document.url = self.request.route_url('Tender Bid Documents', tender_id=self.tender_id, bid_id=self.bid_id, id=document.id, _query={'download': key})\n bid.documents.append(document)\n filename = \"{}_{}\".format(document.id, key)\n tender['_attachments'][filename] = {\n \"content_type\": data.type,\n \"data\": b64encode(data.file.read())\n }\n patch = make_patch(tender.serialize(\"plain\"), src).patch\n tender.revisions.append(revision({'changes': patch}))\n try:\n tender.store(self.db)\n except Exception, e:\n return self.request.errors.add('body', 'data', str(e))\n self.request.response.status = 201\n self.request.response.headers['Location'] = self.request.route_url('Tender Bid Documents', tender_id=self.tender_id, bid_id=self.bid_id, id=document.id)\n return {'data': document.serialize(\"view\")}","def upload_latest(self, project_id, document):\n url = base_url + 'portal/' + str(self.portal_id) + '/projects/' + str(project_id) + '/documents/' + str(document.get_id()) + '/' \n data = parser.to_json(document)\n if document.get_upload_doc():\n file_list = []\n for value in document.get_upload_doc():\n attachment = {\n 'uploaddoc': {\n 'filename': basename(value), \n 'content':open(value).read()\n } \n }\n file_list.append(attachment)\n else:\n file_list = []\n response = zoho_http_client.post(url, self.details, data, None, file_list)\n return parser.get_documents(response)[0]","def upload2notion(page, name, tags):\n row = page.collection.add_row()\n row.name = str(name.stem)\n row.Tags = tags\n for image_path in image_dir.iterdir():\n image = row.children.add_new(ImageBlock)\n image.upload_file(str(image_path))\n pdf = row.children.add_new(FileBlock)\n pdf.upload_file(str(name))","def multipart():\n with commit():\n link_and_create_multipart_volumes()\n reindex_pidtype('docid')\n reindex_pidtype('serid')","def test_upload(self):\n\n\n username,userpass = self.testdata.find_account_for('toolsubmitter')\n\n self.utils.account.login_as(username,userpass)\n\n self.contribtool.upload(TOOLNAME,TOOLFILEDATA,username,userpass)","def test_upload_job_description_file_post(self):\n pass","def collection_post(self):\n if not self.validate_complaint_document(\"add\"):\n return\n document = upload_file(self.request)\n document.author = self.request.authenticated_role\n self.context.documents.append(document)\n if save_tender(self.request):\n self.LOGGER.info(\n \"Created tender award complaint document {}\".format(document.id),\n extra=context_unpack(\n self.request, {\"MESSAGE_ID\": \"tender_award_complaint_document_create\"}, {\"document_id\": document.id}\n ),\n )\n self.request.response.status = 201\n document_route = self.request.matched_route.name.replace(\"collection_\", \"\")\n self.request.response.headers[\"Location\"] = self.request.current_route_url(\n _route_name=document_route, document_id=document.id, _query={}\n )\n return {\"data\": document.serialize(\"view\")}","def put(self):\n if not self.validate_complaint_document(\"update\"):\n return\n document = upload_file(self.request)\n document.author = self.request.authenticated_role\n self.request.validated[\"complaint\"].documents.append(document)\n if save_tender(self.request):\n self.LOGGER.info(\n \"Updated tender award complaint document {}\".format(self.request.context.id),\n extra=context_unpack(self.request, {\"MESSAGE_ID\": \"tender_award_complaint_document_put\"}),\n )\n return {\"data\": document.serialize(\"view\")}","def UploadResourceSample():\n client = CreateClient()\n doc = gdata.docs.data.Resource(type='document', title='My Sample Doc')\n # Set the description\n doc.description = gdata.docs.data.Description(\n 'This is a simple Word document.')\n # This is a convenient MS Word doc that we know exists\n path = _GetDataFilePath('test.0.doc')\n print 'Selected file at: %s' % path\n # Create a MediaSource, pointing to the file\n media = gdata.data.MediaSource()\n media.SetFileHandle(path, 'application/msword')\n # Pass the MediaSource when creating the new Resource\n doc = client.CreateResource(doc, media=media)\n print 'Created, and uploaded:', doc.title.text, doc.resource_id.text","def upload_file(self, file_path, file_name, output_path):","def test_kyc_put_document(self):\n pass","def test_upload_voice_dataset(self):\n pass","def post_doc_upload(\n self,\n project_id: int,\n file_format: str,\n file_name: str,\n file_path: str = './',\n ) -> requests.models.Response:\n files = {\n 'file': (\n file_name,\n open(os.path.join(file_path, file_name), 'rb')\n )\n }\n data = {\n 'file': (\n file_name,\n open(os.path.join(file_path, file_name), 'rb')\n ),\n 'format': file_format\n }\n return self.post(\n 'v1/projects/{project_id}/docs/upload'.format(\n project_id=project_id\n ),\n files=files,\n data=data\n )","def post(self):\n source = 'uploaded by user'\n upload_files = self.get_uploads('file')\n blob_key = upload_files[0].key()\n name = self.request.get('name')\n\n user = users.get_current_user()\n\n username = 'admin'\n date = datetime.datetime.now()\n str_blob_key = str(blob_key)\n key = FileMetadata.get_key_name(username, date, str_blob_key)\n\n ctx = ndb.get_context()\n meta = FileMetadata(key_name=key, parent=_PARENT)\n meta.owner = user\n meta.filename = name\n meta.uploaded_on = date\n meta.source = source\n meta.blobkey = str_blob_key\n meta.put()\n ctx.clear_cache()\n self.redirect('/admin')","def test_kyc_post_document(self):\n pass","def document(self):\n ...","def upload_document_to_xtracta(workflow, document_file):\n response = None\n file = {\"userfile\":document_file}\n response = requests.post(XTRACTA['url']+\"documents\"+\"/\"+\"upload\",\\\n files=file, data={\"submit\":\"Submit\", \"api_key\":XTRACTA['key'],\\\n \"workflow_id\":workflow})\n response_content = xmltodict.parse(response.content)\n if response_content['xml']['status'] == '200':\n return response_content['xml']\n else:\n LOGGER.exception(\"upload_document_to_xtracta() %s\", response_content['xml']['message'])\n return response_content['xml']","def upload_single_file(request):\n message, success, title = \"\", 0, \"error\"\n is_data_ok = False\n\n if request.method == 'POST':\n data_in_post = [\"id_campaign\", \"field_name\"]\n # defined in utils.py\n is_data_in_post = check_all_data_available_in_post(\n data_in_post, request.POST)\n\n if is_data_in_post['success']:\n is_data_ok = True\n else:\n message = is_data_in_post['message']\n\n if is_data_ok:\n for filename, file in request.FILES.items():\n name = request.FILES[filename].name\n print(\"filename : \", name)\n\n # myfile = request.FILES['abm_company_list_file']\n myfile = request.FILES[filename]\n fs = FileSystemStorage()\n filename = fs.save(\"campaign/\" + myfile.name, myfile)\n print(filename)\n\n # get campaign id\n id_campaign = request.POST.get(\"id_campaign\")\n\n # django get campaign object from model\n campaign = Campaign.objects.filter(id=id_campaign).first()\n\n if campaign:\n # get specification record\n specification = Specification.objects.filter(campaign=campaign).first()\n if specification:\n # get field name to save\n field_name = request.POST.get(\"field_name\")\n\n # check object has property with field name\n if hasattr(specification, field_name):\n # nested_setattr(object, 'pet.name', 'Sparky')\n model_field_name = str(field_name) + \".name\"\n model_field_name = model_field_name.replace(\" \", \"\")\n print(model_field_name)\n\n # set nested attribute\n # ex. form.name\n nested_setattr(specification, model_field_name, filename)\n\n specification.save()\n print(nested_getattr(specification, model_field_name, 'default')) # will print string similar to filename\n\n success = 1\n title = 'success'\n message = \"specification updated successfully\"\n else:\n message += \"Error... Specification table has no field '\" + field_name + \"'\"\n\n else:\n message += \"Specification not exists with campaign: '\", str(campaign), \"'\"\n else:\n message += \"Campaign not exist with id : '\", id_campaign, \"'\"\n\n # uploaded_file_url = fs.url(filename)\n success = 1\n else:\n message = \"Please post data using post method\"\n\n jsonresponse = {\n \"success\": 1,\n \"title\": request.POST,\n \"message\": message,\n }\n return JsonResponse(jsonresponse, safe=False)","def upload_preset(self, filename, title, description, version, author, REQUEST=None):\r\n\r\n # TODO presets.py - upload_preset - specify how to authenticate\r\n\r\n raise NotImplementedError","def upload_finish(self, cloud_file):","def upload(self, request, parent_lookup_client, format=None):\n serializer = serializers.PDFUploadWritableSerializer(data=request.data)\n serializer.is_valid(raise_exception=True)\n serializer.update(request.user.client, serializer.validated_data)\n client = Client.objects.get(pk=parent_lookup_client)\n return Response(serializers.PDFUploadSerializer(client).data)","def post(self):\n\n upload_files = self.get_uploads('file')\n blob_info = upload_files[0]\n self.redirect('/?upload_info=%s' % urllib.quote(blob_info.filename))","def upload():\n\n file = request.files['query']\n filepath = upload_filepath(secure_filename(file.filename))\n file.save(filepath)\n classification = classify(filepath)\n classification['filename'] = file.filename\n return render_template('index.html', classification=classification)","def upload_document_fileobj(file_obj, file_name, documents_resource):\n try:\n fields = documents_resource.init_multipart_upload()\n except requests.exceptions.HTTPError as e:\n raise_api_error(e.response, state=\"init\")\n except requests.exceptions.ConnectionError:\n raise_connectivity_error(file_name)\n\n s3_upload = _s3_intermediate_upload(\n file_obj,\n file_name,\n fields,\n documents_resource._client.session,\n documents_resource._client._root_url + fields[\"callback_url\"], # full callback url\n )\n\n document_id = s3_upload.get(\"document_id\", \"<UUID not yet assigned>\")\n\n log.info(\"{}: finished as document {}\".format(file_name, document_id))\n return document_id","def setup_upload(self, dbkey=None):\n if dbkey:\n [upload] = Upload.objects.filter(id=dbkey)\n return upload\n\n files = [\n (\"gmpe_logic_tree.xml\", \"lt_gmpe\"),\n (\"small_exposure.xml\", \"exposure\"),\n (\"source_model1.xml\", \"source\"),\n (\"source_model2.xml\", \"source\"),\n (\"source_model_logic_tree.xml\", \"lt_source\"),\n (\"vulnerability.xml\", \"vulnerability\")]\n upload = view_utils.prepare_upload()\n for file, type in files:\n path = os.path.join(upload.path, file)\n # This is equivalent to what the touch command does.\n open(path, \"w+\").close()\n input = Input(path=path, owner=upload.owner, input_type=type,\n upload=upload)\n input.save()\n return upload","def upload_samples(args):\n clarity_epp.upload.samples.from_helix(lims, config.email, args.input_file)","def edit_document():","def _UploadFile(self, media_source, title, category):\n media_entry = gdata.GDataEntry()\n media_entry.title = atom.Title(text=title)\n media_entry.category.append(category)\n media_entry = self.Post(media_entry, '/feeds/documents/private/full',\n media_source = media_source,\n extra_headers = {'Slug' : media_source.file_name })\n\n return media_entry","def upload(self, filename, file_path):\n return","def test_upload_file(self):\n pass","def main():\n credentials = get_credentials()\n http = credentials.authorize(httplib2.Http())\n service = apiclient.discovery.build('drive', 'v3', http=http)\n\n sheet_id = raw_input(\"Input sheet id: \")\n sheet = sefaria_sheet_api(sheet_id)\n\n file_metadata = {\n 'name': sheet.get('title', '').strip(),\n 'mimeType': 'application/vnd.google-apps.document'\n }\n\n media = apiclient.http.MediaIoBaseUpload(\n StringIO.StringIO(create_html_string(sheet)),\n mimetype='text/html',\n resumable=True)\n\n new_file = service.files().create(body=file_metadata,\n media_body=media,\n fields='id,webViewLink').execute()\n\n print '{} (id: {})'.format(new_file['webViewLink'], new_file['id'])","def complete_upload(self):\r\n xml = self.to_xml()\r\n return self.bucket.complete_multipart_upload(self.key_name,\r\n self.id, xml)","def test_upload_file1(self):\n pass","def _upload_file_to_file_system(upload_details):\n upload_url = \"%s%s\" % (main_url, upload_details['upload_path'])\n fsysparams = {\n 'qqfile': upload_filepath,\n 'import_record': upload_dataset_id,\n 'source_type': upload_datatype\n }\n return requests.post(upload_url,\n params=fsysparams,\n files={'file': open(upload_filepath, 'rb')},\n headers=upload_header)","def execute(pagename, request):\n _ = request.getText\n\n do = request.values.get('do', 'upload_form')\n handler = globals().get('_do_%s' % do)\n if handler:\n msg = handler(pagename, request)\n else:\n msg = _('Unsupported AttachFile sub-action: %s') % do\n if msg:\n error_msg(pagename, request, msg)","def index(self, file_object, pems):\n res, search = self.get(file_object.system,\n os.path.dirname(file_object.path.strip('/')),\n os.path.basename(file_object.path.strip('/')))\n if res.hits.total > 1:\n for doc in res[1:]:\n doc.delete(ignore=404)\n if res.hits.total >= 1:\n document = res[0]\n file_object.pop('_links')\n file_object.pop('permissions')\n document.update(**file_object)\n else:\n document = IndexedFile(\n name=os.path.basename(file_object.path.strip('/')),\n path=os.path.dirname(file_object.path.strip('/')) or '/',\n lastModified=file_object.lastModified.isoformat(),\n length=file_object.length,\n format=file_object.format,\n mimeType=file_object.mimeType,\n type=file_object.type,\n system=file_object.system,\n )\n if pems is None or not pems:\n document.permissions = [{\n 'username': self.username,\n 'permission': {\n 'read': True,\n 'write': True,\n 'execute': True\n }\n }]\n document.save()\n\n if pems:\n for pem in pems:\n pem.pop('_links', None)\n pem.pop('internalUsername', None)\n document.update(permissions=pems)\n return document","def patch(self):\n if apply_patch(self.request, src=self.request.context.serialize()):\n update_file_content_type(self.request)\n self.LOGGER.info(\n \"Updated tender qualification document {}\".format(self.request.context.id),\n extra=context_unpack(self.request, {\"MESSAGE_ID\": \"tender_qualification_document_patch\"}),\n )\n return {\"data\": self.request.context.serialize(\"view\")}","def upload_samples():\n # Retrieve a list of all files and paths within the target\n paths = Path(Config.target_dir).glob(Config.target_pattern)\n # Inform the user as to what we're doing\n logger.info(\"Assembling %s volume for submission\", Config.target_dir)\n # Loop through each identified file and upload it to the sandbox for analysis\n for path in paths:\n # Convert the path to a string\n filepath = str(path)\n # Grab the file name\n filename = os.path.basename(filepath)\n # Open the file for binary read, this will be our payload\n with open(filepath, 'rb') as upload_file:\n payload = upload_file.read()\n # Upload the file using the Sandbox\n response = Samples.upload_sample(file_name=filename, sample=payload)\n # Grab the SHA256 unique identifier for the file we just uploaded\n sha = response[\"body\"][\"resources\"][0][\"sha256\"]\n # Add this SHA256 to the volume payload element\n Analyzer.uploaded.append(sha)\n # Track the upload so we can remove the file when we're done\n Analyzer.files.append([filename, filepath, sha])\n # Inform the user of our progress\n logger.debug(\"Uploaded %s to %s\", filename, sha)","def uploadToRM(dry):\n # list of files in Library\n syncFilesList = glob.glob(syncDirectory + \"/*/*.pdf\")\n # list of files on the rM (hashed)\n rmPdfList = glob.glob(remarkableBackupDirectory + remContent + \"/*.pdf\")\n # make list of actual names (not hashed)\n pdfNamesOnRm = []\n for i in range(0, len(rmPdfList)):\n refNrPath = rmPdfList[i][:-4]\n # get meta Data\n meta = json.loads(open(refNrPath + \".metadata\").read())\n # Make record of pdf files already on device\n rmPdfName = meta[\"visibleName\"] + \".pdf\" if meta[\"visibleName\"][-4:] != \".pdf\" else meta[\"visibleName\"]\n pdfNamesOnRm.append(rmPdfName)\n\n # remove files in the Notes directory from the list (those dont need to be re-uploaded)\n syncFilesList = [x for x in syncFilesList if \"/Notes/\" not in x]\n # find absolute path\n syncNames = [os.path.basename(f) for f in syncFilesList]\n # remove annotated pdf files from the list (those dont need to be re-uploaded)\n syncNames = [x for x in syncNames if \"annot\" not in x]\n\n # find files that are not already on the rM\n # this gets elements that are in the sync list but not on the rM\n uploadList = [x for x in syncNames if x not in pdfNamesOnRm]\n # print(\"uploadList:\")\n # print(uploadList)\n\n uploadPathList = [glob.glob(syncDirectory + \"/*/\" + x)[0] for x in uploadList]\n # print(\"uploadPathList:\")\n # print(uploadPathList)\n # do in batches of the folders\n folderList = [os.path.dirname(x).split(\"/\")[-1] for x in uploadPathList]\n # print(folderList)\n batches = list(set(folderList))\n\n # print(batches)\n\n for folder in batches:\n filesInFolder = [f for f in uploadPathList if folder == os.path.dirname(f).split(\"/\")[-1]]\n print(\"upload \" + \" \".join(filesInFolder) + \" to \" + folder)\n\n folderpath = os.path.dirname(filesInFolder[0])\n if folderpath != syncDirectory:\n uploadCmd = \"\".join([\"bash \", pushScript, \" -o /\", folder, \" \", \" \".join(filesInFolder)])\n else:\n uploadCmd = \"\".join([\"bash \", pushScript, \" \".join(filesInFolder)])\n\n if dry:\n print(\"uploadCmd: \")\n print(uploadCmd)\n else:\n os.system(uploadCmd)\n #Sleep to allow restart\n print(\"sleeping while rM restarts\")\n time.sleep(15)","def uploadToRM_curl(dry):\n # list of files in Library\n syncFilesList = glob.glob(os.path.join(syncDirectory, \"*\", \"*.pdf\"))\n # list of files on the rM (hashed)\n rmPdfList = glob.glob(os.path.join(remarkableBackupDirectory, remContent,\n \"*.pdf\"))\n # make list of actual names (not hashed)\n pdfNamesOnRm = []\n for i in range(0, len(rmPdfList)):\n refNrPath = rmPdfList[i][:-4]\n # get meta Data\n meta = json.loads(open(refNrPath + \".metadata\").read())\n # Make record of pdf files already on device\n if meta[\"visibleName\"][-4:] != \".pdf\":\n rmPdfName = meta[\"visibleName\"] + \".pdf\"\n else:\n rmPdfName = meta[\"visibleName\"]\n pdfNamesOnRm.append(rmPdfName)\n # remove files in the Notes directory from the list\n # (those dont need to be re-uploaded)\n syncFilesList = [x for x in syncFilesList \\\n if \"/\" + notesDirectory + \"/\" not in x]\n # find absolute path\n syncNames = [os.path.basename(f) for f in syncFilesList]\n # remove annotated pdf files from the list\n # (those dont need to be re-uploaded)\n syncNames = [x for x in syncNames if \"annot\" not in x]\n\n # find files that are not already on the rM\n # this gets elements that are in the sync list but not on the rM\n uploadList = [x for x in syncNames if x not in pdfNamesOnRm]\n for upl in uploadList:\n # get full path for the file to be uploaded\n filePath = glob.glob(os.path.join(syncDirectory, \"*\", upl))[0]\n # chop the ending if necessary to get file name\n fileName = upl if upl[-4:0] != \"pdf\" else upl[:-4]\n\n print(\"upload \"+ fileName +\" from \"+filePath)\n\n # # CURL version (can't copy directly to folders)\n # #http://remarkablewiki.com/index.php?title=Methods_of_access\n # #chronos@localhost ~/Downloads $ curl 'http://10.11.99.1/upload' -H 'Origin: http://10.11.99.1' -H 'Accept: */*' -H 'Referer: http://10.11.99.1/' -H 'Connection: keep-alive' -F \"file=@Get_started_with_reMarkable.pdf;filename=Get_started_with_reMarkable.pdf;type=application/pdf\"\n #uploadCmd = \"\".join([\"curl 'http://10.11.99.1/upload' -H 'Origin: http://10.11.99.1' -H 'Accept: */*' -H 'Referer: http://10.11.99.1/' -H 'Connection: keep-alive' -F 'file=@\", filePath, \";filename=\", fileName, \";type=application/pdf'\"])\n uploadCmd = \"\".join([\"curl 'http://\",remarkableIP,\"/upload' -H 'Origin: http://\",remarkableIP,\"' -H 'Accept: */*' -H 'Referer: http://\",remarkableIP,\"' -H 'Connection: keep-alive' -F 'file=@\", filePath, \";filename=\", fileName, \";type=application/pdf'\"])\n\n if dry:\n print(\"uploadCmd: \")\n print(uploadCmd)\n else:\n os.system(uploadCmd)","def typesense_index_record(rec, client=None):\n if not client:\n client = typesense_client()\n\n rec_document = {\n 'id': str(rec.pk),\n 'created': rec.created.timestamp(),\n 'referral_id': rec.referral.pk,\n 'name': rec.name,\n 'description': rec.description if rec.description else '',\n 'file_name': rec.filename,\n 'file_type': rec.extension,\n }\n file_content = ''\n\n # PDF document content.\n if rec.extension == 'PDF':\n try:\n # PDF text extraction can be a little error-prone.\n # In the event of an exception here, we'll just accept it and pass.\n if settings.LOCAL_MEDIA_STORAGE:\n file_content = high_level.extract_text(open(rec.uploaded_file.path, 'rb'))\n else:\n file_content = high_level.extract_text(open(rec.uploaded_file))\n except:\n pass\n\n # MSG document content.\n if rec.extension == 'MSG':\n if settings.LOCAL_MEDIA_STORAGE:\n message = Message(rec.uploaded_file.path)\n else:\n message = Message(rec.uploaded_file)\n file_content = '{} {}'.format(message.subject, message.body.replace('\\r\\n', ' '))\n\n # DOCX document content.\n if rec.extension == 'DOCX':\n if settings.LOCAL_MEDIA_STORAGE:\n file_content = docx2txt.process(rec.uploaded_file.path)\n else:\n file_content = docx2txt.process(rec.uploaded_file)\n\n # TXT document content.\n if rec.extension == 'TXT':\n if settings.LOCAL_MEDIA_STORAGE:\n file_content = open(rec.uploaded_file.path, 'r').read()\n else:\n file_content = rec.uploaded_file.read()\n\n # Trim down the content of uploaded files a little.\n if file_content:\n # Decode a bytes object to a string.\n if isinstance(file_content, bytes):\n file_content = file_content.decode('utf-8')\n # Replace punctuation with a space.\n file_content = re.sub(r'[^\\w\\s]', ' ', file_content)\n # Replace newlines with a space.\n file_content = file_content.replace('\\r\\n', ' ')\n # Replace multiple spaces with a single one.\n file_content = re.sub(r'\\s+', ' ', file_content)\n file_content = file_content.strip()\n\n rec_document['file_content'] = file_content\n client.collections['records'].documents.upsert(rec_document)","def uploadResourceFile(url, user, pWd, resourceName, fileName, fullPath):\n print(\"uploading file for resource \" + url + \" resource=\" + \n resourceName + ' user=' + user)\n apiURL = url + '/access/1/catalog/resources/' + resourceName + \"/files\"\n print(\"\\turl=\" + apiURL)\n # header = {\"accept\": \"*/*\", \"Content-Type\" : \"multipart/form-data\"} \n header = {\"accept\": \"*/*\"} \n print(\"\\t\" + str(header))\n params = {\"scannerid\": \"LineageScanner\", \"filename\": fileName, \n \"optionid\": \"File\"}\n print(\"\\t\" + str(params))\n# files = {'file': fullPath}\n mimeType = 'text/csv'\n readMode = 'rt'\n if fileName.endswith(\".zip\"):\n mimeType = 'application/zip'\n readMode = 'rb'\n \n file = { 'file' : (fileName, open(fullPath, readMode), mimeType)}\n print('\\t' + str(file))\n uploadResp = requests.post(apiURL, data=params, files=file, headers=header, \n auth=HTTPBasicAuth(user,pWd))\n print(\"\\tresponse=\" + str(uploadResp.status_code))\n if uploadResp.status_code == 200:\n # valid - return the jsom\n return uploadResp.status_code\n else:\n # not valid\n print(\"\\tupload file failed\")\n print(\"\\t\" + str(uploadResp))\n print(\"\\t\" + str(uploadResp.text))\n return uploadResp.status_code","def upload_submission(request, learner, trigger, no_thumbnail=True):\n base_dir_for_file_uploads = settings.MEDIA_ROOT\n thumbnail_file_name_django = ''\n entry_point = trigger.entry_point\n\n files = request.FILES.getlist('file_upload', None)\n if files is None:\n return None\n\n # Is the storage space reachable?\n deepest_dir = base_dir_for_file_uploads + 'uploads/{0}/tmp/'.format(\n entry_point.id)\n\n try:\n os.makedirs(deepest_dir)\n except OSError:\n if not os.path.isdir(deepest_dir):\n logger.error('Cannot create directory for upload: {0}'.format(\n deepest_dir))\n raise\n\n if len(files) == 1:\n filename = files[0].name\n extension = filename.split('.')[-1].lower()\n submitted_file_name_django = 'uploads/{0}/{1}'.format(entry_point.id,\n generate_random_token(token_length=16) + '.' + extension)\n full_path = base_dir_for_file_uploads + submitted_file_name_django\n with open(full_path, 'wb+') as dst:\n for chunk in files[0].chunks():\n dst.write(chunk)\n\n\n f_size = os.path.getsize(full_path)\n if f_size > trigger.max_file_upload_size_MB * 1024 * 1024:\n logger.warning('File too large {0}'.format(\n submitted_file_name_django))\n return None, ('File too large ({0} MB); it must be less than '\n '{1} MB.'.format(round(float(f_size/1024.0/1024.0), 1),\n trigger.max_file_upload_size_MB))\n\n\n else: #if trigger.allow_multiple_files: this is removed for now\n filename = ''\n extension = ''\n submitted_file_name_django = ''\n full_path = ''\n\n\n # Check that the file format is PDF, if that is required.\n strike1 = False\n if 'pdf' in trigger.accepted_file_types_comma_separated.lower() and \\\n extension in ('pdf',):\n try:\n mime = magic.from_file(full_path, mime=True)\n if not(isinstance(mime, str)):\n mime = mime.decode('utf-8')\n except Exception as exp:\n logger.error('Could not determine MIME type: ' + str(exp))\n mime = ''\n strike1 = True\n\n if 'application/pdf' not in mime.lower():\n strike1 = True\n\n if strike1:\n logger.debug('Invalid PDF upload: {0} [{1}]'.format(mime,\n full_path))\n #return None, 'Invalid file uploaded. Uploaded file must be a PDF.'\n\n doc = PdfFileReader(full_path)\n if doc.isEncrypted:\n logger.debug('Encrypted PDF upload: {0}'.format(full_path))\n return None, ('An encrypted PDF cannot be uploaded. Please remove '\n 'the encryption and try again.')\n\n\n strike1 = False\n if (('jpeg' in trigger.accepted_file_types_comma_separated.lower()) or \\\n ('jpg' in trigger.accepted_file_types_comma_separated.lower())) and \\\n extension in ('jpg', 'jpeg'):\n\n try:\n mime = magic.from_file(full_path, mime=True)\n if not(isinstance(mime, str)):\n mime = mime.decode('utf-8')\n except Exception as exp:\n logger.error('Could not determine MIME type: ' + str(exp))\n mime = ''\n strike1 = True\n\n if 'image/jpeg' not in mime.lower():\n strike1 = True\n\n if strike1:\n logger.debug('Invalid JPG upload: {0} [{1}]'.format(mime,\n full_path))\n return None, ('Invalid file. Uploaded image should be a valid '\n 'and readable JPEG file.')\n\n\n strike1 = False\n if ('png' in trigger.accepted_file_types_comma_separated.lower()) and \\\n extension in ('png',):\n\n try:\n mime = magic.from_file(full_path, mime=True)\n if not(isinstance(mime, str)):\n mime = mime.decode('utf-8')\n except Exception as exp:\n logger.error('Could not determine MIME type: ' + str(exp))\n mime = ''\n strike1 = True\n\n if 'image/png' not in mime.lower():\n strike1 = True\n\n if strike1:\n logger.debug('Invalid PNG upload: {0} [{1}]'.format(mime,\n full_path))\n return None, ('Invalid file. Uploaded image should be a valid '\n 'and readable PNG file.')\n\n\n strike2 = False\n if extension.lower() not in \\\n trigger.accepted_file_types_comma_separated.lower():\n logger.debug('Invalid file type upload: received \".{0}\"; [{1}]'.format(\\\n extension, full_path))\n return None, ('Invalid file uploaded. Uploaded file must be: {}'.format(\\\n trigger.accepted_file_types_comma_separated))\n\n\n if trigger == entry_point:\n # In some instances we don't use triggers, just entry_points\n prior = Submission.objects.filter(status='S',\n submitted_by=learner,\n entry_point=entry_point,\n is_valid=True\n )\n else:\n prior_indiv = Q(status='S', submitted_by=learner, entry_point=entry_point,\n trigger=trigger, is_valid=True)\n\n # We need this here, but also for the code later in the next\n # if (trigger==entry_point) part\n\n # Default returned by this function is ``None`` if the user is not\n # enrolled in a group, or if this course simply does not use groups.\n group_submitted = is_group_submission(learner, entry_point)\n if is_group_submission(learner, entry_point):\n group_submitted = group_submitted.group\n\n prior_group = Q(status='S', group_submitted=group_submitted,\n entry_point=entry_point, trigger=trigger,\n is_valid=True)\n else:\n prior_group = Q()\n\n prior = Submission.objects.filter(prior_indiv | prior_group)\n\n\n for item in prior:\n logger.debug(('Setting prior submission to False: {0} and name '\n '\"{1}\"'.format(str(item), item.submitted_file_name)))\n item.is_valid = False\n item.save()\n\n\n if trigger == entry_point:\n # In some instances we don't use triggers, just entry_points\n sub = Submission(submitted_by=learner,\n group_submitted=None,\n status='S',\n entry_point=entry_point,\n is_valid=True,\n file_upload=submitted_file_name_django,\n thumbnail=thumbnail_file_name_django,\n submitted_file_name=filename,\n ip_address=get_IP_address(request),\n )\n sub.save()\n else:\n\n sub = Submission(submitted_by=learner,\n group_submitted=group_submitted,\n status='S',\n entry_point=entry_point,\n trigger=trigger,\n is_valid=True,\n file_upload=submitted_file_name_django,\n thumbnail=thumbnail_file_name_django,\n submitted_file_name=filename,\n ip_address=get_IP_address(request),\n )\n sub.save()\n\n if 'pdf' in trigger.accepted_file_types_comma_separated.lower() and \\\n extension in ('pdf',):\n clean_PDF(sub)\n\n return sub","def upload(context, request):\n if request.method == 'POST':\n if not hasattr(request.POST['content'], 'file'):\n raise RuntimeError('No file attached')\n\n fieldstorage = request.POST['content']\n filename = fieldstorage.filename\n logger.info(\"%s posted\", filename)\n\n with bm(\"%s released\" %filename):\n dest = path(request.file_root) / request.namer(filename)\n dest.write_bytes(fieldstorage.file.read())\n try:\n request.registry.notify(event.PackageAdded(request.index, path=dest))\n request.response.headers['X-Swalow-Status'] = 'SUCCESS'\n try:\n for ep in pkg_resources.iter_entry_points('cheeseprism.on_upload'):\n func = ep.load()\n func(context, request, dest)\n except Exception as e:\n logger.exception('Entry point %r failed', ep)\n return request.response\n except :\n logger.exception(\"Processing of %s failed\", filename)\n raise\n return {}","def test_client_document_create(self):\n pass","def put(self, request, code, suggested_format=None):\n context = {'request': request}\n conten_type = request.content_type\n uploaded_obj = None\n if 'multipart/form-data' in conten_type:\n # We have a file upload encoded with multipart/form-data\n file_content = StringIO(request.body)\n parser = MultiPartParser()\n dnf = parser.parse(file_content, media_type=conten_type, parser_context=context)\n extra = dnf.data\n if 'file' in dnf.files:\n uploaded_obj = dnf.files['file']\n else:\n extra = request.QUERY_PARAMS\n # TODO: do we require SQL tagging logic in this API call?\n sql_tag_string = extra.get('tag_string', None)\n sql_remove_tag_string = extra.get('remove_tag_string', None)\n new_name = extra.get('new_name', None)\n new_type = extra.get('new_type', None)\n index_data = extra.get('indexing_data', None)\n if index_data:\n index_data = json.loads(index_data)\n processor = DocumentProcessor()\n options = {\n 'tag_string': sql_tag_string,\n 'remove_tag_string': sql_remove_tag_string,\n 'extension': suggested_format,\n 'new_name': new_name,\n 'new_type': new_type,\n 'new_indexes': index_data,\n 'update_file': uploaded_obj,\n 'user': request.user,\n }\n document = processor.update(code, options)\n if len(processor.errors) > 0:\n log.error('FileHandler.update manager errors %s' % processor.errors)\n if settings.DEBUG:\n print processor.errors\n raise Exception('FileHandler.update manager errors')\n else:\n return Response(status=status.HTTP_400_BAD_REQUEST)\n log.info('FileHandler.update request fulfilled for code: %s, extension: %s'\n % (code, suggested_format))\n resp = DMSOBjectRevisionsData(document).data\n return Response(resp, status=status.HTTP_200_OK)","def uploadFile(self,path):\n\n response = requests.post('https://api.imagga.com/v1/content',\n auth=(self.apikey, self.secret),\n files={'image': open(path, 'r')})\n json_data = json.loads(response.text)\n uploadedData=json_data[u'uploaded'][0]\n resourceId=uploadedData[u'id']\n filename = uploadedData[u'filename']\n self.fileToIdMap[filename] = resourceId\n self.getTagsUsingId(resourceId)","def upload(request):\n\n\tdoc_form = DocumentForm()\n\n\tif request.method == \"POST\":\n\n\t\tdoc_form = DocumentForm(request.POST,request.FILES)\n\t\tuser = request.user.username\n\t\tuser_obj = User.objects.get(username=user)\n\t\ttodays_pdfs = Document.objects.filter(user=user_obj.pk).filter(created_at__date=timezone.now())\n\t\tusers_today_uploads = todays_pdfs.count()\n\n\t\tif users_today_uploads == 5:\n\t\t\tmessages.info(request, \"You can Only upload 5 docs/day !\")\n\t\t\treturn redirect(reverse('upload'))\n\n\t\telse:\n\t\t\tbreakpoint()\n\t\t\tif doc_form.is_valid():\n\t\t\t\tif request.FILES['PDF'].size > 5242880:\n\t\t\t\t\tmessages.info(request, \"Size can't be more than 5 MiB\")\n\t\t\t\t\treturn redirect(reverse('upload'))\n\t\t\t\telse:\t\n\t\t\t\t\tdoc_obj = doc_form.save(commit=False)\n\t\t\t\t\tdoc_obj.user = user_obj\n\t\t\t\t\tdoc_obj.save()\n\t\t\t\t\t# breakpoint()\n\t\t\t\t\tmessages.success(request, \"Uploaded Successfully\")\n\t\t\t\t\treturn redirect(reverse('upload'))\n\t\t\telse:\n\t\t\t\tmessages.error(request, \"Error Occured\")\n\t\t\t\treturn redirect(reverse('upload'))\n\n\telse:\n\t\t\n\t\tcontext = {'form':doc_form}\n\t\treturn render(request, 'document_manager/upload.html', context)","def upload_from_file(self, file_obj, name_on_storage, **keyword_args):\n blob = self.bucket.blob(name_on_storage)\n blob.upload_from_file(file_obj, **keyword_args)\n print(f\"Upload object {name_on_storage}\")","def upload(study_id, payload, song_url, auth_token):\n song_client = SongClient(\n song_url,\n auth_token,\n VERIFY_CERTIFICATES\n )\n response = song_client.create_custom_analysis(\n study_id,\n payload\n )\n return response['analysisId']","def _call_init_upload(\n file_name, file_size, metadata, tags, project, samples_resource, sample_id, external_sample_id\n):\n upload_args = {\n \"filename\": file_name,\n \"size\": file_size,\n \"upload_type\": \"standard\", # this is multipart form data\n \"sample_id\": sample_id,\n \"external_sample_id\": external_sample_id,\n }\n\n upload_args.update(build_upload_dict(metadata, tags, project))\n\n try:\n return samples_resource.init_upload(upload_args)\n except requests.exceptions.HTTPError as e:\n raise_api_error(e.response, state=\"init\")\n except requests.exceptions.ConnectionError:\n raise_connectivity_error(file_name)","def webhook_upload(user, application, complete_path, init_es, tool, scan_name, user_host, to_name,hook_log):\n hook_log = WebhookLog.objects.get(id=hook_log)\n hook_log.file_upload_event = True\n hook_log.file_upload_datetime = timezone.now()\n hook_log.save()\n process_files(user, application, complete_path, init_es, tool, scan_name, user_host, to_name,hook_log=hook_log)\n info_debug_log(event='Webhook upload',status='success')","def _upload_file(self, file_name, full_path, quiet, request, resources):\r\n\r\n if not quiet:\r\n print('Starting upload for file ' + file_name)\r\n\r\n content_length = os.path.getsize(full_path)\r\n token = self.dataset_upload_file(full_path, quiet)\r\n if token is None:\r\n if not quiet:\r\n print('Upload unsuccessful: ' + file_name)\r\n return True\r\n if not quiet:\r\n print('Upload successful: ' + file_name + ' (' +\r\n File.get_size(content_length) + ')')\r\n upload_file = DatasetUploadFile()\r\n upload_file.token = token\r\n if resources:\r\n for item in resources:\r\n if file_name == item.get('path'):\r\n upload_file.description = item.get('description')\r\n if 'schema' in item:\r\n fields = self.get_or_default(item['schema'], 'fields',\r\n [])\r\n processed = []\r\n count = 0\r\n for field in fields:\r\n processed.append(self.process_column(field))\r\n processed[count].order = count\r\n count += 1\r\n upload_file.columns = processed\r\n request.files.append(upload_file)\r\n return False","def oparl_documentsss():\n start_time = time.time()\n jsonp_callback = request.args.get('callback', None)\n ref = request.args.get('reference', '')\n references = ref.split(',')\n if references == ['']:\n references = None\n output = request.args.get('output', '').split(',')\n rs = util.get_rs()\n q = request.args.get('q', '*:*')\n fq = request.args.get('fq', '')\n sort = request.args.get('sort', 'score desc')\n start = int(request.args.get('start', '0'))\n numdocs = int(request.args.get('docs', '10'))\n date_param = request.args.get('date', '')\n get_attachments = 'attachments' in output\n get_thumbnails = 'thumbnails' in output and get_attachments\n get_consultations = 'consultations' in output\n get_facets = 'facets' in output\n #get_relations = 'relations' in output\n request_info = {} # Info über die Anfrage\n query = False\n docs = False\n submission_ids = []\n # TODO: entscheiden, was mit get_relations passiert\n \"\"\"\n Anhand der übergebenen Parameter wird entschieden, ob eine ES-Suche\n durchgeführt wird, oder ob die Abfrage direkt anhand von Kennungen\n (references) erfolgen kann.\n \"\"\"\n \n if references is None:\n # Suche wird durchgeführt\n # (References-Liste via Suchmaschine füllen)\n query = db.query_submissions(rs=rs, q=q, fq=fq, sort=sort, start=start,\n docs=numdocs, date=date_param, facets=get_facets)\n if query['numhits'] > 0:\n submission_ids = [x['_id'] for x in query['result']]\n else:\n docs = []\n else:\n # Direkte Abfrage\n request_info = {\n 'references': references\n }\n request_info['output'] = output\n\n # Abrufen der benötigten Dokumente aus der Datenbank\n if references is not None:\n docs = db.get_submissions(rs=rs, references=references,\n get_attachments=get_attachments,\n get_consultations=get_consultations,\n get_thumbnails=get_thumbnails)\n elif len(submission_ids) > 0:\n docs = db.get_submissions(rs=rs, submission_ids=submission_ids,\n get_attachments=get_attachments,\n get_consultations=get_consultations,\n get_thumbnails=get_thumbnails)\n\n ret = {\n 'status': 0,\n 'duration': int((time.time() - start_time) * 1000),\n 'request': request_info,\n 'response': {}\n }\n if docs:\n ret['response']['documents'] = docs\n ret['response']['numdocs'] = len(docs)\n if query and 'maxscore' in query:\n ret['response']['maxscore'] = query['maxscore']\n for n in range(len(docs)):\n docs[n]['reference'] = docs[n]['identifier']\n del docs[n]['identifier']\n\n if query:\n ret['response']['numhits'] = query['numhits']\n if get_facets and 'facets' in query:\n ret['response']['facets'] = query['facets']\n \n ret['response']['start'] = start\n ret['request']['sort'] = sort\n ret['request']['fq'] = fq\n\n json_output = json.dumps(ret, cls=util.MyEncoder, sort_keys=True)\n if jsonp_callback is not None:\n json_output = jsonp_callback + '(' + json_output + ')'\n response = make_response(json_output, 200)\n response.mimetype = 'application/json'\n response.headers['Expires'] = util.expires_date(hours=24)\n response.headers['Cache-Control'] = util.cache_max_age(hours=24)\n return response","def update_filedetails_ajax(request):\n try:\n document_id = request.GET.get('document_id')\n tag = request.GET.get('tag')\n get_index = find_index_with_document(document_id)\n updated_data = update(get_index, document_id, tag)\n return JsonResponse({\"fs_metadata\": updated_data, \"message\": \"Success\", \"status_code\": \"200\"})\n except Exception as e:\n print(\"Update Error : \", e)\n return False","def index_fobj(fobj):\n doc = fileobject_to_dict(fobj)\n if doc is not None:\n #print doc\n SOLR.add(doc)\n else:\n pass","def test_kyc_post_document_shareholder(self):\n pass","def CreateNewFile(self):\n\t\tself.acad.Documents.Add()","def createStructuredTranscript_Non_Core_Doc():\n\n #create a temporary folder that will hold the data transformed from doc to docx\n os.system('mkdir ' + INPUT_FOLDER+'temp')\n\n core_doc_asset = []\n missing_count = 0\n missing_files=[]\n # get all the docx files that are part of the core asset\n for file in glob.glob(INPUT_FOLDER+\"*.doc\"):\n\n # RG numbers for the core asset\n if (\"RG-50.030\" not in file and\n \"RG-50.106\" not in file and\n \"RG-50.549\" not in file):\n \n\n \n # convert file to docx, storing it in an untracked folder called temp\n file_docx = file + 'x'\n command = 'textutil -convert docx ' + file + ' -output ' + INPUT_FOLDER+'temp/'+ file_docx.split('/')[-1]\n call(command, shell=True)\n\n # append to the array\n core_doc_asset.append(file_docx)\n \n\n \n\n # get the units for each file, store them and update tracker\n core_doc_asset=create_dictionary_of_file_list(core_doc_asset)\n \n not_processed=0\n processed_doc=0\n \n # get the units for each file, store them and update tracker \n for mongo_rg in core_doc_asset:\n # get text units for this entry\n processed=[]\n result=[]\n \n for file in core_doc_asset[mongo_rg]:\n \n \n \n units = getTextUnits(INPUT_FOLDER+'temp/'+file.split('/')[-1])\n \n if units:\n #replace white spaces\n for i,element in enumerate(units):\n units[i]['unit']=' '.join(element['unit'].split())\n result.extend(units)\n \n processed.append(True)\n else:\n #check if processed\n processed.append(False)\n\n #set the method used to transform the transcript\n h.update_field(DB, TRACKER, \"rg_number\", mongo_rg, \"method\", \"transcribe_non_core_doc\")\n\n not_processed=not_processed+1\n\n if False in processed:\n\n h.update_field(DB, TRACKER, \"rg_number\", mongo_rg, \"status\", \"Unprocessed\")\n not_processed=not_processed+1\n missing_files.append(' '.join(core_doc_asset[mongo_rg]))\n else:\n # insert units on the output collection\n h.update_field(DB, OUTPUT, \"shelfmark\", 'USHMM '+mongo_rg, \"structured_transcript\", result)\n\n \n # update status on the stracker\n \n h.update_field(DB, TRACKER, \"rg_number\", mongo_rg, \"status\", \"Processed\")\n processed_doc=processed_doc+1\n \n\n #delete the temporary folder\n os.system('rm -r ' + INPUT_FOLDER+'temp')\n\n \n #write the missing files to text file\n file = open(OUTPUT_FOLDER_USHMM_PROCESSING_LOGS+'transcribe_non_core_doc_failed.txt','w')\n file.write('\\n'.join(missing_files))\n\n \n # success\n pprint.pprint(\"Non-core doc files were successfully processed, but there are \" + str(missing_count) + \" missing\")","def action_upload(self):\n options=self.env['plm.config.settings'].GetOptions()\n status = 'uploaded'\n action = 'upload'\n default = {\n 'state': status,\n 'engineering_writable': False,\n }\n doc_default = {\n 'state': status,\n 'writable': False,\n }\n operationParams = {\n 'status': status,\n 'statusName': _('Uploaded'),\n 'action': action,\n 'docaction': 'uploaddoc',\n 'excludeStatuses': ['uploaded', 'confirmed', 'transmitted','released', 'undermodify', 'obsoleted'],\n 'includeStatuses': ['draft'],\n 'default': default,\n 'doc_default': doc_default,\n }\n if options.get('opt_showWFanalysis', False):\n return self.action_check_workflow(operationParams)\n else:\n ids=self._ids\n self.logging_workflow(ids, action, status)\n return self._action_to_perform(ids, operationParams, default)","def file_upload():\n\n click.secho('*** Uploading image...', fg='green')\n uploaded = _uploaded_file('cover.jpg')\n click.secho(json.dumps(uploaded, indent=2, sort_keys=True), fg='yellow')\n\n click.secho('*** Creating a Picture document for it...', fg='green')\n picture = _make_document('picture', title='cover image', sys_filename=uploaded['path'])\n click.secho(json.dumps(picture, indent=2, sort_keys=True), fg='yellow')\n\n click.secho('*** Attaching it to a Blueray as cover...', fg='green')\n slp = _make_document('movie', title='Silver Linings Playbook')\n blueray = _make_document('blueray', movie_id=slp['_id'], cover_id=picture['_id'])\n click.secho(json.dumps(blueray, indent=2, sort_keys=True), fg='yellow')","def test_client_verification_document_create(self):\n pass","def multipart(self):\n self.add_file_string('Multipart file')\n self.should_copy = False","def tests_ti_document_file_name(self, request: FixtureRequest):\n helper_ti = cast(Document, self.ti_helper.create_group())\n\n # update file name\n file_name = request.node.name\n r = helper_ti.file_name(file_name)\n assert r.status_code == 200","def upload_file(self):\n request = copy.deepcopy(self.request_template)\n data = json.dumps(request)\n curr_file = {\n 'request': data,\n 'file': open(self.file_path, 'rb')\n }\n print(\"Sending Upload request of av for file {}\".format(self.file_name))\n try:\n response = requests.post(url=self.url + \"upload\", files=curr_file, verify=False)\n except Exception as E:\n print(\"Upload file failed. file: {} , failure: {}\".format(self.file_name, E))\n raise\n response_j = response.json()\n print(\"av Upload response status for file {} : {}\".format(self.file_name,\n response_j[\"response\"][0][\"status\"][\"label\"]))\n return response_j","def upload():\n\treturn render_template(\"upload.html\", title=\"Upload a file\")","def upload_file(filename: str) -> Document:\n with open(filename) as file:\n return create_document(file.read())","def test_upload_text(client: FlaskClient):\n file = get_example_file(ExampleFileType.Txt)\n response = util.upload_file(client, DEFAULT_USER, file)\n assert response.status == \"201 CREATED\"\n assert response.json[\"filetype\"] == \"DOCUMENT\"\n assert response.json[\"upload_name\"] == file.filename\n assert response.json[\"uploaded_by\"][\"id\"] == 1\n assert response.json[\"size\"] == len(file.contents)\n assert response.json[\"hash\"] == hashlib.md5(file.contents).hexdigest()\n\n # Access the file via URL\n response_get = client.get(response.json[\"url\"])\n assert response_get.status == \"200 OK\"\n assert list(response_get.response)[0] == file.contents","def uploader():\n\tif request.method == 'POST':\n\t\t\n\t\tif \"file\" not in request.files:\n\t\t\treturn \"No data in file.\"\n\n\t\tFile = request.files['file']\n\t\t\n\t\tif File.filename == \"\":\n\t\t\treturn \"No file selected.\"\n\t\t\n\t\tfilename, ext = secure_filename(File.filename).split('.')\n\t\t#Check if file stream exists and file tpye correct.\n\t\tif File and ext == \"hepmc\":\n\t\t\t#The file is a byte stream by default which is not compatible with the current version of hepmcio.\n\t\t\tstring_stream = io.StringIO(File.read().decode('utf-8'))\n\n\t\t\t#Get all events from file and jsonify them.\n\t\t\tevents = hepmcio.HepMCReader(string_stream).all_events()\n\t\t\thepMCEncoder = hepmcio_json.HepMCJSONEncoder()\n\t\t\tjsonified = [hepMCEncoder.encode(event) for event in events]\n\n\t\t\t#Each collection contains all the data in a file.\n\t\t\tif filename not in mongo.db.collection_names():\n\t\t\t\tcollection = mongo.db[filename]\n\t\t\t\tjsonDecoder = json.JSONDecoder()\n\n\t\t\t\t#MongoDB takes in Python objects and not JSON strings, so have to decode before adding documents.\n\t\t\t\tfor jsonObject in jsonified:\n\t\t\t\t\tjsonEvent = jsonDecoder.decode(jsonObject.evt)\n\t\t\t\t\tjsonParticles = [jsonDecoder.decode(p) for p in jsonObject.particles]\n\t\t\t\t\tjsonVertices = [jsonDecoder.decode(v) for v in jsonObject.vertices]\n\n\t\t\t\t\tcollection.insert_one(jsonEvent)\n\t\t\t\t\tcollection.insert_many(jsonParticles)\n\t\t\t\t\tcollection.insert_many(jsonVertices)\n\t\t\n\t\t\t\treturn \"Succesfully uploaded file.\"\n\t\t\t\n\t\t\treturn \"File already in database.\"\n\n\t\treturn \"Incorrect file type.\"","def upload(self, nameObjectDict):\n return self.cpp.upload(nameObjectDict)","def upload(self, sources=None):\n\n # Backwards compatible with < v1.4\n if self.path is None:\n self.path = self.name\n\n if self.name is None:\n raise ValueError(\"Cannot upload without a file name\")\n\n if self.ftype is None:\n raise ValueError(\"Cannot upload without a file type\")\n\n data = {}\n sources = ThreatQSource.make_source_list(sources)\n if sources:\n data['sources'] = [src.to_dict() for src in sources if src]\n\n fname = os.path.basename(self.name)\n new_filename = \"%i-%s\" % (\n random.randint(1, 100000),\n fname.replace('.', ''))\n\n content = self.content\n if not content:\n inf = open(self.path, 'rb')\n content = inf.read()\n inf.close()\n\n res = self.tq.post(\n '/api/attachments/upload',\n data={\n 'resumableIdentifier': new_filename,\n 'resumableRelativePath': fname,\n 'resumableTotalChunks': 1,\n 'resumableFilename': fname,\n },\n files={\n 'file': ('blob', content, 'application/octet-stream')\n })\n\n data['name'] = fname\n if self.title:\n data['title'] = self.title\n data['type'] = self.ftype\n data['malware_locked'] = self.locked\n\n res = self.tq.post('/api/attachments', data=data)\n\n r = res.get('data')\n if not r or 'id' not in r:\n raise exceptions.UploadFailedError(res)\n\n for t in self.tags:\n res = self.tq.post('/api/attachments/%i/tags' % r['id'], data={'name': t})\n\n self.fid = r['id']\n return self","def _put(self, name, document):\n raise NotImplementedError","def test_upload_file(self):\n data = dict(additional_metadata='additional_metadata_example',\n file='file_example')\n response = self.client.open(\n '/pet/{petId}/uploadImage'.format(pet_id=789),\n method='POST',\n data=data,\n content_type='multipart/form-data')\n self.assert200(response,\n 'Response body is : ' + response.data.decode('utf-8'))","def test_post_file(self):\n inline_object = {}\n headers = { \n 'Accept': 'application/json',\n 'Content-Type': 'multipart/form-data',\n 'admin_passphrase': 'special-key',\n 'passphrase': 'special-key',\n }\n response = self.client.open(\n '/openapi/file',\n method='POST',\n headers=headers,\n data=json.dumps(inline_object),\n content_type='multipart/form-data')\n self.assert200(response,\n 'Response body is : ' + response.data.decode('utf-8'))","def upload():\n upload_old_file = False\n file = request.files[\"data\"]\n stream_data = file.stream\n \n website_ticket = \"https://tedxruppticket.web.app/\"\n\n df = pd.read_csv(stream_data)\n name = df[\"name\"].values\n\n if \"id\" in df.columns:\n _id = df[\"id\"].values\n _name = df[\"name\"].values\n \n audiences = []\n for i in range(len(_id)):\n audiences.append(Audience(_id[i], _name[i]))\n add_to_database(audiences, multiple=True)\n\n return jsonify({\"data\": \"added\"})\n\n tickets = df[\"Ticket\"].values\n ticket_num = df[\"Ticket\"].values.sum()\n \n _name = []\n for i, n in enumerate(tickets):\n for j in range(n):\n print()\n _name.append(name[i])\n\n _id = [str(uuid4()).upper()[:7] for i in range(ticket_num)]\n\n if \"id\" in df.columns:\n upload_old_file = True\n _id = df[\"id\"].values\n\n audiences = []\n _tickets = []\n for i in range(len(_id)):\n audiences.append(Audience(_id[i], _name[i]))\n _tickets.append(website_ticket + f\"{_id[i]}\")\n add_to_database(audiences, multiple=True)\n\n output_dataframe = pd.DataFrame(data={\n \"id\": _id,\n \"name\": _name,\n \"ticket_url\": _tickets\n })\n\n output_dataframe.to_csv(\"./files/CircleAudiences.csv\")\n data_obj = output_dataframe.set_index(\"id\").to_dict()\n\n return {\"code\": \"0\", \"data\": data_obj}","def dealDocument(update: Update, _: CallbackContext) -> None:\n file_name = update.message.document.file_name\n file_name = uuid.uuid4().hex + \".\" + \\\n secure_filename(file_name).split(\".\")[-1]\n imagePath = os.path.join(args.input, file_name)\n update.message.document.get_file().download(custom_path=imagePath)\n add_mark(imagePath, mark, args)\n resultPath = os.path.join(args.out, file_name)\n with open(resultPath,\"rb\") as file:\n update.message.reply_document(file)","def test_access_cartography_upload_form(self):\n\t\tc = Client()\n\t\tUser.objects.create_superuser('bobby', 'bobby@foo.com', 'bob')\n\t\tlog = c.login(username='bobby', password='bob')\n\t\tself.assertTrue(log)\n\t\tresponse = c.get(\"/cartography/upload\")\n\t\tself.assertTrue('Add document' in response.content)","def savedoc():\r\n document.save('QSDoc_{0}_{1}_{2}_{3}.docx'.format(args.server, year, month, day))","async def complete_upload_file(\n body_item: Envelope[FileUploadCompletionBody],\n location_id: LocationID,\n file_id: StorageFileID,\n user_id: UserID,\n):","def upload(self) :\n\t\ttry :\n\t\t\treturn self._upload\n\t\texcept Exception as e:\n\t\t\traise e","def save_and_upload_samples(data, namespace, workspace, tsca_id):\n os.system('mkdir -p %s'%tsca_id)\n filename = '%s/fc_upload_samples_tsca_%s.txt' % (tsca_id, tsca_id)\n data.to_csv(filename, sep='\\t', index=False)\n res = upload_entities_from_tsv(namespace, workspace, filename)\n return res","def __init__(self, mimetype):\n self.mimetype = mimetype\n self.name = \"Filters.document.mime_type('{}')\".format(self.mimetype)"],"string":"[\n \"def put(self):\\n document = upload_file(self.request)\\n self.request.validated[\\\"qualification\\\"].documents.append(document)\\n if save_tender(self.request):\\n self.LOGGER.info(\\n \\\"Updated tender qualification document {}\\\".format(self.request.context.id),\\n extra=context_unpack(self.request, {\\\"MESSAGE_ID\\\": \\\"tender_qualification_document_put\\\"}),\\n )\\n return {\\\"data\\\": document.serialize(\\\"view\\\")}\",\n \"def upload_doc():\\n file = request.files[\\\"file\\\"]\\n meta_data = {\\\"name\\\": request.form[\\\"name\\\"].lower()}\\n file_id = save_file(meta_data, file)\\n print('file-id: ' + file_id)\\n index_after_uploading(file_id)\\n return jsonify({\\\"file_id\\\": file_id})\",\n \"def test_create_document(self):\\n self.client.force_login(user=Customer.objects.get(id=self.dummy.customer[0]).user)\\n url = reverse('document-list')\\n\\n data = {\\n 'file':open('Murphy.txt'),\\n 'type':2,\\n 'res':self.res_id,\\n 'obsolete': True,\\n 'description':'Sth',\\n }\\n response = self.client.post(url,data,format='multipart')\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n document = Document.objects.get(id=json.loads(response.content)['id'])\\n self.assertEqual(document.res_id,self.res_id)\\n self.client.logout()\",\n \"def document_upload():\\n form = SourceTextForm()\\n if form.validate_on_submit():\\n user = current_user\\n\\n doc = {}\\n doc[\\\"file\\\"] = form.filename.data\\n doc[\\\"author\\\"] = form.author.data\\n doc[\\\"title\\\"] = form.title.data\\n doc[\\\"language\\\"] = form.language.data\\n\\n params = {}\\n params[\\\"email\\\"] = user.email\\n params[\\\"new_page\\\"] = current_app.config[\\\"DOCUMENT_UPLOAD\\\"][\\\"PAGE_LIMIT\\\"]\\n params[\\\"line_size\\\"] = current_app.config[\\\"DOCUMENT_UPLOAD\\\"][\\\"LINE_SIZE\\\"]\\n params[\\\"early_cutoff\\\"] = current_app.config[\\\"DOCUMENT_UPLOAD\\\"][\\\"EARLY_CUTOFF\\\"]\\n params[\\\"batch_size\\\"] = current_app.config[\\\"DOCUMENT_UPLOAD\\\"][\\\"BATCH_SIZE\\\"]\\n params[\\\"tokenizer\\\"] = current_app.config[\\\"TOKENIZER\\\"].select(doc[\\\"language\\\"])\\n params[\\\"resource\\\"] = create_book\\n doc_uploader = DocumentUploader(params)\\n \\n could_upload = True\\n try:\\n doc_uploader.upload(doc)\\n except Exception as e:\\n traceback.print_exc()\\n could_upload = False\\n error_msg = \\\"Error uploading document. Please try again.\\\"\\n flash(error_msg)\\n\\n if could_upload:\\n success_msg = \\\"Document successfully uploaded.\\\"\\n flash(success_msg)\\n\\n return render_template('content_management/document_upload.html', form=form)\",\n \"def upload(self, upload_request):\\n raise NotImplementedError\",\n \"def upload_corpus(self, name, directory, replace=False):\\n logging.info('Not uploading corpus because no Filestore.')\",\n \"def handle_upload(f, attrs):\\n\\n # chunked = False\\n dest_folder = os.path.join(app.config['UPLOAD_DIRECTORY'], attrs['qquuid'])\\n dest = os.path.join(dest_folder, attrs['qqfilename'])\\n save_upload(f, dest)\",\n \"def get_upload(arn=None):\\n pass\",\n \"def upload(self, cr, ads_manager):\\n if self.data['order']['articles']:\\n res = super(ads_sales_order, self).upload(cr, ads_manager)\\n if self.browse_record and self.file_name:\\n self.browse_record.write({'ads_file_name': self.file_name})\\n return res\\n else:\\n return False\",\n \"def put(self):\\n if 'file' not in self.request.POST:\\n self.request.errors.add('body', 'file', 'Not Found')\\n self.request.errors.status = 404\\n return\\n tender = TenderDocument.load(self.db, self.tender_id)\\n if not tender:\\n self.request.errors.add('url', 'tender_id', 'Not Found')\\n self.request.errors.status = 404\\n return\\n data = self.request.POST['file']\\n bids = [i for i in tender.bids if i.id == self.bid_id]\\n if not bids:\\n self.request.errors.add('url', 'bid_id', 'Not Found')\\n self.request.errors.status = 404\\n return\\n bid = bids[0]\\n documents = [i for i in bid.documents if i.id == self.request.matchdict['id']]\\n if not documents:\\n self.request.errors.add('url', 'id', 'Not Found')\\n self.request.errors.status = 404\\n return\\n src = tender.serialize(\\\"plain\\\")\\n document = Document()\\n document.id = self.request.matchdict['id']\\n document.title = data.filename\\n document.format = data.type\\n document.datePublished = documents[0].datePublished\\n key = uuid4().hex\\n document.url = self.request.route_url('Tender Bid Documents', tender_id=self.tender_id, bid_id=self.bid_id, id=document.id, _query={'download': key})\\n bid.documents.append(document)\\n filename = \\\"{}_{}\\\".format(document.id, key)\\n tender['_attachments'][filename] = {\\n \\\"content_type\\\": data.type,\\n \\\"data\\\": b64encode(data.file.read())\\n }\\n patch = make_patch(tender.serialize(\\\"plain\\\"), src).patch\\n tender.revisions.append(revision({'changes': patch}))\\n try:\\n tender.store(self.db)\\n except Exception, e:\\n return self.request.errors.add('body', 'data', str(e))\\n return {'data': document.serialize(\\\"view\\\")}\",\n \"def click_upload_document_button(self):\\n self.click_element(self.upload_document_button_locator, True, True)\",\n \"def configure_ext_uploads(app):\\n configure_uploads(app, [documents])\",\n \"def initiate_multipart_upload(self):\\n request = self.s3.create_request(\\\"OBJECT_POST\\\", uri = self.uri, headers = self.headers_baseline, extra = \\\"?uploads\\\")\\n response = self.s3.send_request(request)\\n data = response[\\\"data\\\"]\\n self.upload_id = getTextFromXml(data, \\\"UploadId\\\")\\n return self.upload_id\",\n \"def client_upload_to_doc_service(self, doc_to_upload):\\n return self.doc_service_client.upload(file_name, create_file(doc_to_upload), 'application/yaml',\\n headers={'X-Client-Request-ID': doc_to_upload[\\\"meta\\\"][\\\"id\\\"]})\",\n \"def UploadUnconvertedFileSample():\\n client = CreateClient()\\n doc = gdata.docs.data.Resource(type='document', title='My Sample Raw Doc')\\n path = _GetDataFilePath('test.0.doc')\\n media = gdata.data.MediaSource()\\n media.SetFileHandle(path, 'application/msword')\\n # Pass the convert=false parameter\\n create_uri = gdata.docs.client.RESOURCE_UPLOAD_URI + '?convert=false'\\n doc = client.CreateResource(doc, create_uri=create_uri, media=media)\\n print 'Created, and uploaded:', doc.title.text, doc.resource_id.text\",\n \"def upload_question(self, request, suffix=''):\\n log.info(\\\"upload_question called\\\")\\n qupload = request.params['qassignment'] \\n sha1 = _get_sha1(qupload.file)\\n question = {\\n \\\"sha1\\\": sha1,\\n \\\"filename\\\": qupload.file.name,\\n \\\"mimetype\\\": mimetypes.guess_type(qupload.file.name)[0]\\n }\\n\\n self.raw_question = question\\n\\n path = self._question_storage_path(sha1, qupload.file.name)\\n\\n \\n filepathexists=os.path.join(IMAGEDIFF_ROOT, path)\\n file_exists=os.path.exists(filepathexists)\\n if not file_exists:\\n save_file(path, File(qupload.file))\\n file_exists=True\\n log.info(\\\"File uploaded locally\\\")\\n\\n\\n try:\\n storage.store_data(str(self.course_id), \\\"question\\\", str(self.location.block_id), file(IMAGEDIFF_ROOT + path))\\n log.info(\\\"upload through storage api successful\\\")\\n except PersonValueError:\\n log.info(\\\"storage api upload failed:\\\")\\n log.info(\\\"peson argument cant be an empty string\\\")\\n except DepartmentValueError:\\n log.info(\\\"storage api upload failed:\\\")\\n log.info(\\\"department argument cant be an empty string\\\")\\n except QualifierValueError:\\n log.info(\\\"storage api upload failed:\\\")\\n log.info(\\\"qualifier argument cant be an empty string\\\")\\n except BucketValueError:\\n log.info(\\\"storage api upload failed:\\\")\\n log.info(\\\"invalid bucket key argument\\\")\\n except S3ValueError:\\n log.info(\\\"storage api upload failed:\\\")\\n log.info(\\\"invalid S3 credentials\\\")\\n except SocketValueError:\\n log.info(\\\"storage api upload failed:\\\")\\n log.info(\\\"invalid host\\\")\\n\\n\\n \\n self.save()\\n \\n return Response(json_body=self.studio_state())\",\n \"def handle_upload(f, attrs):\\n\\n # chunked = False\\n print 'UPLOAD DIRECTORY:', UPLOAD_DIRECTORY\\n dest_folder = os.path.join(UPLOAD_DIRECTORY, attrs['qquuid'])\\n dest = os.path.join(dest_folder, attrs['qqfilename'])\\n save_upload(f, dest)\",\n \"def prepare_quick_upload(self, req):\\n\\t\\tresult, filename = self.handle_upload(req, self.get_selected_root(req))\\n\\t\\tfile_url = self.selected_root['url_callback'](req, filename)\\n\\t\\t\\n\\t\\tself.content = [str(tags.script(type=\\\"text/javascript\\\")[\\n\\t\\t\\t\\t\\t\\t\\\"window.parent.OnUploadCompleted(%s, '%s', '%s', '');\\\\n\\\" % (result, file_url, filename)\\n\\t\\t\\t\\t\\t\\t])]\",\n \"def collection_post(self):\\n if 'file' not in self.request.POST:\\n self.request.errors.add('body', 'file', 'Not Found')\\n self.request.errors.status = 404\\n return\\n tender = TenderDocument.load(self.db, self.tender_id)\\n if not tender:\\n self.request.errors.add('url', 'tender_id', 'Not Found')\\n self.request.errors.status = 404\\n return\\n src = tender.serialize(\\\"plain\\\")\\n bids = [i for i in tender.bids if i.id == self.bid_id]\\n if not bids:\\n self.request.errors.add('url', 'bid_id', 'Not Found')\\n self.request.errors.status = 404\\n return\\n bid = bids[0]\\n data = self.request.POST['file']\\n document = Document()\\n document.id = uuid4().hex\\n document.title = data.filename\\n document.format = data.type\\n key = uuid4().hex\\n document.url = self.request.route_url('Tender Bid Documents', tender_id=self.tender_id, bid_id=self.bid_id, id=document.id, _query={'download': key})\\n bid.documents.append(document)\\n filename = \\\"{}_{}\\\".format(document.id, key)\\n tender['_attachments'][filename] = {\\n \\\"content_type\\\": data.type,\\n \\\"data\\\": b64encode(data.file.read())\\n }\\n patch = make_patch(tender.serialize(\\\"plain\\\"), src).patch\\n tender.revisions.append(revision({'changes': patch}))\\n try:\\n tender.store(self.db)\\n except Exception, e:\\n return self.request.errors.add('body', 'data', str(e))\\n self.request.response.status = 201\\n self.request.response.headers['Location'] = self.request.route_url('Tender Bid Documents', tender_id=self.tender_id, bid_id=self.bid_id, id=document.id)\\n return {'data': document.serialize(\\\"view\\\")}\",\n \"def upload_latest(self, project_id, document):\\n url = base_url + 'portal/' + str(self.portal_id) + '/projects/' + str(project_id) + '/documents/' + str(document.get_id()) + '/' \\n data = parser.to_json(document)\\n if document.get_upload_doc():\\n file_list = []\\n for value in document.get_upload_doc():\\n attachment = {\\n 'uploaddoc': {\\n 'filename': basename(value), \\n 'content':open(value).read()\\n } \\n }\\n file_list.append(attachment)\\n else:\\n file_list = []\\n response = zoho_http_client.post(url, self.details, data, None, file_list)\\n return parser.get_documents(response)[0]\",\n \"def upload2notion(page, name, tags):\\n row = page.collection.add_row()\\n row.name = str(name.stem)\\n row.Tags = tags\\n for image_path in image_dir.iterdir():\\n image = row.children.add_new(ImageBlock)\\n image.upload_file(str(image_path))\\n pdf = row.children.add_new(FileBlock)\\n pdf.upload_file(str(name))\",\n \"def multipart():\\n with commit():\\n link_and_create_multipart_volumes()\\n reindex_pidtype('docid')\\n reindex_pidtype('serid')\",\n \"def test_upload(self):\\n\\n\\n username,userpass = self.testdata.find_account_for('toolsubmitter')\\n\\n self.utils.account.login_as(username,userpass)\\n\\n self.contribtool.upload(TOOLNAME,TOOLFILEDATA,username,userpass)\",\n \"def test_upload_job_description_file_post(self):\\n pass\",\n \"def collection_post(self):\\n if not self.validate_complaint_document(\\\"add\\\"):\\n return\\n document = upload_file(self.request)\\n document.author = self.request.authenticated_role\\n self.context.documents.append(document)\\n if save_tender(self.request):\\n self.LOGGER.info(\\n \\\"Created tender award complaint document {}\\\".format(document.id),\\n extra=context_unpack(\\n self.request, {\\\"MESSAGE_ID\\\": \\\"tender_award_complaint_document_create\\\"}, {\\\"document_id\\\": document.id}\\n ),\\n )\\n self.request.response.status = 201\\n document_route = self.request.matched_route.name.replace(\\\"collection_\\\", \\\"\\\")\\n self.request.response.headers[\\\"Location\\\"] = self.request.current_route_url(\\n _route_name=document_route, document_id=document.id, _query={}\\n )\\n return {\\\"data\\\": document.serialize(\\\"view\\\")}\",\n \"def put(self):\\n if not self.validate_complaint_document(\\\"update\\\"):\\n return\\n document = upload_file(self.request)\\n document.author = self.request.authenticated_role\\n self.request.validated[\\\"complaint\\\"].documents.append(document)\\n if save_tender(self.request):\\n self.LOGGER.info(\\n \\\"Updated tender award complaint document {}\\\".format(self.request.context.id),\\n extra=context_unpack(self.request, {\\\"MESSAGE_ID\\\": \\\"tender_award_complaint_document_put\\\"}),\\n )\\n return {\\\"data\\\": document.serialize(\\\"view\\\")}\",\n \"def UploadResourceSample():\\n client = CreateClient()\\n doc = gdata.docs.data.Resource(type='document', title='My Sample Doc')\\n # Set the description\\n doc.description = gdata.docs.data.Description(\\n 'This is a simple Word document.')\\n # This is a convenient MS Word doc that we know exists\\n path = _GetDataFilePath('test.0.doc')\\n print 'Selected file at: %s' % path\\n # Create a MediaSource, pointing to the file\\n media = gdata.data.MediaSource()\\n media.SetFileHandle(path, 'application/msword')\\n # Pass the MediaSource when creating the new Resource\\n doc = client.CreateResource(doc, media=media)\\n print 'Created, and uploaded:', doc.title.text, doc.resource_id.text\",\n \"def upload_file(self, file_path, file_name, output_path):\",\n \"def test_kyc_put_document(self):\\n pass\",\n \"def test_upload_voice_dataset(self):\\n pass\",\n \"def post_doc_upload(\\n self,\\n project_id: int,\\n file_format: str,\\n file_name: str,\\n file_path: str = './',\\n ) -> requests.models.Response:\\n files = {\\n 'file': (\\n file_name,\\n open(os.path.join(file_path, file_name), 'rb')\\n )\\n }\\n data = {\\n 'file': (\\n file_name,\\n open(os.path.join(file_path, file_name), 'rb')\\n ),\\n 'format': file_format\\n }\\n return self.post(\\n 'v1/projects/{project_id}/docs/upload'.format(\\n project_id=project_id\\n ),\\n files=files,\\n data=data\\n )\",\n \"def post(self):\\n source = 'uploaded by user'\\n upload_files = self.get_uploads('file')\\n blob_key = upload_files[0].key()\\n name = self.request.get('name')\\n\\n user = users.get_current_user()\\n\\n username = 'admin'\\n date = datetime.datetime.now()\\n str_blob_key = str(blob_key)\\n key = FileMetadata.get_key_name(username, date, str_blob_key)\\n\\n ctx = ndb.get_context()\\n meta = FileMetadata(key_name=key, parent=_PARENT)\\n meta.owner = user\\n meta.filename = name\\n meta.uploaded_on = date\\n meta.source = source\\n meta.blobkey = str_blob_key\\n meta.put()\\n ctx.clear_cache()\\n self.redirect('/admin')\",\n \"def test_kyc_post_document(self):\\n pass\",\n \"def document(self):\\n ...\",\n \"def upload_document_to_xtracta(workflow, document_file):\\n response = None\\n file = {\\\"userfile\\\":document_file}\\n response = requests.post(XTRACTA['url']+\\\"documents\\\"+\\\"/\\\"+\\\"upload\\\",\\\\\\n files=file, data={\\\"submit\\\":\\\"Submit\\\", \\\"api_key\\\":XTRACTA['key'],\\\\\\n \\\"workflow_id\\\":workflow})\\n response_content = xmltodict.parse(response.content)\\n if response_content['xml']['status'] == '200':\\n return response_content['xml']\\n else:\\n LOGGER.exception(\\\"upload_document_to_xtracta() %s\\\", response_content['xml']['message'])\\n return response_content['xml']\",\n \"def upload_single_file(request):\\n message, success, title = \\\"\\\", 0, \\\"error\\\"\\n is_data_ok = False\\n\\n if request.method == 'POST':\\n data_in_post = [\\\"id_campaign\\\", \\\"field_name\\\"]\\n # defined in utils.py\\n is_data_in_post = check_all_data_available_in_post(\\n data_in_post, request.POST)\\n\\n if is_data_in_post['success']:\\n is_data_ok = True\\n else:\\n message = is_data_in_post['message']\\n\\n if is_data_ok:\\n for filename, file in request.FILES.items():\\n name = request.FILES[filename].name\\n print(\\\"filename : \\\", name)\\n\\n # myfile = request.FILES['abm_company_list_file']\\n myfile = request.FILES[filename]\\n fs = FileSystemStorage()\\n filename = fs.save(\\\"campaign/\\\" + myfile.name, myfile)\\n print(filename)\\n\\n # get campaign id\\n id_campaign = request.POST.get(\\\"id_campaign\\\")\\n\\n # django get campaign object from model\\n campaign = Campaign.objects.filter(id=id_campaign).first()\\n\\n if campaign:\\n # get specification record\\n specification = Specification.objects.filter(campaign=campaign).first()\\n if specification:\\n # get field name to save\\n field_name = request.POST.get(\\\"field_name\\\")\\n\\n # check object has property with field name\\n if hasattr(specification, field_name):\\n # nested_setattr(object, 'pet.name', 'Sparky')\\n model_field_name = str(field_name) + \\\".name\\\"\\n model_field_name = model_field_name.replace(\\\" \\\", \\\"\\\")\\n print(model_field_name)\\n\\n # set nested attribute\\n # ex. form.name\\n nested_setattr(specification, model_field_name, filename)\\n\\n specification.save()\\n print(nested_getattr(specification, model_field_name, 'default')) # will print string similar to filename\\n\\n success = 1\\n title = 'success'\\n message = \\\"specification updated successfully\\\"\\n else:\\n message += \\\"Error... Specification table has no field '\\\" + field_name + \\\"'\\\"\\n\\n else:\\n message += \\\"Specification not exists with campaign: '\\\", str(campaign), \\\"'\\\"\\n else:\\n message += \\\"Campaign not exist with id : '\\\", id_campaign, \\\"'\\\"\\n\\n # uploaded_file_url = fs.url(filename)\\n success = 1\\n else:\\n message = \\\"Please post data using post method\\\"\\n\\n jsonresponse = {\\n \\\"success\\\": 1,\\n \\\"title\\\": request.POST,\\n \\\"message\\\": message,\\n }\\n return JsonResponse(jsonresponse, safe=False)\",\n \"def upload_preset(self, filename, title, description, version, author, REQUEST=None):\\r\\n\\r\\n # TODO presets.py - upload_preset - specify how to authenticate\\r\\n\\r\\n raise NotImplementedError\",\n \"def upload_finish(self, cloud_file):\",\n \"def upload(self, request, parent_lookup_client, format=None):\\n serializer = serializers.PDFUploadWritableSerializer(data=request.data)\\n serializer.is_valid(raise_exception=True)\\n serializer.update(request.user.client, serializer.validated_data)\\n client = Client.objects.get(pk=parent_lookup_client)\\n return Response(serializers.PDFUploadSerializer(client).data)\",\n \"def post(self):\\n\\n upload_files = self.get_uploads('file')\\n blob_info = upload_files[0]\\n self.redirect('/?upload_info=%s' % urllib.quote(blob_info.filename))\",\n \"def upload():\\n\\n file = request.files['query']\\n filepath = upload_filepath(secure_filename(file.filename))\\n file.save(filepath)\\n classification = classify(filepath)\\n classification['filename'] = file.filename\\n return render_template('index.html', classification=classification)\",\n \"def upload_document_fileobj(file_obj, file_name, documents_resource):\\n try:\\n fields = documents_resource.init_multipart_upload()\\n except requests.exceptions.HTTPError as e:\\n raise_api_error(e.response, state=\\\"init\\\")\\n except requests.exceptions.ConnectionError:\\n raise_connectivity_error(file_name)\\n\\n s3_upload = _s3_intermediate_upload(\\n file_obj,\\n file_name,\\n fields,\\n documents_resource._client.session,\\n documents_resource._client._root_url + fields[\\\"callback_url\\\"], # full callback url\\n )\\n\\n document_id = s3_upload.get(\\\"document_id\\\", \\\"<UUID not yet assigned>\\\")\\n\\n log.info(\\\"{}: finished as document {}\\\".format(file_name, document_id))\\n return document_id\",\n \"def setup_upload(self, dbkey=None):\\n if dbkey:\\n [upload] = Upload.objects.filter(id=dbkey)\\n return upload\\n\\n files = [\\n (\\\"gmpe_logic_tree.xml\\\", \\\"lt_gmpe\\\"),\\n (\\\"small_exposure.xml\\\", \\\"exposure\\\"),\\n (\\\"source_model1.xml\\\", \\\"source\\\"),\\n (\\\"source_model2.xml\\\", \\\"source\\\"),\\n (\\\"source_model_logic_tree.xml\\\", \\\"lt_source\\\"),\\n (\\\"vulnerability.xml\\\", \\\"vulnerability\\\")]\\n upload = view_utils.prepare_upload()\\n for file, type in files:\\n path = os.path.join(upload.path, file)\\n # This is equivalent to what the touch command does.\\n open(path, \\\"w+\\\").close()\\n input = Input(path=path, owner=upload.owner, input_type=type,\\n upload=upload)\\n input.save()\\n return upload\",\n \"def upload_samples(args):\\n clarity_epp.upload.samples.from_helix(lims, config.email, args.input_file)\",\n \"def edit_document():\",\n \"def _UploadFile(self, media_source, title, category):\\n media_entry = gdata.GDataEntry()\\n media_entry.title = atom.Title(text=title)\\n media_entry.category.append(category)\\n media_entry = self.Post(media_entry, '/feeds/documents/private/full',\\n media_source = media_source,\\n extra_headers = {'Slug' : media_source.file_name })\\n\\n return media_entry\",\n \"def upload(self, filename, file_path):\\n return\",\n \"def test_upload_file(self):\\n pass\",\n \"def main():\\n credentials = get_credentials()\\n http = credentials.authorize(httplib2.Http())\\n service = apiclient.discovery.build('drive', 'v3', http=http)\\n\\n sheet_id = raw_input(\\\"Input sheet id: \\\")\\n sheet = sefaria_sheet_api(sheet_id)\\n\\n file_metadata = {\\n 'name': sheet.get('title', '').strip(),\\n 'mimeType': 'application/vnd.google-apps.document'\\n }\\n\\n media = apiclient.http.MediaIoBaseUpload(\\n StringIO.StringIO(create_html_string(sheet)),\\n mimetype='text/html',\\n resumable=True)\\n\\n new_file = service.files().create(body=file_metadata,\\n media_body=media,\\n fields='id,webViewLink').execute()\\n\\n print '{} (id: {})'.format(new_file['webViewLink'], new_file['id'])\",\n \"def complete_upload(self):\\r\\n xml = self.to_xml()\\r\\n return self.bucket.complete_multipart_upload(self.key_name,\\r\\n self.id, xml)\",\n \"def test_upload_file1(self):\\n pass\",\n \"def _upload_file_to_file_system(upload_details):\\n upload_url = \\\"%s%s\\\" % (main_url, upload_details['upload_path'])\\n fsysparams = {\\n 'qqfile': upload_filepath,\\n 'import_record': upload_dataset_id,\\n 'source_type': upload_datatype\\n }\\n return requests.post(upload_url,\\n params=fsysparams,\\n files={'file': open(upload_filepath, 'rb')},\\n headers=upload_header)\",\n \"def execute(pagename, request):\\n _ = request.getText\\n\\n do = request.values.get('do', 'upload_form')\\n handler = globals().get('_do_%s' % do)\\n if handler:\\n msg = handler(pagename, request)\\n else:\\n msg = _('Unsupported AttachFile sub-action: %s') % do\\n if msg:\\n error_msg(pagename, request, msg)\",\n \"def index(self, file_object, pems):\\n res, search = self.get(file_object.system,\\n os.path.dirname(file_object.path.strip('/')),\\n os.path.basename(file_object.path.strip('/')))\\n if res.hits.total > 1:\\n for doc in res[1:]:\\n doc.delete(ignore=404)\\n if res.hits.total >= 1:\\n document = res[0]\\n file_object.pop('_links')\\n file_object.pop('permissions')\\n document.update(**file_object)\\n else:\\n document = IndexedFile(\\n name=os.path.basename(file_object.path.strip('/')),\\n path=os.path.dirname(file_object.path.strip('/')) or '/',\\n lastModified=file_object.lastModified.isoformat(),\\n length=file_object.length,\\n format=file_object.format,\\n mimeType=file_object.mimeType,\\n type=file_object.type,\\n system=file_object.system,\\n )\\n if pems is None or not pems:\\n document.permissions = [{\\n 'username': self.username,\\n 'permission': {\\n 'read': True,\\n 'write': True,\\n 'execute': True\\n }\\n }]\\n document.save()\\n\\n if pems:\\n for pem in pems:\\n pem.pop('_links', None)\\n pem.pop('internalUsername', None)\\n document.update(permissions=pems)\\n return document\",\n \"def patch(self):\\n if apply_patch(self.request, src=self.request.context.serialize()):\\n update_file_content_type(self.request)\\n self.LOGGER.info(\\n \\\"Updated tender qualification document {}\\\".format(self.request.context.id),\\n extra=context_unpack(self.request, {\\\"MESSAGE_ID\\\": \\\"tender_qualification_document_patch\\\"}),\\n )\\n return {\\\"data\\\": self.request.context.serialize(\\\"view\\\")}\",\n \"def upload_samples():\\n # Retrieve a list of all files and paths within the target\\n paths = Path(Config.target_dir).glob(Config.target_pattern)\\n # Inform the user as to what we're doing\\n logger.info(\\\"Assembling %s volume for submission\\\", Config.target_dir)\\n # Loop through each identified file and upload it to the sandbox for analysis\\n for path in paths:\\n # Convert the path to a string\\n filepath = str(path)\\n # Grab the file name\\n filename = os.path.basename(filepath)\\n # Open the file for binary read, this will be our payload\\n with open(filepath, 'rb') as upload_file:\\n payload = upload_file.read()\\n # Upload the file using the Sandbox\\n response = Samples.upload_sample(file_name=filename, sample=payload)\\n # Grab the SHA256 unique identifier for the file we just uploaded\\n sha = response[\\\"body\\\"][\\\"resources\\\"][0][\\\"sha256\\\"]\\n # Add this SHA256 to the volume payload element\\n Analyzer.uploaded.append(sha)\\n # Track the upload so we can remove the file when we're done\\n Analyzer.files.append([filename, filepath, sha])\\n # Inform the user of our progress\\n logger.debug(\\\"Uploaded %s to %s\\\", filename, sha)\",\n \"def uploadToRM(dry):\\n # list of files in Library\\n syncFilesList = glob.glob(syncDirectory + \\\"/*/*.pdf\\\")\\n # list of files on the rM (hashed)\\n rmPdfList = glob.glob(remarkableBackupDirectory + remContent + \\\"/*.pdf\\\")\\n # make list of actual names (not hashed)\\n pdfNamesOnRm = []\\n for i in range(0, len(rmPdfList)):\\n refNrPath = rmPdfList[i][:-4]\\n # get meta Data\\n meta = json.loads(open(refNrPath + \\\".metadata\\\").read())\\n # Make record of pdf files already on device\\n rmPdfName = meta[\\\"visibleName\\\"] + \\\".pdf\\\" if meta[\\\"visibleName\\\"][-4:] != \\\".pdf\\\" else meta[\\\"visibleName\\\"]\\n pdfNamesOnRm.append(rmPdfName)\\n\\n # remove files in the Notes directory from the list (those dont need to be re-uploaded)\\n syncFilesList = [x for x in syncFilesList if \\\"/Notes/\\\" not in x]\\n # find absolute path\\n syncNames = [os.path.basename(f) for f in syncFilesList]\\n # remove annotated pdf files from the list (those dont need to be re-uploaded)\\n syncNames = [x for x in syncNames if \\\"annot\\\" not in x]\\n\\n # find files that are not already on the rM\\n # this gets elements that are in the sync list but not on the rM\\n uploadList = [x for x in syncNames if x not in pdfNamesOnRm]\\n # print(\\\"uploadList:\\\")\\n # print(uploadList)\\n\\n uploadPathList = [glob.glob(syncDirectory + \\\"/*/\\\" + x)[0] for x in uploadList]\\n # print(\\\"uploadPathList:\\\")\\n # print(uploadPathList)\\n # do in batches of the folders\\n folderList = [os.path.dirname(x).split(\\\"/\\\")[-1] for x in uploadPathList]\\n # print(folderList)\\n batches = list(set(folderList))\\n\\n # print(batches)\\n\\n for folder in batches:\\n filesInFolder = [f for f in uploadPathList if folder == os.path.dirname(f).split(\\\"/\\\")[-1]]\\n print(\\\"upload \\\" + \\\" \\\".join(filesInFolder) + \\\" to \\\" + folder)\\n\\n folderpath = os.path.dirname(filesInFolder[0])\\n if folderpath != syncDirectory:\\n uploadCmd = \\\"\\\".join([\\\"bash \\\", pushScript, \\\" -o /\\\", folder, \\\" \\\", \\\" \\\".join(filesInFolder)])\\n else:\\n uploadCmd = \\\"\\\".join([\\\"bash \\\", pushScript, \\\" \\\".join(filesInFolder)])\\n\\n if dry:\\n print(\\\"uploadCmd: \\\")\\n print(uploadCmd)\\n else:\\n os.system(uploadCmd)\\n #Sleep to allow restart\\n print(\\\"sleeping while rM restarts\\\")\\n time.sleep(15)\",\n \"def uploadToRM_curl(dry):\\n # list of files in Library\\n syncFilesList = glob.glob(os.path.join(syncDirectory, \\\"*\\\", \\\"*.pdf\\\"))\\n # list of files on the rM (hashed)\\n rmPdfList = glob.glob(os.path.join(remarkableBackupDirectory, remContent,\\n \\\"*.pdf\\\"))\\n # make list of actual names (not hashed)\\n pdfNamesOnRm = []\\n for i in range(0, len(rmPdfList)):\\n refNrPath = rmPdfList[i][:-4]\\n # get meta Data\\n meta = json.loads(open(refNrPath + \\\".metadata\\\").read())\\n # Make record of pdf files already on device\\n if meta[\\\"visibleName\\\"][-4:] != \\\".pdf\\\":\\n rmPdfName = meta[\\\"visibleName\\\"] + \\\".pdf\\\"\\n else:\\n rmPdfName = meta[\\\"visibleName\\\"]\\n pdfNamesOnRm.append(rmPdfName)\\n # remove files in the Notes directory from the list\\n # (those dont need to be re-uploaded)\\n syncFilesList = [x for x in syncFilesList \\\\\\n if \\\"/\\\" + notesDirectory + \\\"/\\\" not in x]\\n # find absolute path\\n syncNames = [os.path.basename(f) for f in syncFilesList]\\n # remove annotated pdf files from the list\\n # (those dont need to be re-uploaded)\\n syncNames = [x for x in syncNames if \\\"annot\\\" not in x]\\n\\n # find files that are not already on the rM\\n # this gets elements that are in the sync list but not on the rM\\n uploadList = [x for x in syncNames if x not in pdfNamesOnRm]\\n for upl in uploadList:\\n # get full path for the file to be uploaded\\n filePath = glob.glob(os.path.join(syncDirectory, \\\"*\\\", upl))[0]\\n # chop the ending if necessary to get file name\\n fileName = upl if upl[-4:0] != \\\"pdf\\\" else upl[:-4]\\n\\n print(\\\"upload \\\"+ fileName +\\\" from \\\"+filePath)\\n\\n # # CURL version (can't copy directly to folders)\\n # #http://remarkablewiki.com/index.php?title=Methods_of_access\\n # #chronos@localhost ~/Downloads $ curl 'http://10.11.99.1/upload' -H 'Origin: http://10.11.99.1' -H 'Accept: */*' -H 'Referer: http://10.11.99.1/' -H 'Connection: keep-alive' -F \\\"file=@Get_started_with_reMarkable.pdf;filename=Get_started_with_reMarkable.pdf;type=application/pdf\\\"\\n #uploadCmd = \\\"\\\".join([\\\"curl 'http://10.11.99.1/upload' -H 'Origin: http://10.11.99.1' -H 'Accept: */*' -H 'Referer: http://10.11.99.1/' -H 'Connection: keep-alive' -F 'file=@\\\", filePath, \\\";filename=\\\", fileName, \\\";type=application/pdf'\\\"])\\n uploadCmd = \\\"\\\".join([\\\"curl 'http://\\\",remarkableIP,\\\"/upload' -H 'Origin: http://\\\",remarkableIP,\\\"' -H 'Accept: */*' -H 'Referer: http://\\\",remarkableIP,\\\"' -H 'Connection: keep-alive' -F 'file=@\\\", filePath, \\\";filename=\\\", fileName, \\\";type=application/pdf'\\\"])\\n\\n if dry:\\n print(\\\"uploadCmd: \\\")\\n print(uploadCmd)\\n else:\\n os.system(uploadCmd)\",\n \"def typesense_index_record(rec, client=None):\\n if not client:\\n client = typesense_client()\\n\\n rec_document = {\\n 'id': str(rec.pk),\\n 'created': rec.created.timestamp(),\\n 'referral_id': rec.referral.pk,\\n 'name': rec.name,\\n 'description': rec.description if rec.description else '',\\n 'file_name': rec.filename,\\n 'file_type': rec.extension,\\n }\\n file_content = ''\\n\\n # PDF document content.\\n if rec.extension == 'PDF':\\n try:\\n # PDF text extraction can be a little error-prone.\\n # In the event of an exception here, we'll just accept it and pass.\\n if settings.LOCAL_MEDIA_STORAGE:\\n file_content = high_level.extract_text(open(rec.uploaded_file.path, 'rb'))\\n else:\\n file_content = high_level.extract_text(open(rec.uploaded_file))\\n except:\\n pass\\n\\n # MSG document content.\\n if rec.extension == 'MSG':\\n if settings.LOCAL_MEDIA_STORAGE:\\n message = Message(rec.uploaded_file.path)\\n else:\\n message = Message(rec.uploaded_file)\\n file_content = '{} {}'.format(message.subject, message.body.replace('\\\\r\\\\n', ' '))\\n\\n # DOCX document content.\\n if rec.extension == 'DOCX':\\n if settings.LOCAL_MEDIA_STORAGE:\\n file_content = docx2txt.process(rec.uploaded_file.path)\\n else:\\n file_content = docx2txt.process(rec.uploaded_file)\\n\\n # TXT document content.\\n if rec.extension == 'TXT':\\n if settings.LOCAL_MEDIA_STORAGE:\\n file_content = open(rec.uploaded_file.path, 'r').read()\\n else:\\n file_content = rec.uploaded_file.read()\\n\\n # Trim down the content of uploaded files a little.\\n if file_content:\\n # Decode a bytes object to a string.\\n if isinstance(file_content, bytes):\\n file_content = file_content.decode('utf-8')\\n # Replace punctuation with a space.\\n file_content = re.sub(r'[^\\\\w\\\\s]', ' ', file_content)\\n # Replace newlines with a space.\\n file_content = file_content.replace('\\\\r\\\\n', ' ')\\n # Replace multiple spaces with a single one.\\n file_content = re.sub(r'\\\\s+', ' ', file_content)\\n file_content = file_content.strip()\\n\\n rec_document['file_content'] = file_content\\n client.collections['records'].documents.upsert(rec_document)\",\n \"def uploadResourceFile(url, user, pWd, resourceName, fileName, fullPath):\\n print(\\\"uploading file for resource \\\" + url + \\\" resource=\\\" + \\n resourceName + ' user=' + user)\\n apiURL = url + '/access/1/catalog/resources/' + resourceName + \\\"/files\\\"\\n print(\\\"\\\\turl=\\\" + apiURL)\\n # header = {\\\"accept\\\": \\\"*/*\\\", \\\"Content-Type\\\" : \\\"multipart/form-data\\\"} \\n header = {\\\"accept\\\": \\\"*/*\\\"} \\n print(\\\"\\\\t\\\" + str(header))\\n params = {\\\"scannerid\\\": \\\"LineageScanner\\\", \\\"filename\\\": fileName, \\n \\\"optionid\\\": \\\"File\\\"}\\n print(\\\"\\\\t\\\" + str(params))\\n# files = {'file': fullPath}\\n mimeType = 'text/csv'\\n readMode = 'rt'\\n if fileName.endswith(\\\".zip\\\"):\\n mimeType = 'application/zip'\\n readMode = 'rb'\\n \\n file = { 'file' : (fileName, open(fullPath, readMode), mimeType)}\\n print('\\\\t' + str(file))\\n uploadResp = requests.post(apiURL, data=params, files=file, headers=header, \\n auth=HTTPBasicAuth(user,pWd))\\n print(\\\"\\\\tresponse=\\\" + str(uploadResp.status_code))\\n if uploadResp.status_code == 200:\\n # valid - return the jsom\\n return uploadResp.status_code\\n else:\\n # not valid\\n print(\\\"\\\\tupload file failed\\\")\\n print(\\\"\\\\t\\\" + str(uploadResp))\\n print(\\\"\\\\t\\\" + str(uploadResp.text))\\n return uploadResp.status_code\",\n \"def upload_submission(request, learner, trigger, no_thumbnail=True):\\n base_dir_for_file_uploads = settings.MEDIA_ROOT\\n thumbnail_file_name_django = ''\\n entry_point = trigger.entry_point\\n\\n files = request.FILES.getlist('file_upload', None)\\n if files is None:\\n return None\\n\\n # Is the storage space reachable?\\n deepest_dir = base_dir_for_file_uploads + 'uploads/{0}/tmp/'.format(\\n entry_point.id)\\n\\n try:\\n os.makedirs(deepest_dir)\\n except OSError:\\n if not os.path.isdir(deepest_dir):\\n logger.error('Cannot create directory for upload: {0}'.format(\\n deepest_dir))\\n raise\\n\\n if len(files) == 1:\\n filename = files[0].name\\n extension = filename.split('.')[-1].lower()\\n submitted_file_name_django = 'uploads/{0}/{1}'.format(entry_point.id,\\n generate_random_token(token_length=16) + '.' + extension)\\n full_path = base_dir_for_file_uploads + submitted_file_name_django\\n with open(full_path, 'wb+') as dst:\\n for chunk in files[0].chunks():\\n dst.write(chunk)\\n\\n\\n f_size = os.path.getsize(full_path)\\n if f_size > trigger.max_file_upload_size_MB * 1024 * 1024:\\n logger.warning('File too large {0}'.format(\\n submitted_file_name_django))\\n return None, ('File too large ({0} MB); it must be less than '\\n '{1} MB.'.format(round(float(f_size/1024.0/1024.0), 1),\\n trigger.max_file_upload_size_MB))\\n\\n\\n else: #if trigger.allow_multiple_files: this is removed for now\\n filename = ''\\n extension = ''\\n submitted_file_name_django = ''\\n full_path = ''\\n\\n\\n # Check that the file format is PDF, if that is required.\\n strike1 = False\\n if 'pdf' in trigger.accepted_file_types_comma_separated.lower() and \\\\\\n extension in ('pdf',):\\n try:\\n mime = magic.from_file(full_path, mime=True)\\n if not(isinstance(mime, str)):\\n mime = mime.decode('utf-8')\\n except Exception as exp:\\n logger.error('Could not determine MIME type: ' + str(exp))\\n mime = ''\\n strike1 = True\\n\\n if 'application/pdf' not in mime.lower():\\n strike1 = True\\n\\n if strike1:\\n logger.debug('Invalid PDF upload: {0} [{1}]'.format(mime,\\n full_path))\\n #return None, 'Invalid file uploaded. Uploaded file must be a PDF.'\\n\\n doc = PdfFileReader(full_path)\\n if doc.isEncrypted:\\n logger.debug('Encrypted PDF upload: {0}'.format(full_path))\\n return None, ('An encrypted PDF cannot be uploaded. Please remove '\\n 'the encryption and try again.')\\n\\n\\n strike1 = False\\n if (('jpeg' in trigger.accepted_file_types_comma_separated.lower()) or \\\\\\n ('jpg' in trigger.accepted_file_types_comma_separated.lower())) and \\\\\\n extension in ('jpg', 'jpeg'):\\n\\n try:\\n mime = magic.from_file(full_path, mime=True)\\n if not(isinstance(mime, str)):\\n mime = mime.decode('utf-8')\\n except Exception as exp:\\n logger.error('Could not determine MIME type: ' + str(exp))\\n mime = ''\\n strike1 = True\\n\\n if 'image/jpeg' not in mime.lower():\\n strike1 = True\\n\\n if strike1:\\n logger.debug('Invalid JPG upload: {0} [{1}]'.format(mime,\\n full_path))\\n return None, ('Invalid file. Uploaded image should be a valid '\\n 'and readable JPEG file.')\\n\\n\\n strike1 = False\\n if ('png' in trigger.accepted_file_types_comma_separated.lower()) and \\\\\\n extension in ('png',):\\n\\n try:\\n mime = magic.from_file(full_path, mime=True)\\n if not(isinstance(mime, str)):\\n mime = mime.decode('utf-8')\\n except Exception as exp:\\n logger.error('Could not determine MIME type: ' + str(exp))\\n mime = ''\\n strike1 = True\\n\\n if 'image/png' not in mime.lower():\\n strike1 = True\\n\\n if strike1:\\n logger.debug('Invalid PNG upload: {0} [{1}]'.format(mime,\\n full_path))\\n return None, ('Invalid file. Uploaded image should be a valid '\\n 'and readable PNG file.')\\n\\n\\n strike2 = False\\n if extension.lower() not in \\\\\\n trigger.accepted_file_types_comma_separated.lower():\\n logger.debug('Invalid file type upload: received \\\".{0}\\\"; [{1}]'.format(\\\\\\n extension, full_path))\\n return None, ('Invalid file uploaded. Uploaded file must be: {}'.format(\\\\\\n trigger.accepted_file_types_comma_separated))\\n\\n\\n if trigger == entry_point:\\n # In some instances we don't use triggers, just entry_points\\n prior = Submission.objects.filter(status='S',\\n submitted_by=learner,\\n entry_point=entry_point,\\n is_valid=True\\n )\\n else:\\n prior_indiv = Q(status='S', submitted_by=learner, entry_point=entry_point,\\n trigger=trigger, is_valid=True)\\n\\n # We need this here, but also for the code later in the next\\n # if (trigger==entry_point) part\\n\\n # Default returned by this function is ``None`` if the user is not\\n # enrolled in a group, or if this course simply does not use groups.\\n group_submitted = is_group_submission(learner, entry_point)\\n if is_group_submission(learner, entry_point):\\n group_submitted = group_submitted.group\\n\\n prior_group = Q(status='S', group_submitted=group_submitted,\\n entry_point=entry_point, trigger=trigger,\\n is_valid=True)\\n else:\\n prior_group = Q()\\n\\n prior = Submission.objects.filter(prior_indiv | prior_group)\\n\\n\\n for item in prior:\\n logger.debug(('Setting prior submission to False: {0} and name '\\n '\\\"{1}\\\"'.format(str(item), item.submitted_file_name)))\\n item.is_valid = False\\n item.save()\\n\\n\\n if trigger == entry_point:\\n # In some instances we don't use triggers, just entry_points\\n sub = Submission(submitted_by=learner,\\n group_submitted=None,\\n status='S',\\n entry_point=entry_point,\\n is_valid=True,\\n file_upload=submitted_file_name_django,\\n thumbnail=thumbnail_file_name_django,\\n submitted_file_name=filename,\\n ip_address=get_IP_address(request),\\n )\\n sub.save()\\n else:\\n\\n sub = Submission(submitted_by=learner,\\n group_submitted=group_submitted,\\n status='S',\\n entry_point=entry_point,\\n trigger=trigger,\\n is_valid=True,\\n file_upload=submitted_file_name_django,\\n thumbnail=thumbnail_file_name_django,\\n submitted_file_name=filename,\\n ip_address=get_IP_address(request),\\n )\\n sub.save()\\n\\n if 'pdf' in trigger.accepted_file_types_comma_separated.lower() and \\\\\\n extension in ('pdf',):\\n clean_PDF(sub)\\n\\n return sub\",\n \"def upload(context, request):\\n if request.method == 'POST':\\n if not hasattr(request.POST['content'], 'file'):\\n raise RuntimeError('No file attached')\\n\\n fieldstorage = request.POST['content']\\n filename = fieldstorage.filename\\n logger.info(\\\"%s posted\\\", filename)\\n\\n with bm(\\\"%s released\\\" %filename):\\n dest = path(request.file_root) / request.namer(filename)\\n dest.write_bytes(fieldstorage.file.read())\\n try:\\n request.registry.notify(event.PackageAdded(request.index, path=dest))\\n request.response.headers['X-Swalow-Status'] = 'SUCCESS'\\n try:\\n for ep in pkg_resources.iter_entry_points('cheeseprism.on_upload'):\\n func = ep.load()\\n func(context, request, dest)\\n except Exception as e:\\n logger.exception('Entry point %r failed', ep)\\n return request.response\\n except :\\n logger.exception(\\\"Processing of %s failed\\\", filename)\\n raise\\n return {}\",\n \"def test_client_document_create(self):\\n pass\",\n \"def put(self, request, code, suggested_format=None):\\n context = {'request': request}\\n conten_type = request.content_type\\n uploaded_obj = None\\n if 'multipart/form-data' in conten_type:\\n # We have a file upload encoded with multipart/form-data\\n file_content = StringIO(request.body)\\n parser = MultiPartParser()\\n dnf = parser.parse(file_content, media_type=conten_type, parser_context=context)\\n extra = dnf.data\\n if 'file' in dnf.files:\\n uploaded_obj = dnf.files['file']\\n else:\\n extra = request.QUERY_PARAMS\\n # TODO: do we require SQL tagging logic in this API call?\\n sql_tag_string = extra.get('tag_string', None)\\n sql_remove_tag_string = extra.get('remove_tag_string', None)\\n new_name = extra.get('new_name', None)\\n new_type = extra.get('new_type', None)\\n index_data = extra.get('indexing_data', None)\\n if index_data:\\n index_data = json.loads(index_data)\\n processor = DocumentProcessor()\\n options = {\\n 'tag_string': sql_tag_string,\\n 'remove_tag_string': sql_remove_tag_string,\\n 'extension': suggested_format,\\n 'new_name': new_name,\\n 'new_type': new_type,\\n 'new_indexes': index_data,\\n 'update_file': uploaded_obj,\\n 'user': request.user,\\n }\\n document = processor.update(code, options)\\n if len(processor.errors) > 0:\\n log.error('FileHandler.update manager errors %s' % processor.errors)\\n if settings.DEBUG:\\n print processor.errors\\n raise Exception('FileHandler.update manager errors')\\n else:\\n return Response(status=status.HTTP_400_BAD_REQUEST)\\n log.info('FileHandler.update request fulfilled for code: %s, extension: %s'\\n % (code, suggested_format))\\n resp = DMSOBjectRevisionsData(document).data\\n return Response(resp, status=status.HTTP_200_OK)\",\n \"def uploadFile(self,path):\\n\\n response = requests.post('https://api.imagga.com/v1/content',\\n auth=(self.apikey, self.secret),\\n files={'image': open(path, 'r')})\\n json_data = json.loads(response.text)\\n uploadedData=json_data[u'uploaded'][0]\\n resourceId=uploadedData[u'id']\\n filename = uploadedData[u'filename']\\n self.fileToIdMap[filename] = resourceId\\n self.getTagsUsingId(resourceId)\",\n \"def upload(request):\\n\\n\\tdoc_form = DocumentForm()\\n\\n\\tif request.method == \\\"POST\\\":\\n\\n\\t\\tdoc_form = DocumentForm(request.POST,request.FILES)\\n\\t\\tuser = request.user.username\\n\\t\\tuser_obj = User.objects.get(username=user)\\n\\t\\ttodays_pdfs = Document.objects.filter(user=user_obj.pk).filter(created_at__date=timezone.now())\\n\\t\\tusers_today_uploads = todays_pdfs.count()\\n\\n\\t\\tif users_today_uploads == 5:\\n\\t\\t\\tmessages.info(request, \\\"You can Only upload 5 docs/day !\\\")\\n\\t\\t\\treturn redirect(reverse('upload'))\\n\\n\\t\\telse:\\n\\t\\t\\tbreakpoint()\\n\\t\\t\\tif doc_form.is_valid():\\n\\t\\t\\t\\tif request.FILES['PDF'].size > 5242880:\\n\\t\\t\\t\\t\\tmessages.info(request, \\\"Size can't be more than 5 MiB\\\")\\n\\t\\t\\t\\t\\treturn redirect(reverse('upload'))\\n\\t\\t\\t\\telse:\\t\\n\\t\\t\\t\\t\\tdoc_obj = doc_form.save(commit=False)\\n\\t\\t\\t\\t\\tdoc_obj.user = user_obj\\n\\t\\t\\t\\t\\tdoc_obj.save()\\n\\t\\t\\t\\t\\t# breakpoint()\\n\\t\\t\\t\\t\\tmessages.success(request, \\\"Uploaded Successfully\\\")\\n\\t\\t\\t\\t\\treturn redirect(reverse('upload'))\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmessages.error(request, \\\"Error Occured\\\")\\n\\t\\t\\t\\treturn redirect(reverse('upload'))\\n\\n\\telse:\\n\\t\\t\\n\\t\\tcontext = {'form':doc_form}\\n\\t\\treturn render(request, 'document_manager/upload.html', context)\",\n \"def upload_from_file(self, file_obj, name_on_storage, **keyword_args):\\n blob = self.bucket.blob(name_on_storage)\\n blob.upload_from_file(file_obj, **keyword_args)\\n print(f\\\"Upload object {name_on_storage}\\\")\",\n \"def upload(study_id, payload, song_url, auth_token):\\n song_client = SongClient(\\n song_url,\\n auth_token,\\n VERIFY_CERTIFICATES\\n )\\n response = song_client.create_custom_analysis(\\n study_id,\\n payload\\n )\\n return response['analysisId']\",\n \"def _call_init_upload(\\n file_name, file_size, metadata, tags, project, samples_resource, sample_id, external_sample_id\\n):\\n upload_args = {\\n \\\"filename\\\": file_name,\\n \\\"size\\\": file_size,\\n \\\"upload_type\\\": \\\"standard\\\", # this is multipart form data\\n \\\"sample_id\\\": sample_id,\\n \\\"external_sample_id\\\": external_sample_id,\\n }\\n\\n upload_args.update(build_upload_dict(metadata, tags, project))\\n\\n try:\\n return samples_resource.init_upload(upload_args)\\n except requests.exceptions.HTTPError as e:\\n raise_api_error(e.response, state=\\\"init\\\")\\n except requests.exceptions.ConnectionError:\\n raise_connectivity_error(file_name)\",\n \"def webhook_upload(user, application, complete_path, init_es, tool, scan_name, user_host, to_name,hook_log):\\n hook_log = WebhookLog.objects.get(id=hook_log)\\n hook_log.file_upload_event = True\\n hook_log.file_upload_datetime = timezone.now()\\n hook_log.save()\\n process_files(user, application, complete_path, init_es, tool, scan_name, user_host, to_name,hook_log=hook_log)\\n info_debug_log(event='Webhook upload',status='success')\",\n \"def _upload_file(self, file_name, full_path, quiet, request, resources):\\r\\n\\r\\n if not quiet:\\r\\n print('Starting upload for file ' + file_name)\\r\\n\\r\\n content_length = os.path.getsize(full_path)\\r\\n token = self.dataset_upload_file(full_path, quiet)\\r\\n if token is None:\\r\\n if not quiet:\\r\\n print('Upload unsuccessful: ' + file_name)\\r\\n return True\\r\\n if not quiet:\\r\\n print('Upload successful: ' + file_name + ' (' +\\r\\n File.get_size(content_length) + ')')\\r\\n upload_file = DatasetUploadFile()\\r\\n upload_file.token = token\\r\\n if resources:\\r\\n for item in resources:\\r\\n if file_name == item.get('path'):\\r\\n upload_file.description = item.get('description')\\r\\n if 'schema' in item:\\r\\n fields = self.get_or_default(item['schema'], 'fields',\\r\\n [])\\r\\n processed = []\\r\\n count = 0\\r\\n for field in fields:\\r\\n processed.append(self.process_column(field))\\r\\n processed[count].order = count\\r\\n count += 1\\r\\n upload_file.columns = processed\\r\\n request.files.append(upload_file)\\r\\n return False\",\n \"def oparl_documentsss():\\n start_time = time.time()\\n jsonp_callback = request.args.get('callback', None)\\n ref = request.args.get('reference', '')\\n references = ref.split(',')\\n if references == ['']:\\n references = None\\n output = request.args.get('output', '').split(',')\\n rs = util.get_rs()\\n q = request.args.get('q', '*:*')\\n fq = request.args.get('fq', '')\\n sort = request.args.get('sort', 'score desc')\\n start = int(request.args.get('start', '0'))\\n numdocs = int(request.args.get('docs', '10'))\\n date_param = request.args.get('date', '')\\n get_attachments = 'attachments' in output\\n get_thumbnails = 'thumbnails' in output and get_attachments\\n get_consultations = 'consultations' in output\\n get_facets = 'facets' in output\\n #get_relations = 'relations' in output\\n request_info = {} # Info über die Anfrage\\n query = False\\n docs = False\\n submission_ids = []\\n # TODO: entscheiden, was mit get_relations passiert\\n \\\"\\\"\\\"\\n Anhand der übergebenen Parameter wird entschieden, ob eine ES-Suche\\n durchgeführt wird, oder ob die Abfrage direkt anhand von Kennungen\\n (references) erfolgen kann.\\n \\\"\\\"\\\"\\n \\n if references is None:\\n # Suche wird durchgeführt\\n # (References-Liste via Suchmaschine füllen)\\n query = db.query_submissions(rs=rs, q=q, fq=fq, sort=sort, start=start,\\n docs=numdocs, date=date_param, facets=get_facets)\\n if query['numhits'] > 0:\\n submission_ids = [x['_id'] for x in query['result']]\\n else:\\n docs = []\\n else:\\n # Direkte Abfrage\\n request_info = {\\n 'references': references\\n }\\n request_info['output'] = output\\n\\n # Abrufen der benötigten Dokumente aus der Datenbank\\n if references is not None:\\n docs = db.get_submissions(rs=rs, references=references,\\n get_attachments=get_attachments,\\n get_consultations=get_consultations,\\n get_thumbnails=get_thumbnails)\\n elif len(submission_ids) > 0:\\n docs = db.get_submissions(rs=rs, submission_ids=submission_ids,\\n get_attachments=get_attachments,\\n get_consultations=get_consultations,\\n get_thumbnails=get_thumbnails)\\n\\n ret = {\\n 'status': 0,\\n 'duration': int((time.time() - start_time) * 1000),\\n 'request': request_info,\\n 'response': {}\\n }\\n if docs:\\n ret['response']['documents'] = docs\\n ret['response']['numdocs'] = len(docs)\\n if query and 'maxscore' in query:\\n ret['response']['maxscore'] = query['maxscore']\\n for n in range(len(docs)):\\n docs[n]['reference'] = docs[n]['identifier']\\n del docs[n]['identifier']\\n\\n if query:\\n ret['response']['numhits'] = query['numhits']\\n if get_facets and 'facets' in query:\\n ret['response']['facets'] = query['facets']\\n \\n ret['response']['start'] = start\\n ret['request']['sort'] = sort\\n ret['request']['fq'] = fq\\n\\n json_output = json.dumps(ret, cls=util.MyEncoder, sort_keys=True)\\n if jsonp_callback is not None:\\n json_output = jsonp_callback + '(' + json_output + ')'\\n response = make_response(json_output, 200)\\n response.mimetype = 'application/json'\\n response.headers['Expires'] = util.expires_date(hours=24)\\n response.headers['Cache-Control'] = util.cache_max_age(hours=24)\\n return response\",\n \"def update_filedetails_ajax(request):\\n try:\\n document_id = request.GET.get('document_id')\\n tag = request.GET.get('tag')\\n get_index = find_index_with_document(document_id)\\n updated_data = update(get_index, document_id, tag)\\n return JsonResponse({\\\"fs_metadata\\\": updated_data, \\\"message\\\": \\\"Success\\\", \\\"status_code\\\": \\\"200\\\"})\\n except Exception as e:\\n print(\\\"Update Error : \\\", e)\\n return False\",\n \"def index_fobj(fobj):\\n doc = fileobject_to_dict(fobj)\\n if doc is not None:\\n #print doc\\n SOLR.add(doc)\\n else:\\n pass\",\n \"def test_kyc_post_document_shareholder(self):\\n pass\",\n \"def CreateNewFile(self):\\n\\t\\tself.acad.Documents.Add()\",\n \"def createStructuredTranscript_Non_Core_Doc():\\n\\n #create a temporary folder that will hold the data transformed from doc to docx\\n os.system('mkdir ' + INPUT_FOLDER+'temp')\\n\\n core_doc_asset = []\\n missing_count = 0\\n missing_files=[]\\n # get all the docx files that are part of the core asset\\n for file in glob.glob(INPUT_FOLDER+\\\"*.doc\\\"):\\n\\n # RG numbers for the core asset\\n if (\\\"RG-50.030\\\" not in file and\\n \\\"RG-50.106\\\" not in file and\\n \\\"RG-50.549\\\" not in file):\\n \\n\\n \\n # convert file to docx, storing it in an untracked folder called temp\\n file_docx = file + 'x'\\n command = 'textutil -convert docx ' + file + ' -output ' + INPUT_FOLDER+'temp/'+ file_docx.split('/')[-1]\\n call(command, shell=True)\\n\\n # append to the array\\n core_doc_asset.append(file_docx)\\n \\n\\n \\n\\n # get the units for each file, store them and update tracker\\n core_doc_asset=create_dictionary_of_file_list(core_doc_asset)\\n \\n not_processed=0\\n processed_doc=0\\n \\n # get the units for each file, store them and update tracker \\n for mongo_rg in core_doc_asset:\\n # get text units for this entry\\n processed=[]\\n result=[]\\n \\n for file in core_doc_asset[mongo_rg]:\\n \\n \\n \\n units = getTextUnits(INPUT_FOLDER+'temp/'+file.split('/')[-1])\\n \\n if units:\\n #replace white spaces\\n for i,element in enumerate(units):\\n units[i]['unit']=' '.join(element['unit'].split())\\n result.extend(units)\\n \\n processed.append(True)\\n else:\\n #check if processed\\n processed.append(False)\\n\\n #set the method used to transform the transcript\\n h.update_field(DB, TRACKER, \\\"rg_number\\\", mongo_rg, \\\"method\\\", \\\"transcribe_non_core_doc\\\")\\n\\n not_processed=not_processed+1\\n\\n if False in processed:\\n\\n h.update_field(DB, TRACKER, \\\"rg_number\\\", mongo_rg, \\\"status\\\", \\\"Unprocessed\\\")\\n not_processed=not_processed+1\\n missing_files.append(' '.join(core_doc_asset[mongo_rg]))\\n else:\\n # insert units on the output collection\\n h.update_field(DB, OUTPUT, \\\"shelfmark\\\", 'USHMM '+mongo_rg, \\\"structured_transcript\\\", result)\\n\\n \\n # update status on the stracker\\n \\n h.update_field(DB, TRACKER, \\\"rg_number\\\", mongo_rg, \\\"status\\\", \\\"Processed\\\")\\n processed_doc=processed_doc+1\\n \\n\\n #delete the temporary folder\\n os.system('rm -r ' + INPUT_FOLDER+'temp')\\n\\n \\n #write the missing files to text file\\n file = open(OUTPUT_FOLDER_USHMM_PROCESSING_LOGS+'transcribe_non_core_doc_failed.txt','w')\\n file.write('\\\\n'.join(missing_files))\\n\\n \\n # success\\n pprint.pprint(\\\"Non-core doc files were successfully processed, but there are \\\" + str(missing_count) + \\\" missing\\\")\",\n \"def action_upload(self):\\n options=self.env['plm.config.settings'].GetOptions()\\n status = 'uploaded'\\n action = 'upload'\\n default = {\\n 'state': status,\\n 'engineering_writable': False,\\n }\\n doc_default = {\\n 'state': status,\\n 'writable': False,\\n }\\n operationParams = {\\n 'status': status,\\n 'statusName': _('Uploaded'),\\n 'action': action,\\n 'docaction': 'uploaddoc',\\n 'excludeStatuses': ['uploaded', 'confirmed', 'transmitted','released', 'undermodify', 'obsoleted'],\\n 'includeStatuses': ['draft'],\\n 'default': default,\\n 'doc_default': doc_default,\\n }\\n if options.get('opt_showWFanalysis', False):\\n return self.action_check_workflow(operationParams)\\n else:\\n ids=self._ids\\n self.logging_workflow(ids, action, status)\\n return self._action_to_perform(ids, operationParams, default)\",\n \"def file_upload():\\n\\n click.secho('*** Uploading image...', fg='green')\\n uploaded = _uploaded_file('cover.jpg')\\n click.secho(json.dumps(uploaded, indent=2, sort_keys=True), fg='yellow')\\n\\n click.secho('*** Creating a Picture document for it...', fg='green')\\n picture = _make_document('picture', title='cover image', sys_filename=uploaded['path'])\\n click.secho(json.dumps(picture, indent=2, sort_keys=True), fg='yellow')\\n\\n click.secho('*** Attaching it to a Blueray as cover...', fg='green')\\n slp = _make_document('movie', title='Silver Linings Playbook')\\n blueray = _make_document('blueray', movie_id=slp['_id'], cover_id=picture['_id'])\\n click.secho(json.dumps(blueray, indent=2, sort_keys=True), fg='yellow')\",\n \"def test_client_verification_document_create(self):\\n pass\",\n \"def multipart(self):\\n self.add_file_string('Multipart file')\\n self.should_copy = False\",\n \"def tests_ti_document_file_name(self, request: FixtureRequest):\\n helper_ti = cast(Document, self.ti_helper.create_group())\\n\\n # update file name\\n file_name = request.node.name\\n r = helper_ti.file_name(file_name)\\n assert r.status_code == 200\",\n \"def upload_file(self):\\n request = copy.deepcopy(self.request_template)\\n data = json.dumps(request)\\n curr_file = {\\n 'request': data,\\n 'file': open(self.file_path, 'rb')\\n }\\n print(\\\"Sending Upload request of av for file {}\\\".format(self.file_name))\\n try:\\n response = requests.post(url=self.url + \\\"upload\\\", files=curr_file, verify=False)\\n except Exception as E:\\n print(\\\"Upload file failed. file: {} , failure: {}\\\".format(self.file_name, E))\\n raise\\n response_j = response.json()\\n print(\\\"av Upload response status for file {} : {}\\\".format(self.file_name,\\n response_j[\\\"response\\\"][0][\\\"status\\\"][\\\"label\\\"]))\\n return response_j\",\n \"def upload():\\n\\treturn render_template(\\\"upload.html\\\", title=\\\"Upload a file\\\")\",\n \"def upload_file(filename: str) -> Document:\\n with open(filename) as file:\\n return create_document(file.read())\",\n \"def test_upload_text(client: FlaskClient):\\n file = get_example_file(ExampleFileType.Txt)\\n response = util.upload_file(client, DEFAULT_USER, file)\\n assert response.status == \\\"201 CREATED\\\"\\n assert response.json[\\\"filetype\\\"] == \\\"DOCUMENT\\\"\\n assert response.json[\\\"upload_name\\\"] == file.filename\\n assert response.json[\\\"uploaded_by\\\"][\\\"id\\\"] == 1\\n assert response.json[\\\"size\\\"] == len(file.contents)\\n assert response.json[\\\"hash\\\"] == hashlib.md5(file.contents).hexdigest()\\n\\n # Access the file via URL\\n response_get = client.get(response.json[\\\"url\\\"])\\n assert response_get.status == \\\"200 OK\\\"\\n assert list(response_get.response)[0] == file.contents\",\n \"def uploader():\\n\\tif request.method == 'POST':\\n\\t\\t\\n\\t\\tif \\\"file\\\" not in request.files:\\n\\t\\t\\treturn \\\"No data in file.\\\"\\n\\n\\t\\tFile = request.files['file']\\n\\t\\t\\n\\t\\tif File.filename == \\\"\\\":\\n\\t\\t\\treturn \\\"No file selected.\\\"\\n\\t\\t\\n\\t\\tfilename, ext = secure_filename(File.filename).split('.')\\n\\t\\t#Check if file stream exists and file tpye correct.\\n\\t\\tif File and ext == \\\"hepmc\\\":\\n\\t\\t\\t#The file is a byte stream by default which is not compatible with the current version of hepmcio.\\n\\t\\t\\tstring_stream = io.StringIO(File.read().decode('utf-8'))\\n\\n\\t\\t\\t#Get all events from file and jsonify them.\\n\\t\\t\\tevents = hepmcio.HepMCReader(string_stream).all_events()\\n\\t\\t\\thepMCEncoder = hepmcio_json.HepMCJSONEncoder()\\n\\t\\t\\tjsonified = [hepMCEncoder.encode(event) for event in events]\\n\\n\\t\\t\\t#Each collection contains all the data in a file.\\n\\t\\t\\tif filename not in mongo.db.collection_names():\\n\\t\\t\\t\\tcollection = mongo.db[filename]\\n\\t\\t\\t\\tjsonDecoder = json.JSONDecoder()\\n\\n\\t\\t\\t\\t#MongoDB takes in Python objects and not JSON strings, so have to decode before adding documents.\\n\\t\\t\\t\\tfor jsonObject in jsonified:\\n\\t\\t\\t\\t\\tjsonEvent = jsonDecoder.decode(jsonObject.evt)\\n\\t\\t\\t\\t\\tjsonParticles = [jsonDecoder.decode(p) for p in jsonObject.particles]\\n\\t\\t\\t\\t\\tjsonVertices = [jsonDecoder.decode(v) for v in jsonObject.vertices]\\n\\n\\t\\t\\t\\t\\tcollection.insert_one(jsonEvent)\\n\\t\\t\\t\\t\\tcollection.insert_many(jsonParticles)\\n\\t\\t\\t\\t\\tcollection.insert_many(jsonVertices)\\n\\t\\t\\n\\t\\t\\t\\treturn \\\"Succesfully uploaded file.\\\"\\n\\t\\t\\t\\n\\t\\t\\treturn \\\"File already in database.\\\"\\n\\n\\t\\treturn \\\"Incorrect file type.\\\"\",\n \"def upload(self, nameObjectDict):\\n return self.cpp.upload(nameObjectDict)\",\n \"def upload(self, sources=None):\\n\\n # Backwards compatible with < v1.4\\n if self.path is None:\\n self.path = self.name\\n\\n if self.name is None:\\n raise ValueError(\\\"Cannot upload without a file name\\\")\\n\\n if self.ftype is None:\\n raise ValueError(\\\"Cannot upload without a file type\\\")\\n\\n data = {}\\n sources = ThreatQSource.make_source_list(sources)\\n if sources:\\n data['sources'] = [src.to_dict() for src in sources if src]\\n\\n fname = os.path.basename(self.name)\\n new_filename = \\\"%i-%s\\\" % (\\n random.randint(1, 100000),\\n fname.replace('.', ''))\\n\\n content = self.content\\n if not content:\\n inf = open(self.path, 'rb')\\n content = inf.read()\\n inf.close()\\n\\n res = self.tq.post(\\n '/api/attachments/upload',\\n data={\\n 'resumableIdentifier': new_filename,\\n 'resumableRelativePath': fname,\\n 'resumableTotalChunks': 1,\\n 'resumableFilename': fname,\\n },\\n files={\\n 'file': ('blob', content, 'application/octet-stream')\\n })\\n\\n data['name'] = fname\\n if self.title:\\n data['title'] = self.title\\n data['type'] = self.ftype\\n data['malware_locked'] = self.locked\\n\\n res = self.tq.post('/api/attachments', data=data)\\n\\n r = res.get('data')\\n if not r or 'id' not in r:\\n raise exceptions.UploadFailedError(res)\\n\\n for t in self.tags:\\n res = self.tq.post('/api/attachments/%i/tags' % r['id'], data={'name': t})\\n\\n self.fid = r['id']\\n return self\",\n \"def _put(self, name, document):\\n raise NotImplementedError\",\n \"def test_upload_file(self):\\n data = dict(additional_metadata='additional_metadata_example',\\n file='file_example')\\n response = self.client.open(\\n '/pet/{petId}/uploadImage'.format(pet_id=789),\\n method='POST',\\n data=data,\\n content_type='multipart/form-data')\\n self.assert200(response,\\n 'Response body is : ' + response.data.decode('utf-8'))\",\n \"def test_post_file(self):\\n inline_object = {}\\n headers = { \\n 'Accept': 'application/json',\\n 'Content-Type': 'multipart/form-data',\\n 'admin_passphrase': 'special-key',\\n 'passphrase': 'special-key',\\n }\\n response = self.client.open(\\n '/openapi/file',\\n method='POST',\\n headers=headers,\\n data=json.dumps(inline_object),\\n content_type='multipart/form-data')\\n self.assert200(response,\\n 'Response body is : ' + response.data.decode('utf-8'))\",\n \"def upload():\\n upload_old_file = False\\n file = request.files[\\\"data\\\"]\\n stream_data = file.stream\\n \\n website_ticket = \\\"https://tedxruppticket.web.app/\\\"\\n\\n df = pd.read_csv(stream_data)\\n name = df[\\\"name\\\"].values\\n\\n if \\\"id\\\" in df.columns:\\n _id = df[\\\"id\\\"].values\\n _name = df[\\\"name\\\"].values\\n \\n audiences = []\\n for i in range(len(_id)):\\n audiences.append(Audience(_id[i], _name[i]))\\n add_to_database(audiences, multiple=True)\\n\\n return jsonify({\\\"data\\\": \\\"added\\\"})\\n\\n tickets = df[\\\"Ticket\\\"].values\\n ticket_num = df[\\\"Ticket\\\"].values.sum()\\n \\n _name = []\\n for i, n in enumerate(tickets):\\n for j in range(n):\\n print()\\n _name.append(name[i])\\n\\n _id = [str(uuid4()).upper()[:7] for i in range(ticket_num)]\\n\\n if \\\"id\\\" in df.columns:\\n upload_old_file = True\\n _id = df[\\\"id\\\"].values\\n\\n audiences = []\\n _tickets = []\\n for i in range(len(_id)):\\n audiences.append(Audience(_id[i], _name[i]))\\n _tickets.append(website_ticket + f\\\"{_id[i]}\\\")\\n add_to_database(audiences, multiple=True)\\n\\n output_dataframe = pd.DataFrame(data={\\n \\\"id\\\": _id,\\n \\\"name\\\": _name,\\n \\\"ticket_url\\\": _tickets\\n })\\n\\n output_dataframe.to_csv(\\\"./files/CircleAudiences.csv\\\")\\n data_obj = output_dataframe.set_index(\\\"id\\\").to_dict()\\n\\n return {\\\"code\\\": \\\"0\\\", \\\"data\\\": data_obj}\",\n \"def dealDocument(update: Update, _: CallbackContext) -> None:\\n file_name = update.message.document.file_name\\n file_name = uuid.uuid4().hex + \\\".\\\" + \\\\\\n secure_filename(file_name).split(\\\".\\\")[-1]\\n imagePath = os.path.join(args.input, file_name)\\n update.message.document.get_file().download(custom_path=imagePath)\\n add_mark(imagePath, mark, args)\\n resultPath = os.path.join(args.out, file_name)\\n with open(resultPath,\\\"rb\\\") as file:\\n update.message.reply_document(file)\",\n \"def test_access_cartography_upload_form(self):\\n\\t\\tc = Client()\\n\\t\\tUser.objects.create_superuser('bobby', 'bobby@foo.com', 'bob')\\n\\t\\tlog = c.login(username='bobby', password='bob')\\n\\t\\tself.assertTrue(log)\\n\\t\\tresponse = c.get(\\\"/cartography/upload\\\")\\n\\t\\tself.assertTrue('Add document' in response.content)\",\n \"def savedoc():\\r\\n document.save('QSDoc_{0}_{1}_{2}_{3}.docx'.format(args.server, year, month, day))\",\n \"async def complete_upload_file(\\n body_item: Envelope[FileUploadCompletionBody],\\n location_id: LocationID,\\n file_id: StorageFileID,\\n user_id: UserID,\\n):\",\n \"def upload(self) :\\n\\t\\ttry :\\n\\t\\t\\treturn self._upload\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def save_and_upload_samples(data, namespace, workspace, tsca_id):\\n os.system('mkdir -p %s'%tsca_id)\\n filename = '%s/fc_upload_samples_tsca_%s.txt' % (tsca_id, tsca_id)\\n data.to_csv(filename, sep='\\\\t', index=False)\\n res = upload_entities_from_tsv(namespace, workspace, filename)\\n return res\",\n \"def __init__(self, mimetype):\\n self.mimetype = mimetype\\n self.name = \\\"Filters.document.mime_type('{}')\\\".format(self.mimetype)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7011324","0.6625791","0.6056341","0.604441","0.599105","0.58514357","0.58014864","0.57448494","0.5722403","0.5647626","0.5646104","0.5611597","0.55856794","0.55776405","0.5573368","0.5542979","0.55415756","0.5528359","0.55037415","0.5495104","0.54863006","0.5470108","0.5469689","0.5465662","0.5453449","0.5449899","0.54410344","0.5413643","0.5409172","0.5403117","0.54001063","0.5393863","0.5388423","0.5387152","0.5341882","0.5329555","0.5313411","0.5308925","0.53000855","0.5282668","0.5274996","0.5231541","0.52025676","0.51973677","0.5194101","0.51934946","0.5192396","0.5182973","0.51782244","0.5169452","0.516563","0.5157684","0.51463413","0.514082","0.5139932","0.5137991","0.5134352","0.51339465","0.5132156","0.5131161","0.51300186","0.5129168","0.5127412","0.5126468","0.51254237","0.51240957","0.5116546","0.5114465","0.5098075","0.5092026","0.50868213","0.50812966","0.5074984","0.5072679","0.50685656","0.50669307","0.50663257","0.50539213","0.50480103","0.504193","0.5040515","0.5038628","0.50329953","0.50309503","0.50296915","0.50263274","0.5022836","0.5019496","0.5018757","0.5017615","0.50169784","0.5012558","0.50067747","0.49897507","0.49762592","0.49740198","0.4963928","0.4963143","0.49576184","0.49514616"],"string":"[\n \"0.7011324\",\n \"0.6625791\",\n \"0.6056341\",\n \"0.604441\",\n \"0.599105\",\n \"0.58514357\",\n \"0.58014864\",\n \"0.57448494\",\n \"0.5722403\",\n \"0.5647626\",\n \"0.5646104\",\n \"0.5611597\",\n \"0.55856794\",\n \"0.55776405\",\n \"0.5573368\",\n \"0.5542979\",\n \"0.55415756\",\n \"0.5528359\",\n \"0.55037415\",\n \"0.5495104\",\n \"0.54863006\",\n \"0.5470108\",\n \"0.5469689\",\n \"0.5465662\",\n \"0.5453449\",\n \"0.5449899\",\n \"0.54410344\",\n \"0.5413643\",\n \"0.5409172\",\n \"0.5403117\",\n \"0.54001063\",\n \"0.5393863\",\n \"0.5388423\",\n \"0.5387152\",\n \"0.5341882\",\n \"0.5329555\",\n \"0.5313411\",\n \"0.5308925\",\n \"0.53000855\",\n \"0.5282668\",\n \"0.5274996\",\n \"0.5231541\",\n \"0.52025676\",\n \"0.51973677\",\n \"0.5194101\",\n \"0.51934946\",\n \"0.5192396\",\n \"0.5182973\",\n \"0.51782244\",\n \"0.5169452\",\n \"0.516563\",\n \"0.5157684\",\n \"0.51463413\",\n \"0.514082\",\n \"0.5139932\",\n \"0.5137991\",\n \"0.5134352\",\n \"0.51339465\",\n \"0.5132156\",\n \"0.5131161\",\n \"0.51300186\",\n \"0.5129168\",\n \"0.5127412\",\n \"0.5126468\",\n \"0.51254237\",\n \"0.51240957\",\n \"0.5116546\",\n \"0.5114465\",\n \"0.5098075\",\n \"0.5092026\",\n \"0.50868213\",\n \"0.50812966\",\n \"0.5074984\",\n \"0.5072679\",\n \"0.50685656\",\n \"0.50669307\",\n \"0.50663257\",\n \"0.50539213\",\n \"0.50480103\",\n \"0.504193\",\n \"0.5040515\",\n \"0.5038628\",\n \"0.50329953\",\n \"0.50309503\",\n \"0.50296915\",\n \"0.50263274\",\n \"0.5022836\",\n \"0.5019496\",\n \"0.5018757\",\n \"0.5017615\",\n \"0.50169784\",\n \"0.5012558\",\n \"0.50067747\",\n \"0.49897507\",\n \"0.49762592\",\n \"0.49740198\",\n \"0.4963928\",\n \"0.4963143\",\n \"0.49576184\",\n \"0.49514616\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6640573"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84574,"cells":{"query":{"kind":"string","value":"Tender Qualification Document Read"},"document":{"kind":"string","value":"def get(self):\n if self.request.params.get(\"download\"):\n return get_file(self.request)\n document = self.request.validated[\"document\"]\n document_data = document.serialize(\"view\")\n document_data[\"previousVersions\"] = [\n i.serialize(\"view\") for i in self.request.validated[\"documents\"] if i.url != document.url\n ]\n return {\"data\": document_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 test_reader(qn_filepath, answers_dirpath):\n qns = get_questions(qn_filepath)\n for qn in qns:\n if qn.qid == 100:\n q = qn\n break\n assert q\n docs = get_documents(answers_dirpath, q.qid)\n print docs\n print docs[0].content","def find_document(self):\n pass","def read(self):","def test_client_document_retrieve(self):\n pass","def test_document_retrieval(self):","def getDocuments(self):\n return self.objectValues('Multifile')","def search_read(self, filters=None):\n raise NotImplementedError","def getDoc(file, line, offset):\n args = {\"file\": file, \"line\": line, \"offset\": offset}\n response = send_request(\"quickinfo\", args)\n return get_response_body(response)","def read(self, *args, **kwargs):\n pass","def read(self, **kwargs):\n pass","def getDocumentQuery(text, DOCUMENT_ORIGIN_CODE, file, pathFolder, extension):\n DOCUMENT_DATE = regex.getDateDoc(text)\n #getting probable author\n AUTHOR = regex.getAuthor(text)\n strModif = file[len(pathFolder):-len(extension)] #getting rid of path and extension\n documentName = strModif.split(\"_\")\n patientIpp = documentName[0]\n documentId = documentName[1]\n #get patient id from patientIpp\n conn = db.create_connection(DATABASE)\n patient_num = db.select_patient_id(conn, patientIpp.lstrip('0')) #removing leading 0 causing troubles in select\n conn.close()\n return (documentId, patient_num, DOCUMENT_ORIGIN_CODE, DOCUMENT_DATE, date.today().strftime(\"%m/%d/%y\"), text, AUTHOR)","def getbyname(self, name, doctype='experiment'):\n\n if doctype not in self.documents:\n self.documents[doctype] = esd.search(self.source, doctype)\n return self.documents[doctype].load_document(name)","def document(self):\n ...","def documents(pmid_23982599, civic_aid6_document):\n return [pmid_23982599, civic_aid6_document]","def indexCranFull(path, writer):\n # Title field type\n tft = FieldType()\n tft.setIndexed(True)\n tft.setStored(True)\n tft.setTokenized(TokenizeFields)\n tft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS) #only index the document and frequency data\n\n\n # Author field type\n aft = FieldType()\n aft.setIndexed(True)\n aft.setStored(True)\n aft.setTokenized(TokenizeFields)\n aft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) #index the document, term frequency and position data\n\n\n # Content field type\n cft = FieldType()\n cft.setIndexed(True)\n cft.setStored(True)\n cft.setTokenized(True)\n cft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS)\n\n txt = open(path)\n \"\"\"\n cran documents are listed in this order:\n .I # -> ignore\n .T -> starting on the next line, multi-line title\n .A -> on the next line, multiple authored separated by 'and'\n .B -> on the next line, ignore\n .W -> starting on the next line, multi-line body (content)\n \"\"\"\n docid = 0\n debug = False\n while True: # in each iteration, read all the lines corresponding to a document\n line = txt.readline()\n\n if line == '':\n break\n\n if docid == 1400:\n debug = True\n\n if line.startswith('.I'):\n docid = int(line.split(' ')[1].strip())\n continue\n\n if line.startswith('.T'):\n title = ''\n while True:\n line = txt.readline()\n if line.startswith('.A'):\n break\n title = ' '.join([title, line]).strip()\n\n line = txt.readline()\n # authors = ' '.join(line.split('and'))\n authors = line.strip()\n\n #.B, its corresponding line and .W\n txt.readline()\n txt.readline()\n txt.readline()\n body = ''\n while True:\n line = txt.readline()\n if line.startswith('.I'):\n docid = int(line.split(' ')[1].strip())\n break\n if line == '':\n break\n body = ' '.join([body, line]).strip()\n\n doc = Document()\n doc.add(Field(title_field, title, tft))\n doc.add(Field(author_field, authors, aft))\n doc.add(Field(content_field, body, cft))\n doc.add(IntField(docid_field, docid, Field.Store.YES))\n writer.addDocument(doc)","def read():\n # TODO","def read(self):\n return self.client.get(\n index=self.index,\n id=self.document_id,\n ignore=[404],\n )['_source']","def readFromMetadata(cls, context, fqId):\n pass","def docs():","def GetDocument(self, *args, **kwargs):\n pass","def _read_data(self):","def get_synopsis(file_data):\n for individual in file_data:\n if 'synopsis' in individual:\n synopsis = individual.split('\"')\n return synopsis[1]","def retrieve_document(self, format):\n self._validate_extension(format.upper(), self.ALLOWED_DOCUMENT_EXT)\n return self.client.service.RetrieveDocument(format=format.upper()).decode('base64')","def read_all(self):\r\n pass","def Read(self, *args, **kwargs):\n pass","def get_doc_data(self):\n return self.data_read","def read(cred, output, depth, type, exclude, path):\n click.echo('Reading from firetore, credential file: %s' % (cred))\n cred = os.path.abspath(cred)\n output = os.path.abspath(output)\n click.echo('Document path: %s' % path)\n click.echo('Output path: %s' % output)\n\n if depth<0:\n depth = 1000000\n\n if path and path.startswith('/'):\n path = path[1:]\n\n if os.listdir(output):\n click.echo('\\nError: folder \"%s\" is not empty' % output)\n return\n\n global total_doc_count\n global start_time\n total_doc_count = 0\n start_time = time.time()\n fs = firestore.client(initialize_app(credentials.Certificate(cred)))\n # data = fs.collection('schools').get()\n # for item in data:\n # print(json.dumps(item.to_dict()))\n # break\n if not path or path == '/': # get all root collections\n collections = fs.collections() # root collections\n # collections = fs.document('schools/dev').collections() # root collections\n for col in collections:\n read_collection(output, col.id, col, 1, depth, exclude)\n elif type=='document':\n doc = fs.document(path).get()\n read_document(output, path, doc, 1, depth, exclude)\n else: # 'collection'\n col = fs.collection(path)\n read_collection(output, path, col, 1, depth, exclude)","def document_view(index_name, doc_type, doc_id):\n resp = es.get(index=index_name, doc_type=doc_type, id=doc_id)\n document = resp[\"_source\"]\n print(document)","def get_document(self, docid):\n raise NotImplementedError","def main(rc):\n with store_client(rc) as sclient:\n for doc in rc.documents:\n sclient.copydoc(doc)","def document(self) -> str:\n return pulumi.get(self, \"document\")","def read(self):\n raise NotImplementedError","def document(self, **kw):\r\n \r\n for p in self.documents(**kw):\r\n return p","def getResourceSearchText(self, authenticationToken, guid):\r\n pass","def example_metadata(study_name, draft_name):\n odm = ODM(\"SYSTEM_NAME\", filetype=ODM.FILETYPE_SNAPSHOT)\n\n study = Study(study_name, project_type=Study.PROJECT)\n\n # Push study element into odm\n odm << study\n\n # Create global variables and set them into study.\n study << GlobalVariables(study_name) #Expected that protocol name will match the Study OID.\n\n # Create some basic definitions\n bd = BasicDefinitions()\n\n # Add some measurement units to the basic definitions. This time using the call () syntax:\n bd(\n MeasurementUnit(\"KG\", \"Kilograms\")(\n Symbol()(TranslatedText(\"Kilograms\"))\n ),\n MeasurementUnit(\"CM\", \"Centimeters\")(\n Symbol()(TranslatedText(\"Centimeters\"))\n )\n )\n\n # Add basic definitions to study\n study << bd\n\n # Now metadata which will contain all our form and field defs eventually\n meta = MetaDataVersion('META1', draft_name)\n study << meta\n\n # Protocol contains StudyEventRefs\n protocol = Protocol()\n # Add some StudyEventRefs\n protocol << StudyEventRef(\"FLDR1\", 1, True) # Order 1, Mandatory\n # protocol << StudyEventRef(\"FLDR2\", 2, False) # Order 2, Not Mandatory\n # protocol << StudyEventRef(\"AE\", 3, True)\n\n meta << protocol\n\n # Add Study Event Defs with some child FormRefs\n fldr1 = StudyEventDef(\"FLDR1\", \"Folder 1\", False, StudyEventDef.SCHEDULED)\n\n fldr1 << FormRef(\"DM\", 1, True)\n fldr1 << FormRef(\"VS\", 2, True)\n\n meta << fldr1\n\n meta << StudyEventDef(\"FLDR2\", \"Folder 2\", False, StudyEventDef.UNSCHEDULED)(\n FormRef(\"VS\", 1, True)\n )\n\n meta << StudyEventDef(\"AE\", \"Adverse Events\", False, StudyEventDef.COMMON)(\n FormRef(\"AE\", 1, False)\n )\n\n dm_form = FormDef(\"DM\",\"Demography\")\n dm_form << MdsolHelpText(\"en\",\"Some help text for Demography\")\n dm_form << MdsolViewRestriction('Data Manager')\n dm_form << MdsolEntryRestriction('Batch Upload')\n dm_form << ItemGroupRef(\"DM_IG1\", 1)\n dm_form << ItemGroupRef(\"DM_IG2\", 2)\n\n # Add to metadata\n meta << dm_form\n\n # Define item group\n meta << ItemGroupDef(\"DM_IG1\", \"DM Item Group 1\")(\n MdsolLabelRef(\"LBL1\", 1),\n ItemRef(\"SEX\", 2)(\n MdsolAttribute(\"Standards\",\"CDASH\",\"SEX\"),\n MdsolAttribute(\"Standards\",\"STDNUMBER\",\"1120\")\n ),\n ItemRef(\"RACE\", 3),\n ItemRef(\"RACE_OTH\", 4),\n ItemRef(\"DOB\", 5),\n ItemRef(\"AGE\", 6)\n )\n\n # Add the ItemDefs\n meta << ItemDef(\"SEX\", \"Gender\", DataType.Text, 1, control_type=ControlType.RadioButton\n )(\n Question()(TranslatedText(\"Gender at Birth\")),\n CodeListRef(\"CL_SEX\")\n )\n meta << ItemDef(\"RACE\", \"Race\", DataType.Text, 2,\n control_type=ControlType.RadioButtonVertical\n )(\n Question()(TranslatedText(\"Race\")),\n CodeListRef(\"CL_RACE\")\n )\n meta << ItemDef(\"RACE_OTH\", \"RaceOther\", DataType.Text, 20) \\\n << Question() << TranslatedText(\"If Race Other, please specify\")\n\n meta << ItemDef(\"DOB\", \"DateOfBirth\", DataType.Date, 10,\n control_type=ControlType.DateTime,\n date_time_format=\"dd/mm/yyyy\"\n )(\n Question()(TranslatedText(\"Date of Birth\")),\n MdsolHelpText(\"en\",\"If month unknown, enter January\")\n )\n\n meta << ItemDef(\"AGE\", \"Age in Years\", DataType.Integer, 4, significant_digits=3, control_type=ControlType.Text\n )(\n Question()(TranslatedText(\"Age in Years\")),\n RangeCheck(RangeCheckComparatorType.GreaterThanEqualTo, RangeCheckType.Soft) (\n CheckValue(\"18\")\n ),\n RangeCheck(RangeCheckComparatorType.LessThanEqualTo, RangeCheckType.Soft) (\n CheckValue(\"65\")\n )\n )\n\n # Add a Label\n meta.add(MdsolLabelDef(\"LBL1\", \"Label1\")(TranslatedText(\"Please answer all questions.\")))\n\n # As well as () and << you can use add()\n meta.add(\n CodeList(\"CL_SEX\", \"SEX\", datatype=DataType.Text)(\n CodeListItem(\"M\").add(\n Decode().add(\n TranslatedText(\"Male\"))\n ),\n CodeListItem(\"F\").add(\n Decode().add(\n TranslatedText(\"Female\"))\n ),\n ),\n CodeList(\"CL_RACE\", \"RACE\", datatype=DataType.Text)(\n CodeListItem(\"AS\")(Decode()(TranslatedText(\"Asian\"))),\n CodeListItem(\"CA\")(Decode()(TranslatedText(\"White\"))),\n CodeListItem(\"OT\")(Decode()(TranslatedText(\"Other\"))),\n )\n )\n\n meta.add(MdsolEditCheckDef('CHECK1')(\n # Static value required to make this stick, gets ignored but won't load without it\n MdsolCheckStep(form_oid=\"DM\", field_oid=\"RACE\", data_format='CodedValue', static_value=\"1\"),\n MdsolCheckStep(static_value=\"OT\", data_format=\"$2\"),\n MdsolCheckStep(function=StepType.IsEqualTo),\n MdsolCheckStep(form_oid=\"DM\", field_oid=\"RACE_OTH\"),\n MdsolCheckStep(function=StepType.IsEmpty),\n MdsolCheckStep(function=StepType.And),\n\n MdsolCheckAction(form_oid=\"DM\", field_oid=\"RACE_OTH\",\n check_action_type=ActionType.OpenQuery,\n check_string=\"Race is set as OTHER but not specified. Please correct.\",\n check_options=\"Site from System,RequiresResponse,RequiresManualClose\"\n )\n\n ),\n MdsolEditCheckDef('CHECK2')\n )\n\n meta.add(MdsolCustomFunctionDef(\"CF1\",\"SELECT 1,2 FROM DataPoints\", language=\"SQ\"))\n meta.add(MdsolCustomFunctionDef(\"CF2\",\"return true;\", language=\"C#\"))\n\n meta.add(\n # Variable OID required\n MdsolDerivationDef(\"AGE\", form_oid=\"DM\", field_oid=\"AGE\")(\n # Variable OID required to be identified as a data step\n MdsolDerivationStep(form_oid=\"DM\", field_oid=\"DOB\", data_format=\"StandardValue\", variable_oid=\"DOB\"),\n MdsolDerivationStep(function=StepType.Age)\n )\n )\n\n return odm","def read_rdkit_out(rdkit_conf, quantity='structure'):\n\n if quantity == 'structure':\n return read_structure(rdkit_conf)\n \n if quantity == 'atomic_numbers':\n return read_atomic_numbers(rdkit_conf)","def can_read(self):\n\n return super(RamanSpeReader, self).can_read(extension='spe')","def test_client_verification_document_retrieve(self):\n pass","def load_reference(self, path_to_reference):\n with open(path_to_reference,'r') as f:\n qids_to_relevant_docids = self.load_reference_from_stream(f)\n return qids_to_relevant_docids","def get(self, docid):\n file = os.path.join(self.dirname, docid)\n with open(file,'r',encoding='utf-8') as f:\n text = f.read()\n return text","def __call__(self, doc):\n return doc","def get_doc(self):\n return self.p","def find_qualtrics_readme(self, dn: DepositorName):\n\n dn_dict = dn.name_dict\n qualtrics_df = self.get_survey_responses(self.readme_survey_id)\n\n # First perform search via article_id or curation_id\n self.log.info(\"Attempting to identify using article_id or curation_id ...\")\n article_id = str(dn_dict['article_id'])\n curation_id = str(dn_dict['curation_id'])\n\n try:\n response_df = qualtrics_df[(qualtrics_df['article_id'] == article_id) |\n (qualtrics_df['curation_id'] == curation_id)]\n except KeyError:\n self.log.warn(\"article_id and curation_id not in qualtrics survey !\")\n response_df = pd.DataFrame()\n\n if response_df.empty:\n self.log.warn(\"Empty DataFrame\")\n raise ValueError\n else:\n self.log.info(\"Unique match based on article_id or curation_id !\")\n self.pandas_write_buffer(response_df[readme_cols_order])\n if response_df.shape[0] == 1:\n response_dict = df_to_dict_single(response_df)\n self.log.info(\"Only one entry found!\")\n self.log.info(f\"Survey completed on {response_dict['date_completed']}\")\n self.log.info(f\" ... for {response_dict['article_id']}\")\n return response_dict['ResponseId'], response_df\n else:\n self.log.warn(\"Multiple entries found\")\n raise ValueError","def documents(self, **kw):\r\n \r\n doc_reader = self.doc_reader\r\n return (doc_reader[docnum] for docnum in self.document_numbers(**kw))","def test_read_index(self):\n\n indexfile = tempfile.mktemp()\n self.addCleanup(os.unlink, indexfile)\n\n TroveIndexBuilder(\"test/short.dat\", out=indexfile)\n\n index = TroveIndex()\n index.reload(indexfile)\n\n docs = sorted([doc for doc in index.documents])\n self.assertEquals(10, len(docs))\n\n self.assertEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], docs)\n\n doc = index.get_document(1)\n ref = {u\"id\":\"1\",u\"titleName\":u\"Hello\"}\n self.assertNotEquals(None, doc, \"Document not found for id 1\")\n self.assertDictEqual(ref, doc)\n\n doc = index.get_document(10)\n ref = {\"id\":\"10\",\"titleName\":\"Hello\"}\n self.assertNotEquals(None, doc)\n self.assertDictEqual(ref, doc)","def get(self, *args):\n return self.docs.get(*args)","def test_get_occurrence_note(self):\n pass","def read(self):\n pass","def fini_doc(self):\n raise NotImplementedError()","def read(self):\n return self.readentries()","def documento():\r\n\tpass","def retrieve(document_id: str) -> Fulltext:\n return current_session().retrieve(document_id)","def get_document(self):\n return self.document","def _get_doc(results, index):\n return results[index]","def getResourceRecognition(self, authenticationToken, guid):\r\n pass","def load_reference_from_stream(self, f):\n qids_to_relevant_docids = {}\n for l in f:\n vals = l.strip().split('\\t')\n if len(vals) != 4:\n vals = l.strip().split(' ')\n if len(vals) != 4:\n pdb.set_trace()\n raise IOError('\\\"%s\\\" is not valid format' % l)\n\n qid = vals[0]\n if qid in qids_to_relevant_docids:\n pass\n else:\n qids_to_relevant_docids[qid] = []\n _rel = int(vals[3])\n if _rel > 0:\n qids_to_relevant_docids[qid].append(vals[2])\n\n return qids_to_relevant_docids","def findNotesMetadata(self, authenticationToken, filter, offset, maxNotes, resultSpec):\r\n pass","def get_metadata(self, docname, moderator):\n raise NotImplementedError()","def __getattribute__(self, name: str) -> Any:\n if name in (FLD_TITLE, FLD_ABSTRACT, FLD_FEES, FLD_ACCESS_CONSTRAINTS, FLD_CONTACT_POSITION, FLD_CONTACT_ORGANISATION):\n return self.read_local_metadata(name)\n elif name == FLD_KEYWORDS:\n kw = self.read_local_metadata(FLD_KEYWORDS)\n if kw:\n return set(kw.split(\",\"))\n else:\n return set()\n elif name == FLD_ATTRIBUTION:\n return self.read_local_metadata(FLD_ATTRIBUTION)\n else:\n return super().__getattribute__(name)","def _getForDocument (self):\n return self.__forDocument","def put(self):\n document = upload_file(self.request)\n self.request.validated[\"qualification\"].documents.append(document)\n if save_tender(self.request):\n self.LOGGER.info(\n \"Updated tender qualification document {}\".format(self.request.context.id),\n extra=context_unpack(self.request, {\"MESSAGE_ID\": \"tender_qualification_document_put\"}),\n )\n return {\"data\": document.serialize(\"view\")}","def test_get_document(index_with_documents):\n response = index_with_documents().get_document(\"500682\")\n assert isinstance(response, Document)\n assert hasattr(response, \"title\")\n assert response.title == \"The Highwaymen\"","def test_documents_detailed_search_endpoint(self):\n\n # Search for documents using more specific criterias, like presidential names.\n presidential_documents = self.federal_client.documents(\n presidents=['donald-trump']\n )\n\n # Make sure we have a response.\n self.assertIsNotNone(presidential_documents)\n\n # And make sure we have some results.\n self.assertGreaterEqual(presidential_documents['count'], 10)","def kaggle_accessor(document):\r\n return document[1]","def read(self, filename): # real signature unknown; restored from __doc__\n pass","def getdoc(doctype, name, user=None):\n\n\timport webnotes\n\t\n\tif not (doctype and name):\n\t\traise Exception, 'doctype and name required!'\n\t\n\tif not name: \n\t\tname = doctype\n\n\tif not webnotes.conn.exists(doctype, name):\n\t\treturn []\n\n\ttry:\n\t\tbean = webnotes.bean(doctype, name)\n\t\tbean.run_method(\"onload\")\n\n\t\tdoclist = bean.doclist\n\n\t\t# add file list\n\t\tset_docinfo(doctype, name)\n\t\t\n\texcept Exception, e:\n\t\twebnotes.errprint(webnotes.utils.getTraceback())\n\t\twebnotes.msgprint('Did not load.')\n\t\traise e\n\n\tif bean and not name.startswith('_'):\n\t\twebnotes.user.update_recent(doctype, name)\n\t\n\twebnotes.response['docs'] = doclist","def read(self, path):\n pbase = os.path.splitext(path)[0]\n gsid = pbase.split('/')[-2]\n gender, sid = gsid[0], gsid[1:]\n assert sid in self._spkr_table\n phoneseq = phnread(pbase+'.PHN')\n wrdseq = phnread(pbase+'.WRD')\n transcrpt = txtread(pbase+'.TXT')\n sample = TIMITSpeech(\n *audioread(path), speaker=sid, gender=gender,\n transcript=transcrpt, phonemeseq=phoneseq,\n wordseq=wrdseq\n )\n #sample.phonemeseq = [\n # (t, PHONETABLE[p]) for t, p in sample.phonemeseq]\n return sample","def read(self):\n print(f'Metadata version {self.version_num}')\n print(f'Saved at: {self.datetime}')\n print(f'Self chat: {self.self_chat}')\n print(f'Speakers: {self.speakers}')\n print('Opt:')\n for k, v in self.opt.items():\n print(f'\\t{k}: {v}')\n for k, v in self.extra_data.items():\n print(f'{k}: {v}')","def read_all(self, *args, **kwargs):\n pass","def get_qualification(qual_id: int) -> Any:\n qualification = Qualification.query.get(qual_id)\n if qualification is None:\n raise APIError(reason=\"no_such_object\", status_code=400)\n return QualificationSchema().dump(qualification)","def engine():\r\n document.add_heading('Engine details', 1)\r\n\r\n engine_metrics = ['customProperties','listenerPorts','autosaveInterval', 'tableFilesDirectory', 'genericUndoBufferMaxSize', 'documentTimeout','documentDirectory',\r\n 'allowDataLineage', 'qrsHttpNotificationPort', 'standardReload',\r\n 'workingSetSizeLoPct', 'workingSetSizeHiPct', 'workingSetSizeMode','cpuThrottlePercentage', 'maxCoreMaskPersisted', 'maxCoreMask',\r\n 'maxCoreMaskHiPersisted', 'maxCoreMaskHi','objectTimeLimitSec', 'exportTimeLimitSec', 'reloadTimeLimitSec',\r\n 'hyperCubeMemoryLimit', 'exportMemoryLimit', 'reloadMemoryLimit', 'createSearchIndexOnReloadEnabled', 'hostname',\r\n 'globalLogMinuteInterval','auditActivityLogVerbosity','auditSecurityLogVerbosity','serviceLogVerbosity','systemLogVerbosity','performanceLogVerbosity',\r\n 'qixPerformanceLogVerbosity','auditLogVerbosity','sessionLogVerbosity','trafficLogVerbosity']\r\n\r\n enginenodes = get_qlik_sense.get_engine()\r\n num_of_engines = len(enginenodes)\r\n num_of_engine_metrics = len(engine_metrics)\r\n table = document.add_table(rows=num_of_engine_metrics+1, cols=num_of_engines+1)\r\n table.style = 'Grid Table 1 Light Accent 1'\r\n row = table.rows[0]\r\n row.cells[0].text = 'Metric'\r\n for item in range(0, num_of_engines):\r\n row.cells[item+1].text = enginenodes[item][36]\r\n for item in range(num_of_engine_metrics):\r\n row = table.rows[item+1]\r\n row.cells[0].text = str(engine_metrics[item])\r\n for enginenode in range(num_of_engines):\r\n row.cells[enginenode+1].text = str(enginenodes[enginenode][item])\r\n\r\n document.add_page_break()","def read(self, *args) -> \"PyObject *\":\n return _ida_fpro.qfile_t_read(self, *args)","def test_query_generic_embedded_document(self):\n\n class A(EmbeddedDocument):\n a_name = StringField()\n\n class B(EmbeddedDocument):\n b_name = StringField()\n\n class Doc(Document):\n document = GenericEmbeddedDocumentField(choices=(A, B))\n\n Doc.drop_collection()\n Doc(document=A(a_name=\"A doc\")).save()\n Doc(document=B(b_name=\"B doc\")).save()\n\n # Using raw in filter working fine\n assert Doc.objects(__raw__={\"document.a_name\": \"A doc\"}).count() == 1\n assert Doc.objects(__raw__={\"document.b_name\": \"B doc\"}).count() == 1\n assert Doc.objects(document__a_name=\"A doc\").count() == 1\n assert Doc.objects(document__b_name=\"B doc\").count() == 1","def reader(name, version=None, mimetype=None):\n\treturn _data_processor('read', name, version, mimetype)","def findReadData(day,scope,chan,shot):\n return readData(conf.dataDir + \"%d_01_2013_osc%d/C%dosc%d-%05d.txt\" % (day, scope, chan, scope, shot),\n conf.timeDelay[scope,chan],\n conf.ampMult[scope,chan])","def GetMetadataSample():\n client = CreateClient()\n # Fetch the metadata entry and display bits of it\n metadata = client.GetMetadata()\n print 'Quota'\n print ' Total:', metadata.quota_bytes_total.text\n print ' Used:', metadata.quota_bytes_used.text\n print ' Trashed:', metadata.quota_bytes_used_in_trash.text\n print 'Import / Export'\n for input_format in metadata.import_formats:\n print ' Import:', input_format.source, 'to', input_format.target\n for export_format in metadata.export_formats:\n print ' Export:', export_format.source, 'to', export_format.target\n print 'Features'\n for feature in metadata.features:\n print ' Feature:', feature.name.text\n print 'Upload Sizes'\n for upload_size in metadata.max_upload_sizes:\n print ' Kind:', upload_size.kind, upload_size.text","def example_clinical_data(study_name, environment):\n\n odm = ODM(\"test system\")(\n ClinicalData(\"Mediflex\", \"DEV\")(\n SubjectData(\"MDSOL\", \"IJS TEST4\", transaction_type=\"Insert\")(\n StudyEventData(\"SUBJECT\")(\n FormData(\"EN\", transaction_type=\"Update\")(\n # Although Signature is ODM1.3.1 RWS does not support it inbound currently\n # RWSBuilders do support outbound generation of Signature at FormData level\n # Signature()(\n # UserRef(\"isparks\"),\n # LocationRef(\"MDSOL\"),\n # SignatureRef(\"APPROVED\"),\n # DateTimeStamp(datetime(2015, 9, 11, 10, 15, 22, 80))\n # ),\n ItemGroupData()(\n ItemData(\"SUBJINIT\", \"AAA\")(\n AuditRecord(edit_point=AuditRecord.EDIT_DATA_MANAGEMENT,\n used_imputation_method= False,\n identifier='X2011',\n include_file_oid=False)(\n UserRef(\"isparks\"),\n LocationRef(\"MDSOL\"),\n ReasonForChange(\"Data Entry Error\"),\n DateTimeStamp(datetime(2015, 9, 11, 10, 15, 22, 80))\n ),\n MdsolQuery(value=\"Subject initials should be 2 chars only.\", recipient=\"Site from System\",\n status=QueryStatusType.Open)\n ),\n ItemData(\"SUBJID\", '001')\n )\n )\n )\n )\n )\n )\n return odm","def get(ref):\n cmd = 'qri get --format json %s' % ref\n result, err = shell_exec(cmd)\n if err:\n raise RuntimeError(err)\n d = dataset.Dataset(json.loads(result))\n return d","def get(self, index, id):\n url = f'{self.host}{index}/_doc/{id}'\n resp = requests.get(url)\n return resp.json()","def get_scope_read_default(self):\n return f\"{self.api_name}:read:default\"","def _getDocumentType(self):\n\n fileName, fileExtension = os.path.splitext(self.sourceFileName)\n documentType = None\n\n for knownType in list(TextRepresentation.KNOWNTYPES.keys()):\n if knownType == fileExtension[1:]:\n documentType = knownType\n\n if documentType is None:\n raise Exception(\"Unknown document type: %s\" % fileExtension[1:])\n \n return documentType","def parse_design(self, detailed_design_file):","def get_document(self, value, key='name'):\n if value.endswith('.json'):\n key = 'filename'\n return [x for x in self.vocab if x[key] == value][0]","def test_all_documents(self):","def getdoc():\n\n\timport webnotes\n\tfrom webnotes.utils import cint\n\t\n\tform = webnotes.form_dict\n\tdoctype, docname = form.get('doctype'), form.get('name')\n\tprefix = cint(form.get('from_archive')) and 'arc' or 'tab'\n\n\tif not (doctype and docname):\n\t\traise Exception, 'doctype and name required!'\n\t\n\tdoclist = []\n\t# single\n\tdoclist = load_single_doc(doctype, docname, (form.get('user') or webnotes.session['user']), prefix)\n\t\n\t# load doctype along with the doc\n\tif form.get('getdoctype'):\n\t\timport webnotes.model.doctype\n\t\tdoclist += webnotes.model.doctype.get(doctype)\n\n\t# tag as archived\n\tif prefix == 'arc':\n\t\tdoclist[0].__archived=1\n\n\twebnotes.response['docs'] = doclist","def object_readers(name, *, specify_reader=False):\n\treturn object_access('read', name, specify_reader)","def read(self, fileobj):\n raise NotImplementedError","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 _ATTopic_query(self, **kw):\n del kw['path'] # don't want to limit to context as w/ folders\n return self.context.queryCatalog(self.context.REQUEST, \n False, # no batch here\n None, # no b_size here\n False,\n **kw)","def getSongTextInfo():\n sids = []\n documents = []\n sFile = open('../txt/two__Lastfm_song_Docs.txt')\n lines = sFile.readlines()\n index = 0\n for line in lines:\n line.strip('\\n')\n line.strip('\\r\\n')\n items = line.split('>>')\n sid = int(items[0])\n text = items[1]\n documents.append(text)\n sids.append(sid)\n sFile.close()\n print 'len = ',len(sids)\n print 'len = ',len(documents)\n return sids,documents","def read_data(term):\n course_url = '/admweb/!SWKSECX.main?term='+ term + '&title=&course=&crn=&coll=&dept=&subj='\n connection = httplib.HTTPSConnection('courses.rice.edu', 443)\n connection.connect()\n connection.request(\n 'GET',\n course_url\n )\n courses_xml = connection.getresponse()\n return courses_xml","def get_doc_from_MP(mp_id):\n apr=mpr.get_doc(mp_id)\n return apr","def readByName(self, name):\n pass","def document_indexer(self):\n return self.indexer_by_pid_type(DOCUMENT_PID_TYPE)","def read(self, index, n_samples):\n raise NotImplementedError","def doc(obj):\n return Documentation.fromObject(obj).first","def read(self):\n pass","def getnotes():","def stored_fields(self, docnum):\r\n return self.doc_reader[docnum]","def get_document(name):\n document = [d for d in documents if d.name == name]\n if len(document) > 0:\n return document[0]","def retrieve(dbxrefs, basics=True, hierarchy=True, wikipedia=True, literature=True, cross_references=True, overlaps=True):\n resolved = dbxref.resolver.resolve(dbxrefs, check_existence=False)\n documents = []\n for entry in resolved:\n # Construct URL for retrieve\n json_url = entry['locations']['json'][0]\n logger.debug('URL: %s', json_url)\n r = requests.get(json_url)\n logger.debug('Content: %s', r.text)\n ipro = json.loads(r.text)\n\n # Parse retrieved json file by selected Options\n output = {\"id\": entry[\"dbxref\"]}\n if basics:\n try:\n output.update(accession=ipro[\"metadata\"][\"accession\"], entry_type=ipro[\"metadata\"][\"type\"],\n description=ipro[\"metadata\"][\"description\"], counters=ipro[\"metadata\"][\"counters\"],\n entry_id=ipro[\"metadata\"][\"entry_id\"], name=ipro[\"metadata\"][\"name\"],\n source_database=ipro[\"metadata\"][\"source_database\"])\n except KeyError:\n logger.warning(\"One or more basic information were not available for the given entry. Please check your output.\")\n if hierarchy:\n try:\n output.update(hierarchy=ipro[\"metadata\"][\"hierarchy\"])\n except KeyError:\n logger.warning(\"Hierarchy information was not available for the given entry.\")\n if wikipedia:\n try:\n output.update(wikipedia=ipro[\"metadata\"][\"wikipedia\"])\n except KeyError:\n logger.warning(\"Wikipedia articles were not available for the given entry.\")\n if literature:\n try:\n output.update(literature=ipro[\"metadata\"][\"literature\"])\n except KeyError:\n logger.warning(\"Literature was not available for the given entry.\")\n if cross_references:\n try:\n output.update(cross_references=ipro[\"metadata\"][\"cross_references\"])\n except KeyError:\n logger.warning(\"Cross_references were not available for the given entry.\")\n if overlaps:\n try:\n output.update(overlaps=ipro[\"metadata\"][\"overlaps_with\"])\n except KeyError:\n logger.warning(\"Overlap information was not available for the given entry.\")\n documents.append(output)\n return documents"],"string":"[\n \"def test_reader(qn_filepath, answers_dirpath):\\n qns = get_questions(qn_filepath)\\n for qn in qns:\\n if qn.qid == 100:\\n q = qn\\n break\\n assert q\\n docs = get_documents(answers_dirpath, q.qid)\\n print docs\\n print docs[0].content\",\n \"def find_document(self):\\n pass\",\n \"def read(self):\",\n \"def test_client_document_retrieve(self):\\n pass\",\n \"def test_document_retrieval(self):\",\n \"def getDocuments(self):\\n return self.objectValues('Multifile')\",\n \"def search_read(self, filters=None):\\n raise NotImplementedError\",\n \"def getDoc(file, line, offset):\\n args = {\\\"file\\\": file, \\\"line\\\": line, \\\"offset\\\": offset}\\n response = send_request(\\\"quickinfo\\\", args)\\n return get_response_body(response)\",\n \"def read(self, *args, **kwargs):\\n pass\",\n \"def read(self, **kwargs):\\n pass\",\n \"def getDocumentQuery(text, DOCUMENT_ORIGIN_CODE, file, pathFolder, extension):\\n DOCUMENT_DATE = regex.getDateDoc(text)\\n #getting probable author\\n AUTHOR = regex.getAuthor(text)\\n strModif = file[len(pathFolder):-len(extension)] #getting rid of path and extension\\n documentName = strModif.split(\\\"_\\\")\\n patientIpp = documentName[0]\\n documentId = documentName[1]\\n #get patient id from patientIpp\\n conn = db.create_connection(DATABASE)\\n patient_num = db.select_patient_id(conn, patientIpp.lstrip('0')) #removing leading 0 causing troubles in select\\n conn.close()\\n return (documentId, patient_num, DOCUMENT_ORIGIN_CODE, DOCUMENT_DATE, date.today().strftime(\\\"%m/%d/%y\\\"), text, AUTHOR)\",\n \"def getbyname(self, name, doctype='experiment'):\\n\\n if doctype not in self.documents:\\n self.documents[doctype] = esd.search(self.source, doctype)\\n return self.documents[doctype].load_document(name)\",\n \"def document(self):\\n ...\",\n \"def documents(pmid_23982599, civic_aid6_document):\\n return [pmid_23982599, civic_aid6_document]\",\n \"def indexCranFull(path, writer):\\n # Title field type\\n tft = FieldType()\\n tft.setIndexed(True)\\n tft.setStored(True)\\n tft.setTokenized(TokenizeFields)\\n tft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS) #only index the document and frequency data\\n\\n\\n # Author field type\\n aft = FieldType()\\n aft.setIndexed(True)\\n aft.setStored(True)\\n aft.setTokenized(TokenizeFields)\\n aft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) #index the document, term frequency and position data\\n\\n\\n # Content field type\\n cft = FieldType()\\n cft.setIndexed(True)\\n cft.setStored(True)\\n cft.setTokenized(True)\\n cft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS)\\n\\n txt = open(path)\\n \\\"\\\"\\\"\\n cran documents are listed in this order:\\n .I # -> ignore\\n .T -> starting on the next line, multi-line title\\n .A -> on the next line, multiple authored separated by 'and'\\n .B -> on the next line, ignore\\n .W -> starting on the next line, multi-line body (content)\\n \\\"\\\"\\\"\\n docid = 0\\n debug = False\\n while True: # in each iteration, read all the lines corresponding to a document\\n line = txt.readline()\\n\\n if line == '':\\n break\\n\\n if docid == 1400:\\n debug = True\\n\\n if line.startswith('.I'):\\n docid = int(line.split(' ')[1].strip())\\n continue\\n\\n if line.startswith('.T'):\\n title = ''\\n while True:\\n line = txt.readline()\\n if line.startswith('.A'):\\n break\\n title = ' '.join([title, line]).strip()\\n\\n line = txt.readline()\\n # authors = ' '.join(line.split('and'))\\n authors = line.strip()\\n\\n #.B, its corresponding line and .W\\n txt.readline()\\n txt.readline()\\n txt.readline()\\n body = ''\\n while True:\\n line = txt.readline()\\n if line.startswith('.I'):\\n docid = int(line.split(' ')[1].strip())\\n break\\n if line == '':\\n break\\n body = ' '.join([body, line]).strip()\\n\\n doc = Document()\\n doc.add(Field(title_field, title, tft))\\n doc.add(Field(author_field, authors, aft))\\n doc.add(Field(content_field, body, cft))\\n doc.add(IntField(docid_field, docid, Field.Store.YES))\\n writer.addDocument(doc)\",\n \"def read():\\n # TODO\",\n \"def read(self):\\n return self.client.get(\\n index=self.index,\\n id=self.document_id,\\n ignore=[404],\\n )['_source']\",\n \"def readFromMetadata(cls, context, fqId):\\n pass\",\n \"def docs():\",\n \"def GetDocument(self, *args, **kwargs):\\n pass\",\n \"def _read_data(self):\",\n \"def get_synopsis(file_data):\\n for individual in file_data:\\n if 'synopsis' in individual:\\n synopsis = individual.split('\\\"')\\n return synopsis[1]\",\n \"def retrieve_document(self, format):\\n self._validate_extension(format.upper(), self.ALLOWED_DOCUMENT_EXT)\\n return self.client.service.RetrieveDocument(format=format.upper()).decode('base64')\",\n \"def read_all(self):\\r\\n pass\",\n \"def Read(self, *args, **kwargs):\\n pass\",\n \"def get_doc_data(self):\\n return self.data_read\",\n \"def read(cred, output, depth, type, exclude, path):\\n click.echo('Reading from firetore, credential file: %s' % (cred))\\n cred = os.path.abspath(cred)\\n output = os.path.abspath(output)\\n click.echo('Document path: %s' % path)\\n click.echo('Output path: %s' % output)\\n\\n if depth<0:\\n depth = 1000000\\n\\n if path and path.startswith('/'):\\n path = path[1:]\\n\\n if os.listdir(output):\\n click.echo('\\\\nError: folder \\\"%s\\\" is not empty' % output)\\n return\\n\\n global total_doc_count\\n global start_time\\n total_doc_count = 0\\n start_time = time.time()\\n fs = firestore.client(initialize_app(credentials.Certificate(cred)))\\n # data = fs.collection('schools').get()\\n # for item in data:\\n # print(json.dumps(item.to_dict()))\\n # break\\n if not path or path == '/': # get all root collections\\n collections = fs.collections() # root collections\\n # collections = fs.document('schools/dev').collections() # root collections\\n for col in collections:\\n read_collection(output, col.id, col, 1, depth, exclude)\\n elif type=='document':\\n doc = fs.document(path).get()\\n read_document(output, path, doc, 1, depth, exclude)\\n else: # 'collection'\\n col = fs.collection(path)\\n read_collection(output, path, col, 1, depth, exclude)\",\n \"def document_view(index_name, doc_type, doc_id):\\n resp = es.get(index=index_name, doc_type=doc_type, id=doc_id)\\n document = resp[\\\"_source\\\"]\\n print(document)\",\n \"def get_document(self, docid):\\n raise NotImplementedError\",\n \"def main(rc):\\n with store_client(rc) as sclient:\\n for doc in rc.documents:\\n sclient.copydoc(doc)\",\n \"def document(self) -> str:\\n return pulumi.get(self, \\\"document\\\")\",\n \"def read(self):\\n raise NotImplementedError\",\n \"def document(self, **kw):\\r\\n \\r\\n for p in self.documents(**kw):\\r\\n return p\",\n \"def getResourceSearchText(self, authenticationToken, guid):\\r\\n pass\",\n \"def example_metadata(study_name, draft_name):\\n odm = ODM(\\\"SYSTEM_NAME\\\", filetype=ODM.FILETYPE_SNAPSHOT)\\n\\n study = Study(study_name, project_type=Study.PROJECT)\\n\\n # Push study element into odm\\n odm << study\\n\\n # Create global variables and set them into study.\\n study << GlobalVariables(study_name) #Expected that protocol name will match the Study OID.\\n\\n # Create some basic definitions\\n bd = BasicDefinitions()\\n\\n # Add some measurement units to the basic definitions. This time using the call () syntax:\\n bd(\\n MeasurementUnit(\\\"KG\\\", \\\"Kilograms\\\")(\\n Symbol()(TranslatedText(\\\"Kilograms\\\"))\\n ),\\n MeasurementUnit(\\\"CM\\\", \\\"Centimeters\\\")(\\n Symbol()(TranslatedText(\\\"Centimeters\\\"))\\n )\\n )\\n\\n # Add basic definitions to study\\n study << bd\\n\\n # Now metadata which will contain all our form and field defs eventually\\n meta = MetaDataVersion('META1', draft_name)\\n study << meta\\n\\n # Protocol contains StudyEventRefs\\n protocol = Protocol()\\n # Add some StudyEventRefs\\n protocol << StudyEventRef(\\\"FLDR1\\\", 1, True) # Order 1, Mandatory\\n # protocol << StudyEventRef(\\\"FLDR2\\\", 2, False) # Order 2, Not Mandatory\\n # protocol << StudyEventRef(\\\"AE\\\", 3, True)\\n\\n meta << protocol\\n\\n # Add Study Event Defs with some child FormRefs\\n fldr1 = StudyEventDef(\\\"FLDR1\\\", \\\"Folder 1\\\", False, StudyEventDef.SCHEDULED)\\n\\n fldr1 << FormRef(\\\"DM\\\", 1, True)\\n fldr1 << FormRef(\\\"VS\\\", 2, True)\\n\\n meta << fldr1\\n\\n meta << StudyEventDef(\\\"FLDR2\\\", \\\"Folder 2\\\", False, StudyEventDef.UNSCHEDULED)(\\n FormRef(\\\"VS\\\", 1, True)\\n )\\n\\n meta << StudyEventDef(\\\"AE\\\", \\\"Adverse Events\\\", False, StudyEventDef.COMMON)(\\n FormRef(\\\"AE\\\", 1, False)\\n )\\n\\n dm_form = FormDef(\\\"DM\\\",\\\"Demography\\\")\\n dm_form << MdsolHelpText(\\\"en\\\",\\\"Some help text for Demography\\\")\\n dm_form << MdsolViewRestriction('Data Manager')\\n dm_form << MdsolEntryRestriction('Batch Upload')\\n dm_form << ItemGroupRef(\\\"DM_IG1\\\", 1)\\n dm_form << ItemGroupRef(\\\"DM_IG2\\\", 2)\\n\\n # Add to metadata\\n meta << dm_form\\n\\n # Define item group\\n meta << ItemGroupDef(\\\"DM_IG1\\\", \\\"DM Item Group 1\\\")(\\n MdsolLabelRef(\\\"LBL1\\\", 1),\\n ItemRef(\\\"SEX\\\", 2)(\\n MdsolAttribute(\\\"Standards\\\",\\\"CDASH\\\",\\\"SEX\\\"),\\n MdsolAttribute(\\\"Standards\\\",\\\"STDNUMBER\\\",\\\"1120\\\")\\n ),\\n ItemRef(\\\"RACE\\\", 3),\\n ItemRef(\\\"RACE_OTH\\\", 4),\\n ItemRef(\\\"DOB\\\", 5),\\n ItemRef(\\\"AGE\\\", 6)\\n )\\n\\n # Add the ItemDefs\\n meta << ItemDef(\\\"SEX\\\", \\\"Gender\\\", DataType.Text, 1, control_type=ControlType.RadioButton\\n )(\\n Question()(TranslatedText(\\\"Gender at Birth\\\")),\\n CodeListRef(\\\"CL_SEX\\\")\\n )\\n meta << ItemDef(\\\"RACE\\\", \\\"Race\\\", DataType.Text, 2,\\n control_type=ControlType.RadioButtonVertical\\n )(\\n Question()(TranslatedText(\\\"Race\\\")),\\n CodeListRef(\\\"CL_RACE\\\")\\n )\\n meta << ItemDef(\\\"RACE_OTH\\\", \\\"RaceOther\\\", DataType.Text, 20) \\\\\\n << Question() << TranslatedText(\\\"If Race Other, please specify\\\")\\n\\n meta << ItemDef(\\\"DOB\\\", \\\"DateOfBirth\\\", DataType.Date, 10,\\n control_type=ControlType.DateTime,\\n date_time_format=\\\"dd/mm/yyyy\\\"\\n )(\\n Question()(TranslatedText(\\\"Date of Birth\\\")),\\n MdsolHelpText(\\\"en\\\",\\\"If month unknown, enter January\\\")\\n )\\n\\n meta << ItemDef(\\\"AGE\\\", \\\"Age in Years\\\", DataType.Integer, 4, significant_digits=3, control_type=ControlType.Text\\n )(\\n Question()(TranslatedText(\\\"Age in Years\\\")),\\n RangeCheck(RangeCheckComparatorType.GreaterThanEqualTo, RangeCheckType.Soft) (\\n CheckValue(\\\"18\\\")\\n ),\\n RangeCheck(RangeCheckComparatorType.LessThanEqualTo, RangeCheckType.Soft) (\\n CheckValue(\\\"65\\\")\\n )\\n )\\n\\n # Add a Label\\n meta.add(MdsolLabelDef(\\\"LBL1\\\", \\\"Label1\\\")(TranslatedText(\\\"Please answer all questions.\\\")))\\n\\n # As well as () and << you can use add()\\n meta.add(\\n CodeList(\\\"CL_SEX\\\", \\\"SEX\\\", datatype=DataType.Text)(\\n CodeListItem(\\\"M\\\").add(\\n Decode().add(\\n TranslatedText(\\\"Male\\\"))\\n ),\\n CodeListItem(\\\"F\\\").add(\\n Decode().add(\\n TranslatedText(\\\"Female\\\"))\\n ),\\n ),\\n CodeList(\\\"CL_RACE\\\", \\\"RACE\\\", datatype=DataType.Text)(\\n CodeListItem(\\\"AS\\\")(Decode()(TranslatedText(\\\"Asian\\\"))),\\n CodeListItem(\\\"CA\\\")(Decode()(TranslatedText(\\\"White\\\"))),\\n CodeListItem(\\\"OT\\\")(Decode()(TranslatedText(\\\"Other\\\"))),\\n )\\n )\\n\\n meta.add(MdsolEditCheckDef('CHECK1')(\\n # Static value required to make this stick, gets ignored but won't load without it\\n MdsolCheckStep(form_oid=\\\"DM\\\", field_oid=\\\"RACE\\\", data_format='CodedValue', static_value=\\\"1\\\"),\\n MdsolCheckStep(static_value=\\\"OT\\\", data_format=\\\"$2\\\"),\\n MdsolCheckStep(function=StepType.IsEqualTo),\\n MdsolCheckStep(form_oid=\\\"DM\\\", field_oid=\\\"RACE_OTH\\\"),\\n MdsolCheckStep(function=StepType.IsEmpty),\\n MdsolCheckStep(function=StepType.And),\\n\\n MdsolCheckAction(form_oid=\\\"DM\\\", field_oid=\\\"RACE_OTH\\\",\\n check_action_type=ActionType.OpenQuery,\\n check_string=\\\"Race is set as OTHER but not specified. Please correct.\\\",\\n check_options=\\\"Site from System,RequiresResponse,RequiresManualClose\\\"\\n )\\n\\n ),\\n MdsolEditCheckDef('CHECK2')\\n )\\n\\n meta.add(MdsolCustomFunctionDef(\\\"CF1\\\",\\\"SELECT 1,2 FROM DataPoints\\\", language=\\\"SQ\\\"))\\n meta.add(MdsolCustomFunctionDef(\\\"CF2\\\",\\\"return true;\\\", language=\\\"C#\\\"))\\n\\n meta.add(\\n # Variable OID required\\n MdsolDerivationDef(\\\"AGE\\\", form_oid=\\\"DM\\\", field_oid=\\\"AGE\\\")(\\n # Variable OID required to be identified as a data step\\n MdsolDerivationStep(form_oid=\\\"DM\\\", field_oid=\\\"DOB\\\", data_format=\\\"StandardValue\\\", variable_oid=\\\"DOB\\\"),\\n MdsolDerivationStep(function=StepType.Age)\\n )\\n )\\n\\n return odm\",\n \"def read_rdkit_out(rdkit_conf, quantity='structure'):\\n\\n if quantity == 'structure':\\n return read_structure(rdkit_conf)\\n \\n if quantity == 'atomic_numbers':\\n return read_atomic_numbers(rdkit_conf)\",\n \"def can_read(self):\\n\\n return super(RamanSpeReader, self).can_read(extension='spe')\",\n \"def test_client_verification_document_retrieve(self):\\n pass\",\n \"def load_reference(self, path_to_reference):\\n with open(path_to_reference,'r') as f:\\n qids_to_relevant_docids = self.load_reference_from_stream(f)\\n return qids_to_relevant_docids\",\n \"def get(self, docid):\\n file = os.path.join(self.dirname, docid)\\n with open(file,'r',encoding='utf-8') as f:\\n text = f.read()\\n return text\",\n \"def __call__(self, doc):\\n return doc\",\n \"def get_doc(self):\\n return self.p\",\n \"def find_qualtrics_readme(self, dn: DepositorName):\\n\\n dn_dict = dn.name_dict\\n qualtrics_df = self.get_survey_responses(self.readme_survey_id)\\n\\n # First perform search via article_id or curation_id\\n self.log.info(\\\"Attempting to identify using article_id or curation_id ...\\\")\\n article_id = str(dn_dict['article_id'])\\n curation_id = str(dn_dict['curation_id'])\\n\\n try:\\n response_df = qualtrics_df[(qualtrics_df['article_id'] == article_id) |\\n (qualtrics_df['curation_id'] == curation_id)]\\n except KeyError:\\n self.log.warn(\\\"article_id and curation_id not in qualtrics survey !\\\")\\n response_df = pd.DataFrame()\\n\\n if response_df.empty:\\n self.log.warn(\\\"Empty DataFrame\\\")\\n raise ValueError\\n else:\\n self.log.info(\\\"Unique match based on article_id or curation_id !\\\")\\n self.pandas_write_buffer(response_df[readme_cols_order])\\n if response_df.shape[0] == 1:\\n response_dict = df_to_dict_single(response_df)\\n self.log.info(\\\"Only one entry found!\\\")\\n self.log.info(f\\\"Survey completed on {response_dict['date_completed']}\\\")\\n self.log.info(f\\\" ... for {response_dict['article_id']}\\\")\\n return response_dict['ResponseId'], response_df\\n else:\\n self.log.warn(\\\"Multiple entries found\\\")\\n raise ValueError\",\n \"def documents(self, **kw):\\r\\n \\r\\n doc_reader = self.doc_reader\\r\\n return (doc_reader[docnum] for docnum in self.document_numbers(**kw))\",\n \"def test_read_index(self):\\n\\n indexfile = tempfile.mktemp()\\n self.addCleanup(os.unlink, indexfile)\\n\\n TroveIndexBuilder(\\\"test/short.dat\\\", out=indexfile)\\n\\n index = TroveIndex()\\n index.reload(indexfile)\\n\\n docs = sorted([doc for doc in index.documents])\\n self.assertEquals(10, len(docs))\\n\\n self.assertEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], docs)\\n\\n doc = index.get_document(1)\\n ref = {u\\\"id\\\":\\\"1\\\",u\\\"titleName\\\":u\\\"Hello\\\"}\\n self.assertNotEquals(None, doc, \\\"Document not found for id 1\\\")\\n self.assertDictEqual(ref, doc)\\n\\n doc = index.get_document(10)\\n ref = {\\\"id\\\":\\\"10\\\",\\\"titleName\\\":\\\"Hello\\\"}\\n self.assertNotEquals(None, doc)\\n self.assertDictEqual(ref, doc)\",\n \"def get(self, *args):\\n return self.docs.get(*args)\",\n \"def test_get_occurrence_note(self):\\n pass\",\n \"def read(self):\\n pass\",\n \"def fini_doc(self):\\n raise NotImplementedError()\",\n \"def read(self):\\n return self.readentries()\",\n \"def documento():\\r\\n\\tpass\",\n \"def retrieve(document_id: str) -> Fulltext:\\n return current_session().retrieve(document_id)\",\n \"def get_document(self):\\n return self.document\",\n \"def _get_doc(results, index):\\n return results[index]\",\n \"def getResourceRecognition(self, authenticationToken, guid):\\r\\n pass\",\n \"def load_reference_from_stream(self, f):\\n qids_to_relevant_docids = {}\\n for l in f:\\n vals = l.strip().split('\\\\t')\\n if len(vals) != 4:\\n vals = l.strip().split(' ')\\n if len(vals) != 4:\\n pdb.set_trace()\\n raise IOError('\\\\\\\"%s\\\\\\\" is not valid format' % l)\\n\\n qid = vals[0]\\n if qid in qids_to_relevant_docids:\\n pass\\n else:\\n qids_to_relevant_docids[qid] = []\\n _rel = int(vals[3])\\n if _rel > 0:\\n qids_to_relevant_docids[qid].append(vals[2])\\n\\n return qids_to_relevant_docids\",\n \"def findNotesMetadata(self, authenticationToken, filter, offset, maxNotes, resultSpec):\\r\\n pass\",\n \"def get_metadata(self, docname, moderator):\\n raise NotImplementedError()\",\n \"def __getattribute__(self, name: str) -> Any:\\n if name in (FLD_TITLE, FLD_ABSTRACT, FLD_FEES, FLD_ACCESS_CONSTRAINTS, FLD_CONTACT_POSITION, FLD_CONTACT_ORGANISATION):\\n return self.read_local_metadata(name)\\n elif name == FLD_KEYWORDS:\\n kw = self.read_local_metadata(FLD_KEYWORDS)\\n if kw:\\n return set(kw.split(\\\",\\\"))\\n else:\\n return set()\\n elif name == FLD_ATTRIBUTION:\\n return self.read_local_metadata(FLD_ATTRIBUTION)\\n else:\\n return super().__getattribute__(name)\",\n \"def _getForDocument (self):\\n return self.__forDocument\",\n \"def put(self):\\n document = upload_file(self.request)\\n self.request.validated[\\\"qualification\\\"].documents.append(document)\\n if save_tender(self.request):\\n self.LOGGER.info(\\n \\\"Updated tender qualification document {}\\\".format(self.request.context.id),\\n extra=context_unpack(self.request, {\\\"MESSAGE_ID\\\": \\\"tender_qualification_document_put\\\"}),\\n )\\n return {\\\"data\\\": document.serialize(\\\"view\\\")}\",\n \"def test_get_document(index_with_documents):\\n response = index_with_documents().get_document(\\\"500682\\\")\\n assert isinstance(response, Document)\\n assert hasattr(response, \\\"title\\\")\\n assert response.title == \\\"The Highwaymen\\\"\",\n \"def test_documents_detailed_search_endpoint(self):\\n\\n # Search for documents using more specific criterias, like presidential names.\\n presidential_documents = self.federal_client.documents(\\n presidents=['donald-trump']\\n )\\n\\n # Make sure we have a response.\\n self.assertIsNotNone(presidential_documents)\\n\\n # And make sure we have some results.\\n self.assertGreaterEqual(presidential_documents['count'], 10)\",\n \"def kaggle_accessor(document):\\r\\n return document[1]\",\n \"def read(self, filename): # real signature unknown; restored from __doc__\\n pass\",\n \"def getdoc(doctype, name, user=None):\\n\\n\\timport webnotes\\n\\t\\n\\tif not (doctype and name):\\n\\t\\traise Exception, 'doctype and name required!'\\n\\t\\n\\tif not name: \\n\\t\\tname = doctype\\n\\n\\tif not webnotes.conn.exists(doctype, name):\\n\\t\\treturn []\\n\\n\\ttry:\\n\\t\\tbean = webnotes.bean(doctype, name)\\n\\t\\tbean.run_method(\\\"onload\\\")\\n\\n\\t\\tdoclist = bean.doclist\\n\\n\\t\\t# add file list\\n\\t\\tset_docinfo(doctype, name)\\n\\t\\t\\n\\texcept Exception, e:\\n\\t\\twebnotes.errprint(webnotes.utils.getTraceback())\\n\\t\\twebnotes.msgprint('Did not load.')\\n\\t\\traise e\\n\\n\\tif bean and not name.startswith('_'):\\n\\t\\twebnotes.user.update_recent(doctype, name)\\n\\t\\n\\twebnotes.response['docs'] = doclist\",\n \"def read(self, path):\\n pbase = os.path.splitext(path)[0]\\n gsid = pbase.split('/')[-2]\\n gender, sid = gsid[0], gsid[1:]\\n assert sid in self._spkr_table\\n phoneseq = phnread(pbase+'.PHN')\\n wrdseq = phnread(pbase+'.WRD')\\n transcrpt = txtread(pbase+'.TXT')\\n sample = TIMITSpeech(\\n *audioread(path), speaker=sid, gender=gender,\\n transcript=transcrpt, phonemeseq=phoneseq,\\n wordseq=wrdseq\\n )\\n #sample.phonemeseq = [\\n # (t, PHONETABLE[p]) for t, p in sample.phonemeseq]\\n return sample\",\n \"def read(self):\\n print(f'Metadata version {self.version_num}')\\n print(f'Saved at: {self.datetime}')\\n print(f'Self chat: {self.self_chat}')\\n print(f'Speakers: {self.speakers}')\\n print('Opt:')\\n for k, v in self.opt.items():\\n print(f'\\\\t{k}: {v}')\\n for k, v in self.extra_data.items():\\n print(f'{k}: {v}')\",\n \"def read_all(self, *args, **kwargs):\\n pass\",\n \"def get_qualification(qual_id: int) -> Any:\\n qualification = Qualification.query.get(qual_id)\\n if qualification is None:\\n raise APIError(reason=\\\"no_such_object\\\", status_code=400)\\n return QualificationSchema().dump(qualification)\",\n \"def engine():\\r\\n document.add_heading('Engine details', 1)\\r\\n\\r\\n engine_metrics = ['customProperties','listenerPorts','autosaveInterval', 'tableFilesDirectory', 'genericUndoBufferMaxSize', 'documentTimeout','documentDirectory',\\r\\n 'allowDataLineage', 'qrsHttpNotificationPort', 'standardReload',\\r\\n 'workingSetSizeLoPct', 'workingSetSizeHiPct', 'workingSetSizeMode','cpuThrottlePercentage', 'maxCoreMaskPersisted', 'maxCoreMask',\\r\\n 'maxCoreMaskHiPersisted', 'maxCoreMaskHi','objectTimeLimitSec', 'exportTimeLimitSec', 'reloadTimeLimitSec',\\r\\n 'hyperCubeMemoryLimit', 'exportMemoryLimit', 'reloadMemoryLimit', 'createSearchIndexOnReloadEnabled', 'hostname',\\r\\n 'globalLogMinuteInterval','auditActivityLogVerbosity','auditSecurityLogVerbosity','serviceLogVerbosity','systemLogVerbosity','performanceLogVerbosity',\\r\\n 'qixPerformanceLogVerbosity','auditLogVerbosity','sessionLogVerbosity','trafficLogVerbosity']\\r\\n\\r\\n enginenodes = get_qlik_sense.get_engine()\\r\\n num_of_engines = len(enginenodes)\\r\\n num_of_engine_metrics = len(engine_metrics)\\r\\n table = document.add_table(rows=num_of_engine_metrics+1, cols=num_of_engines+1)\\r\\n table.style = 'Grid Table 1 Light Accent 1'\\r\\n row = table.rows[0]\\r\\n row.cells[0].text = 'Metric'\\r\\n for item in range(0, num_of_engines):\\r\\n row.cells[item+1].text = enginenodes[item][36]\\r\\n for item in range(num_of_engine_metrics):\\r\\n row = table.rows[item+1]\\r\\n row.cells[0].text = str(engine_metrics[item])\\r\\n for enginenode in range(num_of_engines):\\r\\n row.cells[enginenode+1].text = str(enginenodes[enginenode][item])\\r\\n\\r\\n document.add_page_break()\",\n \"def read(self, *args) -> \\\"PyObject *\\\":\\n return _ida_fpro.qfile_t_read(self, *args)\",\n \"def test_query_generic_embedded_document(self):\\n\\n class A(EmbeddedDocument):\\n a_name = StringField()\\n\\n class B(EmbeddedDocument):\\n b_name = StringField()\\n\\n class Doc(Document):\\n document = GenericEmbeddedDocumentField(choices=(A, B))\\n\\n Doc.drop_collection()\\n Doc(document=A(a_name=\\\"A doc\\\")).save()\\n Doc(document=B(b_name=\\\"B doc\\\")).save()\\n\\n # Using raw in filter working fine\\n assert Doc.objects(__raw__={\\\"document.a_name\\\": \\\"A doc\\\"}).count() == 1\\n assert Doc.objects(__raw__={\\\"document.b_name\\\": \\\"B doc\\\"}).count() == 1\\n assert Doc.objects(document__a_name=\\\"A doc\\\").count() == 1\\n assert Doc.objects(document__b_name=\\\"B doc\\\").count() == 1\",\n \"def reader(name, version=None, mimetype=None):\\n\\treturn _data_processor('read', name, version, mimetype)\",\n \"def findReadData(day,scope,chan,shot):\\n return readData(conf.dataDir + \\\"%d_01_2013_osc%d/C%dosc%d-%05d.txt\\\" % (day, scope, chan, scope, shot),\\n conf.timeDelay[scope,chan],\\n conf.ampMult[scope,chan])\",\n \"def GetMetadataSample():\\n client = CreateClient()\\n # Fetch the metadata entry and display bits of it\\n metadata = client.GetMetadata()\\n print 'Quota'\\n print ' Total:', metadata.quota_bytes_total.text\\n print ' Used:', metadata.quota_bytes_used.text\\n print ' Trashed:', metadata.quota_bytes_used_in_trash.text\\n print 'Import / Export'\\n for input_format in metadata.import_formats:\\n print ' Import:', input_format.source, 'to', input_format.target\\n for export_format in metadata.export_formats:\\n print ' Export:', export_format.source, 'to', export_format.target\\n print 'Features'\\n for feature in metadata.features:\\n print ' Feature:', feature.name.text\\n print 'Upload Sizes'\\n for upload_size in metadata.max_upload_sizes:\\n print ' Kind:', upload_size.kind, upload_size.text\",\n \"def example_clinical_data(study_name, environment):\\n\\n odm = ODM(\\\"test system\\\")(\\n ClinicalData(\\\"Mediflex\\\", \\\"DEV\\\")(\\n SubjectData(\\\"MDSOL\\\", \\\"IJS TEST4\\\", transaction_type=\\\"Insert\\\")(\\n StudyEventData(\\\"SUBJECT\\\")(\\n FormData(\\\"EN\\\", transaction_type=\\\"Update\\\")(\\n # Although Signature is ODM1.3.1 RWS does not support it inbound currently\\n # RWSBuilders do support outbound generation of Signature at FormData level\\n # Signature()(\\n # UserRef(\\\"isparks\\\"),\\n # LocationRef(\\\"MDSOL\\\"),\\n # SignatureRef(\\\"APPROVED\\\"),\\n # DateTimeStamp(datetime(2015, 9, 11, 10, 15, 22, 80))\\n # ),\\n ItemGroupData()(\\n ItemData(\\\"SUBJINIT\\\", \\\"AAA\\\")(\\n AuditRecord(edit_point=AuditRecord.EDIT_DATA_MANAGEMENT,\\n used_imputation_method= False,\\n identifier='X2011',\\n include_file_oid=False)(\\n UserRef(\\\"isparks\\\"),\\n LocationRef(\\\"MDSOL\\\"),\\n ReasonForChange(\\\"Data Entry Error\\\"),\\n DateTimeStamp(datetime(2015, 9, 11, 10, 15, 22, 80))\\n ),\\n MdsolQuery(value=\\\"Subject initials should be 2 chars only.\\\", recipient=\\\"Site from System\\\",\\n status=QueryStatusType.Open)\\n ),\\n ItemData(\\\"SUBJID\\\", '001')\\n )\\n )\\n )\\n )\\n )\\n )\\n return odm\",\n \"def get(ref):\\n cmd = 'qri get --format json %s' % ref\\n result, err = shell_exec(cmd)\\n if err:\\n raise RuntimeError(err)\\n d = dataset.Dataset(json.loads(result))\\n return d\",\n \"def get(self, index, id):\\n url = f'{self.host}{index}/_doc/{id}'\\n resp = requests.get(url)\\n return resp.json()\",\n \"def get_scope_read_default(self):\\n return f\\\"{self.api_name}:read:default\\\"\",\n \"def _getDocumentType(self):\\n\\n fileName, fileExtension = os.path.splitext(self.sourceFileName)\\n documentType = None\\n\\n for knownType in list(TextRepresentation.KNOWNTYPES.keys()):\\n if knownType == fileExtension[1:]:\\n documentType = knownType\\n\\n if documentType is None:\\n raise Exception(\\\"Unknown document type: %s\\\" % fileExtension[1:])\\n \\n return documentType\",\n \"def parse_design(self, detailed_design_file):\",\n \"def get_document(self, value, key='name'):\\n if value.endswith('.json'):\\n key = 'filename'\\n return [x for x in self.vocab if x[key] == value][0]\",\n \"def test_all_documents(self):\",\n \"def getdoc():\\n\\n\\timport webnotes\\n\\tfrom webnotes.utils import cint\\n\\t\\n\\tform = webnotes.form_dict\\n\\tdoctype, docname = form.get('doctype'), form.get('name')\\n\\tprefix = cint(form.get('from_archive')) and 'arc' or 'tab'\\n\\n\\tif not (doctype and docname):\\n\\t\\traise Exception, 'doctype and name required!'\\n\\t\\n\\tdoclist = []\\n\\t# single\\n\\tdoclist = load_single_doc(doctype, docname, (form.get('user') or webnotes.session['user']), prefix)\\n\\t\\n\\t# load doctype along with the doc\\n\\tif form.get('getdoctype'):\\n\\t\\timport webnotes.model.doctype\\n\\t\\tdoclist += webnotes.model.doctype.get(doctype)\\n\\n\\t# tag as archived\\n\\tif prefix == 'arc':\\n\\t\\tdoclist[0].__archived=1\\n\\n\\twebnotes.response['docs'] = doclist\",\n \"def object_readers(name, *, specify_reader=False):\\n\\treturn object_access('read', name, specify_reader)\",\n \"def read(self, fileobj):\\n raise NotImplementedError\",\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 _ATTopic_query(self, **kw):\\n del kw['path'] # don't want to limit to context as w/ folders\\n return self.context.queryCatalog(self.context.REQUEST, \\n False, # no batch here\\n None, # no b_size here\\n False,\\n **kw)\",\n \"def getSongTextInfo():\\n sids = []\\n documents = []\\n sFile = open('../txt/two__Lastfm_song_Docs.txt')\\n lines = sFile.readlines()\\n index = 0\\n for line in lines:\\n line.strip('\\\\n')\\n line.strip('\\\\r\\\\n')\\n items = line.split('>>')\\n sid = int(items[0])\\n text = items[1]\\n documents.append(text)\\n sids.append(sid)\\n sFile.close()\\n print 'len = ',len(sids)\\n print 'len = ',len(documents)\\n return sids,documents\",\n \"def read_data(term):\\n course_url = '/admweb/!SWKSECX.main?term='+ term + '&title=&course=&crn=&coll=&dept=&subj='\\n connection = httplib.HTTPSConnection('courses.rice.edu', 443)\\n connection.connect()\\n connection.request(\\n 'GET',\\n course_url\\n )\\n courses_xml = connection.getresponse()\\n return courses_xml\",\n \"def get_doc_from_MP(mp_id):\\n apr=mpr.get_doc(mp_id)\\n return apr\",\n \"def readByName(self, name):\\n pass\",\n \"def document_indexer(self):\\n return self.indexer_by_pid_type(DOCUMENT_PID_TYPE)\",\n \"def read(self, index, n_samples):\\n raise NotImplementedError\",\n \"def doc(obj):\\n return Documentation.fromObject(obj).first\",\n \"def read(self):\\n pass\",\n \"def getnotes():\",\n \"def stored_fields(self, docnum):\\r\\n return self.doc_reader[docnum]\",\n \"def get_document(name):\\n document = [d for d in documents if d.name == name]\\n if len(document) > 0:\\n return document[0]\",\n \"def retrieve(dbxrefs, basics=True, hierarchy=True, wikipedia=True, literature=True, cross_references=True, overlaps=True):\\n resolved = dbxref.resolver.resolve(dbxrefs, check_existence=False)\\n documents = []\\n for entry in resolved:\\n # Construct URL for retrieve\\n json_url = entry['locations']['json'][0]\\n logger.debug('URL: %s', json_url)\\n r = requests.get(json_url)\\n logger.debug('Content: %s', r.text)\\n ipro = json.loads(r.text)\\n\\n # Parse retrieved json file by selected Options\\n output = {\\\"id\\\": entry[\\\"dbxref\\\"]}\\n if basics:\\n try:\\n output.update(accession=ipro[\\\"metadata\\\"][\\\"accession\\\"], entry_type=ipro[\\\"metadata\\\"][\\\"type\\\"],\\n description=ipro[\\\"metadata\\\"][\\\"description\\\"], counters=ipro[\\\"metadata\\\"][\\\"counters\\\"],\\n entry_id=ipro[\\\"metadata\\\"][\\\"entry_id\\\"], name=ipro[\\\"metadata\\\"][\\\"name\\\"],\\n source_database=ipro[\\\"metadata\\\"][\\\"source_database\\\"])\\n except KeyError:\\n logger.warning(\\\"One or more basic information were not available for the given entry. Please check your output.\\\")\\n if hierarchy:\\n try:\\n output.update(hierarchy=ipro[\\\"metadata\\\"][\\\"hierarchy\\\"])\\n except KeyError:\\n logger.warning(\\\"Hierarchy information was not available for the given entry.\\\")\\n if wikipedia:\\n try:\\n output.update(wikipedia=ipro[\\\"metadata\\\"][\\\"wikipedia\\\"])\\n except KeyError:\\n logger.warning(\\\"Wikipedia articles were not available for the given entry.\\\")\\n if literature:\\n try:\\n output.update(literature=ipro[\\\"metadata\\\"][\\\"literature\\\"])\\n except KeyError:\\n logger.warning(\\\"Literature was not available for the given entry.\\\")\\n if cross_references:\\n try:\\n output.update(cross_references=ipro[\\\"metadata\\\"][\\\"cross_references\\\"])\\n except KeyError:\\n logger.warning(\\\"Cross_references were not available for the given entry.\\\")\\n if overlaps:\\n try:\\n output.update(overlaps=ipro[\\\"metadata\\\"][\\\"overlaps_with\\\"])\\n except KeyError:\\n logger.warning(\\\"Overlap information was not available for the given entry.\\\")\\n documents.append(output)\\n return documents\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5713616","0.55995387","0.5426383","0.5347822","0.52830064","0.52730966","0.523003","0.5208073","0.5207551","0.519923","0.5193545","0.5178876","0.5173786","0.5148251","0.51301056","0.5124473","0.51232445","0.5108244","0.5097899","0.5074501","0.5055006","0.50370204","0.5026453","0.4996217","0.49906132","0.49778035","0.49596938","0.49592006","0.4937378","0.49357298","0.4929702","0.49101683","0.48968914","0.48941162","0.48937201","0.4881869","0.4878186","0.48671645","0.48643944","0.4847187","0.48355561","0.48181456","0.4817517","0.48171762","0.48159462","0.48064744","0.47996253","0.47892424","0.47887772","0.47768614","0.47765395","0.47715095","0.47693014","0.47604692","0.47557282","0.47542533","0.4753665","0.4753298","0.4749248","0.47402427","0.47368652","0.4736571","0.47288164","0.47226614","0.4721155","0.47119546","0.47060144","0.4704752","0.4703649","0.4701257","0.46990156","0.46914962","0.46799853","0.46733034","0.46713978","0.4668221","0.4667084","0.46644405","0.4652399","0.46494874","0.46457443","0.46430844","0.46425062","0.46339428","0.46306327","0.46275002","0.46205565","0.46193978","0.461885","0.46176383","0.46152896","0.46101832","0.46098763","0.46069187","0.46058005","0.460365","0.4603309","0.46020618","0.46017012","0.4595896","0.45908588"],"string":"[\n \"0.5713616\",\n \"0.55995387\",\n \"0.5426383\",\n \"0.5347822\",\n \"0.52830064\",\n \"0.52730966\",\n \"0.523003\",\n \"0.5208073\",\n \"0.5207551\",\n \"0.519923\",\n \"0.5193545\",\n \"0.5178876\",\n \"0.5173786\",\n \"0.5148251\",\n \"0.51301056\",\n \"0.5124473\",\n \"0.51232445\",\n \"0.5108244\",\n \"0.5097899\",\n \"0.5074501\",\n \"0.5055006\",\n \"0.50370204\",\n \"0.5026453\",\n \"0.4996217\",\n \"0.49906132\",\n \"0.49778035\",\n \"0.49596938\",\n \"0.49592006\",\n \"0.4937378\",\n \"0.49357298\",\n \"0.4929702\",\n \"0.49101683\",\n \"0.48968914\",\n \"0.48941162\",\n \"0.48937201\",\n \"0.4881869\",\n \"0.4878186\",\n \"0.48671645\",\n \"0.48643944\",\n \"0.4847187\",\n \"0.48355561\",\n \"0.48181456\",\n \"0.4817517\",\n \"0.48171762\",\n \"0.48159462\",\n \"0.48064744\",\n \"0.47996253\",\n \"0.47892424\",\n \"0.47887772\",\n \"0.47768614\",\n \"0.47765395\",\n \"0.47715095\",\n \"0.47693014\",\n \"0.47604692\",\n \"0.47557282\",\n \"0.47542533\",\n \"0.4753665\",\n \"0.4753298\",\n \"0.4749248\",\n \"0.47402427\",\n \"0.47368652\",\n \"0.4736571\",\n \"0.47288164\",\n \"0.47226614\",\n \"0.4721155\",\n \"0.47119546\",\n \"0.47060144\",\n \"0.4704752\",\n \"0.4703649\",\n \"0.4701257\",\n \"0.46990156\",\n \"0.46914962\",\n \"0.46799853\",\n \"0.46733034\",\n \"0.46713978\",\n \"0.4668221\",\n \"0.4667084\",\n \"0.46644405\",\n \"0.4652399\",\n \"0.46494874\",\n \"0.46457443\",\n \"0.46430844\",\n \"0.46425062\",\n \"0.46339428\",\n \"0.46306327\",\n \"0.46275002\",\n \"0.46205565\",\n \"0.46193978\",\n \"0.461885\",\n \"0.46176383\",\n \"0.46152896\",\n \"0.46101832\",\n \"0.46098763\",\n \"0.46069187\",\n \"0.46058005\",\n \"0.460365\",\n \"0.4603309\",\n \"0.46020618\",\n \"0.46017012\",\n \"0.4595896\",\n \"0.45908588\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84575,"cells":{"query":{"kind":"string","value":"Tender Qualification Document Update"},"document":{"kind":"string","value":"def put(self):\n document = upload_file(self.request)\n self.request.validated[\"qualification\"].documents.append(document)\n if save_tender(self.request):\n self.LOGGER.info(\n \"Updated tender qualification document {}\".format(self.request.context.id),\n extra=context_unpack(self.request, {\"MESSAGE_ID\": \"tender_qualification_document_put\"}),\n )\n return {\"data\": document.serialize(\"view\")}"},"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 update_document(self):\n pass","def edit_document():","def patch(self):\n if apply_patch(self.request, src=self.request.context.serialize()):\n update_file_content_type(self.request)\n self.LOGGER.info(\n \"Updated tender qualification document {}\".format(self.request.context.id),\n extra=context_unpack(self.request, {\"MESSAGE_ID\": \"tender_qualification_document_patch\"}),\n )\n return {\"data\": self.request.context.serialize(\"view\")}","def update_knowledge(self):\n pass","def tests_ti_document_update(self, request: FixtureRequest):\n super().group_update(request)","def test_client_verification_document_update(self):\n pass","def test_update(self):\n doc_fields = document_fields.DocumentFields({\n 'foo@': 'bar',\n })\n self.assertEquals('bar', doc_fields['foo'])\n doc_fields.update({\n 'foo@': 'bbq',\n })\n self.assertEquals('bbq', doc_fields['foo'])","def update_doc(doc):\n doc.long_name = \"X\"","def add_doc_to_get(self,action,update_spec,action_buffer_index):\n doc = {'_index' : action['_index'],\n '_type' : action['_type'],\n '_id' : action['_id']}\n self.doc_to_get.append((doc,update_spec,action_buffer_index))","def test_client_verification_document_partial_update(self):\n pass","def patch(self):\n return super(TenderAwardDocumentResource, self).patch()","def document_update(index_name, doc_type, doc_id, doc=None, new=None):\n if doc:\n resp = es.index(index=index_name, doc_type=doc_type,\n id=doc_id, body=doc)\n print(resp)\n else:\n resp = es.update(index=index_name, doc_type=doc_type,\n id=doc_id, body={\"doc\": new})","def update(get_index, document_id, tag): \n client, index_name = connection_es()\n res = client.update(index = get_index, doc_type = 'nvisnx', id = document_id, body= {\"doc\" : {\"tag\": tag}})\n return res","def test_update_documents(index_with_documents, small_movies):\n index = index_with_documents()\n response = index.get_documents()\n doc = response.results[0]\n doc.title = \"Some title\"\n\n update = index.update_documents([dict(doc)])\n\n assert isinstance(update, TaskInfo)\n assert update.task_uid is not None\n index.wait_for_task(update.task_uid)\n\n response = index.get_document(doc.id)\n assert response.title == \"Some title\"\n\n update = index.update_documents(small_movies)\n index.wait_for_task(update.task_uid)\n\n response = index.get_document(doc.id)\n assert response.title != \"Some title\"","def put(self):\n if not self.validate_complaint_document(\"update\"):\n return\n document = upload_file(self.request)\n document.author = self.request.authenticated_role\n self.request.validated[\"complaint\"].documents.append(document)\n if save_tender(self.request):\n self.LOGGER.info(\n \"Updated tender award complaint document {}\".format(self.request.context.id),\n extra=context_unpack(self.request, {\"MESSAGE_ID\": \"tender_award_complaint_document_put\"}),\n )\n return {\"data\": document.serialize(\"view\")}","def test_kyc_put_document(self):\n pass","def updateAnnoByIdDictFromMeta(syn,idDict,metaDf,refCol,fileExts):\n for key in idDict:\n print \"updating annotaion values for key: %s\" % key\n for synId in idDict[key]:\n print \"> %s\" %synId\n temp = syn.get(synId, downloadFile = False)\n exts = ')|('.join(fileExts)\n exts = r'(' + exts + ')'\n tempName = re.sub(exts,\"\",temp.name)\n row = df.loc[df[refCol] == tempName]\n temp[key] = map(str,row[key])[0]\n temp = syn.store(temp,forceVersion = False)\n print \"\"","def put(self):\n return super(TenderAwardDocumentResource, self).put()","def update_document(self, type: Type, id: str,\n new_data: Dict[str, Any]) -> None:\n if collection := self.client.collection(f'{type}'):\n if document_ref := collection.document(document_id=id):\n if document_ref.get().exists:\n document_ref.update(new_data)\n else:\n document_ref.create(new_data)","def document(self):\n ...","def patch(self):\n return super(TenderAwardContractDocumentResource, self).patch()","def _helperUpdateAnnoByMetadata(syn,temp,metaDf,refCol,cols2Add,fileExts):\n \n print \"Updating annotations by metadata...\"\n \n exts = ')|('.join(fileExts)\n exts = r'(' + exts + ')'\n tempName = re.sub(exts,\"\",temp.name)\n \n row = df.loc[df[refCol] == tempName]\n if row.empty:\n print \"missing metadata\"\n else:\n for colName in cols2Add:\n print \"> %s \" % colName\n temp[colName] = map(str,row[colName])[0]\n temp = syn.store(temp, forceVersion = False)\n print \"\"","def _update_documents(self):\n if self.campaigns.active():\n top_ranked_documents = utils._rank_documents(self.event)\n # [TODO] this is a kludge\n if set(top_ranked_documents) == set(self.documents.all()):\n return False\n print('[DEBUG] Docs changed! New campaign ahoy!')\n self.documents = top_ranked_documents\n return True","def collection_post(self):\n document = upload_file(self.request)\n document.author = self.request.authenticated_role\n self.context.documents.append(document)\n if save_tender(self.request):\n self.LOGGER.info(\n \"Created tender qualification document {}\".format(document.id),\n extra=context_unpack(\n self.request, {\"MESSAGE_ID\": \"tender_qualification_document_create\"}, {\"document_id\": document.id}\n ),\n )\n self.request.response.status = 201\n document_route = self.request.matched_route.name.replace(\"collection_\", \"\")\n self.request.response.headers[\"Location\"] = self.request.current_route_url(\n _route_name=document_route, document_id=document.id, _query={}\n )\n return {\"data\": document.serialize(\"view\")}","def spot_doc_rubrics2(doc_id, rubrics):\n db.doc_apply(doc_id, spot_doc_rubrics, rubrics)","def on_doctype_update():\n\tfrappe.db.add_index(\"Make Serial NO\", [\"item\", \"batch\"])","def _update(self, count=True, forced=False):","def after_insert(self):\n if self.get('update_request') and not self.is_pending_approval():\n self.update_request.created_docname = self.name\n self.set_as_success()","def test_update_with_document_boost(self):\n u = stellr.UpdateCommand(TEST_HTTP)\n u.add_documents({'a': 1}, boost=2.0)\n self.assertEqual(u.body, '{\"add\": {\"doc\": {\"a\": 1}, \"boost\": 2.0}}')","def put(self):\n return super(TenderAwardContractDocumentResource, self).put()","def put(self, request, code, suggested_format=None):\n context = {'request': request}\n conten_type = request.content_type\n uploaded_obj = None\n if 'multipart/form-data' in conten_type:\n # We have a file upload encoded with multipart/form-data\n file_content = StringIO(request.body)\n parser = MultiPartParser()\n dnf = parser.parse(file_content, media_type=conten_type, parser_context=context)\n extra = dnf.data\n if 'file' in dnf.files:\n uploaded_obj = dnf.files['file']\n else:\n extra = request.QUERY_PARAMS\n # TODO: do we require SQL tagging logic in this API call?\n sql_tag_string = extra.get('tag_string', None)\n sql_remove_tag_string = extra.get('remove_tag_string', None)\n new_name = extra.get('new_name', None)\n new_type = extra.get('new_type', None)\n index_data = extra.get('indexing_data', None)\n if index_data:\n index_data = json.loads(index_data)\n processor = DocumentProcessor()\n options = {\n 'tag_string': sql_tag_string,\n 'remove_tag_string': sql_remove_tag_string,\n 'extension': suggested_format,\n 'new_name': new_name,\n 'new_type': new_type,\n 'new_indexes': index_data,\n 'update_file': uploaded_obj,\n 'user': request.user,\n }\n document = processor.update(code, options)\n if len(processor.errors) > 0:\n log.error('FileHandler.update manager errors %s' % processor.errors)\n if settings.DEBUG:\n print processor.errors\n raise Exception('FileHandler.update manager errors')\n else:\n return Response(status=status.HTTP_400_BAD_REQUEST)\n log.info('FileHandler.update request fulfilled for code: %s, extension: %s'\n % (code, suggested_format))\n resp = DMSOBjectRevisionsData(document).data\n return Response(resp, status=status.HTTP_200_OK)","def update(self, doc):\n if app.config.get(\"READ_ONLY_MODE\", False) and app.config.get(\"SCRIPTS_READ_ONLY_MODE\", False):\n app.logger.warn(\"System is in READ-ONLY mode, update command cannot run\")\n return\n\n return requests.post(self.target() + self.id + \"/_update\", data=json.dumps({\"doc\": doc}))","def put(self):\n if 'file' not in self.request.POST:\n self.request.errors.add('body', 'file', 'Not Found')\n self.request.errors.status = 404\n return\n tender = TenderDocument.load(self.db, self.tender_id)\n if not tender:\n self.request.errors.add('url', 'tender_id', 'Not Found')\n self.request.errors.status = 404\n return\n data = self.request.POST['file']\n bids = [i for i in tender.bids if i.id == self.bid_id]\n if not bids:\n self.request.errors.add('url', 'bid_id', 'Not Found')\n self.request.errors.status = 404\n return\n bid = bids[0]\n documents = [i for i in bid.documents if i.id == self.request.matchdict['id']]\n if not documents:\n self.request.errors.add('url', 'id', 'Not Found')\n self.request.errors.status = 404\n return\n src = tender.serialize(\"plain\")\n document = Document()\n document.id = self.request.matchdict['id']\n document.title = data.filename\n document.format = data.type\n document.datePublished = documents[0].datePublished\n key = uuid4().hex\n document.url = self.request.route_url('Tender Bid Documents', tender_id=self.tender_id, bid_id=self.bid_id, id=document.id, _query={'download': key})\n bid.documents.append(document)\n filename = \"{}_{}\".format(document.id, key)\n tender['_attachments'][filename] = {\n \"content_type\": data.type,\n \"data\": b64encode(data.file.read())\n }\n patch = make_patch(tender.serialize(\"plain\"), src).patch\n tender.revisions.append(revision({'changes': patch}))\n try:\n tender.store(self.db)\n except Exception, e:\n return self.request.errors.add('body', 'data', str(e))\n return {'data': document.serialize(\"view\")}","def update(self, es, **kwargs):\n pass","def _put(self, name, document):\n raise NotImplementedError","def test_update_occurrence(self):\n pass","def patch(self):\n if not self.validate_complaint_document(\"update\"):\n return\n if apply_patch(self.request, src=self.request.context.serialize()):\n update_file_content_type(self.request)\n self.LOGGER.info(\n \"Updated tender award complaint document {}\".format(self.request.context.id),\n extra=context_unpack(self.request, {\"MESSAGE_ID\": \"tender_award_complaint_document_patch\"}),\n )\n return {\"data\": self.request.context.serialize(\"view\")}","def oe_update(self, cr, uid, external_session, existing_rec_id, vals, resource, defaults, context=None):\n if context is None: context={}\n context['referential_id'] = external_session.referential_id.id #did it's needed somewhere?\n return self.write(cr, uid, existing_rec_id, vals, context)","def test_queryset_update(self):\n car = Car.objects.all()\n car.index_to_appsearch(update_only=True)\n # Note that the app search chunk size is set to 5 in `tests.settings`\n # Therefore you should see 5 calls to cover 22 documents\n self.assertEqual(self.client_update.call_count, 5)","def updateDocument(self, document):\n data = self.updateDocumentAll([document])\n try:\n return data[0]\n except: pass","def update( ):\r\n pass","def update(self, *args, **kwargs):","def update_records(self, something):\n print(\"Some logic (not shown) to update database of units\")","def update_relevant(query_string, doc_id, corpus):\n #TODO update to toggle relevance (add/remove from relevent or nonrelevant lists)\n relevance_dict = get_relevance_dict(corpus)\n if relevance_dict.get(query_string):\n #toggle\n print(query_string + ' relevance toggled ' + corpus + str(doc_id))\n relevance_dict[query_string] = toggle_relevance(relevance_dict[query_string], doc_id)\n else:\n print(query_string + ' not in dict yet')\n #add_to_dict either after determine if relevent or non relevant\n #create tuple with doc_id in relevant list\n relevance_dict[query_string] = [doc_id], []\n write_relevance_tocsv(relevance_dict, corpus)","def _index_doc(self, db, doc_id):\n doc = db.get(doc_id)\n if doc is None:\n log.warning(\"Unable to find document in database: '%s'\" % doc_id)\n return\n fields = doc.get('solr_fields')\n fields = [\"payload\", \"timesaved\"]\n if not fields:\n log.debug(\"Document '%s' does not define solr_fields\" % doc_id)\n return\n updates = []\n for field in fields:\n if doc.has_key(field):\n self.__normalize(updates, field, doc[field])\n updates.extend([{'type' : 'any'}, {'_id' : doc_id}])\n return updates","def update_documents(self, engine_name, documents):\n endpoint = \"engines/{}/documents\".format(engine_name)\n data = json.dumps(documents)\n\n return self.swiftype_session.request('patch', endpoint, data=data)","def test_update_documents_json(index_with_documents, small_movies_json_file):\n index = index_with_documents()\n response = index.update_documents_json(small_movies_json_file)\n assert isinstance(response, TaskInfo)\n assert response.task_uid is not None\n task = index.wait_for_task(response.task_uid)\n assert task.status == \"succeeded\"\n assert index.get_primary_key() == \"id\"","def test_update_with_overwrite(self):\n u = stellr.UpdateCommand(TEST_HTTP)\n u.add_documents({'a': 1}, overwrite=False)\n self.assertEqual(\n u.body, '{\"add\": {\"doc\": {\"a\": 1}, \"overwrite\": false}}')","def _mark(self, query, doc):\n raise NotImplementedError()","def upgrade_to_21():\n\n def update_project_template(template):\n new_template = {'acquisitions': []}\n for a in template.get('acquisitions', []):\n new_a = {'minimum': a['minimum']}\n properties = a['schema']['properties']\n if 'measurement' in properties:\n m_req = properties['measurement']['pattern']\n m_req = re.sub('^\\(\\?i\\)', '', m_req)\n new_a['files']=[{'measurement': m_req, 'minimum': 1}]\n if 'label' in properties:\n l_req = properties['label']['pattern']\n l_req = re.sub('^\\(\\?i\\)', '', l_req)\n new_a['label'] = l_req\n new_template['acquisitions'].append(new_a)\n\n return new_template\n\n def dm_v2_updates(cont_list, cont_name):\n for container in cont_list:\n\n query = {'_id': container['_id']}\n update = {'$rename': {'metadata': 'info'}}\n\n if cont_name == 'projects' and container.get('template'):\n new_template = update_project_template(json.loads(container.get('template')))\n update['$set'] = {'template': new_template}\n\n\n if cont_name == 'sessions':\n update['$rename'].update({'subject.metadata': 'subject.info'})\n\n\n measurement = None\n modality = None\n info = None\n if cont_name == 'acquisitions':\n update['$unset'] = {'instrument': '', 'measurement': ''}\n measurement = container.get('measurement', None)\n modality = container.get('instrument', None)\n info = container.get('metadata', None)\n if info:\n config.db.acquisitions.update_one(query, {'$set': {'metadata': {}}})\n\n\n # From mongo docs: '$rename does not work if these fields are in array elements.'\n files = container.get('files')\n if files is not None:\n updated_files = []\n for file_ in files:\n file_['info'] = {}\n if 'metadata' in file_:\n file_['info'] = file_.pop('metadata', None)\n if 'instrument' in file_:\n file_['modality'] = file_.pop('instrument', None)\n if measurement:\n # Move the acquisition's measurement to all files\n if file_.get('measurements'):\n file_['measurements'].append(measurement)\n else:\n file_['measurements'] = [measurement]\n if info and file_.get('type', '') == 'dicom':\n # This is going to be the dicom header info\n updated_info = info\n updated_info.update(file_['info'])\n file_['info'] = updated_info\n if modality and not file_.get('modality'):\n file_['modality'] = modality\n\n updated_files.append(file_)\n if update.get('$set'):\n update['$set']['files'] = updated_files\n else:\n update['$set'] = {'files': updated_files}\n\n result = config.db[cont_name].update_one(query, update)\n\n query = {'$or':[{'files.metadata': { '$exists': True}},\n {'metadata': { '$exists': True}},\n {'files.instrument': { '$exists': True}}]}\n\n dm_v2_updates(config.db.collections.find(query), 'collections')\n\n query['$or'].append({'template': { '$exists': True}})\n dm_v2_updates(config.db.projects.find({}), 'projects')\n\n query['$or'].append({'subject': { '$exists': True}})\n dm_v2_updates(config.db.sessions.find(query), 'sessions')\n\n query['$or'].append({'instrument': { '$exists': True}})\n query['$or'].append({'measurement': { '$exists': True}})\n dm_v2_updates(config.db.acquisitions.find(query), 'acquisitions')","def update(self, *args, **kwargs): \n kwargs[\"sampleID\"] = self.__sampleID\n kwargs[\"sampleMetaID\"] = self.id()\n self._eLABJournalObject__api.update_sample_meta(*list(args), **dict(kwargs))\n rp = self._eLABJournalObject__api._request(\"/api/v1/samples/\"+urllib.parse.quote(str(kwargs[\"sampleID\"]))+\"/meta/\"+urllib.parse.quote(str(kwargs[\"sampleMetaID\"])), \"get\", {})\n #check and get\n if (rp is not None) & (type(rp) == dict):\n self.__init__(self._eLABJournalObject__api,kwargs[\"sampleID\"],rp) \n else:\n print(dict)\n raise Exception(\"couldn't perform selfupdate\")","def collection_post(self):\n return super(TenderAwardDocumentResource, self).collection_post()","def testUpdateFailedDoc(self):\n change = ChangeState(self.config, \"changestate_t\")\n\n locationAction = self.daoFactory(classname=\"Locations.New\")\n locationAction.execute(\"site1\", pnn=\"T2_CH_CERN\")\n\n testWorkflow = Workflow(spec=self.specUrl, owner=\"Steve\",\n name=\"wf001\", task=self.taskName)\n testWorkflow.create()\n testFileset = Fileset(name=\"TestFileset\")\n testFileset.create()\n testSubscription = Subscription(fileset=testFileset,\n workflow=testWorkflow,\n split_algo=\"FileBased\")\n testSubscription.create()\n\n testFileA = File(lfn=\"SomeLFNA\", events=1024, size=2048,\n locations=set([\"T2_CH_CERN\"]))\n testFileA.create()\n testFileset.addFile(testFileA)\n testFileset.commit()\n\n splitter = SplitterFactory()\n jobFactory = splitter(package=\"WMCore.WMBS\",\n subscription=testSubscription)\n jobGroup = jobFactory(files_per_job=1)[0]\n\n testJobA = jobGroup.jobs[0]\n testJobA[\"user\"] = \"sfoulkes\"\n testJobA[\"group\"] = \"DMWM\"\n testJobA[\"taskType\"] = \"Merge\"\n testJobA[\"couch_record\"] = str(testJobA[\"id\"])\n\n change.propagate([testJobA], \"new\", \"none\")\n testJobADoc = change.jobsdatabase.document(testJobA[\"couch_record\"])\n\n self.assertTrue(\"states\" in testJobADoc)\n self.assertTrue(\"1\" in testJobADoc[\"states\"])\n\n testFileB = File(lfn=\"SomeLFNB\", events=1024, size=2048,\n locations=set([\"T2_CH_CERN\"]))\n testFileB.create()\n testFileset.addFile(testFileB)\n testFileset.commit()\n\n splitter = SplitterFactory()\n jobFactory = splitter(package=\"WMCore.WMBS\",\n subscription=testSubscription)\n jobGroup = jobFactory(files_per_job=1)[0]\n\n testJobB = jobGroup.jobs[0]\n testJobB[\"user\"] = \"sfoulkes\"\n testJobB[\"group\"] = \"DMWM\"\n testJobB[\"taskType\"] = \"Merge\"\n testJobB[\"couch_record\"] = newstr(testJobB[\"id\"])\n\n change.propagate([testJobB], \"new\", \"none\")\n testJobBDoc = change.jobsdatabase.document(testJobB[\"couch_record\"])\n\n self.assertTrue(\"states\" in testJobBDoc)\n self.assertTrue(\"1\" in testJobBDoc[\"states\"])\n return","def test_update_documents_ndjson(index_with_documents, songs_ndjson):\n index = index_with_documents()\n response = index.update_documents_ndjson(songs_ndjson)\n assert isinstance(response, TaskInfo)\n assert response.task_uid is not None\n task = index.wait_for_task(response.task_uid)\n assert task.status == \"succeeded\"\n assert index.get_primary_key() == \"id\"","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def test_update_transcript(self):\n response = self.client.post(reverse('update-transcript',\n args=[self.gel_ir.id,\n self.proband_variant.id,\n self.transcript2.id]),\n follow=True)\n self.assertContains(response, 'Transcript Updated')\n self.assertEquals(response.status_code, 200)\n response = self.client.get(reverse('proband-view', args=[self.gel_ir.id]))\n self.assertContains(response, self.transcript2.name)","def Regen(self,enum):\n\t\tself.acad.ActiveDocument.Regen(enum)","def update(self, spec, document, upsert=False, multi=False):\n return self.database.connection.request.update_documents(\n self.database.name, self.name, spec, document, upsert, multi)","def add_doc(writer, entry):\n m = 0\n q_id = entry['Id']\n snippets = get_possible_snippets(q_id, False)\n for code, lang, ans_id in snippets:\n writer.add_document(question_id=q_id, answer_id=ans_id, code=return_unicode(code), language=return_unicode(lang))\n m += 1\n return m","def test_update(self):\n u = stellr.UpdateCommand(TEST_HTTP, commit_within=60000)\n self.assertEqual(u.host, 'http://localhost:8983')\n self.assertEqual(u._handler, ('/solr/update/json?'\n 'wt=json&commitWithin=60000'))\n\n a = SimpleObject(DOCUMENTS[0][0], DOCUMENTS[0][1], DOCUMENTS[0][2])\n u.add_documents(a)\n\n b = dict()\n for i, field in enumerate(FIELDS):\n b[field] = DOCUMENTS[1][i]\n u.add_documents(b)\n\n self.assertEqual(len(u._commands), 2)\n for i, comm in enumerate(u._commands):\n self.assertEqual(comm[0], 'add')\n self.assertTrue('doc' in comm[1])\n for field, value in comm[1]['doc'].iteritems():\n field_ord = FIELDS.index(field)\n self.assertEqual(DOCUMENTS[i][field_ord], value)","def update_filedetails_ajax(request):\n try:\n document_id = request.GET.get('document_id')\n tag = request.GET.get('tag')\n get_index = find_index_with_document(document_id)\n updated_data = update(get_index, document_id, tag)\n return JsonResponse({\"fs_metadata\": updated_data, \"message\": \"Success\", \"status_code\": \"200\"})\n except Exception as e:\n print(\"Update Error : \", e)\n return False","def update():","def update():","def update(self, docs: DocumentArray, *args, **kwargs):\n cursor = self.connection.cursor()\n psycopg2.extras.execute_batch(\n cursor,\n f'UPDATE {self.table} SET DOC = %s WHERE ID = %s',\n [\n (\n doc.SerializeToString(),\n doc.id,\n )\n for doc in docs\n ],\n )\n self.connection.commit()","def update(self, data):\n self.data = data\n # extract data\n subject = data.identifier\n self.id = _uri_to_oai(subject)\n self.modified = datetime.utcnow()\n self.deleted = False\n\n itemtype, subtype = _get_itemtype(data, subject)\n\n self.metadata = {}\n\n # fixed fields:\n self.metadata['rif_key'] = _uri_to_key(subject)\n self.metadata['rif_group'] = self.provider.groupDescription\n self.metadata['rif_originatingSource'] = self.provider.originatingSource\n self.metadata['rif_object'] = {'value': itemtype,\n 'type': subtype,\n #'dateModified': '',\n }\n\n if itemtype == 'collection':\n self.updateCollection(data, subject)\n elif itemtype == 'party':\n if subtype == 'person':\n self.updatePartyPerson(data, subject)\n else:\n self.updateParty(data, subject)\n elif itemtype == 'activity':\n self.updateActivity(data, subject)\n elif itemtype == 'service':\n self.updateService(data, subject)","def test_kyc_put_document_shareholder(self):\n pass","def update(*args):","def test_update_with_field_boost(self):\n u = stellr.UpdateCommand(TEST_HTTP)\n u.add_documents({'a': { 'value': 'f', 'boost': 2.0}})\n self.assertEqual(u.body, ('{\"add\": {\"doc\": {\"a\": '\n '{\"boost\": 2.0, \"value\": \"f\"}}}}'))","def updateDoc(self, path):\n self.db.setDb(self.db_file)\n \n if not self.authd:\n self._authorize()\n \n db_row = self.db.getRowFromPath(path)\n if not db_row:\n return False\n \n resource_id = db_row[0]\n etag = db_row[1]\n title = db_row[2]\n \n ms = gdata.data.MediaSource(file_path=path, content_type=MIMETYPES['ODT'])\n doc = self.client.GetDoc(resource_id.replace(':', '%3A'))\n new_version = self.client.Update(doc, media_source=ms)\n print 'Document pushed:', new_version.GetAlternateLink().href\n \n self.db.resetEtag(new_version)","def m_req_Update(self, sender, e):\r\n if e.Instrument != None and e.Error == None:\r\n # Instrument was found\r\n print(\"Found: {0}\".format(e.Instrument.Name))\r\n # Subscribe for Inside Market Data\r\n self.m_ps = ttapi.PriceSubscription(e.Instrument, ttapi.Dispatcher.Current)\r\n self.m_ps.Settings = ttapi.PriceSubscriptionSettings(ttapi.PriceSubscriptionType.InsideMarket)\r\n self.m_ps.FieldsUpdated += self.m_ps_FieldsUpdated\r\n self.m_ps.Start()\r\n elif e.IsFinal:\r\n # Instrument was not found and TT API has given up looking for it\r\n print(\"Cannot find instrument: {0}\".format(e.Error.Message))\r\n self.Dispose()","def update_qualification(qual_id: int) -> Dict[str, Any]:\n qualification_schema = QualificationSchema()\n qualification = qualification_schema.load(request.json)\n if qualification[\"id\"] != qual_id:\n raise APIError(reason=\"incorrect_id\", status_code=400)\n\n if Qualification.query.filter_by(id=qual_id).count() < 1:\n raise APIError(reason=\"no_such_object\", status_code=400)\n\n qualification_obj = Qualification.query.get(qual_id)\n\n try:\n qualification_obj.name = qualification[\"name\"]\n db.session.commit()\n except IntegrityError:\n raise APIError(reason=\"qualification_exists\", status_code=400)\n\n return cast(Dict[str, Any], qualification)","def update_transcript_info(ensembl_info, word, value):\n if \"transcript\" in word:\n if \"id\" in word:\n ensembl_info[\"ensembl_transcript_id\"] = value\n elif \"start\" in word:\n ensembl_info[\"transcript_start\"] = int(value)\n elif \"end\" in word:\n ensembl_info[\"transcript_end\"] = int(value)\n return ensembl_info","def test_model_object_update(self):\n car = Car.objects.first()\n car.index_to_appsearch(update_only=True)\n self.assertEqual(self.client_update.call_count, 1)","def update_document(obj):\n index = obj.get_index_name()\n doc_type = obj.get_document_type()\n body = dict(doc=obj.get_document_body())\n try:\n ES.update(index=index, doc_type=doc_type, body=body, id=obj.pk)\n except NotFoundError:\n raise DocumentNotFound(obj.get_index_name(), obj.pk)","def update(self, *args, **kwargs):\n pass","def update(self, *args, **kwargs):\n pass","def update(self, *args, **kwargs):\n pass","def updateAnnoByMetadata(syn, synId, metaDf, refCol, cols2Add,fileExts):\n \n if type(synId) is list:\n print \"Input is a list of Synapse IDs \\n\"\n for synID in synId:\n print \"Getting File %s ...\" % synID\n temp = syn.get(synID,downloadFile = False)\n _helperUpdateAnnoByMetadata(syn,temp,metaDf,refCol,cols2Add,fileExts)\n else:\n print \"Input is a Synpase ID \\n\"\n starting = syn.get(synId,downloadFile = False)\n if not is_container(starting):\n print \"%s is a File \\n\" % synId\n _helperUpdateAnnoByMetadata(syn,starting,metaDf,refCol,cols2Add,fileExts)\n else:\n directory = synu.walk(syn,synId)\n for dirpath,dirname,filename in directory:\n for i in filename:\n temp = syn.get(i[1],downloadFile = False)\n print \"Getting File %s ...\" % i[1]\n _helperUpdateAnnoByMetadata(syn,temp,metaDf,refCol,cols2Add,fileExts)","def test_partial_update_metadata1(self):\n pass","def savedoc():\r\n document.save('QSDoc_{0}_{1}_{2}_{3}.docx'.format(args.server, year, month, day))","def merge_docs(self):","def test_update_record(self):\n pass","def update_index(self, document):\n\t\tix = self.get_index()\n\n\t\twith ix.searcher():\n\t\t\twriter = AsyncWriter(ix)\n\t\t\twriter.delete_by_term(self.id, document[self.id])\n\t\t\twriter.add_document(**document)\n\t\t\twriter.commit(optimize=True)","def test_partial_update_metadata(self):\n pass","def update_docs():\n managepy('update_docs', site='docs')","def updatePublicationFromSymplectic(publication_object):\r\n #description \r\n #checking\r\n if not(publication_object) or (publication_object.guid == ''):\r\n return \r\n #symplectic api url and local file path\r\n url = SYMPLECTIC_API_URL + 'publications/' + publication_object.guid\r\n tmp_filename = SYMPLECTIC_LOCAL_XML_FOLDER + SYMPLECTIC_LOCAL_PUBS_FOLDER + publication_object.guid + '.xml'\r\n #get xml document from symplectic api and store on hd\r\n (tmp_filename, http_headers,) = urllib.urlretrieve(url, tmp_filename)\r\n #parse xml file\r\n pub_etree = ElementTree(file=tmp_filename)\r\n #delete local file from hd\r\n #try:\r\n os.remove(tmp_filename)\r\n #except:\r\n #pass \r\n #++++++PUBLICATION++++++\r\n #publication element\r\n pub_element = pub_etree.getroot()\r\n #no loading-of/blank publication object required as updating the one passed in\r\n #check returned xml element is valid and for correct publication\r\n if pub_element is None:\r\n return\r\n elif publication_object.guid != pub_element.get('id',''):\r\n return\r\n #publication attributes\r\n if pub_element is not None:\r\n publication_object.new_id = pub_element.get('new-id')\r\n if pub_element.get('is-deleted','false') == 'true':\r\n publication_object.is_deleted = True\r\n else:\r\n publication_object.is_deleted = False\r\n publication_object.type = pub_element.get('type','')\r\n publication_object.created_when = pub_element.get('created-when','')\r\n publication_object.last_modified_when = pub_element.get('last-modified-when','')\r\n #just fetched latest version from symplectic\r\n publication_object.needs_refetch = False\r\n #save updated publication object\r\n publication_object.save()\r\n #++++++BIBLIOGRAPHIC-RECORD++++++\r\n #bibliographic-record elements are held in a subtree\r\n biblio_subtree = pub_etree.find(SYMPLECTIC_NAMESPACE + 'bibliographic-records')\r\n #check if any bibliographic-record elements in subtree\r\n if biblio_subtree is None or len(biblio_subtree) < 1:\r\n return\r\n #for each bibliographic-record element in subtree\r\n for biblio_element in biblio_subtree.getchildren():\r\n SymplecticXMLPubs.__createBiblioObjFromBiblioElement(biblio_element, publication_object)","def update_existing(doc_data_tples):\n def per_doc(doc, data_tples):\n def per_field(data_tple):\n field, datas = data_tple\n map(_do_append_field(doc, field), datas)\n map(per_field, data_tples)\n return doc\n\n __docs = ( (per_doc(doc, data_tples), data_tples) for doc,data_tples in doc_data_tples )\n return __docs","def run():\n\n #django patient -> django_uuid = new\n #cpatient-> doc_id = case_id, doc_id = new, == to djpatient.django_uuid\n\n #this needs to be coupled with fixing up the patient/all querying\n #patient/all needs to emit the case_id\n patients = Patient.objects.all()\n db = get_db()\n for p in patients:\n print \"Flipping ID Patient ID: %s: Couchdoc: %s\" % (p.id, p.doc_id)\n #so the p.couchdoc is useless here because if the model code is changed we need to do it manually.\n\n #establish the updated ids and get them separated out\n real_case_id = p.doc_id + \"\" #the doc_id had been used as the case_id which in real casexml, that's bad.\n new_doc_id = uuid.uuid1().hex #now make a new doc_id for the patient document.\n\n couchdoc = db.open_doc(p.doc_id)\n\n #flip the document ids.\n copy_doc = PactPatient.wrap(couchdoc)\n copy_doc.case_id = real_case_id\n copy_doc._id = new_doc_id\n copy_doc.doc_type = PactPatient.__name__\n copy_doc.save()\n p.doc_id = new_doc_id\n p._couchdoc = copy_doc\n p.save()\n print \"\\tSwapping case id %s -> %s\" % (real_case_id, new_doc_id)\n\n #having just saved it, we need to now remove the original id\n dupe_doc = db.open_doc(real_case_id) #the old doc_id\n delresult = db.delete_doc(dupe_doc)\n print \"\\tDeleting doc %s\" % (real_case_id)\n print \"\\t%s\" % (delresult)\n\n i = 0\n while db.doc_exist(real_case_id):\n i+= 1\n print \"\\tTrying to freaking delete!!!\"\n print \"\\tReally deleting doc %s\" % (real_case_id)\n delresult = db.delete_doc(dupe_doc)\n print \"\\t%s\" % (delresult)\n if i == 10:\n break","def obj_update(self, bundle, **kwargs):\n logger.info(\"Updating acknowledgement...\")\n \n bundle = super(AcknowledgementResource, self).obj_update(bundle, **kwargs)\n \n bundle.obj.create_and_upload_pdfs()\n \n return bundle","def update(self, index, id, **kwargs):\n url = f'{self.host}{index}/_doc/{id}/_update'\n data = {'doc': {**kwargs}}\n requests.post(url, json=data)\n self.flush(index)\n return self.get(index, id)","def update(db, spec, doc):\n resp = db.sole.sole.update(spec, doc, upsert=False, safe=True)\n if (resp.get('updatedExisting') == False):\n return False\n return True","def update(self) -> None:\n ...","def test_update_enrollment_term(self):\n # This method utilises the PUT request method and will make changes to the Canvas instance. This needs consideration.\n pass","def updateUniqueID(self, updateAll=False):\n fieldsFound = False\n for format in self.values():\n if format.findUniqueIDFields():\n fieldsFound = True\n if updateAll and fieldsFound:\n globalref.docRef.root.setDescendantUniqueID()","def test_audiobook_can_update(self):\n\n data = {\n \"audiotype\": \"Audiobook\",\n \"metadata\": {\n \"title\": \"audiobook1\",\n \"duration\": 45678,\n \"author\": \"Solomon\",\n \"narrator\": \"Aniefiok\"\n }\n }\n\n num = str(3)\n\n response = requests.put(\n \"http://localhost:9001/api/update-audio/Audiobook/\"+num, json=data)\n\n self.assertEqual(response.status_code, 200)"],"string":"[\n \"def update_document(self):\\n pass\",\n \"def edit_document():\",\n \"def patch(self):\\n if apply_patch(self.request, src=self.request.context.serialize()):\\n update_file_content_type(self.request)\\n self.LOGGER.info(\\n \\\"Updated tender qualification document {}\\\".format(self.request.context.id),\\n extra=context_unpack(self.request, {\\\"MESSAGE_ID\\\": \\\"tender_qualification_document_patch\\\"}),\\n )\\n return {\\\"data\\\": self.request.context.serialize(\\\"view\\\")}\",\n \"def update_knowledge(self):\\n pass\",\n \"def tests_ti_document_update(self, request: FixtureRequest):\\n super().group_update(request)\",\n \"def test_client_verification_document_update(self):\\n pass\",\n \"def test_update(self):\\n doc_fields = document_fields.DocumentFields({\\n 'foo@': 'bar',\\n })\\n self.assertEquals('bar', doc_fields['foo'])\\n doc_fields.update({\\n 'foo@': 'bbq',\\n })\\n self.assertEquals('bbq', doc_fields['foo'])\",\n \"def update_doc(doc):\\n doc.long_name = \\\"X\\\"\",\n \"def add_doc_to_get(self,action,update_spec,action_buffer_index):\\n doc = {'_index' : action['_index'],\\n '_type' : action['_type'],\\n '_id' : action['_id']}\\n self.doc_to_get.append((doc,update_spec,action_buffer_index))\",\n \"def test_client_verification_document_partial_update(self):\\n pass\",\n \"def patch(self):\\n return super(TenderAwardDocumentResource, self).patch()\",\n \"def document_update(index_name, doc_type, doc_id, doc=None, new=None):\\n if doc:\\n resp = es.index(index=index_name, doc_type=doc_type,\\n id=doc_id, body=doc)\\n print(resp)\\n else:\\n resp = es.update(index=index_name, doc_type=doc_type,\\n id=doc_id, body={\\\"doc\\\": new})\",\n \"def update(get_index, document_id, tag): \\n client, index_name = connection_es()\\n res = client.update(index = get_index, doc_type = 'nvisnx', id = document_id, body= {\\\"doc\\\" : {\\\"tag\\\": tag}})\\n return res\",\n \"def test_update_documents(index_with_documents, small_movies):\\n index = index_with_documents()\\n response = index.get_documents()\\n doc = response.results[0]\\n doc.title = \\\"Some title\\\"\\n\\n update = index.update_documents([dict(doc)])\\n\\n assert isinstance(update, TaskInfo)\\n assert update.task_uid is not None\\n index.wait_for_task(update.task_uid)\\n\\n response = index.get_document(doc.id)\\n assert response.title == \\\"Some title\\\"\\n\\n update = index.update_documents(small_movies)\\n index.wait_for_task(update.task_uid)\\n\\n response = index.get_document(doc.id)\\n assert response.title != \\\"Some title\\\"\",\n \"def put(self):\\n if not self.validate_complaint_document(\\\"update\\\"):\\n return\\n document = upload_file(self.request)\\n document.author = self.request.authenticated_role\\n self.request.validated[\\\"complaint\\\"].documents.append(document)\\n if save_tender(self.request):\\n self.LOGGER.info(\\n \\\"Updated tender award complaint document {}\\\".format(self.request.context.id),\\n extra=context_unpack(self.request, {\\\"MESSAGE_ID\\\": \\\"tender_award_complaint_document_put\\\"}),\\n )\\n return {\\\"data\\\": document.serialize(\\\"view\\\")}\",\n \"def test_kyc_put_document(self):\\n pass\",\n \"def updateAnnoByIdDictFromMeta(syn,idDict,metaDf,refCol,fileExts):\\n for key in idDict:\\n print \\\"updating annotaion values for key: %s\\\" % key\\n for synId in idDict[key]:\\n print \\\"> %s\\\" %synId\\n temp = syn.get(synId, downloadFile = False)\\n exts = ')|('.join(fileExts)\\n exts = r'(' + exts + ')'\\n tempName = re.sub(exts,\\\"\\\",temp.name)\\n row = df.loc[df[refCol] == tempName]\\n temp[key] = map(str,row[key])[0]\\n temp = syn.store(temp,forceVersion = False)\\n print \\\"\\\"\",\n \"def put(self):\\n return super(TenderAwardDocumentResource, self).put()\",\n \"def update_document(self, type: Type, id: str,\\n new_data: Dict[str, Any]) -> None:\\n if collection := self.client.collection(f'{type}'):\\n if document_ref := collection.document(document_id=id):\\n if document_ref.get().exists:\\n document_ref.update(new_data)\\n else:\\n document_ref.create(new_data)\",\n \"def document(self):\\n ...\",\n \"def patch(self):\\n return super(TenderAwardContractDocumentResource, self).patch()\",\n \"def _helperUpdateAnnoByMetadata(syn,temp,metaDf,refCol,cols2Add,fileExts):\\n \\n print \\\"Updating annotations by metadata...\\\"\\n \\n exts = ')|('.join(fileExts)\\n exts = r'(' + exts + ')'\\n tempName = re.sub(exts,\\\"\\\",temp.name)\\n \\n row = df.loc[df[refCol] == tempName]\\n if row.empty:\\n print \\\"missing metadata\\\"\\n else:\\n for colName in cols2Add:\\n print \\\"> %s \\\" % colName\\n temp[colName] = map(str,row[colName])[0]\\n temp = syn.store(temp, forceVersion = False)\\n print \\\"\\\"\",\n \"def _update_documents(self):\\n if self.campaigns.active():\\n top_ranked_documents = utils._rank_documents(self.event)\\n # [TODO] this is a kludge\\n if set(top_ranked_documents) == set(self.documents.all()):\\n return False\\n print('[DEBUG] Docs changed! New campaign ahoy!')\\n self.documents = top_ranked_documents\\n return True\",\n \"def collection_post(self):\\n document = upload_file(self.request)\\n document.author = self.request.authenticated_role\\n self.context.documents.append(document)\\n if save_tender(self.request):\\n self.LOGGER.info(\\n \\\"Created tender qualification document {}\\\".format(document.id),\\n extra=context_unpack(\\n self.request, {\\\"MESSAGE_ID\\\": \\\"tender_qualification_document_create\\\"}, {\\\"document_id\\\": document.id}\\n ),\\n )\\n self.request.response.status = 201\\n document_route = self.request.matched_route.name.replace(\\\"collection_\\\", \\\"\\\")\\n self.request.response.headers[\\\"Location\\\"] = self.request.current_route_url(\\n _route_name=document_route, document_id=document.id, _query={}\\n )\\n return {\\\"data\\\": document.serialize(\\\"view\\\")}\",\n \"def spot_doc_rubrics2(doc_id, rubrics):\\n db.doc_apply(doc_id, spot_doc_rubrics, rubrics)\",\n \"def on_doctype_update():\\n\\tfrappe.db.add_index(\\\"Make Serial NO\\\", [\\\"item\\\", \\\"batch\\\"])\",\n \"def _update(self, count=True, forced=False):\",\n \"def after_insert(self):\\n if self.get('update_request') and not self.is_pending_approval():\\n self.update_request.created_docname = self.name\\n self.set_as_success()\",\n \"def test_update_with_document_boost(self):\\n u = stellr.UpdateCommand(TEST_HTTP)\\n u.add_documents({'a': 1}, boost=2.0)\\n self.assertEqual(u.body, '{\\\"add\\\": {\\\"doc\\\": {\\\"a\\\": 1}, \\\"boost\\\": 2.0}}')\",\n \"def put(self):\\n return super(TenderAwardContractDocumentResource, self).put()\",\n \"def put(self, request, code, suggested_format=None):\\n context = {'request': request}\\n conten_type = request.content_type\\n uploaded_obj = None\\n if 'multipart/form-data' in conten_type:\\n # We have a file upload encoded with multipart/form-data\\n file_content = StringIO(request.body)\\n parser = MultiPartParser()\\n dnf = parser.parse(file_content, media_type=conten_type, parser_context=context)\\n extra = dnf.data\\n if 'file' in dnf.files:\\n uploaded_obj = dnf.files['file']\\n else:\\n extra = request.QUERY_PARAMS\\n # TODO: do we require SQL tagging logic in this API call?\\n sql_tag_string = extra.get('tag_string', None)\\n sql_remove_tag_string = extra.get('remove_tag_string', None)\\n new_name = extra.get('new_name', None)\\n new_type = extra.get('new_type', None)\\n index_data = extra.get('indexing_data', None)\\n if index_data:\\n index_data = json.loads(index_data)\\n processor = DocumentProcessor()\\n options = {\\n 'tag_string': sql_tag_string,\\n 'remove_tag_string': sql_remove_tag_string,\\n 'extension': suggested_format,\\n 'new_name': new_name,\\n 'new_type': new_type,\\n 'new_indexes': index_data,\\n 'update_file': uploaded_obj,\\n 'user': request.user,\\n }\\n document = processor.update(code, options)\\n if len(processor.errors) > 0:\\n log.error('FileHandler.update manager errors %s' % processor.errors)\\n if settings.DEBUG:\\n print processor.errors\\n raise Exception('FileHandler.update manager errors')\\n else:\\n return Response(status=status.HTTP_400_BAD_REQUEST)\\n log.info('FileHandler.update request fulfilled for code: %s, extension: %s'\\n % (code, suggested_format))\\n resp = DMSOBjectRevisionsData(document).data\\n return Response(resp, status=status.HTTP_200_OK)\",\n \"def update(self, doc):\\n if app.config.get(\\\"READ_ONLY_MODE\\\", False) and app.config.get(\\\"SCRIPTS_READ_ONLY_MODE\\\", False):\\n app.logger.warn(\\\"System is in READ-ONLY mode, update command cannot run\\\")\\n return\\n\\n return requests.post(self.target() + self.id + \\\"/_update\\\", data=json.dumps({\\\"doc\\\": doc}))\",\n \"def put(self):\\n if 'file' not in self.request.POST:\\n self.request.errors.add('body', 'file', 'Not Found')\\n self.request.errors.status = 404\\n return\\n tender = TenderDocument.load(self.db, self.tender_id)\\n if not tender:\\n self.request.errors.add('url', 'tender_id', 'Not Found')\\n self.request.errors.status = 404\\n return\\n data = self.request.POST['file']\\n bids = [i for i in tender.bids if i.id == self.bid_id]\\n if not bids:\\n self.request.errors.add('url', 'bid_id', 'Not Found')\\n self.request.errors.status = 404\\n return\\n bid = bids[0]\\n documents = [i for i in bid.documents if i.id == self.request.matchdict['id']]\\n if not documents:\\n self.request.errors.add('url', 'id', 'Not Found')\\n self.request.errors.status = 404\\n return\\n src = tender.serialize(\\\"plain\\\")\\n document = Document()\\n document.id = self.request.matchdict['id']\\n document.title = data.filename\\n document.format = data.type\\n document.datePublished = documents[0].datePublished\\n key = uuid4().hex\\n document.url = self.request.route_url('Tender Bid Documents', tender_id=self.tender_id, bid_id=self.bid_id, id=document.id, _query={'download': key})\\n bid.documents.append(document)\\n filename = \\\"{}_{}\\\".format(document.id, key)\\n tender['_attachments'][filename] = {\\n \\\"content_type\\\": data.type,\\n \\\"data\\\": b64encode(data.file.read())\\n }\\n patch = make_patch(tender.serialize(\\\"plain\\\"), src).patch\\n tender.revisions.append(revision({'changes': patch}))\\n try:\\n tender.store(self.db)\\n except Exception, e:\\n return self.request.errors.add('body', 'data', str(e))\\n return {'data': document.serialize(\\\"view\\\")}\",\n \"def update(self, es, **kwargs):\\n pass\",\n \"def _put(self, name, document):\\n raise NotImplementedError\",\n \"def test_update_occurrence(self):\\n pass\",\n \"def patch(self):\\n if not self.validate_complaint_document(\\\"update\\\"):\\n return\\n if apply_patch(self.request, src=self.request.context.serialize()):\\n update_file_content_type(self.request)\\n self.LOGGER.info(\\n \\\"Updated tender award complaint document {}\\\".format(self.request.context.id),\\n extra=context_unpack(self.request, {\\\"MESSAGE_ID\\\": \\\"tender_award_complaint_document_patch\\\"}),\\n )\\n return {\\\"data\\\": self.request.context.serialize(\\\"view\\\")}\",\n \"def oe_update(self, cr, uid, external_session, existing_rec_id, vals, resource, defaults, context=None):\\n if context is None: context={}\\n context['referential_id'] = external_session.referential_id.id #did it's needed somewhere?\\n return self.write(cr, uid, existing_rec_id, vals, context)\",\n \"def test_queryset_update(self):\\n car = Car.objects.all()\\n car.index_to_appsearch(update_only=True)\\n # Note that the app search chunk size is set to 5 in `tests.settings`\\n # Therefore you should see 5 calls to cover 22 documents\\n self.assertEqual(self.client_update.call_count, 5)\",\n \"def updateDocument(self, document):\\n data = self.updateDocumentAll([document])\\n try:\\n return data[0]\\n except: pass\",\n \"def update( ):\\r\\n pass\",\n \"def update(self, *args, **kwargs):\",\n \"def update_records(self, something):\\n print(\\\"Some logic (not shown) to update database of units\\\")\",\n \"def update_relevant(query_string, doc_id, corpus):\\n #TODO update to toggle relevance (add/remove from relevent or nonrelevant lists)\\n relevance_dict = get_relevance_dict(corpus)\\n if relevance_dict.get(query_string):\\n #toggle\\n print(query_string + ' relevance toggled ' + corpus + str(doc_id))\\n relevance_dict[query_string] = toggle_relevance(relevance_dict[query_string], doc_id)\\n else:\\n print(query_string + ' not in dict yet')\\n #add_to_dict either after determine if relevent or non relevant\\n #create tuple with doc_id in relevant list\\n relevance_dict[query_string] = [doc_id], []\\n write_relevance_tocsv(relevance_dict, corpus)\",\n \"def _index_doc(self, db, doc_id):\\n doc = db.get(doc_id)\\n if doc is None:\\n log.warning(\\\"Unable to find document in database: '%s'\\\" % doc_id)\\n return\\n fields = doc.get('solr_fields')\\n fields = [\\\"payload\\\", \\\"timesaved\\\"]\\n if not fields:\\n log.debug(\\\"Document '%s' does not define solr_fields\\\" % doc_id)\\n return\\n updates = []\\n for field in fields:\\n if doc.has_key(field):\\n self.__normalize(updates, field, doc[field])\\n updates.extend([{'type' : 'any'}, {'_id' : doc_id}])\\n return updates\",\n \"def update_documents(self, engine_name, documents):\\n endpoint = \\\"engines/{}/documents\\\".format(engine_name)\\n data = json.dumps(documents)\\n\\n return self.swiftype_session.request('patch', endpoint, data=data)\",\n \"def test_update_documents_json(index_with_documents, small_movies_json_file):\\n index = index_with_documents()\\n response = index.update_documents_json(small_movies_json_file)\\n assert isinstance(response, TaskInfo)\\n assert response.task_uid is not None\\n task = index.wait_for_task(response.task_uid)\\n assert task.status == \\\"succeeded\\\"\\n assert index.get_primary_key() == \\\"id\\\"\",\n \"def test_update_with_overwrite(self):\\n u = stellr.UpdateCommand(TEST_HTTP)\\n u.add_documents({'a': 1}, overwrite=False)\\n self.assertEqual(\\n u.body, '{\\\"add\\\": {\\\"doc\\\": {\\\"a\\\": 1}, \\\"overwrite\\\": false}}')\",\n \"def _mark(self, query, doc):\\n raise NotImplementedError()\",\n \"def upgrade_to_21():\\n\\n def update_project_template(template):\\n new_template = {'acquisitions': []}\\n for a in template.get('acquisitions', []):\\n new_a = {'minimum': a['minimum']}\\n properties = a['schema']['properties']\\n if 'measurement' in properties:\\n m_req = properties['measurement']['pattern']\\n m_req = re.sub('^\\\\(\\\\?i\\\\)', '', m_req)\\n new_a['files']=[{'measurement': m_req, 'minimum': 1}]\\n if 'label' in properties:\\n l_req = properties['label']['pattern']\\n l_req = re.sub('^\\\\(\\\\?i\\\\)', '', l_req)\\n new_a['label'] = l_req\\n new_template['acquisitions'].append(new_a)\\n\\n return new_template\\n\\n def dm_v2_updates(cont_list, cont_name):\\n for container in cont_list:\\n\\n query = {'_id': container['_id']}\\n update = {'$rename': {'metadata': 'info'}}\\n\\n if cont_name == 'projects' and container.get('template'):\\n new_template = update_project_template(json.loads(container.get('template')))\\n update['$set'] = {'template': new_template}\\n\\n\\n if cont_name == 'sessions':\\n update['$rename'].update({'subject.metadata': 'subject.info'})\\n\\n\\n measurement = None\\n modality = None\\n info = None\\n if cont_name == 'acquisitions':\\n update['$unset'] = {'instrument': '', 'measurement': ''}\\n measurement = container.get('measurement', None)\\n modality = container.get('instrument', None)\\n info = container.get('metadata', None)\\n if info:\\n config.db.acquisitions.update_one(query, {'$set': {'metadata': {}}})\\n\\n\\n # From mongo docs: '$rename does not work if these fields are in array elements.'\\n files = container.get('files')\\n if files is not None:\\n updated_files = []\\n for file_ in files:\\n file_['info'] = {}\\n if 'metadata' in file_:\\n file_['info'] = file_.pop('metadata', None)\\n if 'instrument' in file_:\\n file_['modality'] = file_.pop('instrument', None)\\n if measurement:\\n # Move the acquisition's measurement to all files\\n if file_.get('measurements'):\\n file_['measurements'].append(measurement)\\n else:\\n file_['measurements'] = [measurement]\\n if info and file_.get('type', '') == 'dicom':\\n # This is going to be the dicom header info\\n updated_info = info\\n updated_info.update(file_['info'])\\n file_['info'] = updated_info\\n if modality and not file_.get('modality'):\\n file_['modality'] = modality\\n\\n updated_files.append(file_)\\n if update.get('$set'):\\n update['$set']['files'] = updated_files\\n else:\\n update['$set'] = {'files': updated_files}\\n\\n result = config.db[cont_name].update_one(query, update)\\n\\n query = {'$or':[{'files.metadata': { '$exists': True}},\\n {'metadata': { '$exists': True}},\\n {'files.instrument': { '$exists': True}}]}\\n\\n dm_v2_updates(config.db.collections.find(query), 'collections')\\n\\n query['$or'].append({'template': { '$exists': True}})\\n dm_v2_updates(config.db.projects.find({}), 'projects')\\n\\n query['$or'].append({'subject': { '$exists': True}})\\n dm_v2_updates(config.db.sessions.find(query), 'sessions')\\n\\n query['$or'].append({'instrument': { '$exists': True}})\\n query['$or'].append({'measurement': { '$exists': True}})\\n dm_v2_updates(config.db.acquisitions.find(query), 'acquisitions')\",\n \"def update(self, *args, **kwargs): \\n kwargs[\\\"sampleID\\\"] = self.__sampleID\\n kwargs[\\\"sampleMetaID\\\"] = self.id()\\n self._eLABJournalObject__api.update_sample_meta(*list(args), **dict(kwargs))\\n rp = self._eLABJournalObject__api._request(\\\"/api/v1/samples/\\\"+urllib.parse.quote(str(kwargs[\\\"sampleID\\\"]))+\\\"/meta/\\\"+urllib.parse.quote(str(kwargs[\\\"sampleMetaID\\\"])), \\\"get\\\", {})\\n #check and get\\n if (rp is not None) & (type(rp) == dict):\\n self.__init__(self._eLABJournalObject__api,kwargs[\\\"sampleID\\\"],rp) \\n else:\\n print(dict)\\n raise Exception(\\\"couldn't perform selfupdate\\\")\",\n \"def collection_post(self):\\n return super(TenderAwardDocumentResource, self).collection_post()\",\n \"def testUpdateFailedDoc(self):\\n change = ChangeState(self.config, \\\"changestate_t\\\")\\n\\n locationAction = self.daoFactory(classname=\\\"Locations.New\\\")\\n locationAction.execute(\\\"site1\\\", pnn=\\\"T2_CH_CERN\\\")\\n\\n testWorkflow = Workflow(spec=self.specUrl, owner=\\\"Steve\\\",\\n name=\\\"wf001\\\", task=self.taskName)\\n testWorkflow.create()\\n testFileset = Fileset(name=\\\"TestFileset\\\")\\n testFileset.create()\\n testSubscription = Subscription(fileset=testFileset,\\n workflow=testWorkflow,\\n split_algo=\\\"FileBased\\\")\\n testSubscription.create()\\n\\n testFileA = File(lfn=\\\"SomeLFNA\\\", events=1024, size=2048,\\n locations=set([\\\"T2_CH_CERN\\\"]))\\n testFileA.create()\\n testFileset.addFile(testFileA)\\n testFileset.commit()\\n\\n splitter = SplitterFactory()\\n jobFactory = splitter(package=\\\"WMCore.WMBS\\\",\\n subscription=testSubscription)\\n jobGroup = jobFactory(files_per_job=1)[0]\\n\\n testJobA = jobGroup.jobs[0]\\n testJobA[\\\"user\\\"] = \\\"sfoulkes\\\"\\n testJobA[\\\"group\\\"] = \\\"DMWM\\\"\\n testJobA[\\\"taskType\\\"] = \\\"Merge\\\"\\n testJobA[\\\"couch_record\\\"] = str(testJobA[\\\"id\\\"])\\n\\n change.propagate([testJobA], \\\"new\\\", \\\"none\\\")\\n testJobADoc = change.jobsdatabase.document(testJobA[\\\"couch_record\\\"])\\n\\n self.assertTrue(\\\"states\\\" in testJobADoc)\\n self.assertTrue(\\\"1\\\" in testJobADoc[\\\"states\\\"])\\n\\n testFileB = File(lfn=\\\"SomeLFNB\\\", events=1024, size=2048,\\n locations=set([\\\"T2_CH_CERN\\\"]))\\n testFileB.create()\\n testFileset.addFile(testFileB)\\n testFileset.commit()\\n\\n splitter = SplitterFactory()\\n jobFactory = splitter(package=\\\"WMCore.WMBS\\\",\\n subscription=testSubscription)\\n jobGroup = jobFactory(files_per_job=1)[0]\\n\\n testJobB = jobGroup.jobs[0]\\n testJobB[\\\"user\\\"] = \\\"sfoulkes\\\"\\n testJobB[\\\"group\\\"] = \\\"DMWM\\\"\\n testJobB[\\\"taskType\\\"] = \\\"Merge\\\"\\n testJobB[\\\"couch_record\\\"] = newstr(testJobB[\\\"id\\\"])\\n\\n change.propagate([testJobB], \\\"new\\\", \\\"none\\\")\\n testJobBDoc = change.jobsdatabase.document(testJobB[\\\"couch_record\\\"])\\n\\n self.assertTrue(\\\"states\\\" in testJobBDoc)\\n self.assertTrue(\\\"1\\\" in testJobBDoc[\\\"states\\\"])\\n return\",\n \"def test_update_documents_ndjson(index_with_documents, songs_ndjson):\\n index = index_with_documents()\\n response = index.update_documents_ndjson(songs_ndjson)\\n assert isinstance(response, TaskInfo)\\n assert response.task_uid is not None\\n task = index.wait_for_task(response.task_uid)\\n assert task.status == \\\"succeeded\\\"\\n assert index.get_primary_key() == \\\"id\\\"\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def test_update_transcript(self):\\n response = self.client.post(reverse('update-transcript',\\n args=[self.gel_ir.id,\\n self.proband_variant.id,\\n self.transcript2.id]),\\n follow=True)\\n self.assertContains(response, 'Transcript Updated')\\n self.assertEquals(response.status_code, 200)\\n response = self.client.get(reverse('proband-view', args=[self.gel_ir.id]))\\n self.assertContains(response, self.transcript2.name)\",\n \"def Regen(self,enum):\\n\\t\\tself.acad.ActiveDocument.Regen(enum)\",\n \"def update(self, spec, document, upsert=False, multi=False):\\n return self.database.connection.request.update_documents(\\n self.database.name, self.name, spec, document, upsert, multi)\",\n \"def add_doc(writer, entry):\\n m = 0\\n q_id = entry['Id']\\n snippets = get_possible_snippets(q_id, False)\\n for code, lang, ans_id in snippets:\\n writer.add_document(question_id=q_id, answer_id=ans_id, code=return_unicode(code), language=return_unicode(lang))\\n m += 1\\n return m\",\n \"def test_update(self):\\n u = stellr.UpdateCommand(TEST_HTTP, commit_within=60000)\\n self.assertEqual(u.host, 'http://localhost:8983')\\n self.assertEqual(u._handler, ('/solr/update/json?'\\n 'wt=json&commitWithin=60000'))\\n\\n a = SimpleObject(DOCUMENTS[0][0], DOCUMENTS[0][1], DOCUMENTS[0][2])\\n u.add_documents(a)\\n\\n b = dict()\\n for i, field in enumerate(FIELDS):\\n b[field] = DOCUMENTS[1][i]\\n u.add_documents(b)\\n\\n self.assertEqual(len(u._commands), 2)\\n for i, comm in enumerate(u._commands):\\n self.assertEqual(comm[0], 'add')\\n self.assertTrue('doc' in comm[1])\\n for field, value in comm[1]['doc'].iteritems():\\n field_ord = FIELDS.index(field)\\n self.assertEqual(DOCUMENTS[i][field_ord], value)\",\n \"def update_filedetails_ajax(request):\\n try:\\n document_id = request.GET.get('document_id')\\n tag = request.GET.get('tag')\\n get_index = find_index_with_document(document_id)\\n updated_data = update(get_index, document_id, tag)\\n return JsonResponse({\\\"fs_metadata\\\": updated_data, \\\"message\\\": \\\"Success\\\", \\\"status_code\\\": \\\"200\\\"})\\n except Exception as e:\\n print(\\\"Update Error : \\\", e)\\n return False\",\n \"def update():\",\n \"def update():\",\n \"def update(self, docs: DocumentArray, *args, **kwargs):\\n cursor = self.connection.cursor()\\n psycopg2.extras.execute_batch(\\n cursor,\\n f'UPDATE {self.table} SET DOC = %s WHERE ID = %s',\\n [\\n (\\n doc.SerializeToString(),\\n doc.id,\\n )\\n for doc in docs\\n ],\\n )\\n self.connection.commit()\",\n \"def update(self, data):\\n self.data = data\\n # extract data\\n subject = data.identifier\\n self.id = _uri_to_oai(subject)\\n self.modified = datetime.utcnow()\\n self.deleted = False\\n\\n itemtype, subtype = _get_itemtype(data, subject)\\n\\n self.metadata = {}\\n\\n # fixed fields:\\n self.metadata['rif_key'] = _uri_to_key(subject)\\n self.metadata['rif_group'] = self.provider.groupDescription\\n self.metadata['rif_originatingSource'] = self.provider.originatingSource\\n self.metadata['rif_object'] = {'value': itemtype,\\n 'type': subtype,\\n #'dateModified': '',\\n }\\n\\n if itemtype == 'collection':\\n self.updateCollection(data, subject)\\n elif itemtype == 'party':\\n if subtype == 'person':\\n self.updatePartyPerson(data, subject)\\n else:\\n self.updateParty(data, subject)\\n elif itemtype == 'activity':\\n self.updateActivity(data, subject)\\n elif itemtype == 'service':\\n self.updateService(data, subject)\",\n \"def test_kyc_put_document_shareholder(self):\\n pass\",\n \"def update(*args):\",\n \"def test_update_with_field_boost(self):\\n u = stellr.UpdateCommand(TEST_HTTP)\\n u.add_documents({'a': { 'value': 'f', 'boost': 2.0}})\\n self.assertEqual(u.body, ('{\\\"add\\\": {\\\"doc\\\": {\\\"a\\\": '\\n '{\\\"boost\\\": 2.0, \\\"value\\\": \\\"f\\\"}}}}'))\",\n \"def updateDoc(self, path):\\n self.db.setDb(self.db_file)\\n \\n if not self.authd:\\n self._authorize()\\n \\n db_row = self.db.getRowFromPath(path)\\n if not db_row:\\n return False\\n \\n resource_id = db_row[0]\\n etag = db_row[1]\\n title = db_row[2]\\n \\n ms = gdata.data.MediaSource(file_path=path, content_type=MIMETYPES['ODT'])\\n doc = self.client.GetDoc(resource_id.replace(':', '%3A'))\\n new_version = self.client.Update(doc, media_source=ms)\\n print 'Document pushed:', new_version.GetAlternateLink().href\\n \\n self.db.resetEtag(new_version)\",\n \"def m_req_Update(self, sender, e):\\r\\n if e.Instrument != None and e.Error == None:\\r\\n # Instrument was found\\r\\n print(\\\"Found: {0}\\\".format(e.Instrument.Name))\\r\\n # Subscribe for Inside Market Data\\r\\n self.m_ps = ttapi.PriceSubscription(e.Instrument, ttapi.Dispatcher.Current)\\r\\n self.m_ps.Settings = ttapi.PriceSubscriptionSettings(ttapi.PriceSubscriptionType.InsideMarket)\\r\\n self.m_ps.FieldsUpdated += self.m_ps_FieldsUpdated\\r\\n self.m_ps.Start()\\r\\n elif e.IsFinal:\\r\\n # Instrument was not found and TT API has given up looking for it\\r\\n print(\\\"Cannot find instrument: {0}\\\".format(e.Error.Message))\\r\\n self.Dispose()\",\n \"def update_qualification(qual_id: int) -> Dict[str, Any]:\\n qualification_schema = QualificationSchema()\\n qualification = qualification_schema.load(request.json)\\n if qualification[\\\"id\\\"] != qual_id:\\n raise APIError(reason=\\\"incorrect_id\\\", status_code=400)\\n\\n if Qualification.query.filter_by(id=qual_id).count() < 1:\\n raise APIError(reason=\\\"no_such_object\\\", status_code=400)\\n\\n qualification_obj = Qualification.query.get(qual_id)\\n\\n try:\\n qualification_obj.name = qualification[\\\"name\\\"]\\n db.session.commit()\\n except IntegrityError:\\n raise APIError(reason=\\\"qualification_exists\\\", status_code=400)\\n\\n return cast(Dict[str, Any], qualification)\",\n \"def update_transcript_info(ensembl_info, word, value):\\n if \\\"transcript\\\" in word:\\n if \\\"id\\\" in word:\\n ensembl_info[\\\"ensembl_transcript_id\\\"] = value\\n elif \\\"start\\\" in word:\\n ensembl_info[\\\"transcript_start\\\"] = int(value)\\n elif \\\"end\\\" in word:\\n ensembl_info[\\\"transcript_end\\\"] = int(value)\\n return ensembl_info\",\n \"def test_model_object_update(self):\\n car = Car.objects.first()\\n car.index_to_appsearch(update_only=True)\\n self.assertEqual(self.client_update.call_count, 1)\",\n \"def update_document(obj):\\n index = obj.get_index_name()\\n doc_type = obj.get_document_type()\\n body = dict(doc=obj.get_document_body())\\n try:\\n ES.update(index=index, doc_type=doc_type, body=body, id=obj.pk)\\n except NotFoundError:\\n raise DocumentNotFound(obj.get_index_name(), obj.pk)\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def updateAnnoByMetadata(syn, synId, metaDf, refCol, cols2Add,fileExts):\\n \\n if type(synId) is list:\\n print \\\"Input is a list of Synapse IDs \\\\n\\\"\\n for synID in synId:\\n print \\\"Getting File %s ...\\\" % synID\\n temp = syn.get(synID,downloadFile = False)\\n _helperUpdateAnnoByMetadata(syn,temp,metaDf,refCol,cols2Add,fileExts)\\n else:\\n print \\\"Input is a Synpase ID \\\\n\\\"\\n starting = syn.get(synId,downloadFile = False)\\n if not is_container(starting):\\n print \\\"%s is a File \\\\n\\\" % synId\\n _helperUpdateAnnoByMetadata(syn,starting,metaDf,refCol,cols2Add,fileExts)\\n else:\\n directory = synu.walk(syn,synId)\\n for dirpath,dirname,filename in directory:\\n for i in filename:\\n temp = syn.get(i[1],downloadFile = False)\\n print \\\"Getting File %s ...\\\" % i[1]\\n _helperUpdateAnnoByMetadata(syn,temp,metaDf,refCol,cols2Add,fileExts)\",\n \"def test_partial_update_metadata1(self):\\n pass\",\n \"def savedoc():\\r\\n document.save('QSDoc_{0}_{1}_{2}_{3}.docx'.format(args.server, year, month, day))\",\n \"def merge_docs(self):\",\n \"def test_update_record(self):\\n pass\",\n \"def update_index(self, document):\\n\\t\\tix = self.get_index()\\n\\n\\t\\twith ix.searcher():\\n\\t\\t\\twriter = AsyncWriter(ix)\\n\\t\\t\\twriter.delete_by_term(self.id, document[self.id])\\n\\t\\t\\twriter.add_document(**document)\\n\\t\\t\\twriter.commit(optimize=True)\",\n \"def test_partial_update_metadata(self):\\n pass\",\n \"def update_docs():\\n managepy('update_docs', site='docs')\",\n \"def updatePublicationFromSymplectic(publication_object):\\r\\n #description \\r\\n #checking\\r\\n if not(publication_object) or (publication_object.guid == ''):\\r\\n return \\r\\n #symplectic api url and local file path\\r\\n url = SYMPLECTIC_API_URL + 'publications/' + publication_object.guid\\r\\n tmp_filename = SYMPLECTIC_LOCAL_XML_FOLDER + SYMPLECTIC_LOCAL_PUBS_FOLDER + publication_object.guid + '.xml'\\r\\n #get xml document from symplectic api and store on hd\\r\\n (tmp_filename, http_headers,) = urllib.urlretrieve(url, tmp_filename)\\r\\n #parse xml file\\r\\n pub_etree = ElementTree(file=tmp_filename)\\r\\n #delete local file from hd\\r\\n #try:\\r\\n os.remove(tmp_filename)\\r\\n #except:\\r\\n #pass \\r\\n #++++++PUBLICATION++++++\\r\\n #publication element\\r\\n pub_element = pub_etree.getroot()\\r\\n #no loading-of/blank publication object required as updating the one passed in\\r\\n #check returned xml element is valid and for correct publication\\r\\n if pub_element is None:\\r\\n return\\r\\n elif publication_object.guid != pub_element.get('id',''):\\r\\n return\\r\\n #publication attributes\\r\\n if pub_element is not None:\\r\\n publication_object.new_id = pub_element.get('new-id')\\r\\n if pub_element.get('is-deleted','false') == 'true':\\r\\n publication_object.is_deleted = True\\r\\n else:\\r\\n publication_object.is_deleted = False\\r\\n publication_object.type = pub_element.get('type','')\\r\\n publication_object.created_when = pub_element.get('created-when','')\\r\\n publication_object.last_modified_when = pub_element.get('last-modified-when','')\\r\\n #just fetched latest version from symplectic\\r\\n publication_object.needs_refetch = False\\r\\n #save updated publication object\\r\\n publication_object.save()\\r\\n #++++++BIBLIOGRAPHIC-RECORD++++++\\r\\n #bibliographic-record elements are held in a subtree\\r\\n biblio_subtree = pub_etree.find(SYMPLECTIC_NAMESPACE + 'bibliographic-records')\\r\\n #check if any bibliographic-record elements in subtree\\r\\n if biblio_subtree is None or len(biblio_subtree) < 1:\\r\\n return\\r\\n #for each bibliographic-record element in subtree\\r\\n for biblio_element in biblio_subtree.getchildren():\\r\\n SymplecticXMLPubs.__createBiblioObjFromBiblioElement(biblio_element, publication_object)\",\n \"def update_existing(doc_data_tples):\\n def per_doc(doc, data_tples):\\n def per_field(data_tple):\\n field, datas = data_tple\\n map(_do_append_field(doc, field), datas)\\n map(per_field, data_tples)\\n return doc\\n\\n __docs = ( (per_doc(doc, data_tples), data_tples) for doc,data_tples in doc_data_tples )\\n return __docs\",\n \"def run():\\n\\n #django patient -> django_uuid = new\\n #cpatient-> doc_id = case_id, doc_id = new, == to djpatient.django_uuid\\n\\n #this needs to be coupled with fixing up the patient/all querying\\n #patient/all needs to emit the case_id\\n patients = Patient.objects.all()\\n db = get_db()\\n for p in patients:\\n print \\\"Flipping ID Patient ID: %s: Couchdoc: %s\\\" % (p.id, p.doc_id)\\n #so the p.couchdoc is useless here because if the model code is changed we need to do it manually.\\n\\n #establish the updated ids and get them separated out\\n real_case_id = p.doc_id + \\\"\\\" #the doc_id had been used as the case_id which in real casexml, that's bad.\\n new_doc_id = uuid.uuid1().hex #now make a new doc_id for the patient document.\\n\\n couchdoc = db.open_doc(p.doc_id)\\n\\n #flip the document ids.\\n copy_doc = PactPatient.wrap(couchdoc)\\n copy_doc.case_id = real_case_id\\n copy_doc._id = new_doc_id\\n copy_doc.doc_type = PactPatient.__name__\\n copy_doc.save()\\n p.doc_id = new_doc_id\\n p._couchdoc = copy_doc\\n p.save()\\n print \\\"\\\\tSwapping case id %s -> %s\\\" % (real_case_id, new_doc_id)\\n\\n #having just saved it, we need to now remove the original id\\n dupe_doc = db.open_doc(real_case_id) #the old doc_id\\n delresult = db.delete_doc(dupe_doc)\\n print \\\"\\\\tDeleting doc %s\\\" % (real_case_id)\\n print \\\"\\\\t%s\\\" % (delresult)\\n\\n i = 0\\n while db.doc_exist(real_case_id):\\n i+= 1\\n print \\\"\\\\tTrying to freaking delete!!!\\\"\\n print \\\"\\\\tReally deleting doc %s\\\" % (real_case_id)\\n delresult = db.delete_doc(dupe_doc)\\n print \\\"\\\\t%s\\\" % (delresult)\\n if i == 10:\\n break\",\n \"def obj_update(self, bundle, **kwargs):\\n logger.info(\\\"Updating acknowledgement...\\\")\\n \\n bundle = super(AcknowledgementResource, self).obj_update(bundle, **kwargs)\\n \\n bundle.obj.create_and_upload_pdfs()\\n \\n return bundle\",\n \"def update(self, index, id, **kwargs):\\n url = f'{self.host}{index}/_doc/{id}/_update'\\n data = {'doc': {**kwargs}}\\n requests.post(url, json=data)\\n self.flush(index)\\n return self.get(index, id)\",\n \"def update(db, spec, doc):\\n resp = db.sole.sole.update(spec, doc, upsert=False, safe=True)\\n if (resp.get('updatedExisting') == False):\\n return False\\n return True\",\n \"def update(self) -> None:\\n ...\",\n \"def test_update_enrollment_term(self):\\n # This method utilises the PUT request method and will make changes to the Canvas instance. This needs consideration.\\n pass\",\n \"def updateUniqueID(self, updateAll=False):\\n fieldsFound = False\\n for format in self.values():\\n if format.findUniqueIDFields():\\n fieldsFound = True\\n if updateAll and fieldsFound:\\n globalref.docRef.root.setDescendantUniqueID()\",\n \"def test_audiobook_can_update(self):\\n\\n data = {\\n \\\"audiotype\\\": \\\"Audiobook\\\",\\n \\\"metadata\\\": {\\n \\\"title\\\": \\\"audiobook1\\\",\\n \\\"duration\\\": 45678,\\n \\\"author\\\": \\\"Solomon\\\",\\n \\\"narrator\\\": \\\"Aniefiok\\\"\\n }\\n }\\n\\n num = str(3)\\n\\n response = requests.put(\\n \\\"http://localhost:9001/api/update-audio/Audiobook/\\\"+num, json=data)\\n\\n self.assertEqual(response.status_code, 200)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65441775","0.6009176","0.6004787","0.5918397","0.5706653","0.56903756","0.56212336","0.5521491","0.550605","0.5475452","0.54754287","0.54498464","0.54302835","0.53948754","0.5377633","0.53746945","0.534313","0.534106","0.5327438","0.5279192","0.527067","0.5262306","0.5248283","0.5230637","0.5227883","0.51983094","0.5180229","0.51651114","0.51646185","0.5144726","0.51435","0.51425016","0.5141727","0.51408213","0.5140688","0.5127828","0.51170605","0.5116783","0.5107336","0.50851107","0.5081226","0.507024","0.50520074","0.5034239","0.5020908","0.5020216","0.5018024","0.5017262","0.50109905","0.5009534","0.49999735","0.49965414","0.49905103","0.49886402","0.49868244","0.49868244","0.49868244","0.49868244","0.49868244","0.49868244","0.4977033","0.49706692","0.49600014","0.4954069","0.49424118","0.49418926","0.494061","0.494061","0.49363014","0.49355775","0.4922662","0.4920753","0.49150887","0.49126518","0.49124047","0.49116582","0.49051744","0.49049622","0.48969993","0.48926497","0.48926497","0.48926497","0.4891499","0.4887548","0.4883899","0.48809898","0.4878322","0.48775893","0.48746622","0.48730904","0.4865259","0.4863532","0.48586458","0.48553807","0.4852116","0.48495716","0.4845493","0.48448887","0.48437294","0.48410806"],"string":"[\n \"0.65441775\",\n \"0.6009176\",\n \"0.6004787\",\n \"0.5918397\",\n \"0.5706653\",\n \"0.56903756\",\n \"0.56212336\",\n \"0.5521491\",\n \"0.550605\",\n \"0.5475452\",\n \"0.54754287\",\n \"0.54498464\",\n \"0.54302835\",\n \"0.53948754\",\n \"0.5377633\",\n \"0.53746945\",\n \"0.534313\",\n \"0.534106\",\n \"0.5327438\",\n \"0.5279192\",\n \"0.527067\",\n \"0.5262306\",\n \"0.5248283\",\n \"0.5230637\",\n \"0.5227883\",\n \"0.51983094\",\n \"0.5180229\",\n \"0.51651114\",\n \"0.51646185\",\n \"0.5144726\",\n \"0.51435\",\n \"0.51425016\",\n \"0.5141727\",\n \"0.51408213\",\n \"0.5140688\",\n \"0.5127828\",\n \"0.51170605\",\n \"0.5116783\",\n \"0.5107336\",\n \"0.50851107\",\n \"0.5081226\",\n \"0.507024\",\n \"0.50520074\",\n \"0.5034239\",\n \"0.5020908\",\n \"0.5020216\",\n \"0.5018024\",\n \"0.5017262\",\n \"0.50109905\",\n \"0.5009534\",\n \"0.49999735\",\n \"0.49965414\",\n \"0.49905103\",\n \"0.49886402\",\n \"0.49868244\",\n \"0.49868244\",\n \"0.49868244\",\n \"0.49868244\",\n \"0.49868244\",\n \"0.49868244\",\n \"0.4977033\",\n \"0.49706692\",\n \"0.49600014\",\n \"0.4954069\",\n \"0.49424118\",\n \"0.49418926\",\n \"0.494061\",\n \"0.494061\",\n \"0.49363014\",\n \"0.49355775\",\n \"0.4922662\",\n \"0.4920753\",\n \"0.49150887\",\n \"0.49126518\",\n \"0.49124047\",\n \"0.49116582\",\n \"0.49051744\",\n \"0.49049622\",\n \"0.48969993\",\n \"0.48926497\",\n \"0.48926497\",\n \"0.48926497\",\n \"0.4891499\",\n \"0.4887548\",\n \"0.4883899\",\n \"0.48809898\",\n \"0.4878322\",\n \"0.48775893\",\n \"0.48746622\",\n \"0.48730904\",\n \"0.4865259\",\n \"0.4863532\",\n \"0.48586458\",\n \"0.48553807\",\n \"0.4852116\",\n \"0.48495716\",\n \"0.4845493\",\n \"0.48448887\",\n \"0.48437294\",\n \"0.48410806\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6770321"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84576,"cells":{"query":{"kind":"string","value":"Tender Qualification Document Update"},"document":{"kind":"string","value":"def patch(self):\n if apply_patch(self.request, src=self.request.context.serialize()):\n update_file_content_type(self.request)\n self.LOGGER.info(\n \"Updated tender qualification document {}\".format(self.request.context.id),\n extra=context_unpack(self.request, {\"MESSAGE_ID\": \"tender_qualification_document_patch\"}),\n )\n return {\"data\": self.request.context.serialize(\"view\")}"},"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 put(self):\n document = upload_file(self.request)\n self.request.validated[\"qualification\"].documents.append(document)\n if save_tender(self.request):\n self.LOGGER.info(\n \"Updated tender qualification document {}\".format(self.request.context.id),\n extra=context_unpack(self.request, {\"MESSAGE_ID\": \"tender_qualification_document_put\"}),\n )\n return {\"data\": document.serialize(\"view\")}","def update_document(self):\n pass","def edit_document():","def update_knowledge(self):\n pass","def tests_ti_document_update(self, request: FixtureRequest):\n super().group_update(request)","def test_client_verification_document_update(self):\n pass","def test_update(self):\n doc_fields = document_fields.DocumentFields({\n 'foo@': 'bar',\n })\n self.assertEquals('bar', doc_fields['foo'])\n doc_fields.update({\n 'foo@': 'bbq',\n })\n self.assertEquals('bbq', doc_fields['foo'])","def update_doc(doc):\n doc.long_name = \"X\"","def add_doc_to_get(self,action,update_spec,action_buffer_index):\n doc = {'_index' : action['_index'],\n '_type' : action['_type'],\n '_id' : action['_id']}\n self.doc_to_get.append((doc,update_spec,action_buffer_index))","def test_client_verification_document_partial_update(self):\n pass","def patch(self):\n return super(TenderAwardDocumentResource, self).patch()","def document_update(index_name, doc_type, doc_id, doc=None, new=None):\n if doc:\n resp = es.index(index=index_name, doc_type=doc_type,\n id=doc_id, body=doc)\n print(resp)\n else:\n resp = es.update(index=index_name, doc_type=doc_type,\n id=doc_id, body={\"doc\": new})","def update(get_index, document_id, tag): \n client, index_name = connection_es()\n res = client.update(index = get_index, doc_type = 'nvisnx', id = document_id, body= {\"doc\" : {\"tag\": tag}})\n return res","def test_update_documents(index_with_documents, small_movies):\n index = index_with_documents()\n response = index.get_documents()\n doc = response.results[0]\n doc.title = \"Some title\"\n\n update = index.update_documents([dict(doc)])\n\n assert isinstance(update, TaskInfo)\n assert update.task_uid is not None\n index.wait_for_task(update.task_uid)\n\n response = index.get_document(doc.id)\n assert response.title == \"Some title\"\n\n update = index.update_documents(small_movies)\n index.wait_for_task(update.task_uid)\n\n response = index.get_document(doc.id)\n assert response.title != \"Some title\"","def put(self):\n if not self.validate_complaint_document(\"update\"):\n return\n document = upload_file(self.request)\n document.author = self.request.authenticated_role\n self.request.validated[\"complaint\"].documents.append(document)\n if save_tender(self.request):\n self.LOGGER.info(\n \"Updated tender award complaint document {}\".format(self.request.context.id),\n extra=context_unpack(self.request, {\"MESSAGE_ID\": \"tender_award_complaint_document_put\"}),\n )\n return {\"data\": document.serialize(\"view\")}","def test_kyc_put_document(self):\n pass","def updateAnnoByIdDictFromMeta(syn,idDict,metaDf,refCol,fileExts):\n for key in idDict:\n print \"updating annotaion values for key: %s\" % key\n for synId in idDict[key]:\n print \"> %s\" %synId\n temp = syn.get(synId, downloadFile = False)\n exts = ')|('.join(fileExts)\n exts = r'(' + exts + ')'\n tempName = re.sub(exts,\"\",temp.name)\n row = df.loc[df[refCol] == tempName]\n temp[key] = map(str,row[key])[0]\n temp = syn.store(temp,forceVersion = False)\n print \"\"","def put(self):\n return super(TenderAwardDocumentResource, self).put()","def update_document(self, type: Type, id: str,\n new_data: Dict[str, Any]) -> None:\n if collection := self.client.collection(f'{type}'):\n if document_ref := collection.document(document_id=id):\n if document_ref.get().exists:\n document_ref.update(new_data)\n else:\n document_ref.create(new_data)","def document(self):\n ...","def patch(self):\n return super(TenderAwardContractDocumentResource, self).patch()","def _helperUpdateAnnoByMetadata(syn,temp,metaDf,refCol,cols2Add,fileExts):\n \n print \"Updating annotations by metadata...\"\n \n exts = ')|('.join(fileExts)\n exts = r'(' + exts + ')'\n tempName = re.sub(exts,\"\",temp.name)\n \n row = df.loc[df[refCol] == tempName]\n if row.empty:\n print \"missing metadata\"\n else:\n for colName in cols2Add:\n print \"> %s \" % colName\n temp[colName] = map(str,row[colName])[0]\n temp = syn.store(temp, forceVersion = False)\n print \"\"","def _update_documents(self):\n if self.campaigns.active():\n top_ranked_documents = utils._rank_documents(self.event)\n # [TODO] this is a kludge\n if set(top_ranked_documents) == set(self.documents.all()):\n return False\n print('[DEBUG] Docs changed! New campaign ahoy!')\n self.documents = top_ranked_documents\n return True","def collection_post(self):\n document = upload_file(self.request)\n document.author = self.request.authenticated_role\n self.context.documents.append(document)\n if save_tender(self.request):\n self.LOGGER.info(\n \"Created tender qualification document {}\".format(document.id),\n extra=context_unpack(\n self.request, {\"MESSAGE_ID\": \"tender_qualification_document_create\"}, {\"document_id\": document.id}\n ),\n )\n self.request.response.status = 201\n document_route = self.request.matched_route.name.replace(\"collection_\", \"\")\n self.request.response.headers[\"Location\"] = self.request.current_route_url(\n _route_name=document_route, document_id=document.id, _query={}\n )\n return {\"data\": document.serialize(\"view\")}","def spot_doc_rubrics2(doc_id, rubrics):\n db.doc_apply(doc_id, spot_doc_rubrics, rubrics)","def on_doctype_update():\n\tfrappe.db.add_index(\"Make Serial NO\", [\"item\", \"batch\"])","def _update(self, count=True, forced=False):","def test_update_with_document_boost(self):\n u = stellr.UpdateCommand(TEST_HTTP)\n u.add_documents({'a': 1}, boost=2.0)\n self.assertEqual(u.body, '{\"add\": {\"doc\": {\"a\": 1}, \"boost\": 2.0}}')","def after_insert(self):\n if self.get('update_request') and not self.is_pending_approval():\n self.update_request.created_docname = self.name\n self.set_as_success()","def put(self):\n return super(TenderAwardContractDocumentResource, self).put()","def put(self, request, code, suggested_format=None):\n context = {'request': request}\n conten_type = request.content_type\n uploaded_obj = None\n if 'multipart/form-data' in conten_type:\n # We have a file upload encoded with multipart/form-data\n file_content = StringIO(request.body)\n parser = MultiPartParser()\n dnf = parser.parse(file_content, media_type=conten_type, parser_context=context)\n extra = dnf.data\n if 'file' in dnf.files:\n uploaded_obj = dnf.files['file']\n else:\n extra = request.QUERY_PARAMS\n # TODO: do we require SQL tagging logic in this API call?\n sql_tag_string = extra.get('tag_string', None)\n sql_remove_tag_string = extra.get('remove_tag_string', None)\n new_name = extra.get('new_name', None)\n new_type = extra.get('new_type', None)\n index_data = extra.get('indexing_data', None)\n if index_data:\n index_data = json.loads(index_data)\n processor = DocumentProcessor()\n options = {\n 'tag_string': sql_tag_string,\n 'remove_tag_string': sql_remove_tag_string,\n 'extension': suggested_format,\n 'new_name': new_name,\n 'new_type': new_type,\n 'new_indexes': index_data,\n 'update_file': uploaded_obj,\n 'user': request.user,\n }\n document = processor.update(code, options)\n if len(processor.errors) > 0:\n log.error('FileHandler.update manager errors %s' % processor.errors)\n if settings.DEBUG:\n print processor.errors\n raise Exception('FileHandler.update manager errors')\n else:\n return Response(status=status.HTTP_400_BAD_REQUEST)\n log.info('FileHandler.update request fulfilled for code: %s, extension: %s'\n % (code, suggested_format))\n resp = DMSOBjectRevisionsData(document).data\n return Response(resp, status=status.HTTP_200_OK)","def put(self):\n if 'file' not in self.request.POST:\n self.request.errors.add('body', 'file', 'Not Found')\n self.request.errors.status = 404\n return\n tender = TenderDocument.load(self.db, self.tender_id)\n if not tender:\n self.request.errors.add('url', 'tender_id', 'Not Found')\n self.request.errors.status = 404\n return\n data = self.request.POST['file']\n bids = [i for i in tender.bids if i.id == self.bid_id]\n if not bids:\n self.request.errors.add('url', 'bid_id', 'Not Found')\n self.request.errors.status = 404\n return\n bid = bids[0]\n documents = [i for i in bid.documents if i.id == self.request.matchdict['id']]\n if not documents:\n self.request.errors.add('url', 'id', 'Not Found')\n self.request.errors.status = 404\n return\n src = tender.serialize(\"plain\")\n document = Document()\n document.id = self.request.matchdict['id']\n document.title = data.filename\n document.format = data.type\n document.datePublished = documents[0].datePublished\n key = uuid4().hex\n document.url = self.request.route_url('Tender Bid Documents', tender_id=self.tender_id, bid_id=self.bid_id, id=document.id, _query={'download': key})\n bid.documents.append(document)\n filename = \"{}_{}\".format(document.id, key)\n tender['_attachments'][filename] = {\n \"content_type\": data.type,\n \"data\": b64encode(data.file.read())\n }\n patch = make_patch(tender.serialize(\"plain\"), src).patch\n tender.revisions.append(revision({'changes': patch}))\n try:\n tender.store(self.db)\n except Exception, e:\n return self.request.errors.add('body', 'data', str(e))\n return {'data': document.serialize(\"view\")}","def update(self, doc):\n if app.config.get(\"READ_ONLY_MODE\", False) and app.config.get(\"SCRIPTS_READ_ONLY_MODE\", False):\n app.logger.warn(\"System is in READ-ONLY mode, update command cannot run\")\n return\n\n return requests.post(self.target() + self.id + \"/_update\", data=json.dumps({\"doc\": doc}))","def update(self, es, **kwargs):\n pass","def _put(self, name, document):\n raise NotImplementedError","def test_update_occurrence(self):\n pass","def patch(self):\n if not self.validate_complaint_document(\"update\"):\n return\n if apply_patch(self.request, src=self.request.context.serialize()):\n update_file_content_type(self.request)\n self.LOGGER.info(\n \"Updated tender award complaint document {}\".format(self.request.context.id),\n extra=context_unpack(self.request, {\"MESSAGE_ID\": \"tender_award_complaint_document_patch\"}),\n )\n return {\"data\": self.request.context.serialize(\"view\")}","def oe_update(self, cr, uid, external_session, existing_rec_id, vals, resource, defaults, context=None):\n if context is None: context={}\n context['referential_id'] = external_session.referential_id.id #did it's needed somewhere?\n return self.write(cr, uid, existing_rec_id, vals, context)","def test_queryset_update(self):\n car = Car.objects.all()\n car.index_to_appsearch(update_only=True)\n # Note that the app search chunk size is set to 5 in `tests.settings`\n # Therefore you should see 5 calls to cover 22 documents\n self.assertEqual(self.client_update.call_count, 5)","def updateDocument(self, document):\n data = self.updateDocumentAll([document])\n try:\n return data[0]\n except: pass","def update( ):\r\n pass","def update(self, *args, **kwargs):","def update_records(self, something):\n print(\"Some logic (not shown) to update database of units\")","def update_relevant(query_string, doc_id, corpus):\n #TODO update to toggle relevance (add/remove from relevent or nonrelevant lists)\n relevance_dict = get_relevance_dict(corpus)\n if relevance_dict.get(query_string):\n #toggle\n print(query_string + ' relevance toggled ' + corpus + str(doc_id))\n relevance_dict[query_string] = toggle_relevance(relevance_dict[query_string], doc_id)\n else:\n print(query_string + ' not in dict yet')\n #add_to_dict either after determine if relevent or non relevant\n #create tuple with doc_id in relevant list\n relevance_dict[query_string] = [doc_id], []\n write_relevance_tocsv(relevance_dict, corpus)","def _index_doc(self, db, doc_id):\n doc = db.get(doc_id)\n if doc is None:\n log.warning(\"Unable to find document in database: '%s'\" % doc_id)\n return\n fields = doc.get('solr_fields')\n fields = [\"payload\", \"timesaved\"]\n if not fields:\n log.debug(\"Document '%s' does not define solr_fields\" % doc_id)\n return\n updates = []\n for field in fields:\n if doc.has_key(field):\n self.__normalize(updates, field, doc[field])\n updates.extend([{'type' : 'any'}, {'_id' : doc_id}])\n return updates","def update_documents(self, engine_name, documents):\n endpoint = \"engines/{}/documents\".format(engine_name)\n data = json.dumps(documents)\n\n return self.swiftype_session.request('patch', endpoint, data=data)","def test_update_documents_json(index_with_documents, small_movies_json_file):\n index = index_with_documents()\n response = index.update_documents_json(small_movies_json_file)\n assert isinstance(response, TaskInfo)\n assert response.task_uid is not None\n task = index.wait_for_task(response.task_uid)\n assert task.status == \"succeeded\"\n assert index.get_primary_key() == \"id\"","def test_update_with_overwrite(self):\n u = stellr.UpdateCommand(TEST_HTTP)\n u.add_documents({'a': 1}, overwrite=False)\n self.assertEqual(\n u.body, '{\"add\": {\"doc\": {\"a\": 1}, \"overwrite\": false}}')","def _mark(self, query, doc):\n raise NotImplementedError()","def upgrade_to_21():\n\n def update_project_template(template):\n new_template = {'acquisitions': []}\n for a in template.get('acquisitions', []):\n new_a = {'minimum': a['minimum']}\n properties = a['schema']['properties']\n if 'measurement' in properties:\n m_req = properties['measurement']['pattern']\n m_req = re.sub('^\\(\\?i\\)', '', m_req)\n new_a['files']=[{'measurement': m_req, 'minimum': 1}]\n if 'label' in properties:\n l_req = properties['label']['pattern']\n l_req = re.sub('^\\(\\?i\\)', '', l_req)\n new_a['label'] = l_req\n new_template['acquisitions'].append(new_a)\n\n return new_template\n\n def dm_v2_updates(cont_list, cont_name):\n for container in cont_list:\n\n query = {'_id': container['_id']}\n update = {'$rename': {'metadata': 'info'}}\n\n if cont_name == 'projects' and container.get('template'):\n new_template = update_project_template(json.loads(container.get('template')))\n update['$set'] = {'template': new_template}\n\n\n if cont_name == 'sessions':\n update['$rename'].update({'subject.metadata': 'subject.info'})\n\n\n measurement = None\n modality = None\n info = None\n if cont_name == 'acquisitions':\n update['$unset'] = {'instrument': '', 'measurement': ''}\n measurement = container.get('measurement', None)\n modality = container.get('instrument', None)\n info = container.get('metadata', None)\n if info:\n config.db.acquisitions.update_one(query, {'$set': {'metadata': {}}})\n\n\n # From mongo docs: '$rename does not work if these fields are in array elements.'\n files = container.get('files')\n if files is not None:\n updated_files = []\n for file_ in files:\n file_['info'] = {}\n if 'metadata' in file_:\n file_['info'] = file_.pop('metadata', None)\n if 'instrument' in file_:\n file_['modality'] = file_.pop('instrument', None)\n if measurement:\n # Move the acquisition's measurement to all files\n if file_.get('measurements'):\n file_['measurements'].append(measurement)\n else:\n file_['measurements'] = [measurement]\n if info and file_.get('type', '') == 'dicom':\n # This is going to be the dicom header info\n updated_info = info\n updated_info.update(file_['info'])\n file_['info'] = updated_info\n if modality and not file_.get('modality'):\n file_['modality'] = modality\n\n updated_files.append(file_)\n if update.get('$set'):\n update['$set']['files'] = updated_files\n else:\n update['$set'] = {'files': updated_files}\n\n result = config.db[cont_name].update_one(query, update)\n\n query = {'$or':[{'files.metadata': { '$exists': True}},\n {'metadata': { '$exists': True}},\n {'files.instrument': { '$exists': True}}]}\n\n dm_v2_updates(config.db.collections.find(query), 'collections')\n\n query['$or'].append({'template': { '$exists': True}})\n dm_v2_updates(config.db.projects.find({}), 'projects')\n\n query['$or'].append({'subject': { '$exists': True}})\n dm_v2_updates(config.db.sessions.find(query), 'sessions')\n\n query['$or'].append({'instrument': { '$exists': True}})\n query['$or'].append({'measurement': { '$exists': True}})\n dm_v2_updates(config.db.acquisitions.find(query), 'acquisitions')","def update(self, *args, **kwargs): \n kwargs[\"sampleID\"] = self.__sampleID\n kwargs[\"sampleMetaID\"] = self.id()\n self._eLABJournalObject__api.update_sample_meta(*list(args), **dict(kwargs))\n rp = self._eLABJournalObject__api._request(\"/api/v1/samples/\"+urllib.parse.quote(str(kwargs[\"sampleID\"]))+\"/meta/\"+urllib.parse.quote(str(kwargs[\"sampleMetaID\"])), \"get\", {})\n #check and get\n if (rp is not None) & (type(rp) == dict):\n self.__init__(self._eLABJournalObject__api,kwargs[\"sampleID\"],rp) \n else:\n print(dict)\n raise Exception(\"couldn't perform selfupdate\")","def collection_post(self):\n return super(TenderAwardDocumentResource, self).collection_post()","def testUpdateFailedDoc(self):\n change = ChangeState(self.config, \"changestate_t\")\n\n locationAction = self.daoFactory(classname=\"Locations.New\")\n locationAction.execute(\"site1\", pnn=\"T2_CH_CERN\")\n\n testWorkflow = Workflow(spec=self.specUrl, owner=\"Steve\",\n name=\"wf001\", task=self.taskName)\n testWorkflow.create()\n testFileset = Fileset(name=\"TestFileset\")\n testFileset.create()\n testSubscription = Subscription(fileset=testFileset,\n workflow=testWorkflow,\n split_algo=\"FileBased\")\n testSubscription.create()\n\n testFileA = File(lfn=\"SomeLFNA\", events=1024, size=2048,\n locations=set([\"T2_CH_CERN\"]))\n testFileA.create()\n testFileset.addFile(testFileA)\n testFileset.commit()\n\n splitter = SplitterFactory()\n jobFactory = splitter(package=\"WMCore.WMBS\",\n subscription=testSubscription)\n jobGroup = jobFactory(files_per_job=1)[0]\n\n testJobA = jobGroup.jobs[0]\n testJobA[\"user\"] = \"sfoulkes\"\n testJobA[\"group\"] = \"DMWM\"\n testJobA[\"taskType\"] = \"Merge\"\n testJobA[\"couch_record\"] = str(testJobA[\"id\"])\n\n change.propagate([testJobA], \"new\", \"none\")\n testJobADoc = change.jobsdatabase.document(testJobA[\"couch_record\"])\n\n self.assertTrue(\"states\" in testJobADoc)\n self.assertTrue(\"1\" in testJobADoc[\"states\"])\n\n testFileB = File(lfn=\"SomeLFNB\", events=1024, size=2048,\n locations=set([\"T2_CH_CERN\"]))\n testFileB.create()\n testFileset.addFile(testFileB)\n testFileset.commit()\n\n splitter = SplitterFactory()\n jobFactory = splitter(package=\"WMCore.WMBS\",\n subscription=testSubscription)\n jobGroup = jobFactory(files_per_job=1)[0]\n\n testJobB = jobGroup.jobs[0]\n testJobB[\"user\"] = \"sfoulkes\"\n testJobB[\"group\"] = \"DMWM\"\n testJobB[\"taskType\"] = \"Merge\"\n testJobB[\"couch_record\"] = newstr(testJobB[\"id\"])\n\n change.propagate([testJobB], \"new\", \"none\")\n testJobBDoc = change.jobsdatabase.document(testJobB[\"couch_record\"])\n\n self.assertTrue(\"states\" in testJobBDoc)\n self.assertTrue(\"1\" in testJobBDoc[\"states\"])\n return","def test_update_documents_ndjson(index_with_documents, songs_ndjson):\n index = index_with_documents()\n response = index.update_documents_ndjson(songs_ndjson)\n assert isinstance(response, TaskInfo)\n assert response.task_uid is not None\n task = index.wait_for_task(response.task_uid)\n assert task.status == \"succeeded\"\n assert index.get_primary_key() == \"id\"","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def test_update_transcript(self):\n response = self.client.post(reverse('update-transcript',\n args=[self.gel_ir.id,\n self.proband_variant.id,\n self.transcript2.id]),\n follow=True)\n self.assertContains(response, 'Transcript Updated')\n self.assertEquals(response.status_code, 200)\n response = self.client.get(reverse('proband-view', args=[self.gel_ir.id]))\n self.assertContains(response, self.transcript2.name)","def Regen(self,enum):\n\t\tself.acad.ActiveDocument.Regen(enum)","def update(self, spec, document, upsert=False, multi=False):\n return self.database.connection.request.update_documents(\n self.database.name, self.name, spec, document, upsert, multi)","def add_doc(writer, entry):\n m = 0\n q_id = entry['Id']\n snippets = get_possible_snippets(q_id, False)\n for code, lang, ans_id in snippets:\n writer.add_document(question_id=q_id, answer_id=ans_id, code=return_unicode(code), language=return_unicode(lang))\n m += 1\n return m","def update_filedetails_ajax(request):\n try:\n document_id = request.GET.get('document_id')\n tag = request.GET.get('tag')\n get_index = find_index_with_document(document_id)\n updated_data = update(get_index, document_id, tag)\n return JsonResponse({\"fs_metadata\": updated_data, \"message\": \"Success\", \"status_code\": \"200\"})\n except Exception as e:\n print(\"Update Error : \", e)\n return False","def test_update(self):\n u = stellr.UpdateCommand(TEST_HTTP, commit_within=60000)\n self.assertEqual(u.host, 'http://localhost:8983')\n self.assertEqual(u._handler, ('/solr/update/json?'\n 'wt=json&commitWithin=60000'))\n\n a = SimpleObject(DOCUMENTS[0][0], DOCUMENTS[0][1], DOCUMENTS[0][2])\n u.add_documents(a)\n\n b = dict()\n for i, field in enumerate(FIELDS):\n b[field] = DOCUMENTS[1][i]\n u.add_documents(b)\n\n self.assertEqual(len(u._commands), 2)\n for i, comm in enumerate(u._commands):\n self.assertEqual(comm[0], 'add')\n self.assertTrue('doc' in comm[1])\n for field, value in comm[1]['doc'].iteritems():\n field_ord = FIELDS.index(field)\n self.assertEqual(DOCUMENTS[i][field_ord], value)","def update():","def update():","def update(self, docs: DocumentArray, *args, **kwargs):\n cursor = self.connection.cursor()\n psycopg2.extras.execute_batch(\n cursor,\n f'UPDATE {self.table} SET DOC = %s WHERE ID = %s',\n [\n (\n doc.SerializeToString(),\n doc.id,\n )\n for doc in docs\n ],\n )\n self.connection.commit()","def update(self, data):\n self.data = data\n # extract data\n subject = data.identifier\n self.id = _uri_to_oai(subject)\n self.modified = datetime.utcnow()\n self.deleted = False\n\n itemtype, subtype = _get_itemtype(data, subject)\n\n self.metadata = {}\n\n # fixed fields:\n self.metadata['rif_key'] = _uri_to_key(subject)\n self.metadata['rif_group'] = self.provider.groupDescription\n self.metadata['rif_originatingSource'] = self.provider.originatingSource\n self.metadata['rif_object'] = {'value': itemtype,\n 'type': subtype,\n #'dateModified': '',\n }\n\n if itemtype == 'collection':\n self.updateCollection(data, subject)\n elif itemtype == 'party':\n if subtype == 'person':\n self.updatePartyPerson(data, subject)\n else:\n self.updateParty(data, subject)\n elif itemtype == 'activity':\n self.updateActivity(data, subject)\n elif itemtype == 'service':\n self.updateService(data, subject)","def test_kyc_put_document_shareholder(self):\n pass","def update(*args):","def test_update_with_field_boost(self):\n u = stellr.UpdateCommand(TEST_HTTP)\n u.add_documents({'a': { 'value': 'f', 'boost': 2.0}})\n self.assertEqual(u.body, ('{\"add\": {\"doc\": {\"a\": '\n '{\"boost\": 2.0, \"value\": \"f\"}}}}'))","def m_req_Update(self, sender, e):\r\n if e.Instrument != None and e.Error == None:\r\n # Instrument was found\r\n print(\"Found: {0}\".format(e.Instrument.Name))\r\n # Subscribe for Inside Market Data\r\n self.m_ps = ttapi.PriceSubscription(e.Instrument, ttapi.Dispatcher.Current)\r\n self.m_ps.Settings = ttapi.PriceSubscriptionSettings(ttapi.PriceSubscriptionType.InsideMarket)\r\n self.m_ps.FieldsUpdated += self.m_ps_FieldsUpdated\r\n self.m_ps.Start()\r\n elif e.IsFinal:\r\n # Instrument was not found and TT API has given up looking for it\r\n print(\"Cannot find instrument: {0}\".format(e.Error.Message))\r\n self.Dispose()","def updateDoc(self, path):\n self.db.setDb(self.db_file)\n \n if not self.authd:\n self._authorize()\n \n db_row = self.db.getRowFromPath(path)\n if not db_row:\n return False\n \n resource_id = db_row[0]\n etag = db_row[1]\n title = db_row[2]\n \n ms = gdata.data.MediaSource(file_path=path, content_type=MIMETYPES['ODT'])\n doc = self.client.GetDoc(resource_id.replace(':', '%3A'))\n new_version = self.client.Update(doc, media_source=ms)\n print 'Document pushed:', new_version.GetAlternateLink().href\n \n self.db.resetEtag(new_version)","def update_qualification(qual_id: int) -> Dict[str, Any]:\n qualification_schema = QualificationSchema()\n qualification = qualification_schema.load(request.json)\n if qualification[\"id\"] != qual_id:\n raise APIError(reason=\"incorrect_id\", status_code=400)\n\n if Qualification.query.filter_by(id=qual_id).count() < 1:\n raise APIError(reason=\"no_such_object\", status_code=400)\n\n qualification_obj = Qualification.query.get(qual_id)\n\n try:\n qualification_obj.name = qualification[\"name\"]\n db.session.commit()\n except IntegrityError:\n raise APIError(reason=\"qualification_exists\", status_code=400)\n\n return cast(Dict[str, Any], qualification)","def update_transcript_info(ensembl_info, word, value):\n if \"transcript\" in word:\n if \"id\" in word:\n ensembl_info[\"ensembl_transcript_id\"] = value\n elif \"start\" in word:\n ensembl_info[\"transcript_start\"] = int(value)\n elif \"end\" in word:\n ensembl_info[\"transcript_end\"] = int(value)\n return ensembl_info","def test_model_object_update(self):\n car = Car.objects.first()\n car.index_to_appsearch(update_only=True)\n self.assertEqual(self.client_update.call_count, 1)","def update_document(obj):\n index = obj.get_index_name()\n doc_type = obj.get_document_type()\n body = dict(doc=obj.get_document_body())\n try:\n ES.update(index=index, doc_type=doc_type, body=body, id=obj.pk)\n except NotFoundError:\n raise DocumentNotFound(obj.get_index_name(), obj.pk)","def updateAnnoByMetadata(syn, synId, metaDf, refCol, cols2Add,fileExts):\n \n if type(synId) is list:\n print \"Input is a list of Synapse IDs \\n\"\n for synID in synId:\n print \"Getting File %s ...\" % synID\n temp = syn.get(synID,downloadFile = False)\n _helperUpdateAnnoByMetadata(syn,temp,metaDf,refCol,cols2Add,fileExts)\n else:\n print \"Input is a Synpase ID \\n\"\n starting = syn.get(synId,downloadFile = False)\n if not is_container(starting):\n print \"%s is a File \\n\" % synId\n _helperUpdateAnnoByMetadata(syn,starting,metaDf,refCol,cols2Add,fileExts)\n else:\n directory = synu.walk(syn,synId)\n for dirpath,dirname,filename in directory:\n for i in filename:\n temp = syn.get(i[1],downloadFile = False)\n print \"Getting File %s ...\" % i[1]\n _helperUpdateAnnoByMetadata(syn,temp,metaDf,refCol,cols2Add,fileExts)","def update(self, *args, **kwargs):\n pass","def update(self, *args, **kwargs):\n pass","def update(self, *args, **kwargs):\n pass","def test_partial_update_metadata1(self):\n pass","def savedoc():\r\n document.save('QSDoc_{0}_{1}_{2}_{3}.docx'.format(args.server, year, month, day))","def merge_docs(self):","def test_update_record(self):\n pass","def update_index(self, document):\n\t\tix = self.get_index()\n\n\t\twith ix.searcher():\n\t\t\twriter = AsyncWriter(ix)\n\t\t\twriter.delete_by_term(self.id, document[self.id])\n\t\t\twriter.add_document(**document)\n\t\t\twriter.commit(optimize=True)","def test_partial_update_metadata(self):\n pass","def update_docs():\n managepy('update_docs', site='docs')","def updatePublicationFromSymplectic(publication_object):\r\n #description \r\n #checking\r\n if not(publication_object) or (publication_object.guid == ''):\r\n return \r\n #symplectic api url and local file path\r\n url = SYMPLECTIC_API_URL + 'publications/' + publication_object.guid\r\n tmp_filename = SYMPLECTIC_LOCAL_XML_FOLDER + SYMPLECTIC_LOCAL_PUBS_FOLDER + publication_object.guid + '.xml'\r\n #get xml document from symplectic api and store on hd\r\n (tmp_filename, http_headers,) = urllib.urlretrieve(url, tmp_filename)\r\n #parse xml file\r\n pub_etree = ElementTree(file=tmp_filename)\r\n #delete local file from hd\r\n #try:\r\n os.remove(tmp_filename)\r\n #except:\r\n #pass \r\n #++++++PUBLICATION++++++\r\n #publication element\r\n pub_element = pub_etree.getroot()\r\n #no loading-of/blank publication object required as updating the one passed in\r\n #check returned xml element is valid and for correct publication\r\n if pub_element is None:\r\n return\r\n elif publication_object.guid != pub_element.get('id',''):\r\n return\r\n #publication attributes\r\n if pub_element is not None:\r\n publication_object.new_id = pub_element.get('new-id')\r\n if pub_element.get('is-deleted','false') == 'true':\r\n publication_object.is_deleted = True\r\n else:\r\n publication_object.is_deleted = False\r\n publication_object.type = pub_element.get('type','')\r\n publication_object.created_when = pub_element.get('created-when','')\r\n publication_object.last_modified_when = pub_element.get('last-modified-when','')\r\n #just fetched latest version from symplectic\r\n publication_object.needs_refetch = False\r\n #save updated publication object\r\n publication_object.save()\r\n #++++++BIBLIOGRAPHIC-RECORD++++++\r\n #bibliographic-record elements are held in a subtree\r\n biblio_subtree = pub_etree.find(SYMPLECTIC_NAMESPACE + 'bibliographic-records')\r\n #check if any bibliographic-record elements in subtree\r\n if biblio_subtree is None or len(biblio_subtree) < 1:\r\n return\r\n #for each bibliographic-record element in subtree\r\n for biblio_element in biblio_subtree.getchildren():\r\n SymplecticXMLPubs.__createBiblioObjFromBiblioElement(biblio_element, publication_object)","def update_existing(doc_data_tples):\n def per_doc(doc, data_tples):\n def per_field(data_tple):\n field, datas = data_tple\n map(_do_append_field(doc, field), datas)\n map(per_field, data_tples)\n return doc\n\n __docs = ( (per_doc(doc, data_tples), data_tples) for doc,data_tples in doc_data_tples )\n return __docs","def run():\n\n #django patient -> django_uuid = new\n #cpatient-> doc_id = case_id, doc_id = new, == to djpatient.django_uuid\n\n #this needs to be coupled with fixing up the patient/all querying\n #patient/all needs to emit the case_id\n patients = Patient.objects.all()\n db = get_db()\n for p in patients:\n print \"Flipping ID Patient ID: %s: Couchdoc: %s\" % (p.id, p.doc_id)\n #so the p.couchdoc is useless here because if the model code is changed we need to do it manually.\n\n #establish the updated ids and get them separated out\n real_case_id = p.doc_id + \"\" #the doc_id had been used as the case_id which in real casexml, that's bad.\n new_doc_id = uuid.uuid1().hex #now make a new doc_id for the patient document.\n\n couchdoc = db.open_doc(p.doc_id)\n\n #flip the document ids.\n copy_doc = PactPatient.wrap(couchdoc)\n copy_doc.case_id = real_case_id\n copy_doc._id = new_doc_id\n copy_doc.doc_type = PactPatient.__name__\n copy_doc.save()\n p.doc_id = new_doc_id\n p._couchdoc = copy_doc\n p.save()\n print \"\\tSwapping case id %s -> %s\" % (real_case_id, new_doc_id)\n\n #having just saved it, we need to now remove the original id\n dupe_doc = db.open_doc(real_case_id) #the old doc_id\n delresult = db.delete_doc(dupe_doc)\n print \"\\tDeleting doc %s\" % (real_case_id)\n print \"\\t%s\" % (delresult)\n\n i = 0\n while db.doc_exist(real_case_id):\n i+= 1\n print \"\\tTrying to freaking delete!!!\"\n print \"\\tReally deleting doc %s\" % (real_case_id)\n delresult = db.delete_doc(dupe_doc)\n print \"\\t%s\" % (delresult)\n if i == 10:\n break","def obj_update(self, bundle, **kwargs):\n logger.info(\"Updating acknowledgement...\")\n \n bundle = super(AcknowledgementResource, self).obj_update(bundle, **kwargs)\n \n bundle.obj.create_and_upload_pdfs()\n \n return bundle","def update(self, index, id, **kwargs):\n url = f'{self.host}{index}/_doc/{id}/_update'\n data = {'doc': {**kwargs}}\n requests.post(url, json=data)\n self.flush(index)\n return self.get(index, id)","def update(db, spec, doc):\n resp = db.sole.sole.update(spec, doc, upsert=False, safe=True)\n if (resp.get('updatedExisting') == False):\n return False\n return True","def test_update_enrollment_term(self):\n # This method utilises the PUT request method and will make changes to the Canvas instance. This needs consideration.\n pass","def updateUniqueID(self, updateAll=False):\n fieldsFound = False\n for format in self.values():\n if format.findUniqueIDFields():\n fieldsFound = True\n if updateAll and fieldsFound:\n globalref.docRef.root.setDescendantUniqueID()","def update(self) -> None:\n ...","def test_audiobook_can_update(self):\n\n data = {\n \"audiotype\": \"Audiobook\",\n \"metadata\": {\n \"title\": \"audiobook1\",\n \"duration\": 45678,\n \"author\": \"Solomon\",\n \"narrator\": \"Aniefiok\"\n }\n }\n\n num = str(3)\n\n response = requests.put(\n \"http://localhost:9001/api/update-audio/Audiobook/\"+num, json=data)\n\n self.assertEqual(response.status_code, 200)"],"string":"[\n \"def put(self):\\n document = upload_file(self.request)\\n self.request.validated[\\\"qualification\\\"].documents.append(document)\\n if save_tender(self.request):\\n self.LOGGER.info(\\n \\\"Updated tender qualification document {}\\\".format(self.request.context.id),\\n extra=context_unpack(self.request, {\\\"MESSAGE_ID\\\": \\\"tender_qualification_document_put\\\"}),\\n )\\n return {\\\"data\\\": document.serialize(\\\"view\\\")}\",\n \"def update_document(self):\\n pass\",\n \"def edit_document():\",\n \"def update_knowledge(self):\\n pass\",\n \"def tests_ti_document_update(self, request: FixtureRequest):\\n super().group_update(request)\",\n \"def test_client_verification_document_update(self):\\n pass\",\n \"def test_update(self):\\n doc_fields = document_fields.DocumentFields({\\n 'foo@': 'bar',\\n })\\n self.assertEquals('bar', doc_fields['foo'])\\n doc_fields.update({\\n 'foo@': 'bbq',\\n })\\n self.assertEquals('bbq', doc_fields['foo'])\",\n \"def update_doc(doc):\\n doc.long_name = \\\"X\\\"\",\n \"def add_doc_to_get(self,action,update_spec,action_buffer_index):\\n doc = {'_index' : action['_index'],\\n '_type' : action['_type'],\\n '_id' : action['_id']}\\n self.doc_to_get.append((doc,update_spec,action_buffer_index))\",\n \"def test_client_verification_document_partial_update(self):\\n pass\",\n \"def patch(self):\\n return super(TenderAwardDocumentResource, self).patch()\",\n \"def document_update(index_name, doc_type, doc_id, doc=None, new=None):\\n if doc:\\n resp = es.index(index=index_name, doc_type=doc_type,\\n id=doc_id, body=doc)\\n print(resp)\\n else:\\n resp = es.update(index=index_name, doc_type=doc_type,\\n id=doc_id, body={\\\"doc\\\": new})\",\n \"def update(get_index, document_id, tag): \\n client, index_name = connection_es()\\n res = client.update(index = get_index, doc_type = 'nvisnx', id = document_id, body= {\\\"doc\\\" : {\\\"tag\\\": tag}})\\n return res\",\n \"def test_update_documents(index_with_documents, small_movies):\\n index = index_with_documents()\\n response = index.get_documents()\\n doc = response.results[0]\\n doc.title = \\\"Some title\\\"\\n\\n update = index.update_documents([dict(doc)])\\n\\n assert isinstance(update, TaskInfo)\\n assert update.task_uid is not None\\n index.wait_for_task(update.task_uid)\\n\\n response = index.get_document(doc.id)\\n assert response.title == \\\"Some title\\\"\\n\\n update = index.update_documents(small_movies)\\n index.wait_for_task(update.task_uid)\\n\\n response = index.get_document(doc.id)\\n assert response.title != \\\"Some title\\\"\",\n \"def put(self):\\n if not self.validate_complaint_document(\\\"update\\\"):\\n return\\n document = upload_file(self.request)\\n document.author = self.request.authenticated_role\\n self.request.validated[\\\"complaint\\\"].documents.append(document)\\n if save_tender(self.request):\\n self.LOGGER.info(\\n \\\"Updated tender award complaint document {}\\\".format(self.request.context.id),\\n extra=context_unpack(self.request, {\\\"MESSAGE_ID\\\": \\\"tender_award_complaint_document_put\\\"}),\\n )\\n return {\\\"data\\\": document.serialize(\\\"view\\\")}\",\n \"def test_kyc_put_document(self):\\n pass\",\n \"def updateAnnoByIdDictFromMeta(syn,idDict,metaDf,refCol,fileExts):\\n for key in idDict:\\n print \\\"updating annotaion values for key: %s\\\" % key\\n for synId in idDict[key]:\\n print \\\"> %s\\\" %synId\\n temp = syn.get(synId, downloadFile = False)\\n exts = ')|('.join(fileExts)\\n exts = r'(' + exts + ')'\\n tempName = re.sub(exts,\\\"\\\",temp.name)\\n row = df.loc[df[refCol] == tempName]\\n temp[key] = map(str,row[key])[0]\\n temp = syn.store(temp,forceVersion = False)\\n print \\\"\\\"\",\n \"def put(self):\\n return super(TenderAwardDocumentResource, self).put()\",\n \"def update_document(self, type: Type, id: str,\\n new_data: Dict[str, Any]) -> None:\\n if collection := self.client.collection(f'{type}'):\\n if document_ref := collection.document(document_id=id):\\n if document_ref.get().exists:\\n document_ref.update(new_data)\\n else:\\n document_ref.create(new_data)\",\n \"def document(self):\\n ...\",\n \"def patch(self):\\n return super(TenderAwardContractDocumentResource, self).patch()\",\n \"def _helperUpdateAnnoByMetadata(syn,temp,metaDf,refCol,cols2Add,fileExts):\\n \\n print \\\"Updating annotations by metadata...\\\"\\n \\n exts = ')|('.join(fileExts)\\n exts = r'(' + exts + ')'\\n tempName = re.sub(exts,\\\"\\\",temp.name)\\n \\n row = df.loc[df[refCol] == tempName]\\n if row.empty:\\n print \\\"missing metadata\\\"\\n else:\\n for colName in cols2Add:\\n print \\\"> %s \\\" % colName\\n temp[colName] = map(str,row[colName])[0]\\n temp = syn.store(temp, forceVersion = False)\\n print \\\"\\\"\",\n \"def _update_documents(self):\\n if self.campaigns.active():\\n top_ranked_documents = utils._rank_documents(self.event)\\n # [TODO] this is a kludge\\n if set(top_ranked_documents) == set(self.documents.all()):\\n return False\\n print('[DEBUG] Docs changed! New campaign ahoy!')\\n self.documents = top_ranked_documents\\n return True\",\n \"def collection_post(self):\\n document = upload_file(self.request)\\n document.author = self.request.authenticated_role\\n self.context.documents.append(document)\\n if save_tender(self.request):\\n self.LOGGER.info(\\n \\\"Created tender qualification document {}\\\".format(document.id),\\n extra=context_unpack(\\n self.request, {\\\"MESSAGE_ID\\\": \\\"tender_qualification_document_create\\\"}, {\\\"document_id\\\": document.id}\\n ),\\n )\\n self.request.response.status = 201\\n document_route = self.request.matched_route.name.replace(\\\"collection_\\\", \\\"\\\")\\n self.request.response.headers[\\\"Location\\\"] = self.request.current_route_url(\\n _route_name=document_route, document_id=document.id, _query={}\\n )\\n return {\\\"data\\\": document.serialize(\\\"view\\\")}\",\n \"def spot_doc_rubrics2(doc_id, rubrics):\\n db.doc_apply(doc_id, spot_doc_rubrics, rubrics)\",\n \"def on_doctype_update():\\n\\tfrappe.db.add_index(\\\"Make Serial NO\\\", [\\\"item\\\", \\\"batch\\\"])\",\n \"def _update(self, count=True, forced=False):\",\n \"def test_update_with_document_boost(self):\\n u = stellr.UpdateCommand(TEST_HTTP)\\n u.add_documents({'a': 1}, boost=2.0)\\n self.assertEqual(u.body, '{\\\"add\\\": {\\\"doc\\\": {\\\"a\\\": 1}, \\\"boost\\\": 2.0}}')\",\n \"def after_insert(self):\\n if self.get('update_request') and not self.is_pending_approval():\\n self.update_request.created_docname = self.name\\n self.set_as_success()\",\n \"def put(self):\\n return super(TenderAwardContractDocumentResource, self).put()\",\n \"def put(self, request, code, suggested_format=None):\\n context = {'request': request}\\n conten_type = request.content_type\\n uploaded_obj = None\\n if 'multipart/form-data' in conten_type:\\n # We have a file upload encoded with multipart/form-data\\n file_content = StringIO(request.body)\\n parser = MultiPartParser()\\n dnf = parser.parse(file_content, media_type=conten_type, parser_context=context)\\n extra = dnf.data\\n if 'file' in dnf.files:\\n uploaded_obj = dnf.files['file']\\n else:\\n extra = request.QUERY_PARAMS\\n # TODO: do we require SQL tagging logic in this API call?\\n sql_tag_string = extra.get('tag_string', None)\\n sql_remove_tag_string = extra.get('remove_tag_string', None)\\n new_name = extra.get('new_name', None)\\n new_type = extra.get('new_type', None)\\n index_data = extra.get('indexing_data', None)\\n if index_data:\\n index_data = json.loads(index_data)\\n processor = DocumentProcessor()\\n options = {\\n 'tag_string': sql_tag_string,\\n 'remove_tag_string': sql_remove_tag_string,\\n 'extension': suggested_format,\\n 'new_name': new_name,\\n 'new_type': new_type,\\n 'new_indexes': index_data,\\n 'update_file': uploaded_obj,\\n 'user': request.user,\\n }\\n document = processor.update(code, options)\\n if len(processor.errors) > 0:\\n log.error('FileHandler.update manager errors %s' % processor.errors)\\n if settings.DEBUG:\\n print processor.errors\\n raise Exception('FileHandler.update manager errors')\\n else:\\n return Response(status=status.HTTP_400_BAD_REQUEST)\\n log.info('FileHandler.update request fulfilled for code: %s, extension: %s'\\n % (code, suggested_format))\\n resp = DMSOBjectRevisionsData(document).data\\n return Response(resp, status=status.HTTP_200_OK)\",\n \"def put(self):\\n if 'file' not in self.request.POST:\\n self.request.errors.add('body', 'file', 'Not Found')\\n self.request.errors.status = 404\\n return\\n tender = TenderDocument.load(self.db, self.tender_id)\\n if not tender:\\n self.request.errors.add('url', 'tender_id', 'Not Found')\\n self.request.errors.status = 404\\n return\\n data = self.request.POST['file']\\n bids = [i for i in tender.bids if i.id == self.bid_id]\\n if not bids:\\n self.request.errors.add('url', 'bid_id', 'Not Found')\\n self.request.errors.status = 404\\n return\\n bid = bids[0]\\n documents = [i for i in bid.documents if i.id == self.request.matchdict['id']]\\n if not documents:\\n self.request.errors.add('url', 'id', 'Not Found')\\n self.request.errors.status = 404\\n return\\n src = tender.serialize(\\\"plain\\\")\\n document = Document()\\n document.id = self.request.matchdict['id']\\n document.title = data.filename\\n document.format = data.type\\n document.datePublished = documents[0].datePublished\\n key = uuid4().hex\\n document.url = self.request.route_url('Tender Bid Documents', tender_id=self.tender_id, bid_id=self.bid_id, id=document.id, _query={'download': key})\\n bid.documents.append(document)\\n filename = \\\"{}_{}\\\".format(document.id, key)\\n tender['_attachments'][filename] = {\\n \\\"content_type\\\": data.type,\\n \\\"data\\\": b64encode(data.file.read())\\n }\\n patch = make_patch(tender.serialize(\\\"plain\\\"), src).patch\\n tender.revisions.append(revision({'changes': patch}))\\n try:\\n tender.store(self.db)\\n except Exception, e:\\n return self.request.errors.add('body', 'data', str(e))\\n return {'data': document.serialize(\\\"view\\\")}\",\n \"def update(self, doc):\\n if app.config.get(\\\"READ_ONLY_MODE\\\", False) and app.config.get(\\\"SCRIPTS_READ_ONLY_MODE\\\", False):\\n app.logger.warn(\\\"System is in READ-ONLY mode, update command cannot run\\\")\\n return\\n\\n return requests.post(self.target() + self.id + \\\"/_update\\\", data=json.dumps({\\\"doc\\\": doc}))\",\n \"def update(self, es, **kwargs):\\n pass\",\n \"def _put(self, name, document):\\n raise NotImplementedError\",\n \"def test_update_occurrence(self):\\n pass\",\n \"def patch(self):\\n if not self.validate_complaint_document(\\\"update\\\"):\\n return\\n if apply_patch(self.request, src=self.request.context.serialize()):\\n update_file_content_type(self.request)\\n self.LOGGER.info(\\n \\\"Updated tender award complaint document {}\\\".format(self.request.context.id),\\n extra=context_unpack(self.request, {\\\"MESSAGE_ID\\\": \\\"tender_award_complaint_document_patch\\\"}),\\n )\\n return {\\\"data\\\": self.request.context.serialize(\\\"view\\\")}\",\n \"def oe_update(self, cr, uid, external_session, existing_rec_id, vals, resource, defaults, context=None):\\n if context is None: context={}\\n context['referential_id'] = external_session.referential_id.id #did it's needed somewhere?\\n return self.write(cr, uid, existing_rec_id, vals, context)\",\n \"def test_queryset_update(self):\\n car = Car.objects.all()\\n car.index_to_appsearch(update_only=True)\\n # Note that the app search chunk size is set to 5 in `tests.settings`\\n # Therefore you should see 5 calls to cover 22 documents\\n self.assertEqual(self.client_update.call_count, 5)\",\n \"def updateDocument(self, document):\\n data = self.updateDocumentAll([document])\\n try:\\n return data[0]\\n except: pass\",\n \"def update( ):\\r\\n pass\",\n \"def update(self, *args, **kwargs):\",\n \"def update_records(self, something):\\n print(\\\"Some logic (not shown) to update database of units\\\")\",\n \"def update_relevant(query_string, doc_id, corpus):\\n #TODO update to toggle relevance (add/remove from relevent or nonrelevant lists)\\n relevance_dict = get_relevance_dict(corpus)\\n if relevance_dict.get(query_string):\\n #toggle\\n print(query_string + ' relevance toggled ' + corpus + str(doc_id))\\n relevance_dict[query_string] = toggle_relevance(relevance_dict[query_string], doc_id)\\n else:\\n print(query_string + ' not in dict yet')\\n #add_to_dict either after determine if relevent or non relevant\\n #create tuple with doc_id in relevant list\\n relevance_dict[query_string] = [doc_id], []\\n write_relevance_tocsv(relevance_dict, corpus)\",\n \"def _index_doc(self, db, doc_id):\\n doc = db.get(doc_id)\\n if doc is None:\\n log.warning(\\\"Unable to find document in database: '%s'\\\" % doc_id)\\n return\\n fields = doc.get('solr_fields')\\n fields = [\\\"payload\\\", \\\"timesaved\\\"]\\n if not fields:\\n log.debug(\\\"Document '%s' does not define solr_fields\\\" % doc_id)\\n return\\n updates = []\\n for field in fields:\\n if doc.has_key(field):\\n self.__normalize(updates, field, doc[field])\\n updates.extend([{'type' : 'any'}, {'_id' : doc_id}])\\n return updates\",\n \"def update_documents(self, engine_name, documents):\\n endpoint = \\\"engines/{}/documents\\\".format(engine_name)\\n data = json.dumps(documents)\\n\\n return self.swiftype_session.request('patch', endpoint, data=data)\",\n \"def test_update_documents_json(index_with_documents, small_movies_json_file):\\n index = index_with_documents()\\n response = index.update_documents_json(small_movies_json_file)\\n assert isinstance(response, TaskInfo)\\n assert response.task_uid is not None\\n task = index.wait_for_task(response.task_uid)\\n assert task.status == \\\"succeeded\\\"\\n assert index.get_primary_key() == \\\"id\\\"\",\n \"def test_update_with_overwrite(self):\\n u = stellr.UpdateCommand(TEST_HTTP)\\n u.add_documents({'a': 1}, overwrite=False)\\n self.assertEqual(\\n u.body, '{\\\"add\\\": {\\\"doc\\\": {\\\"a\\\": 1}, \\\"overwrite\\\": false}}')\",\n \"def _mark(self, query, doc):\\n raise NotImplementedError()\",\n \"def upgrade_to_21():\\n\\n def update_project_template(template):\\n new_template = {'acquisitions': []}\\n for a in template.get('acquisitions', []):\\n new_a = {'minimum': a['minimum']}\\n properties = a['schema']['properties']\\n if 'measurement' in properties:\\n m_req = properties['measurement']['pattern']\\n m_req = re.sub('^\\\\(\\\\?i\\\\)', '', m_req)\\n new_a['files']=[{'measurement': m_req, 'minimum': 1}]\\n if 'label' in properties:\\n l_req = properties['label']['pattern']\\n l_req = re.sub('^\\\\(\\\\?i\\\\)', '', l_req)\\n new_a['label'] = l_req\\n new_template['acquisitions'].append(new_a)\\n\\n return new_template\\n\\n def dm_v2_updates(cont_list, cont_name):\\n for container in cont_list:\\n\\n query = {'_id': container['_id']}\\n update = {'$rename': {'metadata': 'info'}}\\n\\n if cont_name == 'projects' and container.get('template'):\\n new_template = update_project_template(json.loads(container.get('template')))\\n update['$set'] = {'template': new_template}\\n\\n\\n if cont_name == 'sessions':\\n update['$rename'].update({'subject.metadata': 'subject.info'})\\n\\n\\n measurement = None\\n modality = None\\n info = None\\n if cont_name == 'acquisitions':\\n update['$unset'] = {'instrument': '', 'measurement': ''}\\n measurement = container.get('measurement', None)\\n modality = container.get('instrument', None)\\n info = container.get('metadata', None)\\n if info:\\n config.db.acquisitions.update_one(query, {'$set': {'metadata': {}}})\\n\\n\\n # From mongo docs: '$rename does not work if these fields are in array elements.'\\n files = container.get('files')\\n if files is not None:\\n updated_files = []\\n for file_ in files:\\n file_['info'] = {}\\n if 'metadata' in file_:\\n file_['info'] = file_.pop('metadata', None)\\n if 'instrument' in file_:\\n file_['modality'] = file_.pop('instrument', None)\\n if measurement:\\n # Move the acquisition's measurement to all files\\n if file_.get('measurements'):\\n file_['measurements'].append(measurement)\\n else:\\n file_['measurements'] = [measurement]\\n if info and file_.get('type', '') == 'dicom':\\n # This is going to be the dicom header info\\n updated_info = info\\n updated_info.update(file_['info'])\\n file_['info'] = updated_info\\n if modality and not file_.get('modality'):\\n file_['modality'] = modality\\n\\n updated_files.append(file_)\\n if update.get('$set'):\\n update['$set']['files'] = updated_files\\n else:\\n update['$set'] = {'files': updated_files}\\n\\n result = config.db[cont_name].update_one(query, update)\\n\\n query = {'$or':[{'files.metadata': { '$exists': True}},\\n {'metadata': { '$exists': True}},\\n {'files.instrument': { '$exists': True}}]}\\n\\n dm_v2_updates(config.db.collections.find(query), 'collections')\\n\\n query['$or'].append({'template': { '$exists': True}})\\n dm_v2_updates(config.db.projects.find({}), 'projects')\\n\\n query['$or'].append({'subject': { '$exists': True}})\\n dm_v2_updates(config.db.sessions.find(query), 'sessions')\\n\\n query['$or'].append({'instrument': { '$exists': True}})\\n query['$or'].append({'measurement': { '$exists': True}})\\n dm_v2_updates(config.db.acquisitions.find(query), 'acquisitions')\",\n \"def update(self, *args, **kwargs): \\n kwargs[\\\"sampleID\\\"] = self.__sampleID\\n kwargs[\\\"sampleMetaID\\\"] = self.id()\\n self._eLABJournalObject__api.update_sample_meta(*list(args), **dict(kwargs))\\n rp = self._eLABJournalObject__api._request(\\\"/api/v1/samples/\\\"+urllib.parse.quote(str(kwargs[\\\"sampleID\\\"]))+\\\"/meta/\\\"+urllib.parse.quote(str(kwargs[\\\"sampleMetaID\\\"])), \\\"get\\\", {})\\n #check and get\\n if (rp is not None) & (type(rp) == dict):\\n self.__init__(self._eLABJournalObject__api,kwargs[\\\"sampleID\\\"],rp) \\n else:\\n print(dict)\\n raise Exception(\\\"couldn't perform selfupdate\\\")\",\n \"def collection_post(self):\\n return super(TenderAwardDocumentResource, self).collection_post()\",\n \"def testUpdateFailedDoc(self):\\n change = ChangeState(self.config, \\\"changestate_t\\\")\\n\\n locationAction = self.daoFactory(classname=\\\"Locations.New\\\")\\n locationAction.execute(\\\"site1\\\", pnn=\\\"T2_CH_CERN\\\")\\n\\n testWorkflow = Workflow(spec=self.specUrl, owner=\\\"Steve\\\",\\n name=\\\"wf001\\\", task=self.taskName)\\n testWorkflow.create()\\n testFileset = Fileset(name=\\\"TestFileset\\\")\\n testFileset.create()\\n testSubscription = Subscription(fileset=testFileset,\\n workflow=testWorkflow,\\n split_algo=\\\"FileBased\\\")\\n testSubscription.create()\\n\\n testFileA = File(lfn=\\\"SomeLFNA\\\", events=1024, size=2048,\\n locations=set([\\\"T2_CH_CERN\\\"]))\\n testFileA.create()\\n testFileset.addFile(testFileA)\\n testFileset.commit()\\n\\n splitter = SplitterFactory()\\n jobFactory = splitter(package=\\\"WMCore.WMBS\\\",\\n subscription=testSubscription)\\n jobGroup = jobFactory(files_per_job=1)[0]\\n\\n testJobA = jobGroup.jobs[0]\\n testJobA[\\\"user\\\"] = \\\"sfoulkes\\\"\\n testJobA[\\\"group\\\"] = \\\"DMWM\\\"\\n testJobA[\\\"taskType\\\"] = \\\"Merge\\\"\\n testJobA[\\\"couch_record\\\"] = str(testJobA[\\\"id\\\"])\\n\\n change.propagate([testJobA], \\\"new\\\", \\\"none\\\")\\n testJobADoc = change.jobsdatabase.document(testJobA[\\\"couch_record\\\"])\\n\\n self.assertTrue(\\\"states\\\" in testJobADoc)\\n self.assertTrue(\\\"1\\\" in testJobADoc[\\\"states\\\"])\\n\\n testFileB = File(lfn=\\\"SomeLFNB\\\", events=1024, size=2048,\\n locations=set([\\\"T2_CH_CERN\\\"]))\\n testFileB.create()\\n testFileset.addFile(testFileB)\\n testFileset.commit()\\n\\n splitter = SplitterFactory()\\n jobFactory = splitter(package=\\\"WMCore.WMBS\\\",\\n subscription=testSubscription)\\n jobGroup = jobFactory(files_per_job=1)[0]\\n\\n testJobB = jobGroup.jobs[0]\\n testJobB[\\\"user\\\"] = \\\"sfoulkes\\\"\\n testJobB[\\\"group\\\"] = \\\"DMWM\\\"\\n testJobB[\\\"taskType\\\"] = \\\"Merge\\\"\\n testJobB[\\\"couch_record\\\"] = newstr(testJobB[\\\"id\\\"])\\n\\n change.propagate([testJobB], \\\"new\\\", \\\"none\\\")\\n testJobBDoc = change.jobsdatabase.document(testJobB[\\\"couch_record\\\"])\\n\\n self.assertTrue(\\\"states\\\" in testJobBDoc)\\n self.assertTrue(\\\"1\\\" in testJobBDoc[\\\"states\\\"])\\n return\",\n \"def test_update_documents_ndjson(index_with_documents, songs_ndjson):\\n index = index_with_documents()\\n response = index.update_documents_ndjson(songs_ndjson)\\n assert isinstance(response, TaskInfo)\\n assert response.task_uid is not None\\n task = index.wait_for_task(response.task_uid)\\n assert task.status == \\\"succeeded\\\"\\n assert index.get_primary_key() == \\\"id\\\"\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def test_update_transcript(self):\\n response = self.client.post(reverse('update-transcript',\\n args=[self.gel_ir.id,\\n self.proband_variant.id,\\n self.transcript2.id]),\\n follow=True)\\n self.assertContains(response, 'Transcript Updated')\\n self.assertEquals(response.status_code, 200)\\n response = self.client.get(reverse('proband-view', args=[self.gel_ir.id]))\\n self.assertContains(response, self.transcript2.name)\",\n \"def Regen(self,enum):\\n\\t\\tself.acad.ActiveDocument.Regen(enum)\",\n \"def update(self, spec, document, upsert=False, multi=False):\\n return self.database.connection.request.update_documents(\\n self.database.name, self.name, spec, document, upsert, multi)\",\n \"def add_doc(writer, entry):\\n m = 0\\n q_id = entry['Id']\\n snippets = get_possible_snippets(q_id, False)\\n for code, lang, ans_id in snippets:\\n writer.add_document(question_id=q_id, answer_id=ans_id, code=return_unicode(code), language=return_unicode(lang))\\n m += 1\\n return m\",\n \"def update_filedetails_ajax(request):\\n try:\\n document_id = request.GET.get('document_id')\\n tag = request.GET.get('tag')\\n get_index = find_index_with_document(document_id)\\n updated_data = update(get_index, document_id, tag)\\n return JsonResponse({\\\"fs_metadata\\\": updated_data, \\\"message\\\": \\\"Success\\\", \\\"status_code\\\": \\\"200\\\"})\\n except Exception as e:\\n print(\\\"Update Error : \\\", e)\\n return False\",\n \"def test_update(self):\\n u = stellr.UpdateCommand(TEST_HTTP, commit_within=60000)\\n self.assertEqual(u.host, 'http://localhost:8983')\\n self.assertEqual(u._handler, ('/solr/update/json?'\\n 'wt=json&commitWithin=60000'))\\n\\n a = SimpleObject(DOCUMENTS[0][0], DOCUMENTS[0][1], DOCUMENTS[0][2])\\n u.add_documents(a)\\n\\n b = dict()\\n for i, field in enumerate(FIELDS):\\n b[field] = DOCUMENTS[1][i]\\n u.add_documents(b)\\n\\n self.assertEqual(len(u._commands), 2)\\n for i, comm in enumerate(u._commands):\\n self.assertEqual(comm[0], 'add')\\n self.assertTrue('doc' in comm[1])\\n for field, value in comm[1]['doc'].iteritems():\\n field_ord = FIELDS.index(field)\\n self.assertEqual(DOCUMENTS[i][field_ord], value)\",\n \"def update():\",\n \"def update():\",\n \"def update(self, docs: DocumentArray, *args, **kwargs):\\n cursor = self.connection.cursor()\\n psycopg2.extras.execute_batch(\\n cursor,\\n f'UPDATE {self.table} SET DOC = %s WHERE ID = %s',\\n [\\n (\\n doc.SerializeToString(),\\n doc.id,\\n )\\n for doc in docs\\n ],\\n )\\n self.connection.commit()\",\n \"def update(self, data):\\n self.data = data\\n # extract data\\n subject = data.identifier\\n self.id = _uri_to_oai(subject)\\n self.modified = datetime.utcnow()\\n self.deleted = False\\n\\n itemtype, subtype = _get_itemtype(data, subject)\\n\\n self.metadata = {}\\n\\n # fixed fields:\\n self.metadata['rif_key'] = _uri_to_key(subject)\\n self.metadata['rif_group'] = self.provider.groupDescription\\n self.metadata['rif_originatingSource'] = self.provider.originatingSource\\n self.metadata['rif_object'] = {'value': itemtype,\\n 'type': subtype,\\n #'dateModified': '',\\n }\\n\\n if itemtype == 'collection':\\n self.updateCollection(data, subject)\\n elif itemtype == 'party':\\n if subtype == 'person':\\n self.updatePartyPerson(data, subject)\\n else:\\n self.updateParty(data, subject)\\n elif itemtype == 'activity':\\n self.updateActivity(data, subject)\\n elif itemtype == 'service':\\n self.updateService(data, subject)\",\n \"def test_kyc_put_document_shareholder(self):\\n pass\",\n \"def update(*args):\",\n \"def test_update_with_field_boost(self):\\n u = stellr.UpdateCommand(TEST_HTTP)\\n u.add_documents({'a': { 'value': 'f', 'boost': 2.0}})\\n self.assertEqual(u.body, ('{\\\"add\\\": {\\\"doc\\\": {\\\"a\\\": '\\n '{\\\"boost\\\": 2.0, \\\"value\\\": \\\"f\\\"}}}}'))\",\n \"def m_req_Update(self, sender, e):\\r\\n if e.Instrument != None and e.Error == None:\\r\\n # Instrument was found\\r\\n print(\\\"Found: {0}\\\".format(e.Instrument.Name))\\r\\n # Subscribe for Inside Market Data\\r\\n self.m_ps = ttapi.PriceSubscription(e.Instrument, ttapi.Dispatcher.Current)\\r\\n self.m_ps.Settings = ttapi.PriceSubscriptionSettings(ttapi.PriceSubscriptionType.InsideMarket)\\r\\n self.m_ps.FieldsUpdated += self.m_ps_FieldsUpdated\\r\\n self.m_ps.Start()\\r\\n elif e.IsFinal:\\r\\n # Instrument was not found and TT API has given up looking for it\\r\\n print(\\\"Cannot find instrument: {0}\\\".format(e.Error.Message))\\r\\n self.Dispose()\",\n \"def updateDoc(self, path):\\n self.db.setDb(self.db_file)\\n \\n if not self.authd:\\n self._authorize()\\n \\n db_row = self.db.getRowFromPath(path)\\n if not db_row:\\n return False\\n \\n resource_id = db_row[0]\\n etag = db_row[1]\\n title = db_row[2]\\n \\n ms = gdata.data.MediaSource(file_path=path, content_type=MIMETYPES['ODT'])\\n doc = self.client.GetDoc(resource_id.replace(':', '%3A'))\\n new_version = self.client.Update(doc, media_source=ms)\\n print 'Document pushed:', new_version.GetAlternateLink().href\\n \\n self.db.resetEtag(new_version)\",\n \"def update_qualification(qual_id: int) -> Dict[str, Any]:\\n qualification_schema = QualificationSchema()\\n qualification = qualification_schema.load(request.json)\\n if qualification[\\\"id\\\"] != qual_id:\\n raise APIError(reason=\\\"incorrect_id\\\", status_code=400)\\n\\n if Qualification.query.filter_by(id=qual_id).count() < 1:\\n raise APIError(reason=\\\"no_such_object\\\", status_code=400)\\n\\n qualification_obj = Qualification.query.get(qual_id)\\n\\n try:\\n qualification_obj.name = qualification[\\\"name\\\"]\\n db.session.commit()\\n except IntegrityError:\\n raise APIError(reason=\\\"qualification_exists\\\", status_code=400)\\n\\n return cast(Dict[str, Any], qualification)\",\n \"def update_transcript_info(ensembl_info, word, value):\\n if \\\"transcript\\\" in word:\\n if \\\"id\\\" in word:\\n ensembl_info[\\\"ensembl_transcript_id\\\"] = value\\n elif \\\"start\\\" in word:\\n ensembl_info[\\\"transcript_start\\\"] = int(value)\\n elif \\\"end\\\" in word:\\n ensembl_info[\\\"transcript_end\\\"] = int(value)\\n return ensembl_info\",\n \"def test_model_object_update(self):\\n car = Car.objects.first()\\n car.index_to_appsearch(update_only=True)\\n self.assertEqual(self.client_update.call_count, 1)\",\n \"def update_document(obj):\\n index = obj.get_index_name()\\n doc_type = obj.get_document_type()\\n body = dict(doc=obj.get_document_body())\\n try:\\n ES.update(index=index, doc_type=doc_type, body=body, id=obj.pk)\\n except NotFoundError:\\n raise DocumentNotFound(obj.get_index_name(), obj.pk)\",\n \"def updateAnnoByMetadata(syn, synId, metaDf, refCol, cols2Add,fileExts):\\n \\n if type(synId) is list:\\n print \\\"Input is a list of Synapse IDs \\\\n\\\"\\n for synID in synId:\\n print \\\"Getting File %s ...\\\" % synID\\n temp = syn.get(synID,downloadFile = False)\\n _helperUpdateAnnoByMetadata(syn,temp,metaDf,refCol,cols2Add,fileExts)\\n else:\\n print \\\"Input is a Synpase ID \\\\n\\\"\\n starting = syn.get(synId,downloadFile = False)\\n if not is_container(starting):\\n print \\\"%s is a File \\\\n\\\" % synId\\n _helperUpdateAnnoByMetadata(syn,starting,metaDf,refCol,cols2Add,fileExts)\\n else:\\n directory = synu.walk(syn,synId)\\n for dirpath,dirname,filename in directory:\\n for i in filename:\\n temp = syn.get(i[1],downloadFile = False)\\n print \\\"Getting File %s ...\\\" % i[1]\\n _helperUpdateAnnoByMetadata(syn,temp,metaDf,refCol,cols2Add,fileExts)\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def test_partial_update_metadata1(self):\\n pass\",\n \"def savedoc():\\r\\n document.save('QSDoc_{0}_{1}_{2}_{3}.docx'.format(args.server, year, month, day))\",\n \"def merge_docs(self):\",\n \"def test_update_record(self):\\n pass\",\n \"def update_index(self, document):\\n\\t\\tix = self.get_index()\\n\\n\\t\\twith ix.searcher():\\n\\t\\t\\twriter = AsyncWriter(ix)\\n\\t\\t\\twriter.delete_by_term(self.id, document[self.id])\\n\\t\\t\\twriter.add_document(**document)\\n\\t\\t\\twriter.commit(optimize=True)\",\n \"def test_partial_update_metadata(self):\\n pass\",\n \"def update_docs():\\n managepy('update_docs', site='docs')\",\n \"def updatePublicationFromSymplectic(publication_object):\\r\\n #description \\r\\n #checking\\r\\n if not(publication_object) or (publication_object.guid == ''):\\r\\n return \\r\\n #symplectic api url and local file path\\r\\n url = SYMPLECTIC_API_URL + 'publications/' + publication_object.guid\\r\\n tmp_filename = SYMPLECTIC_LOCAL_XML_FOLDER + SYMPLECTIC_LOCAL_PUBS_FOLDER + publication_object.guid + '.xml'\\r\\n #get xml document from symplectic api and store on hd\\r\\n (tmp_filename, http_headers,) = urllib.urlretrieve(url, tmp_filename)\\r\\n #parse xml file\\r\\n pub_etree = ElementTree(file=tmp_filename)\\r\\n #delete local file from hd\\r\\n #try:\\r\\n os.remove(tmp_filename)\\r\\n #except:\\r\\n #pass \\r\\n #++++++PUBLICATION++++++\\r\\n #publication element\\r\\n pub_element = pub_etree.getroot()\\r\\n #no loading-of/blank publication object required as updating the one passed in\\r\\n #check returned xml element is valid and for correct publication\\r\\n if pub_element is None:\\r\\n return\\r\\n elif publication_object.guid != pub_element.get('id',''):\\r\\n return\\r\\n #publication attributes\\r\\n if pub_element is not None:\\r\\n publication_object.new_id = pub_element.get('new-id')\\r\\n if pub_element.get('is-deleted','false') == 'true':\\r\\n publication_object.is_deleted = True\\r\\n else:\\r\\n publication_object.is_deleted = False\\r\\n publication_object.type = pub_element.get('type','')\\r\\n publication_object.created_when = pub_element.get('created-when','')\\r\\n publication_object.last_modified_when = pub_element.get('last-modified-when','')\\r\\n #just fetched latest version from symplectic\\r\\n publication_object.needs_refetch = False\\r\\n #save updated publication object\\r\\n publication_object.save()\\r\\n #++++++BIBLIOGRAPHIC-RECORD++++++\\r\\n #bibliographic-record elements are held in a subtree\\r\\n biblio_subtree = pub_etree.find(SYMPLECTIC_NAMESPACE + 'bibliographic-records')\\r\\n #check if any bibliographic-record elements in subtree\\r\\n if biblio_subtree is None or len(biblio_subtree) < 1:\\r\\n return\\r\\n #for each bibliographic-record element in subtree\\r\\n for biblio_element in biblio_subtree.getchildren():\\r\\n SymplecticXMLPubs.__createBiblioObjFromBiblioElement(biblio_element, publication_object)\",\n \"def update_existing(doc_data_tples):\\n def per_doc(doc, data_tples):\\n def per_field(data_tple):\\n field, datas = data_tple\\n map(_do_append_field(doc, field), datas)\\n map(per_field, data_tples)\\n return doc\\n\\n __docs = ( (per_doc(doc, data_tples), data_tples) for doc,data_tples in doc_data_tples )\\n return __docs\",\n \"def run():\\n\\n #django patient -> django_uuid = new\\n #cpatient-> doc_id = case_id, doc_id = new, == to djpatient.django_uuid\\n\\n #this needs to be coupled with fixing up the patient/all querying\\n #patient/all needs to emit the case_id\\n patients = Patient.objects.all()\\n db = get_db()\\n for p in patients:\\n print \\\"Flipping ID Patient ID: %s: Couchdoc: %s\\\" % (p.id, p.doc_id)\\n #so the p.couchdoc is useless here because if the model code is changed we need to do it manually.\\n\\n #establish the updated ids and get them separated out\\n real_case_id = p.doc_id + \\\"\\\" #the doc_id had been used as the case_id which in real casexml, that's bad.\\n new_doc_id = uuid.uuid1().hex #now make a new doc_id for the patient document.\\n\\n couchdoc = db.open_doc(p.doc_id)\\n\\n #flip the document ids.\\n copy_doc = PactPatient.wrap(couchdoc)\\n copy_doc.case_id = real_case_id\\n copy_doc._id = new_doc_id\\n copy_doc.doc_type = PactPatient.__name__\\n copy_doc.save()\\n p.doc_id = new_doc_id\\n p._couchdoc = copy_doc\\n p.save()\\n print \\\"\\\\tSwapping case id %s -> %s\\\" % (real_case_id, new_doc_id)\\n\\n #having just saved it, we need to now remove the original id\\n dupe_doc = db.open_doc(real_case_id) #the old doc_id\\n delresult = db.delete_doc(dupe_doc)\\n print \\\"\\\\tDeleting doc %s\\\" % (real_case_id)\\n print \\\"\\\\t%s\\\" % (delresult)\\n\\n i = 0\\n while db.doc_exist(real_case_id):\\n i+= 1\\n print \\\"\\\\tTrying to freaking delete!!!\\\"\\n print \\\"\\\\tReally deleting doc %s\\\" % (real_case_id)\\n delresult = db.delete_doc(dupe_doc)\\n print \\\"\\\\t%s\\\" % (delresult)\\n if i == 10:\\n break\",\n \"def obj_update(self, bundle, **kwargs):\\n logger.info(\\\"Updating acknowledgement...\\\")\\n \\n bundle = super(AcknowledgementResource, self).obj_update(bundle, **kwargs)\\n \\n bundle.obj.create_and_upload_pdfs()\\n \\n return bundle\",\n \"def update(self, index, id, **kwargs):\\n url = f'{self.host}{index}/_doc/{id}/_update'\\n data = {'doc': {**kwargs}}\\n requests.post(url, json=data)\\n self.flush(index)\\n return self.get(index, id)\",\n \"def update(db, spec, doc):\\n resp = db.sole.sole.update(spec, doc, upsert=False, safe=True)\\n if (resp.get('updatedExisting') == False):\\n return False\\n return True\",\n \"def test_update_enrollment_term(self):\\n # This method utilises the PUT request method and will make changes to the Canvas instance. This needs consideration.\\n pass\",\n \"def updateUniqueID(self, updateAll=False):\\n fieldsFound = False\\n for format in self.values():\\n if format.findUniqueIDFields():\\n fieldsFound = True\\n if updateAll and fieldsFound:\\n globalref.docRef.root.setDescendantUniqueID()\",\n \"def update(self) -> None:\\n ...\",\n \"def test_audiobook_can_update(self):\\n\\n data = {\\n \\\"audiotype\\\": \\\"Audiobook\\\",\\n \\\"metadata\\\": {\\n \\\"title\\\": \\\"audiobook1\\\",\\n \\\"duration\\\": 45678,\\n \\\"author\\\": \\\"Solomon\\\",\\n \\\"narrator\\\": \\\"Aniefiok\\\"\\n }\\n }\\n\\n num = str(3)\\n\\n response = requests.put(\\n \\\"http://localhost:9001/api/update-audio/Audiobook/\\\"+num, json=data)\\n\\n self.assertEqual(response.status_code, 200)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67698103","0.65418416","0.60076684","0.5916366","0.57062167","0.5689535","0.56196195","0.5519839","0.55059135","0.54753315","0.547409","0.54489356","0.5429259","0.5393973","0.5376314","0.5374029","0.53423685","0.5339217","0.5326033","0.52789885","0.52690953","0.5261485","0.5247339","0.5231342","0.5226704","0.5197106","0.517817","0.5164497","0.51639307","0.5142664","0.5141903","0.5141083","0.51404345","0.51391447","0.5138243","0.5126502","0.5115912","0.511426","0.5107035","0.50833327","0.5078725","0.5068537","0.50497997","0.5034008","0.50205034","0.50190866","0.5017003","0.5016549","0.5010162","0.5009255","0.49994835","0.49964726","0.498955","0.49877134","0.49852523","0.49852523","0.49852523","0.49852523","0.49852523","0.49852523","0.49768794","0.49689263","0.4959088","0.49544924","0.49413627","0.494116","0.49382424","0.49382424","0.49350843","0.4933525","0.49218658","0.49196678","0.4915043","0.49116912","0.49111745","0.4910829","0.49043444","0.4903549","0.48951435","0.48909396","0.48906064","0.48906064","0.48906064","0.4887571","0.48831585","0.488163","0.4876041","0.48758197","0.48745343","0.48724082","0.4863751","0.4863297","0.48575783","0.48539865","0.485082","0.48478785","0.48432186","0.48429066","0.4842549","0.4839649"],"string":"[\n \"0.67698103\",\n \"0.65418416\",\n \"0.60076684\",\n \"0.5916366\",\n \"0.57062167\",\n \"0.5689535\",\n \"0.56196195\",\n \"0.5519839\",\n \"0.55059135\",\n \"0.54753315\",\n \"0.547409\",\n \"0.54489356\",\n \"0.5429259\",\n \"0.5393973\",\n \"0.5376314\",\n \"0.5374029\",\n \"0.53423685\",\n \"0.5339217\",\n \"0.5326033\",\n \"0.52789885\",\n \"0.52690953\",\n \"0.5261485\",\n \"0.5247339\",\n \"0.5231342\",\n \"0.5226704\",\n \"0.5197106\",\n \"0.517817\",\n \"0.5164497\",\n \"0.51639307\",\n \"0.5142664\",\n \"0.5141903\",\n \"0.5141083\",\n \"0.51404345\",\n \"0.51391447\",\n \"0.5138243\",\n \"0.5126502\",\n \"0.5115912\",\n \"0.511426\",\n \"0.5107035\",\n \"0.50833327\",\n \"0.5078725\",\n \"0.5068537\",\n \"0.50497997\",\n \"0.5034008\",\n \"0.50205034\",\n \"0.50190866\",\n \"0.5017003\",\n \"0.5016549\",\n \"0.5010162\",\n \"0.5009255\",\n \"0.49994835\",\n \"0.49964726\",\n \"0.498955\",\n \"0.49877134\",\n \"0.49852523\",\n \"0.49852523\",\n \"0.49852523\",\n \"0.49852523\",\n \"0.49852523\",\n \"0.49852523\",\n \"0.49768794\",\n \"0.49689263\",\n \"0.4959088\",\n \"0.49544924\",\n \"0.49413627\",\n \"0.494116\",\n \"0.49382424\",\n \"0.49382424\",\n \"0.49350843\",\n \"0.4933525\",\n \"0.49218658\",\n \"0.49196678\",\n \"0.4915043\",\n \"0.49116912\",\n \"0.49111745\",\n \"0.4910829\",\n \"0.49043444\",\n \"0.4903549\",\n \"0.48951435\",\n \"0.48909396\",\n \"0.48906064\",\n \"0.48906064\",\n \"0.48906064\",\n \"0.4887571\",\n \"0.48831585\",\n \"0.488163\",\n \"0.4876041\",\n \"0.48758197\",\n \"0.48745343\",\n \"0.48724082\",\n \"0.4863751\",\n \"0.4863297\",\n \"0.48575783\",\n \"0.48539865\",\n \"0.485082\",\n \"0.48478785\",\n \"0.48432186\",\n \"0.48429066\",\n \"0.4842549\",\n \"0.4839649\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6004739"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":84577,"cells":{"query":{"kind":"string","value":"Return _aware_ `datetime.now()` object in UTC timezone. This function must be used to insert or update `datetime` fields in the database, otherwise the validation `validate_utc` will reject the value."},"document":{"kind":"string","value":"def utcnow():\n # From the Python documentation:\n # https://docs.python.org/3/library/datetime.html#datetime.datetime.utcnow\n # datetime.utcnow()\n # Return the current UTC date and time, with `tzinfo None`.\n # This is like `now()`, but returns the current UTC date and time, as a\n # naive `datetime` object. An aware current UTC datetime can be obtained\n # by calling `datetime.now(timezone.utc)`. See also `now()`.\n # Warning:\n # Because naive datetime objects are treated by many datetime methods\n # as local times, it is preferred to use aware datetimes to represent\n # times in UTC. As such, the recommended way to create an object\n # representing the current time in UTC is by calling\n # `datetime.now(timezone.utc)`.\n return datetime.datetime.now(datetime.timezone.utc)"},"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 datetime_utc_now() -> datetime:\n return datetime.now(timezone.utc)","def now_utc() -> datetime:\n return datetime.now(timezone.utc)","def utc_now():\n return datetime.now(tz=timezone.utc)","def get_utc_now():\n return datetime.datetime.utcnow().replace(tzinfo=pytz.timezone(\"UTC\"))","def nowUTC():\n return datetime.datetime.now(pytz.utc)","def utcnow() -> datetime.datetime:\n return datetime.datetime.utcnow().replace(tzinfo=pytz.UTC)","def datetime_utcnow() -> datetime:\n return datetime.now(tz=pytz.timezone('UTC'))","def _get_now():\n return datetime.now(tz=timezone.utc)","def _now():\n return datetime.datetime.utcnow().replace(tzinfo=pytz.utc)","def now():\n return datetime.datetime.now(pytz.utc)","def utcnow():\n return datetime.utcnow().replace(tzinfo=UTC)","def _now():\n return datetime.now(timezone.utc).astimezone()","def now_datetime():\n return datetime.utcnow().replace(tzinfo=timezone)","def utc_now():\n realtime = datetime.utcnow()\n realtime = pytz.utc.localize(realtime)\n return realtime","def get_now():\n return dt.datetime.now(dt.timezone.utc)","def now_dt(tz='UTC'):\n if tz != 'UTC':\n raise NotImplementedError()\n return datetime.datetime.utcnow().replace(tzinfo = pytz.utc)","def now(self):\n if 'timezone' in self._data:\n return pytz.utc.localize(datetime.datetime.utcnow()).astimezone(pytz.timezone(self._data['timezone']))\n else:\n return pytz.utc.localize(datetime.datetime.utcnow())","def db_datetime_utc():\n t = datetime.datetime.utcnow()\n return time.mktime(t.timetuple())","def get_now():\n local_tz = timezone(os.getenv('TZ', settings.TIME_ZONE))\n return datetime.datetime.now(tz=local_tz)","def get_today_utc():\n return pytz.utc.localize(datetime.datetime.utcnow()).replace(\n hour=0, minute=0, second=0, microsecond=0\n )","def get_today_utc():\n return pytz.utc.localize(datetime.datetime.utcnow()).replace(\n hour=0, minute=0, second=0, microsecond=0\n )","def get_now_utc(no_microseconds=True):\n if no_microseconds:\n return pytz.utc.localize(datetime.datetime.utcnow()).replace(\n microsecond=0\n )\n else:\n return pytz.utc.localize(datetime.datetime.utcnow())","def get_now_utc(no_microseconds=True):\n if no_microseconds:\n return pytz.utc.localize(datetime.datetime.utcnow()).replace(\n microsecond=0\n )\n else:\n return pytz.utc.localize(datetime.datetime.utcnow())","def utcnow(cls):\n t = _time.time()\n return cls.utcfromtimestamp(t)","def test_freeze_with_timezone_aware_datetime_in_utc():\n utc_now = datetime.datetime.utcnow()\n assert utc_now.tzinfo is None","async def datetime(self, aware=False) -> dt.datetime:\n if aware is True:\n now = await self.AD.sched.get_now()\n return now.astimezone(self.AD.tz)\n else:\n return await self.AD.sched.get_now_naive()","def utcnow():\r\n if utcnow.override_time:\r\n try:\r\n return utcnow.override_time.pop(0)\r\n except AttributeError:\r\n return utcnow.override_time\r\n return datetime.datetime.utcnow()","def utcnow():\n if utcnow.override_time:\n try:\n return utcnow.override_time.pop(0)\n except AttributeError:\n return utcnow.override_time\n return datetime.datetime.utcnow()","def _getUTC(self, config = {} ):\n # Default implementation: get system local time\n return datetime.datetime.utcnow()","def test_freeze_with_timezone_aware_datetime_in_non_utc():\n utc_now = datetime.datetime.utcnow()\n assert utc_now.tzinfo is None\n assert utc_now == datetime.datetime(1970, 1, 1, 4)","def now(cls, tz=None):\n return datetime()","def get_now(self, tz=None):\n return get_now(tz=tz, default_tz=self.default_tz)","def datetime_now():\n return datetime.datetime.now(GB_TZ)","async def get_now(self) -> dt.datetime:\n now = await self.AD.sched.get_now()\n return now.astimezone(self.AD.tz)","def utc():\n return date_from_utc(dt.utcnow())","def NOW(tz=None):\n return datetime.datetime.now(_get_tzinfo(tz))","def static_now():\n return datetime.datetime(2000, 9, 4).replace(tzinfo=timezone.utc)","def date_now(*, convert_to_current_timezone: bool = False, utc: bool = False):\n now = datetime.datetime.now()\n\n if convert_to_current_timezone:\n now = date_make_timezone_aware(now)\n\n if utc:\n now = date_to_utc(now)\n\n return now","def tz_aware(value: datetime) -> datetime:\n if settings.USE_TZ:\n value = value.replace(tzinfo=timezone.utc)\n\n return value","def now():\n return datetime.datetime.utcnow()","def omniscient_datetime(*args):\n d = original_datetime(*args)\n if settings.USE_TZ:\n d = timezone.make_aware(d, timezone.utc)\n return d","def FromNowUTC(cls):\n t = pytime.time()\n utcTime = pytime.gmtime(t)\n return cls.FromStructTime(utcTime).WithZone(zDirection=0)","def get_time(self):\n return datetime.datetime.now(self.time_zone)","def get_utc_now_timestamp() -> int:\n return int(datetime.datetime.now(datetime.timezone.utc).timestamp() * 1000)","def _Now():\n return datetime.datetime.utcnow()","def now():\n return utcfromtimestamp(time.time())","def _utcnow(self):\n return datetime.datetime.utcnow()","def now (self):\n return datetime.datetime.utcnow ()","def utcnow():\n utctime = datetime.datetime.utcnow()\n utcstamp = utctime.strftime(\"%Y-%m-%d %H:%M:%S\")\n return utcstamp","def currentUTC():\n return str(datetime.utcnow())","def now():\n return datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')","def test_get_current_time_is_in_utc() -> None:\n time_provider = TimeProvider()\n current_time = time_provider.get_current_time()\n\n assert current_time.as_datetime().timezone == UTC","def now() -> datetime:\n now = datetime.now(tz=timezone.utc)\n return now.replace(microsecond=now.microsecond - now.microsecond % 1000)","def setup_datetime(self):\n \n current_date_time = datetime.now()\n timezone_diference = timedelta(hours=-3)\n return timezone(timezone_diference), current_date_time","def isoformat_now():\n return datetime_isoformat(datetime.datetime.utcnow())","def now(cls):\n return DateTime(*time.localtime())","def utcnow_ts():\r\n return calendar.timegm(utcnow().timetuple())","def get_zone_aware_datetime(date):\n return datetime.combine(date, datetime.max.time(), pytz.UTC) if date else None","def now_iso():\n return to_iso(now())","def tstamp_now(self):\n return self.tstamp(datetime.datetime.now(tz))","def mock_datetime_utc(*dec_args, **dec_kwargs):\n # We record original values currently stored in the datetime.datetime and\n # datetime.date here. Note that they are no necessarily vanilla Python types\n # and can already be mock classes - this can happen if nested mocking is used.\n original_datetime = datetime.datetime\n original_date = datetime.date\n\n # Our metaclass must be derived from the parent class metaclass, but if the\n # parent class doesn't have one, we use 'type' type.\n class MockDateTimeMeta(original_datetime.__dict__.get('__metaclass__', type)):\n @classmethod\n def __instancecheck__(cls, instance):\n return isinstance(instance, original_datetime)\n\n class _MockDateTime(original_datetime):\n __metaclass__ = MockDateTimeMeta\n mock_utcnow = original_datetime(*dec_args, **dec_kwargs)\n \n @classmethod\n def utcnow(cls):\n return cls.mock_utcnow\n \n @classmethod\n def now(cls, tz=None):\n if not tz:\n tz = tzlocal.get_localzone()\n tzaware_utcnow = pytz.utc.localize(cls.mock_utcnow)\n return tz.normalize(tzaware_utcnow.astimezone(tz)).replace(tzinfo=None)\n \n @classmethod\n def today(cls):\n return cls.now().date()\n\n @classmethod\n def fromtimestamp(cls, timestamp, tz=None):\n if not tz:\n # TODO(sergiyb): This may fail for some unclear reason because pytz\n # doesn't find normal timezones such as 'Europe/Berlin'. This seems to\n # happen only in appengine/chromium_try_flakes tests, and not in tests\n # for this module itself.\n tz = tzlocal.get_localzone()\n tzaware_dt = pytz.utc.localize(cls.utcfromtimestamp(timestamp))\n return tz.normalize(tzaware_dt.astimezone(tz)).replace(tzinfo=None)\n \n # Our metaclass must be derived from the parent class metaclass, but if the\n # parent class doesn't have one, we use 'type' type.\n class MockDateMeta(original_date.__dict__.get('__metaclass__', type)):\n @classmethod\n def __instancecheck__(cls, instance):\n return isinstance(instance, original_date)\n\n class _MockDate(original_date):\n __metaclass__ = MockDateMeta\n\n @classmethod\n def today(cls):\n return _MockDateTime.today()\n\n @classmethod\n def fromtimestamp(cls, timestamp, tz=None):\n return _MockDateTime.fromtimestamp(timestamp, tz).date()\n\n def decorator(func):\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n with mock.patch('datetime.datetime', _MockDateTime):\n with mock.patch('datetime.date', _MockDate):\n return func(*args, **kwargs)\n return wrapper\n return decorator","def created_time_utc(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"created_time_utc\")","def _database_time_now(self) -> datetime:\n return self._engine.execute(select([func.now()])).scalar()","def make_tz_aware(local_dt):\n aware_dt = timezone('US/Eastern').localize(local_dt)\n return aware_dt","def get_timezone_aware_datetime(datetime):\n if not datetime:\n return None\n local = timezone.get_current_timezone()\n return (local.localize(parse(datetime), is_dst=None)).astimezone(timezone.utc)","def tz_aware(dt: datetime, default: tzinfo = tzutc()) -> datetime:\n if dt.tzinfo is None:\n dt = dt.replace(tzinfo=default)\n return dt","def test_utc_in_timez(monkeypatch):\n utcoffset8_local_time_in_naive_utc = (\n datetime.datetime(\n year=2020,\n month=1,\n day=1,\n hour=1,\n minute=23,\n second=45,\n tzinfo=datetime.timezone(datetime.timedelta(hours=8)),\n )\n .astimezone(datetime.timezone.utc)\n .replace(tzinfo=None)\n )\n\n class mock_datetime:\n @classmethod\n def utcnow(cls):\n return utcoffset8_local_time_in_naive_utc\n\n monkeypatch.setattr('datetime.datetime', mock_datetime)\n rfc3339_utc_time = str(cherrypy._cplogging.LazyRfc3339UtcTime())\n expected_time = '2019-12-31T17:23:45Z'\n assert rfc3339_utc_time == expected_time","def __get_stock_time(stock_tz: timezone) -> datetime:\n return datetime.now().astimezone(stock_tz)","def _get_tz():\n return 'UTC'","def get_now(**kwargs: int) -> DateTime:\n return DateTime.now().replace(**kwargs) # type: ignore","def make_naive_utc(date_time: datetime.datetime) -> datetime.datetime:\n utc_timezone = datetime.timezone(datetime.timedelta(seconds=0))\n return date_time.astimezone(utc_timezone).replace(tzinfo=None)","def created_time_utc(self) -> Optional[str]:\n return pulumi.get(self, \"created_time_utc\")","def get_now():\n return datetime.now()","def get_now():\n return datetime.now()","def make_aware(value: datetime, timezone=None, is_dst=None) -> datetime:\n\n if timezone is None:\n timezone = get_current_timezone()\n\n if hasattr(timezone, \"localize\"):\n # This method is available for pytz time zones.\n return timezone.localize(value, is_dst=is_dst)\n else:\n # Check that we won't overwrite the timezone of an aware datetime.\n if is_aware(value):\n raise ValueError(\"make_aware expects a naive datetime, got %s\" % value)\n # This may be wrong around DST changes!\n return value.replace(tzinfo=timezone)","def now(cls, tz=None):\n t = _time.time()\n return cls.fromtimestamp(t, tz)","def utcTime():\r\n return calendar.timegm(time.gmtime())","def ref_now():\n return as_datetime(datetime.datetime.now(), REF_TZ)","def utc(self):\n return self._utc","def get_local_date(self):\n tz = pytz.timezone(self.timezone)\n utc = pytz.utc\n utc_now = datetime.datetime.now(utc)\n return utc_now.astimezone(tz).date()","def dbCurrentTime():\n return datetime.datetime.utcnow()","def enforce_timezone(self, value):\n try:\n tz = timezone._active.value\n if (self.default_timezone is not None) and not timezone.is_aware(value):\n return timezone.make_aware(value, tz)\n return value\n except AttributeError:\n return super().enforce_timezone(value)","def now(self):\n return conditional_now() + self.timedelta(**self.now_shift_kwargs)","def get_current_datetime ( ) :\n return datetime.datetime.now( )","def nowISO():\n return dt2ISO(datetime.datetime.utcnow())","def get_utc(local_tm, tz):\n utc_tz = pytz.utc\n utc_now = datetime.utcnow().replace(tzinfo=utc_tz)\n local_tz = pytz.timezone(tz)\n local_now = local_tz.normalize(utc_now)\n local_alarm = local_now.replace(hour=local_tm.hour, minute=local_tm.minute)\n utc_alarm = utc_tz.normalize(local_alarm)\n return utc_alarm.time()","def utcdatetime(self):\n utc = self.toZone('UTC')\n second = int(utc._second)\n microsec = utc.micros() % 1000000\n dt = datetime(utc._year, utc._month, utc._day, utc._hour,\n utc._minute, second, microsec)\n return dt","def ensure_utc_time(ts: datetime) -> datetime:\n if ts.tzinfo is None:\n return datetime(*ts.timetuple()[:6], tzinfo=UTC_TZ)\n elif str(ts.tzinfo) != str(UTC_TZ):\n return ts.astimezone(UTC_TZ)\n return ts","def get_site_last_updated(cls, utc_now=None):\n if utc_now is None:\n utc_now = arrow.utcnow()\n\n today_update_hour = cls.stamp_time(utc_now)\n if today_update_hour > utc_now:\n update_time = today_update_hour.shift(days=-1)\n else:\n update_time = today_update_hour\n\n return update_time","def now(self):\n os.environ['TZ'] = conf.timezone\n time.tzset()\n return time.strftime(\"%B %d %Y %H:%M:%S IST\", time.localtime())","def created_time_utc(self) -> str:\n return pulumi.get(self, \"created_time_utc\")","def now():\n return datetime.datetime.now()","def get_now_hour_utc(no_microseconds=True):\n if no_microseconds:\n return datetime.datetime.utcnow().replace(microsecond=0).time()\n else:\n return datetime.datetime.utcnow().time()","def correct_datetime(record_datetime):\n assert record_datetime.date() == datetime.now(timezone.utc).date()","def get_now_hour_utc(no_microseconds=True):\n if no_microseconds:\n return datetime.time.utcnow().replace(microsecond=0).time()\n else:\n return datetime.time.utcnow().time()","def now():\r\n return datetime.datetime.now()","def _get_datetime():\n pst_now = datetime.datetime.utcnow().astimezone(pytz.timezone(\"America/Los_Angeles\"))\n return pst_now.strftime(\"%a %b %e %H:%M %Z %G\")","def get_date():\n\n return datetime.datetime.utcnow().isoformat()","def now(self):\n return datetime.datetime.now()","def now(self):\n return datetime.datetime.now()"],"string":"[\n \"def datetime_utc_now() -> datetime:\\n return datetime.now(timezone.utc)\",\n \"def now_utc() -> datetime:\\n return datetime.now(timezone.utc)\",\n \"def utc_now():\\n return datetime.now(tz=timezone.utc)\",\n \"def get_utc_now():\\n return datetime.datetime.utcnow().replace(tzinfo=pytz.timezone(\\\"UTC\\\"))\",\n \"def nowUTC():\\n return datetime.datetime.now(pytz.utc)\",\n \"def utcnow() -> datetime.datetime:\\n return datetime.datetime.utcnow().replace(tzinfo=pytz.UTC)\",\n \"def datetime_utcnow() -> datetime:\\n return datetime.now(tz=pytz.timezone('UTC'))\",\n \"def _get_now():\\n return datetime.now(tz=timezone.utc)\",\n \"def _now():\\n return datetime.datetime.utcnow().replace(tzinfo=pytz.utc)\",\n \"def now():\\n return datetime.datetime.now(pytz.utc)\",\n \"def utcnow():\\n return datetime.utcnow().replace(tzinfo=UTC)\",\n \"def _now():\\n return datetime.now(timezone.utc).astimezone()\",\n \"def now_datetime():\\n return datetime.utcnow().replace(tzinfo=timezone)\",\n \"def utc_now():\\n realtime = datetime.utcnow()\\n realtime = pytz.utc.localize(realtime)\\n return realtime\",\n \"def get_now():\\n return dt.datetime.now(dt.timezone.utc)\",\n \"def now_dt(tz='UTC'):\\n if tz != 'UTC':\\n raise NotImplementedError()\\n return datetime.datetime.utcnow().replace(tzinfo = pytz.utc)\",\n \"def now(self):\\n if 'timezone' in self._data:\\n return pytz.utc.localize(datetime.datetime.utcnow()).astimezone(pytz.timezone(self._data['timezone']))\\n else:\\n return pytz.utc.localize(datetime.datetime.utcnow())\",\n \"def db_datetime_utc():\\n t = datetime.datetime.utcnow()\\n return time.mktime(t.timetuple())\",\n \"def get_now():\\n local_tz = timezone(os.getenv('TZ', settings.TIME_ZONE))\\n return datetime.datetime.now(tz=local_tz)\",\n \"def get_today_utc():\\n return pytz.utc.localize(datetime.datetime.utcnow()).replace(\\n hour=0, minute=0, second=0, microsecond=0\\n )\",\n \"def get_today_utc():\\n return pytz.utc.localize(datetime.datetime.utcnow()).replace(\\n hour=0, minute=0, second=0, microsecond=0\\n )\",\n \"def get_now_utc(no_microseconds=True):\\n if no_microseconds:\\n return pytz.utc.localize(datetime.datetime.utcnow()).replace(\\n microsecond=0\\n )\\n else:\\n return pytz.utc.localize(datetime.datetime.utcnow())\",\n \"def get_now_utc(no_microseconds=True):\\n if no_microseconds:\\n return pytz.utc.localize(datetime.datetime.utcnow()).replace(\\n microsecond=0\\n )\\n else:\\n return pytz.utc.localize(datetime.datetime.utcnow())\",\n \"def utcnow(cls):\\n t = _time.time()\\n return cls.utcfromtimestamp(t)\",\n \"def test_freeze_with_timezone_aware_datetime_in_utc():\\n utc_now = datetime.datetime.utcnow()\\n assert utc_now.tzinfo is None\",\n \"async def datetime(self, aware=False) -> dt.datetime:\\n if aware is True:\\n now = await self.AD.sched.get_now()\\n return now.astimezone(self.AD.tz)\\n else:\\n return await self.AD.sched.get_now_naive()\",\n \"def utcnow():\\r\\n if utcnow.override_time:\\r\\n try:\\r\\n return utcnow.override_time.pop(0)\\r\\n except AttributeError:\\r\\n return utcnow.override_time\\r\\n return datetime.datetime.utcnow()\",\n \"def utcnow():\\n if utcnow.override_time:\\n try:\\n return utcnow.override_time.pop(0)\\n except AttributeError:\\n return utcnow.override_time\\n return datetime.datetime.utcnow()\",\n \"def _getUTC(self, config = {} ):\\n # Default implementation: get system local time\\n return datetime.datetime.utcnow()\",\n \"def test_freeze_with_timezone_aware_datetime_in_non_utc():\\n utc_now = datetime.datetime.utcnow()\\n assert utc_now.tzinfo is None\\n assert utc_now == datetime.datetime(1970, 1, 1, 4)\",\n \"def now(cls, tz=None):\\n return datetime()\",\n \"def get_now(self, tz=None):\\n return get_now(tz=tz, default_tz=self.default_tz)\",\n \"def datetime_now():\\n return datetime.datetime.now(GB_TZ)\",\n \"async def get_now(self) -> dt.datetime:\\n now = await self.AD.sched.get_now()\\n return now.astimezone(self.AD.tz)\",\n \"def utc():\\n return date_from_utc(dt.utcnow())\",\n \"def NOW(tz=None):\\n return datetime.datetime.now(_get_tzinfo(tz))\",\n \"def static_now():\\n return datetime.datetime(2000, 9, 4).replace(tzinfo=timezone.utc)\",\n \"def date_now(*, convert_to_current_timezone: bool = False, utc: bool = False):\\n now = datetime.datetime.now()\\n\\n if convert_to_current_timezone:\\n now = date_make_timezone_aware(now)\\n\\n if utc:\\n now = date_to_utc(now)\\n\\n return now\",\n \"def tz_aware(value: datetime) -> datetime:\\n if settings.USE_TZ:\\n value = value.replace(tzinfo=timezone.utc)\\n\\n return value\",\n \"def now():\\n return datetime.datetime.utcnow()\",\n \"def omniscient_datetime(*args):\\n d = original_datetime(*args)\\n if settings.USE_TZ:\\n d = timezone.make_aware(d, timezone.utc)\\n return d\",\n \"def FromNowUTC(cls):\\n t = pytime.time()\\n utcTime = pytime.gmtime(t)\\n return cls.FromStructTime(utcTime).WithZone(zDirection=0)\",\n \"def get_time(self):\\n return datetime.datetime.now(self.time_zone)\",\n \"def get_utc_now_timestamp() -> int:\\n return int(datetime.datetime.now(datetime.timezone.utc).timestamp() * 1000)\",\n \"def _Now():\\n return datetime.datetime.utcnow()\",\n \"def now():\\n return utcfromtimestamp(time.time())\",\n \"def _utcnow(self):\\n return datetime.datetime.utcnow()\",\n \"def now (self):\\n return datetime.datetime.utcnow ()\",\n \"def utcnow():\\n utctime = datetime.datetime.utcnow()\\n utcstamp = utctime.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n return utcstamp\",\n \"def currentUTC():\\n return str(datetime.utcnow())\",\n \"def now():\\n return datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')\",\n \"def test_get_current_time_is_in_utc() -> None:\\n time_provider = TimeProvider()\\n current_time = time_provider.get_current_time()\\n\\n assert current_time.as_datetime().timezone == UTC\",\n \"def now() -> datetime:\\n now = datetime.now(tz=timezone.utc)\\n return now.replace(microsecond=now.microsecond - now.microsecond % 1000)\",\n \"def setup_datetime(self):\\n \\n current_date_time = datetime.now()\\n timezone_diference = timedelta(hours=-3)\\n return timezone(timezone_diference), current_date_time\",\n \"def isoformat_now():\\n return datetime_isoformat(datetime.datetime.utcnow())\",\n \"def now(cls):\\n return DateTime(*time.localtime())\",\n \"def utcnow_ts():\\r\\n return calendar.timegm(utcnow().timetuple())\",\n \"def get_zone_aware_datetime(date):\\n return datetime.combine(date, datetime.max.time(), pytz.UTC) if date else None\",\n \"def now_iso():\\n return to_iso(now())\",\n \"def tstamp_now(self):\\n return self.tstamp(datetime.datetime.now(tz))\",\n \"def mock_datetime_utc(*dec_args, **dec_kwargs):\\n # We record original values currently stored in the datetime.datetime and\\n # datetime.date here. Note that they are no necessarily vanilla Python types\\n # and can already be mock classes - this can happen if nested mocking is used.\\n original_datetime = datetime.datetime\\n original_date = datetime.date\\n\\n # Our metaclass must be derived from the parent class metaclass, but if the\\n # parent class doesn't have one, we use 'type' type.\\n class MockDateTimeMeta(original_datetime.__dict__.get('__metaclass__', type)):\\n @classmethod\\n def __instancecheck__(cls, instance):\\n return isinstance(instance, original_datetime)\\n\\n class _MockDateTime(original_datetime):\\n __metaclass__ = MockDateTimeMeta\\n mock_utcnow = original_datetime(*dec_args, **dec_kwargs)\\n \\n @classmethod\\n def utcnow(cls):\\n return cls.mock_utcnow\\n \\n @classmethod\\n def now(cls, tz=None):\\n if not tz:\\n tz = tzlocal.get_localzone()\\n tzaware_utcnow = pytz.utc.localize(cls.mock_utcnow)\\n return tz.normalize(tzaware_utcnow.astimezone(tz)).replace(tzinfo=None)\\n \\n @classmethod\\n def today(cls):\\n return cls.now().date()\\n\\n @classmethod\\n def fromtimestamp(cls, timestamp, tz=None):\\n if not tz:\\n # TODO(sergiyb): This may fail for some unclear reason because pytz\\n # doesn't find normal timezones such as 'Europe/Berlin'. This seems to\\n # happen only in appengine/chromium_try_flakes tests, and not in tests\\n # for this module itself.\\n tz = tzlocal.get_localzone()\\n tzaware_dt = pytz.utc.localize(cls.utcfromtimestamp(timestamp))\\n return tz.normalize(tzaware_dt.astimezone(tz)).replace(tzinfo=None)\\n \\n # Our metaclass must be derived from the parent class metaclass, but if the\\n # parent class doesn't have one, we use 'type' type.\\n class MockDateMeta(original_date.__dict__.get('__metaclass__', type)):\\n @classmethod\\n def __instancecheck__(cls, instance):\\n return isinstance(instance, original_date)\\n\\n class _MockDate(original_date):\\n __metaclass__ = MockDateMeta\\n\\n @classmethod\\n def today(cls):\\n return _MockDateTime.today()\\n\\n @classmethod\\n def fromtimestamp(cls, timestamp, tz=None):\\n return _MockDateTime.fromtimestamp(timestamp, tz).date()\\n\\n def decorator(func):\\n @functools.wraps(func)\\n def wrapper(*args, **kwargs):\\n with mock.patch('datetime.datetime', _MockDateTime):\\n with mock.patch('datetime.date', _MockDate):\\n return func(*args, **kwargs)\\n return wrapper\\n return decorator\",\n \"def created_time_utc(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"created_time_utc\\\")\",\n \"def _database_time_now(self) -> datetime:\\n return self._engine.execute(select([func.now()])).scalar()\",\n \"def make_tz_aware(local_dt):\\n aware_dt = timezone('US/Eastern').localize(local_dt)\\n return aware_dt\",\n \"def get_timezone_aware_datetime(datetime):\\n if not datetime:\\n return None\\n local = timezone.get_current_timezone()\\n return (local.localize(parse(datetime), is_dst=None)).astimezone(timezone.utc)\",\n \"def tz_aware(dt: datetime, default: tzinfo = tzutc()) -> datetime:\\n if dt.tzinfo is None:\\n dt = dt.replace(tzinfo=default)\\n return dt\",\n \"def test_utc_in_timez(monkeypatch):\\n utcoffset8_local_time_in_naive_utc = (\\n datetime.datetime(\\n year=2020,\\n month=1,\\n day=1,\\n hour=1,\\n minute=23,\\n second=45,\\n tzinfo=datetime.timezone(datetime.timedelta(hours=8)),\\n )\\n .astimezone(datetime.timezone.utc)\\n .replace(tzinfo=None)\\n )\\n\\n class mock_datetime:\\n @classmethod\\n def utcnow(cls):\\n return utcoffset8_local_time_in_naive_utc\\n\\n monkeypatch.setattr('datetime.datetime', mock_datetime)\\n rfc3339_utc_time = str(cherrypy._cplogging.LazyRfc3339UtcTime())\\n expected_time = '2019-12-31T17:23:45Z'\\n assert rfc3339_utc_time == expected_time\",\n \"def __get_stock_time(stock_tz: timezone) -> datetime:\\n return datetime.now().astimezone(stock_tz)\",\n \"def _get_tz():\\n return 'UTC'\",\n \"def get_now(**kwargs: int) -> DateTime:\\n return DateTime.now().replace(**kwargs) # type: ignore\",\n \"def make_naive_utc(date_time: datetime.datetime) -> datetime.datetime:\\n utc_timezone = datetime.timezone(datetime.timedelta(seconds=0))\\n return date_time.astimezone(utc_timezone).replace(tzinfo=None)\",\n \"def created_time_utc(self) -> Optional[str]:\\n return pulumi.get(self, \\\"created_time_utc\\\")\",\n \"def get_now():\\n return datetime.now()\",\n \"def get_now():\\n return datetime.now()\",\n \"def make_aware(value: datetime, timezone=None, is_dst=None) -> datetime:\\n\\n if timezone is None:\\n timezone = get_current_timezone()\\n\\n if hasattr(timezone, \\\"localize\\\"):\\n # This method is available for pytz time zones.\\n return timezone.localize(value, is_dst=is_dst)\\n else:\\n # Check that we won't overwrite the timezone of an aware datetime.\\n if is_aware(value):\\n raise ValueError(\\\"make_aware expects a naive datetime, got %s\\\" % value)\\n # This may be wrong around DST changes!\\n return value.replace(tzinfo=timezone)\",\n \"def now(cls, tz=None):\\n t = _time.time()\\n return cls.fromtimestamp(t, tz)\",\n \"def utcTime():\\r\\n return calendar.timegm(time.gmtime())\",\n \"def ref_now():\\n return as_datetime(datetime.datetime.now(), REF_TZ)\",\n \"def utc(self):\\n return self._utc\",\n \"def get_local_date(self):\\n tz = pytz.timezone(self.timezone)\\n utc = pytz.utc\\n utc_now = datetime.datetime.now(utc)\\n return utc_now.astimezone(tz).date()\",\n \"def dbCurrentTime():\\n return datetime.datetime.utcnow()\",\n \"def enforce_timezone(self, value):\\n try:\\n tz = timezone._active.value\\n if (self.default_timezone is not None) and not timezone.is_aware(value):\\n return timezone.make_aware(value, tz)\\n return value\\n except AttributeError:\\n return super().enforce_timezone(value)\",\n \"def now(self):\\n return conditional_now() + self.timedelta(**self.now_shift_kwargs)\",\n \"def get_current_datetime ( ) :\\n return datetime.datetime.now( )\",\n \"def nowISO():\\n return dt2ISO(datetime.datetime.utcnow())\",\n \"def get_utc(local_tm, tz):\\n utc_tz = pytz.utc\\n utc_now = datetime.utcnow().replace(tzinfo=utc_tz)\\n local_tz = pytz.timezone(tz)\\n local_now = local_tz.normalize(utc_now)\\n local_alarm = local_now.replace(hour=local_tm.hour, minute=local_tm.minute)\\n utc_alarm = utc_tz.normalize(local_alarm)\\n return utc_alarm.time()\",\n \"def utcdatetime(self):\\n utc = self.toZone('UTC')\\n second = int(utc._second)\\n microsec = utc.micros() % 1000000\\n dt = datetime(utc._year, utc._month, utc._day, utc._hour,\\n utc._minute, second, microsec)\\n return dt\",\n \"def ensure_utc_time(ts: datetime) -> datetime:\\n if ts.tzinfo is None:\\n return datetime(*ts.timetuple()[:6], tzinfo=UTC_TZ)\\n elif str(ts.tzinfo) != str(UTC_TZ):\\n return ts.astimezone(UTC_TZ)\\n return ts\",\n \"def get_site_last_updated(cls, utc_now=None):\\n if utc_now is None:\\n utc_now = arrow.utcnow()\\n\\n today_update_hour = cls.stamp_time(utc_now)\\n if today_update_hour > utc_now:\\n update_time = today_update_hour.shift(days=-1)\\n else:\\n update_time = today_update_hour\\n\\n return update_time\",\n \"def now(self):\\n os.environ['TZ'] = conf.timezone\\n time.tzset()\\n return time.strftime(\\\"%B %d %Y %H:%M:%S IST\\\", time.localtime())\",\n \"def created_time_utc(self) -> str:\\n return pulumi.get(self, \\\"created_time_utc\\\")\",\n \"def now():\\n return datetime.datetime.now()\",\n \"def get_now_hour_utc(no_microseconds=True):\\n if no_microseconds:\\n return datetime.datetime.utcnow().replace(microsecond=0).time()\\n else:\\n return datetime.datetime.utcnow().time()\",\n \"def correct_datetime(record_datetime):\\n assert record_datetime.date() == datetime.now(timezone.utc).date()\",\n \"def get_now_hour_utc(no_microseconds=True):\\n if no_microseconds:\\n return datetime.time.utcnow().replace(microsecond=0).time()\\n else:\\n return datetime.time.utcnow().time()\",\n \"def now():\\r\\n return datetime.datetime.now()\",\n \"def _get_datetime():\\n pst_now = datetime.datetime.utcnow().astimezone(pytz.timezone(\\\"America/Los_Angeles\\\"))\\n return pst_now.strftime(\\\"%a %b %e %H:%M %Z %G\\\")\",\n \"def get_date():\\n\\n return datetime.datetime.utcnow().isoformat()\",\n \"def now(self):\\n return datetime.datetime.now()\",\n \"def now(self):\\n return datetime.datetime.now()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8656396","0.8527489","0.8506886","0.8276427","0.8191999","0.815434","0.801268","0.7952559","0.7899885","0.78881174","0.7862986","0.7835481","0.7827097","0.775173","0.765144","0.7639328","0.76259637","0.7582488","0.7496754","0.74300855","0.74300855","0.7428635","0.7428635","0.73800373","0.73097783","0.72865903","0.72781616","0.72636503","0.719549","0.71678835","0.7150376","0.7048562","0.70336074","0.6981316","0.694205","0.69233453","0.6913073","0.6861862","0.685418","0.67886823","0.67587423","0.67429304","0.6735026","0.6698459","0.6654514","0.66178465","0.66133636","0.6555577","0.6487567","0.647871","0.646612","0.6447063","0.64276934","0.6411005","0.6408153","0.64032704","0.63968116","0.638201","0.6379869","0.6337828","0.6331563","0.6322745","0.6319821","0.6312316","0.63036644","0.62887484","0.6282424","0.62601346","0.6257932","0.6239568","0.62228596","0.62133074","0.62028056","0.62028056","0.6192154","0.61824065","0.617968","0.6174559","0.6146379","0.61341727","0.61287093","0.6119441","0.6088416","0.6080553","0.60789824","0.6065777","0.6056344","0.60555035","0.6040452","0.6024808","0.5982121","0.59760857","0.5958927","0.5946312","0.5928689","0.5903538","0.5875046","0.5874142","0.58368856","0.58368856"],"string":"[\n \"0.8656396\",\n \"0.8527489\",\n \"0.8506886\",\n \"0.8276427\",\n \"0.8191999\",\n \"0.815434\",\n \"0.801268\",\n \"0.7952559\",\n \"0.7899885\",\n \"0.78881174\",\n \"0.7862986\",\n \"0.7835481\",\n \"0.7827097\",\n \"0.775173\",\n \"0.765144\",\n \"0.7639328\",\n \"0.76259637\",\n \"0.7582488\",\n \"0.7496754\",\n \"0.74300855\",\n \"0.74300855\",\n \"0.7428635\",\n \"0.7428635\",\n \"0.73800373\",\n \"0.73097783\",\n \"0.72865903\",\n \"0.72781616\",\n \"0.72636503\",\n \"0.719549\",\n \"0.71678835\",\n \"0.7150376\",\n \"0.7048562\",\n \"0.70336074\",\n \"0.6981316\",\n \"0.694205\",\n \"0.69233453\",\n \"0.6913073\",\n \"0.6861862\",\n \"0.685418\",\n \"0.67886823\",\n \"0.67587423\",\n \"0.67429304\",\n \"0.6735026\",\n \"0.6698459\",\n \"0.6654514\",\n \"0.66178465\",\n \"0.66133636\",\n \"0.6555577\",\n \"0.6487567\",\n \"0.647871\",\n \"0.646612\",\n \"0.6447063\",\n \"0.64276934\",\n \"0.6411005\",\n \"0.6408153\",\n \"0.64032704\",\n \"0.63968116\",\n \"0.638201\",\n \"0.6379869\",\n \"0.6337828\",\n \"0.6331563\",\n \"0.6322745\",\n \"0.6319821\",\n \"0.6312316\",\n \"0.63036644\",\n \"0.62887484\",\n \"0.6282424\",\n \"0.62601346\",\n \"0.6257932\",\n \"0.6239568\",\n \"0.62228596\",\n \"0.62133074\",\n \"0.62028056\",\n \"0.62028056\",\n \"0.6192154\",\n \"0.61824065\",\n \"0.617968\",\n \"0.6174559\",\n \"0.6146379\",\n \"0.61341727\",\n \"0.61287093\",\n \"0.6119441\",\n \"0.6088416\",\n \"0.6080553\",\n \"0.60789824\",\n \"0.6065777\",\n \"0.6056344\",\n \"0.60555035\",\n \"0.6040452\",\n \"0.6024808\",\n \"0.5982121\",\n \"0.59760857\",\n \"0.5958927\",\n \"0.5946312\",\n \"0.5928689\",\n \"0.5903538\",\n \"0.5875046\",\n \"0.5874142\",\n \"0.58368856\",\n \"0.58368856\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73830366"},"document_rank":{"kind":"string","value":"23"}}},{"rowIdx":84578,"cells":{"query":{"kind":"string","value":"Emulate legacy field superseeded by `patient_consent_date`. The `paitient_consent_date` field is the only source of truth."},"document":{"kind":"string","value":"def patient_consent(self):\n return 1 if self.patient_consent_date is not None else 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 patient_consent(self, value):\n self.patient_consent_date = utcnow() if value else None","def patient_consent_date(self, value):\n self._patient_consent_date = value\n self._patient_consent = 1 if value else 0","def _read_patient_consent_date(self, d: dict):\n consent_date = d.get('patient_consent_date')\n consent_bool = d.get('patient_consent')\n if consent_date is not None:\n return self._str_to_datetime(consent_date)\n elif consent_bool:\n t0 = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\n creation_date = d.get('creation_date')\n return (self._str_to_datetime(creation_date)\n if creation_date is not None\n else t0)\n else:\n return None","def patient_consent_date(self):\n return self._patient_consent_date","def patient_consent(self):\n return self.patient_consent_date != None # noqa: E711","def date(self, date):\n if self.local_vars_configuration.client_side_validation and date is None: # noqa: E501\n raise ValueError(\"Invalid value for `date`, must not be `None`\") # noqa: E501\n\n self._date = date","def set_harvest_date(self, date):\n if not date:\n return datetime.utcnow().strftime(\"%Y/%m/%d\")\n return datetime.strptime(date, \"%Y%m%d\").strftime(\"%Y/%m/%d\")","def alternative_inception_date(self, alternative_inception_date):\n\n self._alternative_inception_date = alternative_inception_date","def set_date(self, date):\n self.date = self.date_to_local(date)\n # ephem deals only in UTC\n self.site.date = ephem.Date(self.date_to_utc(self.date))","def test_patient_one_date_of_birth(self):\r\n self.assertEqual(self.test_patient.dateOfBirth, datetime.date(2000, 2, 13))","def insure_date(d):\n if isinstance(d, BeautifulDate):\n return date(year=d.year, month=d.month, day=d.day)\n else:\n return d","def test_one_off_training_date(self):\n self.assertIsInstance(self.one_off_training.date, datetime.date)\n self.assertEqual(\n self.one_off_training.date,\n datetime.date(2020, 6, 14)\n )","def test_patient_date_of_birth(self):\r\n self.assertEqual(self.test_patient.dateOfBirth, '2000-01-01')","def _get_date(self):\n for fax_out in self:\n DATETIME_FORMAT = \"%Y-%m-%d %H:%M:%S\"\n date_planned = False\n if fax_out.date:\n from_dt = datetime.datetime.strptime(str(fax_out.date[:19]), DATETIME_FORMAT)\n # from_dt = from_dt + datetime.timedelta(hours=5 , minutes=30)\n date_planned = from_dt.strftime('%Y-%m-%d')\n fax_out.fax_date = date_planned","def test_initial_handed_in_date_is_prolongation_date(self):\n thesis = Thesis(\n begin_date=date(2018, 1, 1),\n due_date=date(2018, 3, 30),\n prolongation_date=date(2018, 6, 30),\n status=Thesis.PROLONGED)\n\n form = HandInForm.initialize_from(thesis)\n\n self.assertEqual(thesis.prolongation_date, form[\n \"handed_in_date\"].value())","def date_wrangler(self, date_col):\n data = self.copy() # Create a copy of the DataFrame\n\n # Convert target column to datetime\n data[date_col] = pd.to_datetime(\n data[date_col], infer_datetime_format=True\n )\n\n # Split column into datetime components\n data[f\"{date_col}_year\"] = data[date_col].dt.year\n data[f\"{date_col}_year\"] = data[date_col].dt.month\n data[f\"{date_col}_year\"] = data[date_col].dt.day\n\n # Drop original column\n data = data.drop(columns=date_col)\n\n return data","def _get_date(self):\n for fax_in in self:\n DATETIME_FORMAT = \"%Y-%m-%d %H:%M:%S\"\n date_planned = False\n if fax_in.date:\n from_dt = datetime.datetime.strptime(str(fax_in.date[:19]), DATETIME_FORMAT)\n # from_dt = from_dt + datetime.timedelta(hours=5 , minutes=30)\n date_planned = from_dt.strftime('%Y-%m-%d')\n fax_in.fax_date = date_planned","def setDate(self, p_int, p_int_1, p_int_2): # real signature unknown; restored from __doc__\r\n return False","def __data_set_is_payday_negative_16_17_18(cls):\n _pay_cycle_object = pay_cycle_object()\n date_to_check = date_class(2019,1,24) # The day before first payday\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, False))\n\n date_to_check = date_class(2018,12,27)\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, False))\n\n date_to_check = date_class(2018,2,28)\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, False))","def date(self, date):\n self.value = date.strftime(\"%Y-%m-%d\") if date else \"\"","def set_from_date(self, date):\n self.set_value_into_input_field(self.set_from_date_locator, date)","def test_date_field():","def set_birthdate(self, date):\n\n if validate_date_format(self.birt):\n self.birt = date\n else:\n raise ValueError('Invalid date!')","def _date(self, _date):\n\n self.__date = _date","def _date(self, _date):\n\n self.__date = _date","def _earliest_allowed_date(cls):\r\n DAYS_GOOD_FOR = settings.VERIFY_STUDENT[\"DAYS_GOOD_FOR\"]\r\n allowed_date = (\r\n datetime.now(pytz.UTC) - timedelta(days=DAYS_GOOD_FOR)\r\n )\r\n return allowed_date","def clean_date(self):\r\n from datetime import datetime\r\n\r\n date = self.cleaned_data[\"date\"]\r\n if date < datetime.now():\r\n self.add_error(\"date\", \"You cannot add a date for the past.\")\r\n return date","def set_add_dispute_date(self, date):\n self.set_value_into_input_field(self.add_dispute_date_inputbox_locator, date)","def on_or_before(self, date):\n return (date - mod(date - self.CORRELATION - self.to_ordinal(), 365))","def convert_date_of_attendance(attendance):\n if isinstance(attendance,list):\n for a in attendance:\n a.date_of_att = datetime.datetime.strptime(a.DATE_OF_ATTENDANCE,'%d/%m/%Y').date()\n elif isinstance(attendance,models.AttendanceModel):\n attendance.date_of_att = datetime.datetime.strptime\\\n (attendance.DATE_OF_ATTENDANCE, '%d/%m/%Y').date()","def date(self, new_date):\n self._date.date = new_date","def settlement_position_effective_date_valid(record):\n knowledge_date = record['knowledge_date']\n effective_date = record['effective_date']\n assert effective_date == knowledge_date","def test_change_of_date_field_type(self):\n # Create a user, device and a heartbeat\n user = Dummy.create_user()\n device = Dummy.create_device(user)\n heartbeat_timestamp = datetime(2015, 12, 15, 1, 23, 45, tzinfo=pytz.utc)\n\n heartbeat = Dummy.create_report(\n HeartBeat, device, date=heartbeat_timestamp\n )\n\n # Assert that the date is of type datetime\n self.assertIsInstance(heartbeat.date, datetime)\n\n # Run the migration\n self.migrate_to_dest()\n\n # Assert that the date is now of type date and has the correct value\n heartbeat = HeartBeat.objects.first()\n self.assertIsInstance(heartbeat.date, date)\n self.assertEqual(heartbeat.date, heartbeat_timestamp.date())","def set_adjustment_charge_begin_date(self, begin_date):\n self.set_value_into_input_field(self.adjustment_begin_date_locator, begin_date)","def _date(self) -> datetime:\n return self.__date","def _process_date(self, data):\n def helper(val):\n # Sometime the date has a (1) or (2) following it. Strip that off\n # so that we can successful convert to date.\n s = val.find(\" (\")\n if s >= 0:\n val = val[0:s]\n dv = dt.datetime.strptime(val, '%A, %b %d')\n dv = dv.replace(year=self.start_date.year)\n return dv\n data['Date'] = data['Date'].apply(helper)\n return data","def knowledge_date_valid(record):\n today = datetime.now(timezone.utc).date().strftime(\"%Y-%m-%d\")\n gen_date = record['knowledge_date'].strftime(\"%Y-%m-%d\")\n assert gen_date == today","def date(self):\n bc = self.barcamp\n if bc.start_date and bc.end_date:\n # TODO: localize it\n return \"%s - %s\" %(\n bc.start_date.strftime('%d.%m.%Y'),\n bc.end_date.strftime('%d.%m.%Y'))\n else:\n return self.handler._(\"date to be announced\")","def _fill_date(self):\n if not self.date['year']:\n self.date['year'] = self.DEFAULT_DATE['year']\n if not self.date['month']:\n self.date['month'] = self.DEFAULT_DATE['month']\n if not self.date['day']:\n self.date['day'] = self.DEFAULT_DATE['day']","def set_document_date(self, date):\n self.set_value_into_input_field(self.document_date_text_field_locator, date)","def test_date_conversion():\n schema = pa.schema([\n pa.field(\"foo\", pa.date32())\n ])\n\n data = [{\"foo\": \"2018-01-01\"}, {\"foo\": \"2018-01-02\"}]\n\n converted_data = client.ingest_data(data, schema)\n assert converted_data.to_pydict()['foo'][0].strftime(\"%Y-%m-%d\") == \"2018-01-01\"\n assert converted_data.to_pydict()['foo'][1].strftime(\"%Y-%m-%d\") == \"2018-01-02\"","def verify_date_field(field, data: str) -> str:\n if field in ['started_at', 'ended_at', 'created_at', 'performed_at', 'issued_at', 'expires_at']:\n content = string_to_date(data)\n else:\n content = data\n\n return content","def set_to_date(self):\n self.set_value_into_input_field(self.set_to_date_locator, self.get_current_date())","def form_valid(self, form):\n\n # date_time_committee\n date_time_committee = form.cleaned_data[\n 'date_time_committee']\n\n if date_time_committee is not None:\n\n # We manually enter a date in Oslo/Stockholm time in the GUI\n # so we need to convert it into UTC\n obj = form.save(commit=False)\n datetime_in_utc = date_time_committee.astimezone(pytz.utc)\n obj.date_time_committee = datetime_in_utc\n obj.save()\n\n return super(RatingDecisionUpdateView, self).form_valid(form)","def clean_birth_date(self):\n\n sent_date = self.cleaned_data['birth_date']\n current_date = localtime(now()).date()\n\n if (sent_date - current_date) > datetime.timedelta(seconds=1):\n raise ValidationError(INVALID_BIRTH_DATE_VALUE)\n else:\n return sent_date","def numeric_date_recover(self):\n \n sp_time_zone, current_datetime = self.setup_datetime() \n converter2sptimezone = current_datetime.astimezone(sp_time_zone)\n \n return converter2sptimezone.strftime('%d-%m-%Y')","def date_temporal_paradox_free(self):\n valid_date = True\n new_val = self.date_edit.text()\n datetime_object = datetime.strptime(new_val, \"%Y-%m-%d\")\n\n if datetime_object > datetime.now():\n valid_date = False\n return valid_date","def test_date_of_birth_good_values(self):\n for input_val, output_val in self.known_values:\n self.line._parse_date_of_birth(input_val)\n self.assertEqual(output_val, self.line.date_of_birth)","def admit_from_er(df):\n from_er = pd.read_csv(\n f\"{raw_data}\\\\er_adm.csv\",\n usecols=[\"MemberID\", \"AdmissionDate\", \"Facility\"],\n parse_dates=[\"AdmissionDate\"],\n )\n\n from_er = cognify_facility_changes(from_er, \"Facility\")\n\n from_er[\"merge\"] = (\n from_er[\"MemberID\"].astype(str)\n + from_er[\"AdmissionDate\"].astype(str)\n + from_er[\"Facility\"]\n )\n\n df[\"merge\"] = (\n df[\"member_id\"].astype(str) + df[\"admission_date\"].astype(str) + df[\"facility\"]\n )\n df[\"er\"] = np.where(df[\"merge\"].isin(from_er[\"merge\"].tolist()), 1, 0)\n\n df.drop([\"merge\"], axis=1, inplace=True)\n return df","def post_patient_edit(form):\n # Extract the data from the form and add extra fields.\n\n contacted_fields = [\"Contacted\", \"Comment\"]\n disabled_fields = [\"NextURL\"] + [x for x in form.data.keys() if re.search(r\"Disabled\", x) is not None]\n data = {k: v for (k, v) in form.data.items() if k not in disabled_fields \n and k not in contacted_fields}\n data[\"UpdatedBy\"] = get_current_user()\n data[\"UpdatedDateTime\"] = get_current_datetime()\n\n for k in [\"SymptomType\" + str(n) for n in list(range(1, 11))]:\n if data[k] != []:\n # keep only values that are not \"Select...\"\n data[k] = [v for v in data[k] if v not in [\"Select...\", \" \", \"\",]]\n if data[k] != []:\n data[k] = \"; \".join(data[k])\n else:\n data[k] = None\n else:\n data[k] = None\n\n args = form.data\n cs = get_patient_contacted_status(args)\n try:\n current_cs = cs[\"current\"][\"Contacted\"]\n except:\n current_cs = \"\"\n try:\n current_comment = cs[\"current\"][\"Comment\"]\n except:\n current_comment = \"\"\n cs_user_entered = form.Contacted.data\n cs_comment_user_entered = form.Comment.data\n if current_cs != cs_user_entered or current_comment != cs_comment_user_entered:\n post_patient_contacted_status(args)\n \n # Look up key data that should not be user-changeable. XXX ideally these\n # columns would simply be excluded from PersonEntered\n q = (\"select PatientLastName, PatientSSN \" +\n \"from {schema}.PersonCrosswalk \".format(schema=app_schema) +\n \"where PersonID = ?\")\n print(\"person id\", form.PersonID.data, file=sys.stderr)\n tb = pd.read_sql(q, engine, params=[form.PersonID.data])\n assert tb.shape[0] == 1, \"Expected 1 row, but got {} rows\".format(tb.shape[0])\n d = tb.iloc[0,:].to_dict()\n data[\"LastName\"] = d[\"PatientLastName\"]\n data[\"SSN\"] = d[\"PatientSSN\"]\n\n # Get cursor.\n conn = engine.raw_connection()\n cursor = conn.cursor()\n\n # Define and execute query to insert a new row.\n keys_str = \", \".join(data.keys())\n vals_str = \", \".join(\"?\" for _ in data.keys())\n params = list(data.values())\n q = (\"insert into {schema}.PersonEntered \".format(schema=app_schema) +\n \"(\" + keys_str + \") \" +\n \"values (\" + vals_str + \")\")\n cursor.execute(q, params)\n\n conn.commit()\n \n return None","def test_future_birth_date_import():\n _curr_date = datetime.utcnow()\n _later_date = _curr_date + relativedelta(days=1)\n later_date = _later_date.strftime(\"%d.%m.%Y\")\n\n citizen_with_birth_date_later_than_current = deepcopy(CITIZEN_EXAMPLE)\n citizen_with_birth_date_later_than_current[\"birth_date\"] = later_date\n with TestClient(app) as client:\n response = client.post(\n \"/imports\",\n json={\n \"citizens\": [\n citizen_with_birth_date_later_than_current\n ]}\n )\n\n assert response.status_code == 400","def date_answered(self, date_answered):\n self._date_answered = date_answered","def _normalize_date(date):\n if not date:\n return None\n\n if date.tzinfo:\n date = date.replace(tzinfo=None) - date.tzinfo.utcoffset(date)\n return min(date, datetime.utcnow())","def date(self, date):\n self._date = date","def from_date(cls, d):\n raise NotImplementedError","def to_python(self, value):\n return string_to_partialdate(value)","def date(self, value):\n self.date_value = value","def _set_last_exported_date(self, cr, uid, external_session, date, context=None):\n return True","def collect_interview_date(self, collect_interview_date):\n\n self._collect_interview_date = collect_interview_date","def date(self) -> datetime.datetime:\n return self._data['Date'] - datetime.timedelta(0, float(self.exposuretime), 0)","def test_saving_customized_patient_post_form(self):\n\n form_data = {\"hunger-visible\": None}\n save_customized_patient_post_form(1, form_data)\n \n patient = Patient.query.get(1)\n self.assertEqual(False, patient.hunger_visible)","def mod_date(self, mod_date):\n\n self._mod_date = mod_date","def date(self, new_date):\n date_list = new_date.split(\"/\")\n if 1 > int(date_list[0]) or int(date_list[0]) > 31:\n raise ValueError\n elif 1 > int(date_list[1]) or int(date_list[1]) > 12:\n raise ValueError\n elif 1900 > int(date_list[2]) or int(date_list[2]) > 2020:\n raise ValueError\n else:\n self._date = new_date","def date(self):\n return self.date_value","def test_date_partial_only(self):\n term, rmd = util.parse_date(\"1902\")\n ym = util.parse_date_partial(term)\n self.assertEqual(ym, \"2019-02\")\n self.assertEqual(rmd, \"\", \"Should have no remainder\")","def test_sample_one_date(self):\r\n self.assertEqual(self.test_sample.date, datetime.datetime(2016, 2, 12, 7, 34, 26))","def __get_measurement_DLP(self, datetime: str):\n pass","def _period_from_date(self):\n if self.date['year']:\n if self.date['month']:\n if self.date['day']:\n self.period = Period.DAILY\n else:\n self.period = Period.MONTHLY\n else:\n self.period = Period.YEARLY\n else:\n self.period = Period.FULL","def set_idate(self, idate):\n self.__idate = idate","def localized_date(self):\r\n date_ = self._post['effective_date']\r\n to_localized = self.context.toLocalizedTime\r\n \r\n try:\r\n local_date = to_localized(date_)\r\n except ValueError:\r\n # An invalid date; just return nothing\r\n local_date = None\r\n \r\n return local_date","def _to_report_datetime(date_time: str, include_time: bool = True, expiry: bool = False):\n if len(date_time) < 10: # Legacy may be empty string.\n return date_time\n if len(date_time) == 10: # Legacy has some date only data.\n report_date = model_utils.date_from_iso_format(date_time)\n return report_date.strftime('%B %-d, %Y')\n zone = date_time[20:]\n local_datetime = None\n if not zone.endswith('00'): # Coming from legacy, already local so ignore timezone adjustment.\n local_datetime = model_utils.ts_from_iso_format_local(date_time)\n # current_app.logger.info(f'zone={zone} date_time={date_time}')\n else:\n local_datetime = model_utils.to_local_timestamp(model_utils.ts_from_iso_format(date_time))\n if include_time:\n timestamp = local_datetime.strftime('%B %-d, %Y at %-I:%M:%S %p Pacific time')\n if timestamp.find(' AM ') > 0:\n return timestamp.replace(' AM ', ' am ')\n return timestamp.replace(' PM ', ' pm ')\n\n return local_datetime.strftime('%B %-d, %Y')","def __data_set_is_payday_negative_19_20_21(cls):\n _pay_cycle_object = pay_cycle_object()\n date_to_check = date_class(2020,12,25) # Christmas\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, False))\n\n date_to_check = date_class(2021,12,24)\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, False))\n\n date_to_check = date_class(2022,11,11)\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, False))","def fix_dates(self, row):\r\n for field in self.date_fields:\r\n if field in row:\r\n if not type(row[field]) is datetime:\r\n try:\r\n row[field] = datetime.fromtimestamp(float(row[field]))\r\n except Exception as e:\r\n row[field] = None","def date_answered(self):\n return self._date_answered","def set_from_date_as_current_date(self):\n self.set_value_into_input_field(self.set_from_date_locator, self.get_current_date())","def set_contest_date_time(contest, date_time, field):\n c = biv.load_obj(contest)\n assert type(c) == pem.E15Contest\n dt = _local_date_time_as_utc(c, date_time)\n assert hasattr(c, field), \\\n '{}: has no attr {}'.format(c, field)\n setattr(c, field, dt)\n _add_model(c)","def set_date(self, date_string, date_type):\n if date_type == \"married\":\n self._married_date = datetime.strptime(date_string, '%d %b %Y')\n if date_type == \"divorced\":\n self._divorced_date = datetime.strptime(date_string, '%d %b %Y')","def setBaseDate(self, date=None):\n if date is None:\n date = self.oggi\n self.baseDate = QDate(date.year(), date.month(), 1)","def _cleanup_date(self, date):\n if (not date or\n not isinstance(date, str) or\n 'N/A' in date):\n return None\n\n date, time = date.split()\n day, month, year = date.split('.')\n hour, minute = time.split(':')\n year, month, day, hour, minute = [int(x) for x in (year, month, day, hour, minute)]\n\n # For 2-digit years, 1969/2068 is the wrap-around (POSIX standard)\n if (69 <= year < 100):\n year += 1900\n elif (0 <= year < 69):\n year += 2000\n\n return datetime.datetime(year, month, day, hour, minute)","def on_or_before(self, date):\n return (date - mod(date - self.CORRELATION - self.to_ordinal(), 260))","def isNaive(self, date):\n return not self.isAware(date)","def test_datetime_with_naive_duedate_only_fails(self):\n # setup\n specify_wd = self.project.activity('Specify wheel diameter')\n\n # save old values\n old_start, old_due = datetime.strptime(specify_wd._json_data.get('start_date'), ISOFORMAT), \\\n datetime.strptime(specify_wd._json_data.get('due_date'), ISOFORMAT)\n naive_duedate = datetime(2017, 6, 5, 5, 0, 0)\n with warnings.catch_warnings(record=False) as w:\n warnings.simplefilter(\"ignore\")\n specify_wd.edit(due_date=naive_duedate)\n\n # teardown\n with warnings.catch_warnings(record=False) as w:\n warnings.simplefilter(\"ignore\")\n specify_wd.edit(due_date=old_due)","def DefenceDate(self, default=None):\n return self.data.get('defense_date', default)","def process_datetime(a_date: datetime) -> str:\n\n return str(a_date.date()) if a_date else Presenter.DEFAULT","def observation_date(self, observation_date):\n\n self._observation_date = observation_date","def test_fill_data_with_one_date(self):\n # date = pd.to_datetime('2015-06-30')\n date = pd.to_datetime('2011-05-09')\n print 'testing date: %s' % date.strftime('%Y-%m-%d')\n self.full_iv.get_data()\n\n # df_date = self.full_iv.df_all.query('date == %r' % date)\n # df_date = df_date[['date', 'dte', 'mark', 'strike', 'impl_vol']]\n # print df_date.sort_values(['dte', 'strike']).to_string(line_width=1000)\n\n self.full_iv.df_stock = self.full_iv.df_stock[date:date]\n df_iv = self.full_iv.calc_iv()\n\n print df_iv\n\n self.assertTrue(len(df_iv))","def test_bad_base_date(self):\n self.base_date = 'bad'\n response = self._get(get_kwargs=self._data())\n self._check_response(response, 104)","def test_relative_date(self):\n self.assertEqual(self.show.relative_date, None)","def DateOfBirth(self, reg_date_of_birth = VALUE_NOT_SET):\n ael_reg_dob = None\n if reg_date_of_birth != VALUE_NOT_SET:\n try:\n ael_reg_dob = ael.date_from_string(reg_date_of_birth)\n except:\n if reg_date_of_birth not in ['', None]:\n msg = \"The value <%s> provided for DateOfBirth is invalid and hence will not be set of the DateOfBirth AdditionalInfo\"%reg_date_of_birth\n FRegulatoryLogger.ERROR(logger, msg)\n raise FRegulatoryInfoException.FRegInfoInvalidData(msg)\n if ael_reg_dob:\n self.__reg_date_of_birth = reg_date_of_birth\n else:\n self.__reg_date_of_birth = None\n try:\n self.__contact.AdditionalInfo().DateOfBirth(self.__reg_date_of_birth)\n except:\n pass\n else:\n return self.__reg_date_of_birth","def test_datetime_field():","def clean_date(self):\n input_day = self.cleaned_data.get('day')\n input_date = self.cleaned_data.get('date')\n if input_date < datetime.date.today():\n raise forms.ValidationError(\"Can not create a lesson in the past.\")\n elif input_date.strftime(\"%A\").lower() != input_day:\n raise forms.ValidationError(input_date.strftime(\"%d-%m-%Y\")+\" does not fall on a \"+input_day.title()+\".\")\n return input_date","def _onchange_field(self):\n if not self.secretary_contact_id:\n return\n if self.partner_type in ['dr', 'patient', 'secretary']:\n self.update({\n 'secretary_contact_id': False\n })","def planned_purge_date(self, planned_purge_date):\n\n self._planned_purge_date = planned_purge_date","def planned_purge_date(self, planned_purge_date):\n\n self._planned_purge_date = planned_purge_date","def get_date(self):\n return self.cleaned_data['date']","def date(self, date):\n\n self._date = date","def date(self, date):\n\n self._date = date","def date(self, date):\n\n self._date = date","def date(self, date):\n\n self._date = date","def date(self, date):\n\n self._date = date"],"string":"[\n \"def patient_consent(self, value):\\n self.patient_consent_date = utcnow() if value else None\",\n \"def patient_consent_date(self, value):\\n self._patient_consent_date = value\\n self._patient_consent = 1 if value else 0\",\n \"def _read_patient_consent_date(self, d: dict):\\n consent_date = d.get('patient_consent_date')\\n consent_bool = d.get('patient_consent')\\n if consent_date is not None:\\n return self._str_to_datetime(consent_date)\\n elif consent_bool:\\n t0 = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\\n creation_date = d.get('creation_date')\\n return (self._str_to_datetime(creation_date)\\n if creation_date is not None\\n else t0)\\n else:\\n return None\",\n \"def patient_consent_date(self):\\n return self._patient_consent_date\",\n \"def patient_consent(self):\\n return self.patient_consent_date != None # noqa: E711\",\n \"def date(self, date):\\n if self.local_vars_configuration.client_side_validation and date is None: # noqa: E501\\n raise ValueError(\\\"Invalid value for `date`, must not be `None`\\\") # noqa: E501\\n\\n self._date = date\",\n \"def set_harvest_date(self, date):\\n if not date:\\n return datetime.utcnow().strftime(\\\"%Y/%m/%d\\\")\\n return datetime.strptime(date, \\\"%Y%m%d\\\").strftime(\\\"%Y/%m/%d\\\")\",\n \"def alternative_inception_date(self, alternative_inception_date):\\n\\n self._alternative_inception_date = alternative_inception_date\",\n \"def set_date(self, date):\\n self.date = self.date_to_local(date)\\n # ephem deals only in UTC\\n self.site.date = ephem.Date(self.date_to_utc(self.date))\",\n \"def test_patient_one_date_of_birth(self):\\r\\n self.assertEqual(self.test_patient.dateOfBirth, datetime.date(2000, 2, 13))\",\n \"def insure_date(d):\\n if isinstance(d, BeautifulDate):\\n return date(year=d.year, month=d.month, day=d.day)\\n else:\\n return d\",\n \"def test_one_off_training_date(self):\\n self.assertIsInstance(self.one_off_training.date, datetime.date)\\n self.assertEqual(\\n self.one_off_training.date,\\n datetime.date(2020, 6, 14)\\n )\",\n \"def test_patient_date_of_birth(self):\\r\\n self.assertEqual(self.test_patient.dateOfBirth, '2000-01-01')\",\n \"def _get_date(self):\\n for fax_out in self:\\n DATETIME_FORMAT = \\\"%Y-%m-%d %H:%M:%S\\\"\\n date_planned = False\\n if fax_out.date:\\n from_dt = datetime.datetime.strptime(str(fax_out.date[:19]), DATETIME_FORMAT)\\n # from_dt = from_dt + datetime.timedelta(hours=5 , minutes=30)\\n date_planned = from_dt.strftime('%Y-%m-%d')\\n fax_out.fax_date = date_planned\",\n \"def test_initial_handed_in_date_is_prolongation_date(self):\\n thesis = Thesis(\\n begin_date=date(2018, 1, 1),\\n due_date=date(2018, 3, 30),\\n prolongation_date=date(2018, 6, 30),\\n status=Thesis.PROLONGED)\\n\\n form = HandInForm.initialize_from(thesis)\\n\\n self.assertEqual(thesis.prolongation_date, form[\\n \\\"handed_in_date\\\"].value())\",\n \"def date_wrangler(self, date_col):\\n data = self.copy() # Create a copy of the DataFrame\\n\\n # Convert target column to datetime\\n data[date_col] = pd.to_datetime(\\n data[date_col], infer_datetime_format=True\\n )\\n\\n # Split column into datetime components\\n data[f\\\"{date_col}_year\\\"] = data[date_col].dt.year\\n data[f\\\"{date_col}_year\\\"] = data[date_col].dt.month\\n data[f\\\"{date_col}_year\\\"] = data[date_col].dt.day\\n\\n # Drop original column\\n data = data.drop(columns=date_col)\\n\\n return data\",\n \"def _get_date(self):\\n for fax_in in self:\\n DATETIME_FORMAT = \\\"%Y-%m-%d %H:%M:%S\\\"\\n date_planned = False\\n if fax_in.date:\\n from_dt = datetime.datetime.strptime(str(fax_in.date[:19]), DATETIME_FORMAT)\\n # from_dt = from_dt + datetime.timedelta(hours=5 , minutes=30)\\n date_planned = from_dt.strftime('%Y-%m-%d')\\n fax_in.fax_date = date_planned\",\n \"def setDate(self, p_int, p_int_1, p_int_2): # real signature unknown; restored from __doc__\\r\\n return False\",\n \"def __data_set_is_payday_negative_16_17_18(cls):\\n _pay_cycle_object = pay_cycle_object()\\n date_to_check = date_class(2019,1,24) # The day before first payday\\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, False))\\n\\n date_to_check = date_class(2018,12,27)\\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, False))\\n\\n date_to_check = date_class(2018,2,28)\\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, False))\",\n \"def date(self, date):\\n self.value = date.strftime(\\\"%Y-%m-%d\\\") if date else \\\"\\\"\",\n \"def set_from_date(self, date):\\n self.set_value_into_input_field(self.set_from_date_locator, date)\",\n \"def test_date_field():\",\n \"def set_birthdate(self, date):\\n\\n if validate_date_format(self.birt):\\n self.birt = date\\n else:\\n raise ValueError('Invalid date!')\",\n \"def _date(self, _date):\\n\\n self.__date = _date\",\n \"def _date(self, _date):\\n\\n self.__date = _date\",\n \"def _earliest_allowed_date(cls):\\r\\n DAYS_GOOD_FOR = settings.VERIFY_STUDENT[\\\"DAYS_GOOD_FOR\\\"]\\r\\n allowed_date = (\\r\\n datetime.now(pytz.UTC) - timedelta(days=DAYS_GOOD_FOR)\\r\\n )\\r\\n return allowed_date\",\n \"def clean_date(self):\\r\\n from datetime import datetime\\r\\n\\r\\n date = self.cleaned_data[\\\"date\\\"]\\r\\n if date < datetime.now():\\r\\n self.add_error(\\\"date\\\", \\\"You cannot add a date for the past.\\\")\\r\\n return date\",\n \"def set_add_dispute_date(self, date):\\n self.set_value_into_input_field(self.add_dispute_date_inputbox_locator, date)\",\n \"def on_or_before(self, date):\\n return (date - mod(date - self.CORRELATION - self.to_ordinal(), 365))\",\n \"def convert_date_of_attendance(attendance):\\n if isinstance(attendance,list):\\n for a in attendance:\\n a.date_of_att = datetime.datetime.strptime(a.DATE_OF_ATTENDANCE,'%d/%m/%Y').date()\\n elif isinstance(attendance,models.AttendanceModel):\\n attendance.date_of_att = datetime.datetime.strptime\\\\\\n (attendance.DATE_OF_ATTENDANCE, '%d/%m/%Y').date()\",\n \"def date(self, new_date):\\n self._date.date = new_date\",\n \"def settlement_position_effective_date_valid(record):\\n knowledge_date = record['knowledge_date']\\n effective_date = record['effective_date']\\n assert effective_date == knowledge_date\",\n \"def test_change_of_date_field_type(self):\\n # Create a user, device and a heartbeat\\n user = Dummy.create_user()\\n device = Dummy.create_device(user)\\n heartbeat_timestamp = datetime(2015, 12, 15, 1, 23, 45, tzinfo=pytz.utc)\\n\\n heartbeat = Dummy.create_report(\\n HeartBeat, device, date=heartbeat_timestamp\\n )\\n\\n # Assert that the date is of type datetime\\n self.assertIsInstance(heartbeat.date, datetime)\\n\\n # Run the migration\\n self.migrate_to_dest()\\n\\n # Assert that the date is now of type date and has the correct value\\n heartbeat = HeartBeat.objects.first()\\n self.assertIsInstance(heartbeat.date, date)\\n self.assertEqual(heartbeat.date, heartbeat_timestamp.date())\",\n \"def set_adjustment_charge_begin_date(self, begin_date):\\n self.set_value_into_input_field(self.adjustment_begin_date_locator, begin_date)\",\n \"def _date(self) -> datetime:\\n return self.__date\",\n \"def _process_date(self, data):\\n def helper(val):\\n # Sometime the date has a (1) or (2) following it. Strip that off\\n # so that we can successful convert to date.\\n s = val.find(\\\" (\\\")\\n if s >= 0:\\n val = val[0:s]\\n dv = dt.datetime.strptime(val, '%A, %b %d')\\n dv = dv.replace(year=self.start_date.year)\\n return dv\\n data['Date'] = data['Date'].apply(helper)\\n return data\",\n \"def knowledge_date_valid(record):\\n today = datetime.now(timezone.utc).date().strftime(\\\"%Y-%m-%d\\\")\\n gen_date = record['knowledge_date'].strftime(\\\"%Y-%m-%d\\\")\\n assert gen_date == today\",\n \"def date(self):\\n bc = self.barcamp\\n if bc.start_date and bc.end_date:\\n # TODO: localize it\\n return \\\"%s - %s\\\" %(\\n bc.start_date.strftime('%d.%m.%Y'),\\n bc.end_date.strftime('%d.%m.%Y'))\\n else:\\n return self.handler._(\\\"date to be announced\\\")\",\n \"def _fill_date(self):\\n if not self.date['year']:\\n self.date['year'] = self.DEFAULT_DATE['year']\\n if not self.date['month']:\\n self.date['month'] = self.DEFAULT_DATE['month']\\n if not self.date['day']:\\n self.date['day'] = self.DEFAULT_DATE['day']\",\n \"def set_document_date(self, date):\\n self.set_value_into_input_field(self.document_date_text_field_locator, date)\",\n \"def test_date_conversion():\\n schema = pa.schema([\\n pa.field(\\\"foo\\\", pa.date32())\\n ])\\n\\n data = [{\\\"foo\\\": \\\"2018-01-01\\\"}, {\\\"foo\\\": \\\"2018-01-02\\\"}]\\n\\n converted_data = client.ingest_data(data, schema)\\n assert converted_data.to_pydict()['foo'][0].strftime(\\\"%Y-%m-%d\\\") == \\\"2018-01-01\\\"\\n assert converted_data.to_pydict()['foo'][1].strftime(\\\"%Y-%m-%d\\\") == \\\"2018-01-02\\\"\",\n \"def verify_date_field(field, data: str) -> str:\\n if field in ['started_at', 'ended_at', 'created_at', 'performed_at', 'issued_at', 'expires_at']:\\n content = string_to_date(data)\\n else:\\n content = data\\n\\n return content\",\n \"def set_to_date(self):\\n self.set_value_into_input_field(self.set_to_date_locator, self.get_current_date())\",\n \"def form_valid(self, form):\\n\\n # date_time_committee\\n date_time_committee = form.cleaned_data[\\n 'date_time_committee']\\n\\n if date_time_committee is not None:\\n\\n # We manually enter a date in Oslo/Stockholm time in the GUI\\n # so we need to convert it into UTC\\n obj = form.save(commit=False)\\n datetime_in_utc = date_time_committee.astimezone(pytz.utc)\\n obj.date_time_committee = datetime_in_utc\\n obj.save()\\n\\n return super(RatingDecisionUpdateView, self).form_valid(form)\",\n \"def clean_birth_date(self):\\n\\n sent_date = self.cleaned_data['birth_date']\\n current_date = localtime(now()).date()\\n\\n if (sent_date - current_date) > datetime.timedelta(seconds=1):\\n raise ValidationError(INVALID_BIRTH_DATE_VALUE)\\n else:\\n return sent_date\",\n \"def numeric_date_recover(self):\\n \\n sp_time_zone, current_datetime = self.setup_datetime() \\n converter2sptimezone = current_datetime.astimezone(sp_time_zone)\\n \\n return converter2sptimezone.strftime('%d-%m-%Y')\",\n \"def date_temporal_paradox_free(self):\\n valid_date = True\\n new_val = self.date_edit.text()\\n datetime_object = datetime.strptime(new_val, \\\"%Y-%m-%d\\\")\\n\\n if datetime_object > datetime.now():\\n valid_date = False\\n return valid_date\",\n \"def test_date_of_birth_good_values(self):\\n for input_val, output_val in self.known_values:\\n self.line._parse_date_of_birth(input_val)\\n self.assertEqual(output_val, self.line.date_of_birth)\",\n \"def admit_from_er(df):\\n from_er = pd.read_csv(\\n f\\\"{raw_data}\\\\\\\\er_adm.csv\\\",\\n usecols=[\\\"MemberID\\\", \\\"AdmissionDate\\\", \\\"Facility\\\"],\\n parse_dates=[\\\"AdmissionDate\\\"],\\n )\\n\\n from_er = cognify_facility_changes(from_er, \\\"Facility\\\")\\n\\n from_er[\\\"merge\\\"] = (\\n from_er[\\\"MemberID\\\"].astype(str)\\n + from_er[\\\"AdmissionDate\\\"].astype(str)\\n + from_er[\\\"Facility\\\"]\\n )\\n\\n df[\\\"merge\\\"] = (\\n df[\\\"member_id\\\"].astype(str) + df[\\\"admission_date\\\"].astype(str) + df[\\\"facility\\\"]\\n )\\n df[\\\"er\\\"] = np.where(df[\\\"merge\\\"].isin(from_er[\\\"merge\\\"].tolist()), 1, 0)\\n\\n df.drop([\\\"merge\\\"], axis=1, inplace=True)\\n return df\",\n \"def post_patient_edit(form):\\n # Extract the data from the form and add extra fields.\\n\\n contacted_fields = [\\\"Contacted\\\", \\\"Comment\\\"]\\n disabled_fields = [\\\"NextURL\\\"] + [x for x in form.data.keys() if re.search(r\\\"Disabled\\\", x) is not None]\\n data = {k: v for (k, v) in form.data.items() if k not in disabled_fields \\n and k not in contacted_fields}\\n data[\\\"UpdatedBy\\\"] = get_current_user()\\n data[\\\"UpdatedDateTime\\\"] = get_current_datetime()\\n\\n for k in [\\\"SymptomType\\\" + str(n) for n in list(range(1, 11))]:\\n if data[k] != []:\\n # keep only values that are not \\\"Select...\\\"\\n data[k] = [v for v in data[k] if v not in [\\\"Select...\\\", \\\" \\\", \\\"\\\",]]\\n if data[k] != []:\\n data[k] = \\\"; \\\".join(data[k])\\n else:\\n data[k] = None\\n else:\\n data[k] = None\\n\\n args = form.data\\n cs = get_patient_contacted_status(args)\\n try:\\n current_cs = cs[\\\"current\\\"][\\\"Contacted\\\"]\\n except:\\n current_cs = \\\"\\\"\\n try:\\n current_comment = cs[\\\"current\\\"][\\\"Comment\\\"]\\n except:\\n current_comment = \\\"\\\"\\n cs_user_entered = form.Contacted.data\\n cs_comment_user_entered = form.Comment.data\\n if current_cs != cs_user_entered or current_comment != cs_comment_user_entered:\\n post_patient_contacted_status(args)\\n \\n # Look up key data that should not be user-changeable. XXX ideally these\\n # columns would simply be excluded from PersonEntered\\n q = (\\\"select PatientLastName, PatientSSN \\\" +\\n \\\"from {schema}.PersonCrosswalk \\\".format(schema=app_schema) +\\n \\\"where PersonID = ?\\\")\\n print(\\\"person id\\\", form.PersonID.data, file=sys.stderr)\\n tb = pd.read_sql(q, engine, params=[form.PersonID.data])\\n assert tb.shape[0] == 1, \\\"Expected 1 row, but got {} rows\\\".format(tb.shape[0])\\n d = tb.iloc[0,:].to_dict()\\n data[\\\"LastName\\\"] = d[\\\"PatientLastName\\\"]\\n data[\\\"SSN\\\"] = d[\\\"PatientSSN\\\"]\\n\\n # Get cursor.\\n conn = engine.raw_connection()\\n cursor = conn.cursor()\\n\\n # Define and execute query to insert a new row.\\n keys_str = \\\", \\\".join(data.keys())\\n vals_str = \\\", \\\".join(\\\"?\\\" for _ in data.keys())\\n params = list(data.values())\\n q = (\\\"insert into {schema}.PersonEntered \\\".format(schema=app_schema) +\\n \\\"(\\\" + keys_str + \\\") \\\" +\\n \\\"values (\\\" + vals_str + \\\")\\\")\\n cursor.execute(q, params)\\n\\n conn.commit()\\n \\n return None\",\n \"def test_future_birth_date_import():\\n _curr_date = datetime.utcnow()\\n _later_date = _curr_date + relativedelta(days=1)\\n later_date = _later_date.strftime(\\\"%d.%m.%Y\\\")\\n\\n citizen_with_birth_date_later_than_current = deepcopy(CITIZEN_EXAMPLE)\\n citizen_with_birth_date_later_than_current[\\\"birth_date\\\"] = later_date\\n with TestClient(app) as client:\\n response = client.post(\\n \\\"/imports\\\",\\n json={\\n \\\"citizens\\\": [\\n citizen_with_birth_date_later_than_current\\n ]}\\n )\\n\\n assert response.status_code == 400\",\n \"def date_answered(self, date_answered):\\n self._date_answered = date_answered\",\n \"def _normalize_date(date):\\n if not date:\\n return None\\n\\n if date.tzinfo:\\n date = date.replace(tzinfo=None) - date.tzinfo.utcoffset(date)\\n return min(date, datetime.utcnow())\",\n \"def date(self, date):\\n self._date = date\",\n \"def from_date(cls, d):\\n raise NotImplementedError\",\n \"def to_python(self, value):\\n return string_to_partialdate(value)\",\n \"def date(self, value):\\n self.date_value = value\",\n \"def _set_last_exported_date(self, cr, uid, external_session, date, context=None):\\n return True\",\n \"def collect_interview_date(self, collect_interview_date):\\n\\n self._collect_interview_date = collect_interview_date\",\n \"def date(self) -> datetime.datetime:\\n return self._data['Date'] - datetime.timedelta(0, float(self.exposuretime), 0)\",\n \"def test_saving_customized_patient_post_form(self):\\n\\n form_data = {\\\"hunger-visible\\\": None}\\n save_customized_patient_post_form(1, form_data)\\n \\n patient = Patient.query.get(1)\\n self.assertEqual(False, patient.hunger_visible)\",\n \"def mod_date(self, mod_date):\\n\\n self._mod_date = mod_date\",\n \"def date(self, new_date):\\n date_list = new_date.split(\\\"/\\\")\\n if 1 > int(date_list[0]) or int(date_list[0]) > 31:\\n raise ValueError\\n elif 1 > int(date_list[1]) or int(date_list[1]) > 12:\\n raise ValueError\\n elif 1900 > int(date_list[2]) or int(date_list[2]) > 2020:\\n raise ValueError\\n else:\\n self._date = new_date\",\n \"def date(self):\\n return self.date_value\",\n \"def test_date_partial_only(self):\\n term, rmd = util.parse_date(\\\"1902\\\")\\n ym = util.parse_date_partial(term)\\n self.assertEqual(ym, \\\"2019-02\\\")\\n self.assertEqual(rmd, \\\"\\\", \\\"Should have no remainder\\\")\",\n \"def test_sample_one_date(self):\\r\\n self.assertEqual(self.test_sample.date, datetime.datetime(2016, 2, 12, 7, 34, 26))\",\n \"def __get_measurement_DLP(self, datetime: str):\\n pass\",\n \"def _period_from_date(self):\\n if self.date['year']:\\n if self.date['month']:\\n if self.date['day']:\\n self.period = Period.DAILY\\n else:\\n self.period = Period.MONTHLY\\n else:\\n self.period = Period.YEARLY\\n else:\\n self.period = Period.FULL\",\n \"def set_idate(self, idate):\\n self.__idate = idate\",\n \"def localized_date(self):\\r\\n date_ = self._post['effective_date']\\r\\n to_localized = self.context.toLocalizedTime\\r\\n \\r\\n try:\\r\\n local_date = to_localized(date_)\\r\\n except ValueError:\\r\\n # An invalid date; just return nothing\\r\\n local_date = None\\r\\n \\r\\n return local_date\",\n \"def _to_report_datetime(date_time: str, include_time: bool = True, expiry: bool = False):\\n if len(date_time) < 10: # Legacy may be empty string.\\n return date_time\\n if len(date_time) == 10: # Legacy has some date only data.\\n report_date = model_utils.date_from_iso_format(date_time)\\n return report_date.strftime('%B %-d, %Y')\\n zone = date_time[20:]\\n local_datetime = None\\n if not zone.endswith('00'): # Coming from legacy, already local so ignore timezone adjustment.\\n local_datetime = model_utils.ts_from_iso_format_local(date_time)\\n # current_app.logger.info(f'zone={zone} date_time={date_time}')\\n else:\\n local_datetime = model_utils.to_local_timestamp(model_utils.ts_from_iso_format(date_time))\\n if include_time:\\n timestamp = local_datetime.strftime('%B %-d, %Y at %-I:%M:%S %p Pacific time')\\n if timestamp.find(' AM ') > 0:\\n return timestamp.replace(' AM ', ' am ')\\n return timestamp.replace(' PM ', ' pm ')\\n\\n return local_datetime.strftime('%B %-d, %Y')\",\n \"def __data_set_is_payday_negative_19_20_21(cls):\\n _pay_cycle_object = pay_cycle_object()\\n date_to_check = date_class(2020,12,25) # Christmas\\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, False))\\n\\n date_to_check = date_class(2021,12,24)\\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, False))\\n\\n date_to_check = date_class(2022,11,11)\\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, False))\",\n \"def fix_dates(self, row):\\r\\n for field in self.date_fields:\\r\\n if field in row:\\r\\n if not type(row[field]) is datetime:\\r\\n try:\\r\\n row[field] = datetime.fromtimestamp(float(row[field]))\\r\\n except Exception as e:\\r\\n row[field] = None\",\n \"def date_answered(self):\\n return self._date_answered\",\n \"def set_from_date_as_current_date(self):\\n self.set_value_into_input_field(self.set_from_date_locator, self.get_current_date())\",\n \"def set_contest_date_time(contest, date_time, field):\\n c = biv.load_obj(contest)\\n assert type(c) == pem.E15Contest\\n dt = _local_date_time_as_utc(c, date_time)\\n assert hasattr(c, field), \\\\\\n '{}: has no attr {}'.format(c, field)\\n setattr(c, field, dt)\\n _add_model(c)\",\n \"def set_date(self, date_string, date_type):\\n if date_type == \\\"married\\\":\\n self._married_date = datetime.strptime(date_string, '%d %b %Y')\\n if date_type == \\\"divorced\\\":\\n self._divorced_date = datetime.strptime(date_string, '%d %b %Y')\",\n \"def setBaseDate(self, date=None):\\n if date is None:\\n date = self.oggi\\n self.baseDate = QDate(date.year(), date.month(), 1)\",\n \"def _cleanup_date(self, date):\\n if (not date or\\n not isinstance(date, str) or\\n 'N/A' in date):\\n return None\\n\\n date, time = date.split()\\n day, month, year = date.split('.')\\n hour, minute = time.split(':')\\n year, month, day, hour, minute = [int(x) for x in (year, month, day, hour, minute)]\\n\\n # For 2-digit years, 1969/2068 is the wrap-around (POSIX standard)\\n if (69 <= year < 100):\\n year += 1900\\n elif (0 <= year < 69):\\n year += 2000\\n\\n return datetime.datetime(year, month, day, hour, minute)\",\n \"def on_or_before(self, date):\\n return (date - mod(date - self.CORRELATION - self.to_ordinal(), 260))\",\n \"def isNaive(self, date):\\n return not self.isAware(date)\",\n \"def test_datetime_with_naive_duedate_only_fails(self):\\n # setup\\n specify_wd = self.project.activity('Specify wheel diameter')\\n\\n # save old values\\n old_start, old_due = datetime.strptime(specify_wd._json_data.get('start_date'), ISOFORMAT), \\\\\\n datetime.strptime(specify_wd._json_data.get('due_date'), ISOFORMAT)\\n naive_duedate = datetime(2017, 6, 5, 5, 0, 0)\\n with warnings.catch_warnings(record=False) as w:\\n warnings.simplefilter(\\\"ignore\\\")\\n specify_wd.edit(due_date=naive_duedate)\\n\\n # teardown\\n with warnings.catch_warnings(record=False) as w:\\n warnings.simplefilter(\\\"ignore\\\")\\n specify_wd.edit(due_date=old_due)\",\n \"def DefenceDate(self, default=None):\\n return self.data.get('defense_date', default)\",\n \"def process_datetime(a_date: datetime) -> str:\\n\\n return str(a_date.date()) if a_date else Presenter.DEFAULT\",\n \"def observation_date(self, observation_date):\\n\\n self._observation_date = observation_date\",\n \"def test_fill_data_with_one_date(self):\\n # date = pd.to_datetime('2015-06-30')\\n date = pd.to_datetime('2011-05-09')\\n print 'testing date: %s' % date.strftime('%Y-%m-%d')\\n self.full_iv.get_data()\\n\\n # df_date = self.full_iv.df_all.query('date == %r' % date)\\n # df_date = df_date[['date', 'dte', 'mark', 'strike', 'impl_vol']]\\n # print df_date.sort_values(['dte', 'strike']).to_string(line_width=1000)\\n\\n self.full_iv.df_stock = self.full_iv.df_stock[date:date]\\n df_iv = self.full_iv.calc_iv()\\n\\n print df_iv\\n\\n self.assertTrue(len(df_iv))\",\n \"def test_bad_base_date(self):\\n self.base_date = 'bad'\\n response = self._get(get_kwargs=self._data())\\n self._check_response(response, 104)\",\n \"def test_relative_date(self):\\n self.assertEqual(self.show.relative_date, None)\",\n \"def DateOfBirth(self, reg_date_of_birth = VALUE_NOT_SET):\\n ael_reg_dob = None\\n if reg_date_of_birth != VALUE_NOT_SET:\\n try:\\n ael_reg_dob = ael.date_from_string(reg_date_of_birth)\\n except:\\n if reg_date_of_birth not in ['', None]:\\n msg = \\\"The value <%s> provided for DateOfBirth is invalid and hence will not be set of the DateOfBirth AdditionalInfo\\\"%reg_date_of_birth\\n FRegulatoryLogger.ERROR(logger, msg)\\n raise FRegulatoryInfoException.FRegInfoInvalidData(msg)\\n if ael_reg_dob:\\n self.__reg_date_of_birth = reg_date_of_birth\\n else:\\n self.__reg_date_of_birth = None\\n try:\\n self.__contact.AdditionalInfo().DateOfBirth(self.__reg_date_of_birth)\\n except:\\n pass\\n else:\\n return self.__reg_date_of_birth\",\n \"def test_datetime_field():\",\n \"def clean_date(self):\\n input_day = self.cleaned_data.get('day')\\n input_date = self.cleaned_data.get('date')\\n if input_date < datetime.date.today():\\n raise forms.ValidationError(\\\"Can not create a lesson in the past.\\\")\\n elif input_date.strftime(\\\"%A\\\").lower() != input_day:\\n raise forms.ValidationError(input_date.strftime(\\\"%d-%m-%Y\\\")+\\\" does not fall on a \\\"+input_day.title()+\\\".\\\")\\n return input_date\",\n \"def _onchange_field(self):\\n if not self.secretary_contact_id:\\n return\\n if self.partner_type in ['dr', 'patient', 'secretary']:\\n self.update({\\n 'secretary_contact_id': False\\n })\",\n \"def planned_purge_date(self, planned_purge_date):\\n\\n self._planned_purge_date = planned_purge_date\",\n \"def planned_purge_date(self, planned_purge_date):\\n\\n self._planned_purge_date = planned_purge_date\",\n \"def get_date(self):\\n return self.cleaned_data['date']\",\n \"def date(self, date):\\n\\n self._date = date\",\n \"def date(self, date):\\n\\n self._date = date\",\n \"def date(self, date):\\n\\n self._date = date\",\n \"def date(self, date):\\n\\n self._date = date\",\n \"def date(self, date):\\n\\n self._date = date\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68482417","0.6833161","0.67046666","0.65385973","0.5847413","0.5256622","0.5145824","0.51359266","0.5100234","0.5099467","0.49738032","0.49723637","0.49418914","0.49067584","0.49050087","0.4872588","0.48719132","0.48694134","0.4868018","0.48641708","0.4827333","0.48181742","0.48115486","0.47770038","0.47770038","0.47674763","0.47379908","0.4731006","0.46786505","0.46763533","0.46713048","0.46711475","0.46681765","0.46585998","0.46392077","0.4636055","0.463184","0.46311694","0.4628864","0.46248478","0.4616522","0.46124238","0.46028656","0.4596969","0.45924962","0.4588889","0.45875207","0.45777407","0.45712578","0.45685315","0.45654625","0.4563015","0.45560282","0.4552468","0.45448717","0.45405883","0.45397028","0.45383546","0.45354477","0.45144808","0.4510045","0.45086533","0.44992408","0.4498449","0.44893909","0.44871366","0.44795018","0.44762218","0.44758353","0.44689548","0.44683418","0.44612056","0.44610116","0.44608152","0.4459791","0.44580042","0.44573212","0.44494537","0.44463387","0.44448182","0.44409734","0.44408527","0.44379005","0.44327176","0.4431806","0.4424512","0.4420268","0.4420193","0.4418547","0.4417681","0.44169858","0.4411206","0.44056362","0.44056362","0.44033697","0.44014654","0.44014654","0.44014654","0.44014654","0.44014654"],"string":"[\n \"0.68482417\",\n \"0.6833161\",\n \"0.67046666\",\n \"0.65385973\",\n \"0.5847413\",\n \"0.5256622\",\n \"0.5145824\",\n \"0.51359266\",\n \"0.5100234\",\n \"0.5099467\",\n \"0.49738032\",\n \"0.49723637\",\n \"0.49418914\",\n \"0.49067584\",\n \"0.49050087\",\n \"0.4872588\",\n \"0.48719132\",\n \"0.48694134\",\n \"0.4868018\",\n \"0.48641708\",\n \"0.4827333\",\n \"0.48181742\",\n \"0.48115486\",\n \"0.47770038\",\n \"0.47770038\",\n \"0.47674763\",\n \"0.47379908\",\n \"0.4731006\",\n \"0.46786505\",\n \"0.46763533\",\n \"0.46713048\",\n \"0.46711475\",\n \"0.46681765\",\n \"0.46585998\",\n \"0.46392077\",\n \"0.4636055\",\n \"0.463184\",\n \"0.46311694\",\n \"0.4628864\",\n \"0.46248478\",\n \"0.4616522\",\n \"0.46124238\",\n \"0.46028656\",\n \"0.4596969\",\n \"0.45924962\",\n \"0.4588889\",\n \"0.45875207\",\n \"0.45777407\",\n \"0.45712578\",\n \"0.45685315\",\n \"0.45654625\",\n \"0.4563015\",\n \"0.45560282\",\n \"0.4552468\",\n \"0.45448717\",\n \"0.45405883\",\n \"0.45397028\",\n \"0.45383546\",\n \"0.45354477\",\n \"0.45144808\",\n \"0.4510045\",\n \"0.45086533\",\n \"0.44992408\",\n \"0.4498449\",\n \"0.44893909\",\n \"0.44871366\",\n \"0.44795018\",\n \"0.44762218\",\n \"0.44758353\",\n \"0.44689548\",\n \"0.44683418\",\n \"0.44612056\",\n \"0.44610116\",\n \"0.44608152\",\n \"0.4459791\",\n \"0.44580042\",\n \"0.44573212\",\n \"0.44494537\",\n \"0.44463387\",\n \"0.44448182\",\n \"0.44409734\",\n \"0.44408527\",\n \"0.44379005\",\n \"0.44327176\",\n \"0.4431806\",\n \"0.4424512\",\n \"0.4420268\",\n \"0.4420193\",\n \"0.4418547\",\n \"0.4417681\",\n \"0.44169858\",\n \"0.4411206\",\n \"0.44056362\",\n \"0.44056362\",\n \"0.44033697\",\n \"0.44014654\",\n \"0.44014654\",\n \"0.44014654\",\n \"0.44014654\",\n \"0.44014654\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61643326"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":84579,"cells":{"query":{"kind":"string","value":"To use in Query expressions, define SQL expression separately."},"document":{"kind":"string","value":"def patient_consent(self):\n return self.patient_consent_date != None # noqa: E711"},"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 _expression(self, expression):\n exp, values = _convert_expression(expression)\n if isinstance(exp, sqlalchemy.sql.expression.ClauseElement):\n return exp\n if exp is None:\n return sqlalchemy.sql.expression.literal(True)\n qbh = expr.QueryBuilderHelper(self.table)\n where_clause = qbh.where_clause(exp, values)\n subselect = sql.select([self.table.c.id]).select_from(qbh.from_clause())\n subselect = subselect.where(where_clause)\n return self.table.c.id.in_(subselect)","def test_query_expression_parsing(self):\r\n query1 = self.table.filter(self.table.column('test_id') == 5)\r\n assert len(query1._where) == 1\r\n\r\n op = query1._where[0]\r\n assert isinstance(op.operator, operators.EqualsOperator)\r\n assert op.value == 5\r\n\r\n query2 = query1.filter(self.table.column('expected_result') >= 1)\r\n assert len(query2._where) == 2\r\n\r\n op = query2._where[1]\r\n assert isinstance(op.operator, operators.GreaterThanOrEqualOperator)\r\n assert op.value == 1","def where(self, value, operator=\">\"):\n assert operator in self.operators\n return f\"\"\"\nf_cast_isots(json->>'{sqlq(self.name)}') {sqlq(operator)} ${{arg}}::{sqlq(self.cast_type)}\"\"\"","def _raw_sql(self, values):\n if isinstance(self.model._meta.pk, CharField):\n when_clauses = ' '.join([self._when(\"'{}'\".format(x), y) for (x, y) in values])\n else:\n when_clauses = ' '.join([self._when(x, y) for (x, y) in values])\n table_name = self.model._meta.db_table\n primary_key = self.model._meta.pk.column\n return 'SELECT CASE {}.\"{}\" {} ELSE 0 END'.format(table_name, primary_key, when_clauses)","def where(self, value, operator=\"\"):\n return f\"\"\"\nto_tsvector('english', json->>'{sqlq(self.name)}') @@ plainto_tsquery(${{arg}}::text)\"\"\"","def quote(self, expr):\n return \"'\" + self.escape(str(expr)) + \"'\"","def test_query_expression_where_clause_generation(self):\r\n query1 = self.table.objects(self.table.column('test_id') == 5)\r\n self.assertEqual(len(query1._where), 1)\r\n where = query1._where[0]\r\n self.assertEqual(where.field, 'test_id')\r\n self.assertEqual(where.value, 5)\r\n\r\n query2 = query1.filter(self.table.column('expected_result') >= 1)\r\n self.assertEqual(len(query2._where), 2)\r\n\r\n where = query2._where[0]\r\n self.assertEqual(where.field, 'test_id')\r\n self.assertIsInstance(where.operator, EqualsOperator)\r\n self.assertEqual(where.value, 5)\r\n\r\n where = query2._where[1]\r\n self.assertEqual(where.field, 'expected_result')\r\n self.assertIsInstance(where.operator, GreaterThanOrEqualOperator)\r\n self.assertEqual(where.value, 1)","def test_query_expression_parsing(self):\r\n query1 = TestModel.filter(TestModel.test_id == 5)\r\n assert len(query1._where) == 1\r\n\r\n op = query1._where[0]\r\n assert isinstance(op, statements.WhereClause)\r\n assert isinstance(op.operator, operators.EqualsOperator)\r\n assert op.value == 5\r\n\r\n query2 = query1.filter(TestModel.expected_result >= 1)\r\n assert len(query2._where) == 2\r\n\r\n op = query2._where[1]\r\n self.assertIsInstance(op, statements.WhereClause)\r\n self.assertIsInstance(op.operator, operators.GreaterThanOrEqualOperator)\r\n assert op.value == 1","def get_basic_query_cond(column: str, val: str, query_params: dict):\n if val is not None:\n query_params[column] = val\n return 'AHJ.' + column + '=%(' + column + ')s AND '\n return ''","def where(self, value, operator=\">\"):\n assert operator in self.operators\n return f\"\"\"\nCAST(json->>'{sqlq(self.name)}' AS {sqlq(self.cast_type)}) {sqlq(operator)} ${{arg}}::{sqlq(self.cast_type)}\"\"\" # noqa","def expression(self) -> Expression:\n ...","def gen_q_stmt(name, query):\n return \"query {} `{}`;\\n\".format(name, query)","def sql_statement(self, operation, sql):\n if type(sql) != str:\n raise Exception(\n \"Invalid argument: sql of type {} should be: <class 'str'>\".format(type(sql)))\n if operation == 0 or operation == 2 or operation == 3:\n self.__database__.execute(sql)\n elif operation == 1:\n return self.__database__.execute(sql)\n else:\n raise Exception(\"Invalid SQL operation code\")","def asSQL(self) -> str:\n # To modify this method, pay attentin to SQL injection.\n # For example, if `self.x` is assumed to be integer\n # but is not guaranteed to be,\n # `:d` must always be specified in format strings:\n # `expressions.append(f\"x > {self.x:d}\")`\n expressions = []\n if self.date_start is not None:\n if self.date_start.tzinfo is None:\n datestr = self.date_start.isoformat()\n else:\n datestr = self.date_start.astimezone(datetime.timezone.utc).replace(tzinfo=None).isoformat()\n expressions.append(f\"pfs_visit.issued_at >= '{datestr}'\")\n if self.date_end is not None:\n if self.date_end.tzinfo is None:\n datestr = self.date_end.isoformat()\n else:\n datestr = self.date_end.astimezone(datetime.timezone.utc).replace(tzinfo=None).isoformat()\n expressions.append(f\"pfs_visit.issued_at < '{datestr}'\")\n if self.visit_start is not None:\n expressions.append(f\"pfs_visit.pfs_visit_id >= '{self.visit_start:d}'\")\n if self.visit_end is not None:\n expressions.append(f\"pfs_visit.pfs_visit_id < '{self.visit_end:d}'\")\n\n if expressions:\n return \"(\" + \" AND \".join(expressions) + \")\"\n else:\n return \"TRUE\"","def build_query_clauses(\n where: str = \"\", order: str = \"\", limit: int = 0, offset: int = 0\n ) -> str:\n return SqliteQueryBuilder.build_query_clauses(where, order, limit, offset)","def _sql_where(self, cursor, table, prefix=None, aggregate=False):\n assert False, \"subclass responsibility\"","def translate_call_to_sql(self, query, expr, state):\n args = [query.expression_to_sql(arg, state) for arg in expr.args]\n distinct = expr.distinct and 'DISTINCT ' or ''\n # this will generate a possibly new name, which is why we call this here\n # so we can consider that in the function call translation generated below:\n self.load()\n return f'{self.get_name()}({distinct}{\", \".join(args)})'","def expression(self, expr):\n self.set(expression=expr)","def make_sql_event_condition_string(self, event_names, sub_condition_sql):\n\n if event_names[0] == 'no event filter': \n return 'TRUE'\n else:\n placeholders = ','.join(['%s'] * len(event_names))\n in_events = \"{placeholders}\".format(placeholders = event_names).replace(',)', ')')\n return \"event_name IN \" + in_events + \" \" + sub_condition_sql","def get_expr_exec_format(self):\n if self.haveExpr:\n self.haveExpr = False\n return '{}'\n return 'SELECT {} FROM DUMMY'","def make_where(cls, key, value, operation=\"=\"):\n\n if operation not in cls.__VALID_WHERE_OPERATION_LIST:\n raise SqlSyntaxError(\"operation not supported: \" + str(operation))\n\n if value is not None:\n return \"%s %s %s\" % (\n cls.to_attr_str(key), operation, cls.to_value_str(value))\n\n if operation == \"=\":\n return \"%s IS NULL\" % (cls.to_attr_str(key))\n elif operation == \"!=\":\n return \"%s IS NOT NULL\" % (cls.to_attr_str(key))\n\n raise SqlSyntaxError(\n \"Invalid operation (%s) with None right-hand side\" % (operation))","def generate_select_sql(self, condition, fields):\n return \"SELECT %s FROM %s WHERE %s\" % (fields, self.tablename, condition)","def query(mdx_stmt):","def _build_statement(self, query, query_key, beets_key):\n statement = \"\"\n if query_key in query:\n for query_string in query[query_key]:\n if '\"' in query_string:\n statement += \" and %s = \\'%s\\' \" % (beets_key,\n query_string)\n else:\n statement += ' and %s = \\\"%s\\\" ' % (beets_key,\n query_string)\n return statement","def _sql_where(cur, tables, andalso, orelse, prefix=None, aggregate=False):\n disjunctions = []\n andsql = _cond_where_sql(cur, andalso, tables, prefix=prefix,\n aggregate=aggregate)\n andsql = ' AND '.join(andsql)\n\n if len(andsql) > 0:\n andsql = '(%s)' % andsql\n disjunctions.append(andsql)\n disjunctions += _cond_where_sql(cur, orelse, tables, prefix=prefix,\n aggregate=aggregate)\n\n if len(disjunctions) == 0:\n return ''\n return '(%s)' % (' OR '.join(disjunctions))","def escape(self, expr):\n return mysql.connector.conversion.MySQLConverter().escape(expr)","def make_sql_condition_string(self, field, condition, value, filter_type):\n\n if field == 'no filters': \n return ''\n else: \n if filter_type in ('metric', 'attribute', 'event'):\n # for < (less than) filters on metrics, we need to use a \"having\" filter with an aggregation (only MAX for now) on the metric\n if (filter_type == 'metric'):\n return 'AND ' + 'MAX(cumul_filter_metric)' + ' ' + condition + ' ' + value + ''\n else:\n return 'AND ' + field + ' ' + condition + ' ' + value + ''\n else:\n raise NotImplementedError()","def sql(self, method: str = 'select') -> str:","def _joined_column_sql(editable, generated, joined):\n return f\"IF({editable} IS NOT NULL AND {editable} != '' OR {generated} = 'NA', {editable}, {generated}) AS {joined}\"","def generate_sql(field_map, input_data, macro_map={}):\n if input_data == []:\n return SQL_HEADER\n\n entity = Entity(input_data)\n\n where_clause = ''\n if entity.is_simple_clause():\n where_clause = transpile_simple_clause(field_map, entity, macro_map)\n elif entity.is_compound_clause():\n where_clause = transpile_compound_clause(field_map, entity, macro_map)\n elif entity.is_macro():\n where_clause = transpile_macro(field_map, entity, macro_map)\n else:\n raise TranspilerError(\"Input (%s) not recognized.\" % (input_data))\n\n return SQL_HEADER + ' WHERE '+ where_clause","def sql_execute2(sql,value):\n cur = c.cursor()\n cur.execute(sql,value)","def __convert_to_sql_where(conditions : List[Tuple[Any, RelationalOperator, Any]]) -> str:\n\n formatted_identifiers = []\n\n for identifier in conditions:\n col_name, relation, value = identifier\n\n if relation == RelationalOperator.Between and len(value) != 2:\n raise ValueError(\"Between relational operator requires the value parameter to be a list of length 2\")\n \n if relation != RelationalOperator.Between:\n value = SecurityDatabaseWrapper._validate_value(value)\n \n col_name = SecurityDatabaseWrapper._validate_column_name(col_name)\n\n formatted_identifiers.append((col_name, relation, value))\n\n where_clause_section = ' AND '.join([f'{col_name} {relation.value} {value}' for col_name, relation, value in formatted_identifiers])\n return f\"({where_clause_section})\"","def _build_expression(self, exp, object_class, fields):\n if \"op\" not in exp:\n return None\n\n def autocast(o_key, value):\n \"\"\"Try to guess the type of `value` and parse it from the string.\"\"\"\n if not isinstance(o_key, (str, unicode)):\n return value\n key, _ = self.attr_name_map[object_class].get(o_key, (o_key, None))\n # handle dates\n if (\"date\" in key and \"relative\" not in key) or \\\n key in [\"end_date\", \"start_date\"]:\n if isinstance(value, datetime.date):\n return value\n try:\n month, day, year = [int(part) for part in value.split(\"/\")]\n return datetime.date(year, month, day)\n except Exception:\n raise BadQueryException(\"Field \\\"{}\\\" expects a MM/DD/YYYY date\"\n .format(o_key))\n # fallback\n return value\n\n def relevant():\n \"\"\"Filter by relevant object.\"\"\"\n query = (self.query[exp[\"ids\"][0]]\n if exp[\"object_name\"] == \"__previous__\" else exp)\n return object_class.id.in_(\n RelationshipHelper.get_ids_related_to(\n object_class.__name__,\n query[\"object_name\"],\n query[\"ids\"],\n )\n )\n\n def unknown():\n raise BadQueryException(\"Unknown operator \\\"{}\\\"\"\n .format(exp[\"op\"][\"name\"]))\n\n def with_key(key, p):\n key = key.lower()\n key, filter_by = self.attr_name_map[\n object_class].get(key, (key, None))\n if hasattr(filter_by, \"__call__\"):\n return filter_by(p)\n else:\n attr = getattr(object_class, key, None)\n if attr is None:\n raise BadQueryException(\"Bad query: object '{}' does \"\n \"not have attribute '{}'.\"\n .format(object_class.__name__, key))\n return p(attr)\n\n with_left = lambda p: with_key(exp[\"left\"], p)\n\n lift_bin = lambda f: f(self._build_expression(exp[\"left\"], object_class,\n fields),\n self._build_expression(exp[\"right\"], object_class,\n fields))\n\n def text_search():\n \"\"\"Filter by text search.\n\n The search is done only in fields listed in external `fields` var.\n \"\"\"\n existing_fields = self.attr_name_map[object_class]\n text = \"%{}%\".format(exp[\"text\"])\n p = lambda f: f.ilike(text)\n return or_(*(\n with_key(field, p)\n for field in fields\n if field in existing_fields\n ))\n\n rhs = lambda: autocast(exp[\"left\"], exp[\"right\"])\n\n ops = {\n \"AND\": lambda: lift_bin(and_),\n \"OR\": lambda: lift_bin(or_),\n \"=\": lambda: with_left(lambda l: l == rhs()),\n \"!=\": lambda: not_(with_left(\n lambda l: l == rhs())),\n \"~\": lambda: with_left(lambda l:\n l.ilike(\"%{}%\".format(rhs()))),\n \"!~\": lambda: not_(with_left(\n lambda l: l.ilike(\"%{}%\".format(rhs())))),\n \"<\": lambda: with_left(lambda l: l < rhs()),\n \">\": lambda: with_left(lambda l: l > rhs()),\n \"relevant\": relevant,\n \"text_search\": text_search\n }\n\n return ops.get(exp[\"op\"][\"name\"], unknown)()","def _sql_where(self, cur, tables, prefix=None, aggregate=False):\n if aggregate:\n return _sql_where(cur, tables, self._agg_andalso, self._agg_orelse,\n prefix=prefix, aggregate=aggregate)\n else:\n return _sql_where(cur, tables, self._andalso, self._orelse,\n prefix=prefix, aggregate=aggregate)","def other_op(q, *params):\n db = Database()\n db.cur.execute(q, params)\n db.con.close()","def test_operator_adapt(self):\n\n # test string concatenation\n expr = test_table.c.data + \"somedata\"\n assert testing.db.execute(select([expr])).scalar() == \"somedatasomedata\"\n\n expr = test_table.c.id + 15\n assert testing.db.execute(select([expr])).scalar() == 16\n\n # test custom operator conversion\n expr = test_table.c.avalue + 40\n assert expr.type.__class__ is test_table.c.avalue.type.__class__\n\n # value here is calculated as (250 - 40) / 10 = 21\n # because \"40\" is an integer, not an \"avalue\"\n assert testing.db.execute(select([expr.label('foo')])).scalar() == 21\n\n expr = test_table.c.avalue + literal(40, type_=MyCustomType)\n \n # + operator converted to -\n # value is calculated as: (250 - (40 * 10)) / 10 == -15\n assert testing.db.execute(select([expr.label('foo')])).scalar() == -15\n\n # this one relies upon anonymous labeling to assemble result\n # processing rules on the column.\n assert testing.db.execute(select([expr])).scalar() == -15","def determine_query():\n return query if query is not None \\\n else f\"SELECT * FROM '{table}';\"","def build_expression(self, field_name, sub_field_name, null_value):\n expression = ''\n if field_name:\n expression = \"${object.\" + field_name\n if sub_field_name:\n expression += \".\" + sub_field_name\n if null_value:\n expression += \" or '''%s'''\" % null_value\n expression += \"}\"\n return expression","def make_query(self):","def define_expression(DomainName=None, Expression=None):\n pass","def _make_query(self):\r\n raise NotImplementedError()","def mogrify_sql_statement(self, content):\n sql = content[0]\n args = content[1]\n\n if self.dbmi.__name__ == \"psycopg2\":\n if len(args) == 0:\n return sql\n else:\n if self.connected:\n try:\n return self.cursor.mogrify(sql, args)\n except Exception as exc:\n print(sql, args)\n raise exc\n else:\n self.connect()\n statement = self.cursor.mogrify(sql, args)\n self.close()\n return statement\n\n elif self.dbmi.__name__ == \"sqlite3\":\n if len(args) == 0:\n return sql\n else:\n # Unfortunately as sqlite does not support\n # the transformation of sql strings and qmarked or\n # named arguments we must make our hands dirty\n # and do it by ourself. :(\n # Doors are open for SQL injection because of the\n # limited python sqlite3 implementation!!!\n pos = 0\n count = 0\n maxcount = 100\n statement = sql\n\n while count < maxcount:\n pos = statement.find(\"?\", pos + 1)\n if pos == -1:\n break\n\n if args[count] is None:\n statement = \"%sNULL%s\" % (statement[0:pos],\n statement[pos + 1:])\n elif isinstance(args[count], (int, long)):\n statement = \"%s%d%s\" % (statement[0:pos], args[count],\n statement[pos + 1:])\n elif isinstance(args[count], float):\n statement = \"%s%f%s\" % (statement[0:pos], args[count],\n statement[pos + 1:])\n elif isinstance(args[count], datetime):\n statement = \"%s\\'%s\\'%s\" % (statement[0:pos], str(args[count]),\n statement[pos + 1:])\n else:\n # Default is a string, this works for datetime\n # objects too\n statement = \"%s\\'%s\\'%s\" % (statement[0:pos],\n str(args[count]),\n statement[pos + 1:])\n count += 1\n\n return statement","def make_clause(exprs, orderby=None, limit=None, offset=None):\n exprs = flatten_exprs(exprs)\n assert exprs, 'Must supply exprs to make_clause! (got: %r)' % (exprs,)\n assert all(isinstance(expr, ttypes.Comparison) for expr in exprs)\n\n kwargs = {'exprs': exprs}\n if orderby is not None:\n if isinstance(orderby, (list, tuple)):\n kwargs['orderby'] = [mapserv.query.util.make_orderby(o) for o in orderby]\n else:\n kwargs['orderby'] = [mapserv.query.util.make_orderby(orderby)]\n if limit is not None:\n kwargs['limit'] = limit\n if offset:\n kwargs['offset'] = offset\n\n return ttypes.QueryClause(**kwargs)","def expression(self):\n assert not self._handle_used\n self._expression_used = True\n return self._expression","def sqlwhere(dictionary, grouping=' AND '):\n return SQLQuery.join([k + ' = ' + sqlparam(v) for k, v in dictionary.items()], grouping)","def sql_query(self):\n return self._project.sql_query","def sql_query(self, query_text, edges = False):\n q = QueryWrapper(self.graph, QueryString(query_text, 'sql'),\n edges = edges, debug = self._debug)\n return q","def of(cls, clause=\"\", params=[]):\r\n return Q.C(clause, params)","def conditions_as_sql(self, prewhere=False):\n q_object = self._prewhere_q if prewhere else self._where_q\n return q_object.to_sql(self._model_cls)","def test_operator_check(self):\r\n with self.assertRaises(StatementException):\r\n WhereClause('a', 'b', 'c')","def get_where_clause(self, params: Dict) -> str:\n return ''","def query(self, sql, rowfactory=None, *args, **kwgs):\n return query(self.conn, sql, rowfactory, *args, **kwgs)","def expr():\n def p(tok):\n # commas can appear in quantified variables\n return not(tok.value in [';','.'])\n return reparse('expr').process(c.balanced_condition(p))","def test_where_clause_rendering(self):\r\n wc = WhereClause('a', EqualsOperator(), 'c')\r\n wc.set_context_id(5)\r\n self.assertEqual('\"a\" = :5', unicode(wc))\r\n self.assertEqual('\"a\" = :5', str(wc))","def _getSQLWhere(self, inputTable, queryMeta):\n\t\tsqlPars = {}\n\t\tinputPars = dict((p.name, p.value) for p in inputTable.iterParams())\n\t\treturn base.joinOperatorExpr(\"AND\",\n\t\t\t[cd.asSQL(inputPars, sqlPars, queryMeta)\n\t\t\t\tfor cd in self.condDescs]), sqlPars","def generateSQLFilter(sql_filter, es_type, category):\n query_string = \"Category = ? AND (\"\n insertion_list = [category]\n\n i = 0\n while i < len(sql_filter):\n insertion_list.append(sql_filter[i]) # append values to be inserted into SQL statement (? substitution)\n if (i + 1) != 1: # NOT first loop\n query_string += \" OR \"\n query_string += es_type + \" = ?\"\n i += 1\n\n query_string += \")\"\n #\n #\n\n return query_string, insertion_list","def sqlors(left, lst):\n if isinstance(lst, iters):\n lst = list(lst)\n ln = len(lst)\n if ln == 0:\n return SQLQuery(\"1=2\")\n if ln == 1:\n lst = lst[0]\n\n if isinstance(lst, iters):\n return SQLQuery(['('] + \n sum([[left, sqlparam(x), ' OR '] for x in lst], []) +\n ['1=2)']\n )\n else:\n return left + sqlparam(lst)","def sql_query(sql):\n cur = c.cursor()\n cur.execute(sql)\n c.commit()","def _build_test_query01(self):\n\n\t\tquery = 'select \"GLOBALEVENTID\", \"SQLDATE\", \"MonthYear\", \"Year\" ' + \\\n\t\t\t\t\t 'from \"DEMOUSER00\".\"uni.vlba.gdelt.data::gdelt_dailyupdates\"'\t\t\n\n\t\treturn query","def generate_query(self):\n return","def construct_SELECT_AS(self, exp):\n display_names = self.get_display_names(exp)\n db_colnames = self.get_colnames(exp.measurementmodel)\n \n AS_stmt = ', '.join('%s AS %s' % (db_col, display_col) \n for db_col, display_col in zip(db_colnames, display_names))\n return AS_stmt","def sqlquote(a):\n if isinstance(a, list):\n return _sqllist(a)\n else:\n return sqlparam(a).sqlquery()","def test_simple_where(self):\n query = (Query()\n .match('', 'a')\n .where('exists(a.name)')\n .where('a.age = 2')\n )\n expected = '\\n'.join((\n 'MATCH (a)',\n 'WHERE exists(a.name)',\n ' AND a.age = 2',\n 'RETURN a',\n ))\n self.assertEqual(str(query), expected)","def expr(s):\n if isinstance(s, Expr): return s\n if isnumber(s): return Expr(s)\n ## Replace the alternative spellings of operators with canonical spellings\n s = s.replace('==>', '>>').replace('<==', '<<')\n s = s.replace('<=>', '%').replace('=/=', '^')\n ## Replace a symbol or number, such as 'P' with 'Expr(\"P\")'\n s = re.sub(r'([a-zA-Z0-9_.]+)', r'Expr(\"\\1\")', s)\n ## Now eval the string. (A security hole; do not use with an adversary.)\n return eval(s, {'Expr':Expr})","def gws_q(self, query, attribute, data):\n \n gws_q = query.format(attribute, data) #attribute = SQL table\n \n query_df = db.query(gws_q) \n return query_df","def gen_sql(runtime, query_type, target_model=None):\n\n from_table = runtime.model.table_name\n\n # if target_model not given, use from_table instead\n if target_model is None:\n target_model = runtime.model\n\n target_table = target_model.table_name\n\n data = runtime.data # alias\n\n # quick mark for parse time functions\n _where = Compiler.parse_where(data['where'])\n _set = Compiler.parse_set(data['set'])\n _orderby = Compiler.parse_orderby(data['orderby'])\n _select = Compiler.parse_select(data['select'])\n _limit = Compiler.parse_limit(data['limit'])\n _groupby = Compiler.parse_groupby(data['groupby'])\n _having = Compiler.parse_having(data['having'])\n _distinct = Compiler.parse_distinct(data['distinct'])\n\n pattern = Compiler.SQL_PATTERNS[query_type]\n\n SQL = pattern.format(**{\n 'target': target_table,\n 'set': _set,\n 'from': from_table,\n 'where': _where,\n 'select': _select,\n 'limit': _limit,\n 'orderby': _orderby,\n 'groupby': _groupby,\n 'having': _having,\n 'distinct': _distinct,\n })\n\n return SQL","def __call__(self, expression):\n self.set_expression(expression)","def _Expr(self, tree):\n # Catch odd case of multi line strings and doc strings which are Expr with a Constant string type value\n if isinstance(tree.value, ast.Constant):\n if isinstance(tree.value.value, str):\n return\n # catch special case of Python 3.7 Where doc string is a Str and not a Constant\n elif isinstance(tree.value, ast.Str):\n return \n # otherwise treat like a normal expression\n self.fill()\n self.dispatch(tree.value)\n self.write(\";\")","def sql_command(self):\n return lambda a: 1","def as_sql(self, qn, connection):\n lhs, lhs_params = self.process_lhs(qn, connection)\n rhs, rhs_params = self.process_rhs(qn, connection)\n\n field = lhs\n # JSONField formats query values for the database by wrapping them psycopg2's\n # JsonAdapter, but we need the raw Python dict so that we can parse the\n # query tree. Intercept the query parameter (it'll always be the first\n # element in the parameter list, since the custom jsonb filter only accepts one argument)\n # and revert it back to a Python dict for tree parsing.\n tree = rhs_params[0].adapted\n\n return FilterTree(tree, field).sql()","def where(condition):\r\n return ('', []) if condition.clause == '' else (f'WHERE {condition.clause}', list(condition.params))","def stock_3_query(self):\n return f\"\"\"\n SELECT '{self.stock_3}'\n FROM closing_prices;\"\"\"","def get_list_query_cond(column: str, val: list, query_params: dict):\n if val is not None and len(val) != 0:\n or_list = []\n for i in range(len(val)):\n param_name = f'{column}{i}'\n query_params[param_name] = val[i]\n or_list.append('AHJ.' + column + '=%(' + param_name + ')s')\n ret_str = '(' + ' OR '.join(or_list) + ') AND '\n return ret_str\n return ''","def run_sql(self, sql):\n def mk_run_sql_q(sql):\n return {\n 'type' : 'run_sql',\n 'args': {\n 'sql' : sql\n }\n }\n return self.v1q(mk_run_sql_q(sql))","def test_raw_sql(self):\n\n # GIVEN raw SQL command\n sql = 'SELECT id, date_joined from auth_user WHERE id > %s;'\n params = ['0']\n\n # WHEN executing the SQL\n cursor = TestModel.execute_sql(sql, params)\n\n # THEN it should succeed\n results = cursor.fetchall()\n self.assertEqual(len(results), 1)\n self.assertEqual(len(results[0]), 2)","def build_where_statement(attr_converter):\n statements = []\n values = []\n # iterate over the querystring params\n for attr, val in request.args.iteritems():\n try:\n statements.append(attr_converter[attr]['converter'](\n attr_converter[attr]['column']))\n values.append(val) # add after the possible keyerror\n except KeyError:\n # TODO: handle invalid params somehow or continue to ignore\n pass\n if statements:\n return 'WHERE '+' AND '.join(statements), values\n return '', []","def expression( ):#DOUBLE CHECK THIS\n\t\n\ttok = tokens.peek( )\n\tif debug: print(\"Expression: \", tok)\n\tleft = andExpr( ) #does the left side of the grammar \n\ttok = tokens.peek( )\n\twhile tok == \"or\": #checks to see if there is the token or and will preform what is inside the curly bracket since it is a series \n\t\ttokens.next()\n\t\tright = andExpr( )\n\t\tleft = BinaryExpr(tok, left, right) # MIGHT HAVE TO CHANGE THIS TO STRING CAUSE ITS \"or\"\n\t\ttok = tokens.peek( )\n\treturn left","def test_empty_condition(self):\n\n self.assertRaises(SyntaxError, self.table.where, '')","def test_sqpp_quoted_expr1_and_paren_expr2_and_expr3(self):\n self.assertEqual(self.parser.parse_query('\"expr1\" (expr2) expr3'),\n ['+', '\"expr1\"', '+', 'expr2', '+', 'expr3'])","def get_name_query_cond(column: str, val: str, query_params: dict):\n if val is not None and column is not None:\n query_params[column] = '%' + val + '%'\n return 'AHJ.' + column + ' LIKE %(' + column + ')s AND '\n return ''","def stock_1_query(self):\n return f\"\"\"\n SELECT Date, '{self.stock_1}'\n FROM closing_prices;\"\"\"","def _orderby_expression(self):\n return ''","def test_expr(self):\n self.common_test_expr(True)","def execute_query(self, *args, **kwargs):","def get_sql_str_select(self,table_name, field_names = ['*'],where_ind_name = None, where_ind_value = None, where_clause = None):\n\t\tif (where_ind_name!=None) & (where_ind_value!=None):\n\t\t\tsql_str = 'SELECT %s FROM %s.%s WHERE %s = %s'%(','.join([str(x) for x in field_names]),\t\t\t\t\t\t\t\t\t\t\t\t\tself.__schema_name,\t\t\t\t\t\t\t\t\t\t\t\t\t\ttable_name,\t\t\t\t\t\t\t\t\t\t\t\t\t\t where_ind_name,\t\t\t\t\t\t\t\t\t\t\t\t\t\t where_ind_value)\n\t\telse:\n\t\t\tsql_str = 'SELECT %s FROM %s.%s %s'%(','.join([str(x) for x in field_names]),\t\t\t\t\t\t\t\t\t\t\t\t\tself.__schema_name,\t\t\t\t\t\t\t\t\t\t\t\t\t\ttable_name, where_clause)\n\t\t# print(sql_str)\n\t\treturn sql_str","def _valid_filter_query(self):\n if self._output_invalid_imeis:\n valid_filter_sql = sql.SQL('TRUE')\n else:\n valid_filter_sql = sql.SQL('is_valid IS TRUE')\n return valid_filter_sql","def test_where_clause_type_checking(self):\r\n stmt = BaseCQLStatement('table', [])\r\n with self.assertRaises(StatementException):\r\n stmt.add_where_clause('x=5')","def sql_query(self, new_query):\n self._project.sql_query = new_query","def dynamiQ(fields, types, values, operator='or'):\r\n from django.db.models import Q\r\n\r\n queries = []\r\n q = None\r\n for (f, t, v) in zip(fields, types, values):\r\n # We only want to build a Q with a value\r\n if v != \"\":\r\n kwargs = {str('%s__%s' % (f,t)) : str('%s' % v)}\r\n queries.append(Q(**kwargs))\r\n\r\n # Make sure we have a list of filters\r\n if len(queries) > 0:\r\n q = Q()\r\n # AND/OR awareness\r\n for query in queries:\r\n if operator == \"and\":\r\n q = q & query\r\n elif operator == \"or\":\r\n q = q | query\r\n else:\r\n q = None\r\n\r\n return q","def generate_update_sql(self, fieldupdate, condition):\n return \"UPDATE %s SET %s WHERE %s\" % (self.tablename, fieldupdate, condition)","def __generateQuery(self, query):\n if query == None:\n return [\"1=1\"]\n elif type(query) is not list:\n return [query]\n else:\n return query","def where(self, column, *args):\n\n operator, value = self._extract_operator_value(*args)\n\n if value is None:\n value = \"\"\n elif value is True:\n value = \"1\"\n elif value is False:\n value = \"0\"\n\n if inspect.isfunction(column):\n builder = column(self.new())\n self._wheres += (\n (QueryExpression(None, operator, SubGroupExpression(builder))),\n )\n elif isinstance(value, QueryBuilder):\n self._wheres += (\n (QueryExpression(column, operator, SubSelectExpression(value))),\n )\n else:\n self._wheres += ((QueryExpression(column, operator, value, \"value\")),)\n return self","def query(gp, *args):\n\n def decorator(f):\n add_query_pattern(gp, f, args)\n\n return decorator","def check_where_exist(query: str, column: object, condition: str, like: bool = False) -> str:\n\n if column is not None:\n if like:\n column = convert_to_like(column)\n condition = condition.format(column)\n if \"WHERE\" in query:\n new_query = f\" AND ({condition}) \"\n else:\n new_query = f\" WHERE ({condition}) \"\n return new_query\n return \"\"","def format_sql_in_context(sql_template, param_dict, conn):\n if conn is not None:\n # Postgres, secure\n query = format_sql_postgres(sql_template, param_dict)\n return query.as_string(conn)\n\n # sqlite, may not be perfectly secure, far better than nothing\n return format_query_check_chars(sql_template, param_dict)","def set_expr(self, expr: Expr):\r\n self.expr = Expr.cnf(expr)","def prepare_expr(expr, parameter):\n # First take out of tuple.\n if type(expr) == tuple:\n expr = expr[0]\n # Strip of whitespace\n expr = expr.strip(\" \")\n # Do necessary replacements to Python can interpret expression.\n expr = expr.replace('^', '**')\n expr = expr.replace('{'+'0}', 'x')\n expr = expr.replace('{'+'1}', 'x') ## does this need be another variable???\n expr = expr.replace('x', str(np.float64(parameter)))\n expr = expr.replace('X', str(np.float64(parameter)))\n expr = expr.replace('32768', str(np.float64(32768.0)))\n\n return expr","def query(self, query):","def test_add_dummy_where_with_where_not_present_and_added(self):\n updated_sql = add_dummy_where(self.SQL_WITHOUT_WHERE)\n self.assertEqual(updated_sql, self.SQL_WITH_WHERE)","def _as_mapnik_sql(self,**kwargs):\n # running multidb available in django 1.2\n if hasattr(self.qs.query,'get_compiler'):\n compiler = self.qs.query.get_compiler(self.qs.db)\n sql, args = compiler.as_sql()\n gqn = compiler.connection.ops.geo_quote_name\n else:\n sql, args = self.qs.query.as_sql()\n from django.contrib.gis.db.backends.util import gqn\n #if qs.query.has_where\n if args:\n sql = sql % tuple([str(i) if hasattr(i,'ewkb') else gqn(i) for i in args])\n return \"\"\"(%s) as django_table\"\"\" % sql","def _build_query(self, **query):\n\n available_fields = list(self.model._available_fields.keys())\n\n q_str = ''\n for key, val in list(query.items()):\n # Get the field and the operator from the query\n key_field, key_sep, key_oper = key.partition('__')\n\n if key_field == 'pk' and 'id' not in query:\n key_field = 'id'\n\n if key_field in available_fields:\n if q_str != '':\n q_str += ' AND '\n\n if_cstm = ''\n if key_field.endswith('_c'):\n if_cstm = '_cstm'\n\n field = self.model._table + if_cstm + '.' + key_field\n\n if key_oper in ('exact', 'eq') or (not key_oper and not key_sep):\n q_str += '%s = \"%s\"' % (field, val)\n elif key_oper == 'contains':\n q_str += '%s LIKE \"%%%s%%\"' % (field, val)\n elif key_oper == 'startswith':\n q_str += '%s LIKE \"%s%%\"' % (field, val)\n elif key_oper == 'in':\n q_str += '%s IN (' % field\n for elem in val:\n q_str += \"'%s',\" % elem\n q_str = q_str.rstrip(',')\n q_str += ')'\n elif key_oper == 'gt':\n q_str += '%s > \"%s\"' % (field, val)\n elif key_oper == 'gte':\n q_str += '%s >= \"%s\"' % (field, val)\n elif key_oper == 'lt':\n q_str += '%s < \"%s\"' % (field, val)\n elif key_oper == 'lte':\n q_str += '%s <= \"%s\"' % (field, val)\n else:\n raise LookupError('Unsupported operator')\n\n return q_str"],"string":"[\n \"def _expression(self, expression):\\n exp, values = _convert_expression(expression)\\n if isinstance(exp, sqlalchemy.sql.expression.ClauseElement):\\n return exp\\n if exp is None:\\n return sqlalchemy.sql.expression.literal(True)\\n qbh = expr.QueryBuilderHelper(self.table)\\n where_clause = qbh.where_clause(exp, values)\\n subselect = sql.select([self.table.c.id]).select_from(qbh.from_clause())\\n subselect = subselect.where(where_clause)\\n return self.table.c.id.in_(subselect)\",\n \"def test_query_expression_parsing(self):\\r\\n query1 = self.table.filter(self.table.column('test_id') == 5)\\r\\n assert len(query1._where) == 1\\r\\n\\r\\n op = query1._where[0]\\r\\n assert isinstance(op.operator, operators.EqualsOperator)\\r\\n assert op.value == 5\\r\\n\\r\\n query2 = query1.filter(self.table.column('expected_result') >= 1)\\r\\n assert len(query2._where) == 2\\r\\n\\r\\n op = query2._where[1]\\r\\n assert isinstance(op.operator, operators.GreaterThanOrEqualOperator)\\r\\n assert op.value == 1\",\n \"def where(self, value, operator=\\\">\\\"):\\n assert operator in self.operators\\n return f\\\"\\\"\\\"\\nf_cast_isots(json->>'{sqlq(self.name)}') {sqlq(operator)} ${{arg}}::{sqlq(self.cast_type)}\\\"\\\"\\\"\",\n \"def _raw_sql(self, values):\\n if isinstance(self.model._meta.pk, CharField):\\n when_clauses = ' '.join([self._when(\\\"'{}'\\\".format(x), y) for (x, y) in values])\\n else:\\n when_clauses = ' '.join([self._when(x, y) for (x, y) in values])\\n table_name = self.model._meta.db_table\\n primary_key = self.model._meta.pk.column\\n return 'SELECT CASE {}.\\\"{}\\\" {} ELSE 0 END'.format(table_name, primary_key, when_clauses)\",\n \"def where(self, value, operator=\\\"\\\"):\\n return f\\\"\\\"\\\"\\nto_tsvector('english', json->>'{sqlq(self.name)}') @@ plainto_tsquery(${{arg}}::text)\\\"\\\"\\\"\",\n \"def quote(self, expr):\\n return \\\"'\\\" + self.escape(str(expr)) + \\\"'\\\"\",\n \"def test_query_expression_where_clause_generation(self):\\r\\n query1 = self.table.objects(self.table.column('test_id') == 5)\\r\\n self.assertEqual(len(query1._where), 1)\\r\\n where = query1._where[0]\\r\\n self.assertEqual(where.field, 'test_id')\\r\\n self.assertEqual(where.value, 5)\\r\\n\\r\\n query2 = query1.filter(self.table.column('expected_result') >= 1)\\r\\n self.assertEqual(len(query2._where), 2)\\r\\n\\r\\n where = query2._where[0]\\r\\n self.assertEqual(where.field, 'test_id')\\r\\n self.assertIsInstance(where.operator, EqualsOperator)\\r\\n self.assertEqual(where.value, 5)\\r\\n\\r\\n where = query2._where[1]\\r\\n self.assertEqual(where.field, 'expected_result')\\r\\n self.assertIsInstance(where.operator, GreaterThanOrEqualOperator)\\r\\n self.assertEqual(where.value, 1)\",\n \"def test_query_expression_parsing(self):\\r\\n query1 = TestModel.filter(TestModel.test_id == 5)\\r\\n assert len(query1._where) == 1\\r\\n\\r\\n op = query1._where[0]\\r\\n assert isinstance(op, statements.WhereClause)\\r\\n assert isinstance(op.operator, operators.EqualsOperator)\\r\\n assert op.value == 5\\r\\n\\r\\n query2 = query1.filter(TestModel.expected_result >= 1)\\r\\n assert len(query2._where) == 2\\r\\n\\r\\n op = query2._where[1]\\r\\n self.assertIsInstance(op, statements.WhereClause)\\r\\n self.assertIsInstance(op.operator, operators.GreaterThanOrEqualOperator)\\r\\n assert op.value == 1\",\n \"def get_basic_query_cond(column: str, val: str, query_params: dict):\\n if val is not None:\\n query_params[column] = val\\n return 'AHJ.' + column + '=%(' + column + ')s AND '\\n return ''\",\n \"def where(self, value, operator=\\\">\\\"):\\n assert operator in self.operators\\n return f\\\"\\\"\\\"\\nCAST(json->>'{sqlq(self.name)}' AS {sqlq(self.cast_type)}) {sqlq(operator)} ${{arg}}::{sqlq(self.cast_type)}\\\"\\\"\\\" # noqa\",\n \"def expression(self) -> Expression:\\n ...\",\n \"def gen_q_stmt(name, query):\\n return \\\"query {} `{}`;\\\\n\\\".format(name, query)\",\n \"def sql_statement(self, operation, sql):\\n if type(sql) != str:\\n raise Exception(\\n \\\"Invalid argument: sql of type {} should be: <class 'str'>\\\".format(type(sql)))\\n if operation == 0 or operation == 2 or operation == 3:\\n self.__database__.execute(sql)\\n elif operation == 1:\\n return self.__database__.execute(sql)\\n else:\\n raise Exception(\\\"Invalid SQL operation code\\\")\",\n \"def asSQL(self) -> str:\\n # To modify this method, pay attentin to SQL injection.\\n # For example, if `self.x` is assumed to be integer\\n # but is not guaranteed to be,\\n # `:d` must always be specified in format strings:\\n # `expressions.append(f\\\"x > {self.x:d}\\\")`\\n expressions = []\\n if self.date_start is not None:\\n if self.date_start.tzinfo is None:\\n datestr = self.date_start.isoformat()\\n else:\\n datestr = self.date_start.astimezone(datetime.timezone.utc).replace(tzinfo=None).isoformat()\\n expressions.append(f\\\"pfs_visit.issued_at >= '{datestr}'\\\")\\n if self.date_end is not None:\\n if self.date_end.tzinfo is None:\\n datestr = self.date_end.isoformat()\\n else:\\n datestr = self.date_end.astimezone(datetime.timezone.utc).replace(tzinfo=None).isoformat()\\n expressions.append(f\\\"pfs_visit.issued_at < '{datestr}'\\\")\\n if self.visit_start is not None:\\n expressions.append(f\\\"pfs_visit.pfs_visit_id >= '{self.visit_start:d}'\\\")\\n if self.visit_end is not None:\\n expressions.append(f\\\"pfs_visit.pfs_visit_id < '{self.visit_end:d}'\\\")\\n\\n if expressions:\\n return \\\"(\\\" + \\\" AND \\\".join(expressions) + \\\")\\\"\\n else:\\n return \\\"TRUE\\\"\",\n \"def build_query_clauses(\\n where: str = \\\"\\\", order: str = \\\"\\\", limit: int = 0, offset: int = 0\\n ) -> str:\\n return SqliteQueryBuilder.build_query_clauses(where, order, limit, offset)\",\n \"def _sql_where(self, cursor, table, prefix=None, aggregate=False):\\n assert False, \\\"subclass responsibility\\\"\",\n \"def translate_call_to_sql(self, query, expr, state):\\n args = [query.expression_to_sql(arg, state) for arg in expr.args]\\n distinct = expr.distinct and 'DISTINCT ' or ''\\n # this will generate a possibly new name, which is why we call this here\\n # so we can consider that in the function call translation generated below:\\n self.load()\\n return f'{self.get_name()}({distinct}{\\\", \\\".join(args)})'\",\n \"def expression(self, expr):\\n self.set(expression=expr)\",\n \"def make_sql_event_condition_string(self, event_names, sub_condition_sql):\\n\\n if event_names[0] == 'no event filter': \\n return 'TRUE'\\n else:\\n placeholders = ','.join(['%s'] * len(event_names))\\n in_events = \\\"{placeholders}\\\".format(placeholders = event_names).replace(',)', ')')\\n return \\\"event_name IN \\\" + in_events + \\\" \\\" + sub_condition_sql\",\n \"def get_expr_exec_format(self):\\n if self.haveExpr:\\n self.haveExpr = False\\n return '{}'\\n return 'SELECT {} FROM DUMMY'\",\n \"def make_where(cls, key, value, operation=\\\"=\\\"):\\n\\n if operation not in cls.__VALID_WHERE_OPERATION_LIST:\\n raise SqlSyntaxError(\\\"operation not supported: \\\" + str(operation))\\n\\n if value is not None:\\n return \\\"%s %s %s\\\" % (\\n cls.to_attr_str(key), operation, cls.to_value_str(value))\\n\\n if operation == \\\"=\\\":\\n return \\\"%s IS NULL\\\" % (cls.to_attr_str(key))\\n elif operation == \\\"!=\\\":\\n return \\\"%s IS NOT NULL\\\" % (cls.to_attr_str(key))\\n\\n raise SqlSyntaxError(\\n \\\"Invalid operation (%s) with None right-hand side\\\" % (operation))\",\n \"def generate_select_sql(self, condition, fields):\\n return \\\"SELECT %s FROM %s WHERE %s\\\" % (fields, self.tablename, condition)\",\n \"def query(mdx_stmt):\",\n \"def _build_statement(self, query, query_key, beets_key):\\n statement = \\\"\\\"\\n if query_key in query:\\n for query_string in query[query_key]:\\n if '\\\"' in query_string:\\n statement += \\\" and %s = \\\\'%s\\\\' \\\" % (beets_key,\\n query_string)\\n else:\\n statement += ' and %s = \\\\\\\"%s\\\\\\\" ' % (beets_key,\\n query_string)\\n return statement\",\n \"def _sql_where(cur, tables, andalso, orelse, prefix=None, aggregate=False):\\n disjunctions = []\\n andsql = _cond_where_sql(cur, andalso, tables, prefix=prefix,\\n aggregate=aggregate)\\n andsql = ' AND '.join(andsql)\\n\\n if len(andsql) > 0:\\n andsql = '(%s)' % andsql\\n disjunctions.append(andsql)\\n disjunctions += _cond_where_sql(cur, orelse, tables, prefix=prefix,\\n aggregate=aggregate)\\n\\n if len(disjunctions) == 0:\\n return ''\\n return '(%s)' % (' OR '.join(disjunctions))\",\n \"def escape(self, expr):\\n return mysql.connector.conversion.MySQLConverter().escape(expr)\",\n \"def make_sql_condition_string(self, field, condition, value, filter_type):\\n\\n if field == 'no filters': \\n return ''\\n else: \\n if filter_type in ('metric', 'attribute', 'event'):\\n # for < (less than) filters on metrics, we need to use a \\\"having\\\" filter with an aggregation (only MAX for now) on the metric\\n if (filter_type == 'metric'):\\n return 'AND ' + 'MAX(cumul_filter_metric)' + ' ' + condition + ' ' + value + ''\\n else:\\n return 'AND ' + field + ' ' + condition + ' ' + value + ''\\n else:\\n raise NotImplementedError()\",\n \"def sql(self, method: str = 'select') -> str:\",\n \"def _joined_column_sql(editable, generated, joined):\\n return f\\\"IF({editable} IS NOT NULL AND {editable} != '' OR {generated} = 'NA', {editable}, {generated}) AS {joined}\\\"\",\n \"def generate_sql(field_map, input_data, macro_map={}):\\n if input_data == []:\\n return SQL_HEADER\\n\\n entity = Entity(input_data)\\n\\n where_clause = ''\\n if entity.is_simple_clause():\\n where_clause = transpile_simple_clause(field_map, entity, macro_map)\\n elif entity.is_compound_clause():\\n where_clause = transpile_compound_clause(field_map, entity, macro_map)\\n elif entity.is_macro():\\n where_clause = transpile_macro(field_map, entity, macro_map)\\n else:\\n raise TranspilerError(\\\"Input (%s) not recognized.\\\" % (input_data))\\n\\n return SQL_HEADER + ' WHERE '+ where_clause\",\n \"def sql_execute2(sql,value):\\n cur = c.cursor()\\n cur.execute(sql,value)\",\n \"def __convert_to_sql_where(conditions : List[Tuple[Any, RelationalOperator, Any]]) -> str:\\n\\n formatted_identifiers = []\\n\\n for identifier in conditions:\\n col_name, relation, value = identifier\\n\\n if relation == RelationalOperator.Between and len(value) != 2:\\n raise ValueError(\\\"Between relational operator requires the value parameter to be a list of length 2\\\")\\n \\n if relation != RelationalOperator.Between:\\n value = SecurityDatabaseWrapper._validate_value(value)\\n \\n col_name = SecurityDatabaseWrapper._validate_column_name(col_name)\\n\\n formatted_identifiers.append((col_name, relation, value))\\n\\n where_clause_section = ' AND '.join([f'{col_name} {relation.value} {value}' for col_name, relation, value in formatted_identifiers])\\n return f\\\"({where_clause_section})\\\"\",\n \"def _build_expression(self, exp, object_class, fields):\\n if \\\"op\\\" not in exp:\\n return None\\n\\n def autocast(o_key, value):\\n \\\"\\\"\\\"Try to guess the type of `value` and parse it from the string.\\\"\\\"\\\"\\n if not isinstance(o_key, (str, unicode)):\\n return value\\n key, _ = self.attr_name_map[object_class].get(o_key, (o_key, None))\\n # handle dates\\n if (\\\"date\\\" in key and \\\"relative\\\" not in key) or \\\\\\n key in [\\\"end_date\\\", \\\"start_date\\\"]:\\n if isinstance(value, datetime.date):\\n return value\\n try:\\n month, day, year = [int(part) for part in value.split(\\\"/\\\")]\\n return datetime.date(year, month, day)\\n except Exception:\\n raise BadQueryException(\\\"Field \\\\\\\"{}\\\\\\\" expects a MM/DD/YYYY date\\\"\\n .format(o_key))\\n # fallback\\n return value\\n\\n def relevant():\\n \\\"\\\"\\\"Filter by relevant object.\\\"\\\"\\\"\\n query = (self.query[exp[\\\"ids\\\"][0]]\\n if exp[\\\"object_name\\\"] == \\\"__previous__\\\" else exp)\\n return object_class.id.in_(\\n RelationshipHelper.get_ids_related_to(\\n object_class.__name__,\\n query[\\\"object_name\\\"],\\n query[\\\"ids\\\"],\\n )\\n )\\n\\n def unknown():\\n raise BadQueryException(\\\"Unknown operator \\\\\\\"{}\\\\\\\"\\\"\\n .format(exp[\\\"op\\\"][\\\"name\\\"]))\\n\\n def with_key(key, p):\\n key = key.lower()\\n key, filter_by = self.attr_name_map[\\n object_class].get(key, (key, None))\\n if hasattr(filter_by, \\\"__call__\\\"):\\n return filter_by(p)\\n else:\\n attr = getattr(object_class, key, None)\\n if attr is None:\\n raise BadQueryException(\\\"Bad query: object '{}' does \\\"\\n \\\"not have attribute '{}'.\\\"\\n .format(object_class.__name__, key))\\n return p(attr)\\n\\n with_left = lambda p: with_key(exp[\\\"left\\\"], p)\\n\\n lift_bin = lambda f: f(self._build_expression(exp[\\\"left\\\"], object_class,\\n fields),\\n self._build_expression(exp[\\\"right\\\"], object_class,\\n fields))\\n\\n def text_search():\\n \\\"\\\"\\\"Filter by text search.\\n\\n The search is done only in fields listed in external `fields` var.\\n \\\"\\\"\\\"\\n existing_fields = self.attr_name_map[object_class]\\n text = \\\"%{}%\\\".format(exp[\\\"text\\\"])\\n p = lambda f: f.ilike(text)\\n return or_(*(\\n with_key(field, p)\\n for field in fields\\n if field in existing_fields\\n ))\\n\\n rhs = lambda: autocast(exp[\\\"left\\\"], exp[\\\"right\\\"])\\n\\n ops = {\\n \\\"AND\\\": lambda: lift_bin(and_),\\n \\\"OR\\\": lambda: lift_bin(or_),\\n \\\"=\\\": lambda: with_left(lambda l: l == rhs()),\\n \\\"!=\\\": lambda: not_(with_left(\\n lambda l: l == rhs())),\\n \\\"~\\\": lambda: with_left(lambda l:\\n l.ilike(\\\"%{}%\\\".format(rhs()))),\\n \\\"!~\\\": lambda: not_(with_left(\\n lambda l: l.ilike(\\\"%{}%\\\".format(rhs())))),\\n \\\"<\\\": lambda: with_left(lambda l: l < rhs()),\\n \\\">\\\": lambda: with_left(lambda l: l > rhs()),\\n \\\"relevant\\\": relevant,\\n \\\"text_search\\\": text_search\\n }\\n\\n return ops.get(exp[\\\"op\\\"][\\\"name\\\"], unknown)()\",\n \"def _sql_where(self, cur, tables, prefix=None, aggregate=False):\\n if aggregate:\\n return _sql_where(cur, tables, self._agg_andalso, self._agg_orelse,\\n prefix=prefix, aggregate=aggregate)\\n else:\\n return _sql_where(cur, tables, self._andalso, self._orelse,\\n prefix=prefix, aggregate=aggregate)\",\n \"def other_op(q, *params):\\n db = Database()\\n db.cur.execute(q, params)\\n db.con.close()\",\n \"def test_operator_adapt(self):\\n\\n # test string concatenation\\n expr = test_table.c.data + \\\"somedata\\\"\\n assert testing.db.execute(select([expr])).scalar() == \\\"somedatasomedata\\\"\\n\\n expr = test_table.c.id + 15\\n assert testing.db.execute(select([expr])).scalar() == 16\\n\\n # test custom operator conversion\\n expr = test_table.c.avalue + 40\\n assert expr.type.__class__ is test_table.c.avalue.type.__class__\\n\\n # value here is calculated as (250 - 40) / 10 = 21\\n # because \\\"40\\\" is an integer, not an \\\"avalue\\\"\\n assert testing.db.execute(select([expr.label('foo')])).scalar() == 21\\n\\n expr = test_table.c.avalue + literal(40, type_=MyCustomType)\\n \\n # + operator converted to -\\n # value is calculated as: (250 - (40 * 10)) / 10 == -15\\n assert testing.db.execute(select([expr.label('foo')])).scalar() == -15\\n\\n # this one relies upon anonymous labeling to assemble result\\n # processing rules on the column.\\n assert testing.db.execute(select([expr])).scalar() == -15\",\n \"def determine_query():\\n return query if query is not None \\\\\\n else f\\\"SELECT * FROM '{table}';\\\"\",\n \"def build_expression(self, field_name, sub_field_name, null_value):\\n expression = ''\\n if field_name:\\n expression = \\\"${object.\\\" + field_name\\n if sub_field_name:\\n expression += \\\".\\\" + sub_field_name\\n if null_value:\\n expression += \\\" or '''%s'''\\\" % null_value\\n expression += \\\"}\\\"\\n return expression\",\n \"def make_query(self):\",\n \"def define_expression(DomainName=None, Expression=None):\\n pass\",\n \"def _make_query(self):\\r\\n raise NotImplementedError()\",\n \"def mogrify_sql_statement(self, content):\\n sql = content[0]\\n args = content[1]\\n\\n if self.dbmi.__name__ == \\\"psycopg2\\\":\\n if len(args) == 0:\\n return sql\\n else:\\n if self.connected:\\n try:\\n return self.cursor.mogrify(sql, args)\\n except Exception as exc:\\n print(sql, args)\\n raise exc\\n else:\\n self.connect()\\n statement = self.cursor.mogrify(sql, args)\\n self.close()\\n return statement\\n\\n elif self.dbmi.__name__ == \\\"sqlite3\\\":\\n if len(args) == 0:\\n return sql\\n else:\\n # Unfortunately as sqlite does not support\\n # the transformation of sql strings and qmarked or\\n # named arguments we must make our hands dirty\\n # and do it by ourself. :(\\n # Doors are open for SQL injection because of the\\n # limited python sqlite3 implementation!!!\\n pos = 0\\n count = 0\\n maxcount = 100\\n statement = sql\\n\\n while count < maxcount:\\n pos = statement.find(\\\"?\\\", pos + 1)\\n if pos == -1:\\n break\\n\\n if args[count] is None:\\n statement = \\\"%sNULL%s\\\" % (statement[0:pos],\\n statement[pos + 1:])\\n elif isinstance(args[count], (int, long)):\\n statement = \\\"%s%d%s\\\" % (statement[0:pos], args[count],\\n statement[pos + 1:])\\n elif isinstance(args[count], float):\\n statement = \\\"%s%f%s\\\" % (statement[0:pos], args[count],\\n statement[pos + 1:])\\n elif isinstance(args[count], datetime):\\n statement = \\\"%s\\\\'%s\\\\'%s\\\" % (statement[0:pos], str(args[count]),\\n statement[pos + 1:])\\n else:\\n # Default is a string, this works for datetime\\n # objects too\\n statement = \\\"%s\\\\'%s\\\\'%s\\\" % (statement[0:pos],\\n str(args[count]),\\n statement[pos + 1:])\\n count += 1\\n\\n return statement\",\n \"def make_clause(exprs, orderby=None, limit=None, offset=None):\\n exprs = flatten_exprs(exprs)\\n assert exprs, 'Must supply exprs to make_clause! (got: %r)' % (exprs,)\\n assert all(isinstance(expr, ttypes.Comparison) for expr in exprs)\\n\\n kwargs = {'exprs': exprs}\\n if orderby is not None:\\n if isinstance(orderby, (list, tuple)):\\n kwargs['orderby'] = [mapserv.query.util.make_orderby(o) for o in orderby]\\n else:\\n kwargs['orderby'] = [mapserv.query.util.make_orderby(orderby)]\\n if limit is not None:\\n kwargs['limit'] = limit\\n if offset:\\n kwargs['offset'] = offset\\n\\n return ttypes.QueryClause(**kwargs)\",\n \"def expression(self):\\n assert not self._handle_used\\n self._expression_used = True\\n return self._expression\",\n \"def sqlwhere(dictionary, grouping=' AND '):\\n return SQLQuery.join([k + ' = ' + sqlparam(v) for k, v in dictionary.items()], grouping)\",\n \"def sql_query(self):\\n return self._project.sql_query\",\n \"def sql_query(self, query_text, edges = False):\\n q = QueryWrapper(self.graph, QueryString(query_text, 'sql'),\\n edges = edges, debug = self._debug)\\n return q\",\n \"def of(cls, clause=\\\"\\\", params=[]):\\r\\n return Q.C(clause, params)\",\n \"def conditions_as_sql(self, prewhere=False):\\n q_object = self._prewhere_q if prewhere else self._where_q\\n return q_object.to_sql(self._model_cls)\",\n \"def test_operator_check(self):\\r\\n with self.assertRaises(StatementException):\\r\\n WhereClause('a', 'b', 'c')\",\n \"def get_where_clause(self, params: Dict) -> str:\\n return ''\",\n \"def query(self, sql, rowfactory=None, *args, **kwgs):\\n return query(self.conn, sql, rowfactory, *args, **kwgs)\",\n \"def expr():\\n def p(tok):\\n # commas can appear in quantified variables\\n return not(tok.value in [';','.'])\\n return reparse('expr').process(c.balanced_condition(p))\",\n \"def test_where_clause_rendering(self):\\r\\n wc = WhereClause('a', EqualsOperator(), 'c')\\r\\n wc.set_context_id(5)\\r\\n self.assertEqual('\\\"a\\\" = :5', unicode(wc))\\r\\n self.assertEqual('\\\"a\\\" = :5', str(wc))\",\n \"def _getSQLWhere(self, inputTable, queryMeta):\\n\\t\\tsqlPars = {}\\n\\t\\tinputPars = dict((p.name, p.value) for p in inputTable.iterParams())\\n\\t\\treturn base.joinOperatorExpr(\\\"AND\\\",\\n\\t\\t\\t[cd.asSQL(inputPars, sqlPars, queryMeta)\\n\\t\\t\\t\\tfor cd in self.condDescs]), sqlPars\",\n \"def generateSQLFilter(sql_filter, es_type, category):\\n query_string = \\\"Category = ? AND (\\\"\\n insertion_list = [category]\\n\\n i = 0\\n while i < len(sql_filter):\\n insertion_list.append(sql_filter[i]) # append values to be inserted into SQL statement (? substitution)\\n if (i + 1) != 1: # NOT first loop\\n query_string += \\\" OR \\\"\\n query_string += es_type + \\\" = ?\\\"\\n i += 1\\n\\n query_string += \\\")\\\"\\n #\\n #\\n\\n return query_string, insertion_list\",\n \"def sqlors(left, lst):\\n if isinstance(lst, iters):\\n lst = list(lst)\\n ln = len(lst)\\n if ln == 0:\\n return SQLQuery(\\\"1=2\\\")\\n if ln == 1:\\n lst = lst[0]\\n\\n if isinstance(lst, iters):\\n return SQLQuery(['('] + \\n sum([[left, sqlparam(x), ' OR '] for x in lst], []) +\\n ['1=2)']\\n )\\n else:\\n return left + sqlparam(lst)\",\n \"def sql_query(sql):\\n cur = c.cursor()\\n cur.execute(sql)\\n c.commit()\",\n \"def _build_test_query01(self):\\n\\n\\t\\tquery = 'select \\\"GLOBALEVENTID\\\", \\\"SQLDATE\\\", \\\"MonthYear\\\", \\\"Year\\\" ' + \\\\\\n\\t\\t\\t\\t\\t 'from \\\"DEMOUSER00\\\".\\\"uni.vlba.gdelt.data::gdelt_dailyupdates\\\"'\\t\\t\\n\\n\\t\\treturn query\",\n \"def generate_query(self):\\n return\",\n \"def construct_SELECT_AS(self, exp):\\n display_names = self.get_display_names(exp)\\n db_colnames = self.get_colnames(exp.measurementmodel)\\n \\n AS_stmt = ', '.join('%s AS %s' % (db_col, display_col) \\n for db_col, display_col in zip(db_colnames, display_names))\\n return AS_stmt\",\n \"def sqlquote(a):\\n if isinstance(a, list):\\n return _sqllist(a)\\n else:\\n return sqlparam(a).sqlquery()\",\n \"def test_simple_where(self):\\n query = (Query()\\n .match('', 'a')\\n .where('exists(a.name)')\\n .where('a.age = 2')\\n )\\n expected = '\\\\n'.join((\\n 'MATCH (a)',\\n 'WHERE exists(a.name)',\\n ' AND a.age = 2',\\n 'RETURN a',\\n ))\\n self.assertEqual(str(query), expected)\",\n \"def expr(s):\\n if isinstance(s, Expr): return s\\n if isnumber(s): return Expr(s)\\n ## Replace the alternative spellings of operators with canonical spellings\\n s = s.replace('==>', '>>').replace('<==', '<<')\\n s = s.replace('<=>', '%').replace('=/=', '^')\\n ## Replace a symbol or number, such as 'P' with 'Expr(\\\"P\\\")'\\n s = re.sub(r'([a-zA-Z0-9_.]+)', r'Expr(\\\"\\\\1\\\")', s)\\n ## Now eval the string. (A security hole; do not use with an adversary.)\\n return eval(s, {'Expr':Expr})\",\n \"def gws_q(self, query, attribute, data):\\n \\n gws_q = query.format(attribute, data) #attribute = SQL table\\n \\n query_df = db.query(gws_q) \\n return query_df\",\n \"def gen_sql(runtime, query_type, target_model=None):\\n\\n from_table = runtime.model.table_name\\n\\n # if target_model not given, use from_table instead\\n if target_model is None:\\n target_model = runtime.model\\n\\n target_table = target_model.table_name\\n\\n data = runtime.data # alias\\n\\n # quick mark for parse time functions\\n _where = Compiler.parse_where(data['where'])\\n _set = Compiler.parse_set(data['set'])\\n _orderby = Compiler.parse_orderby(data['orderby'])\\n _select = Compiler.parse_select(data['select'])\\n _limit = Compiler.parse_limit(data['limit'])\\n _groupby = Compiler.parse_groupby(data['groupby'])\\n _having = Compiler.parse_having(data['having'])\\n _distinct = Compiler.parse_distinct(data['distinct'])\\n\\n pattern = Compiler.SQL_PATTERNS[query_type]\\n\\n SQL = pattern.format(**{\\n 'target': target_table,\\n 'set': _set,\\n 'from': from_table,\\n 'where': _where,\\n 'select': _select,\\n 'limit': _limit,\\n 'orderby': _orderby,\\n 'groupby': _groupby,\\n 'having': _having,\\n 'distinct': _distinct,\\n })\\n\\n return SQL\",\n \"def __call__(self, expression):\\n self.set_expression(expression)\",\n \"def _Expr(self, tree):\\n # Catch odd case of multi line strings and doc strings which are Expr with a Constant string type value\\n if isinstance(tree.value, ast.Constant):\\n if isinstance(tree.value.value, str):\\n return\\n # catch special case of Python 3.7 Where doc string is a Str and not a Constant\\n elif isinstance(tree.value, ast.Str):\\n return \\n # otherwise treat like a normal expression\\n self.fill()\\n self.dispatch(tree.value)\\n self.write(\\\";\\\")\",\n \"def sql_command(self):\\n return lambda a: 1\",\n \"def as_sql(self, qn, connection):\\n lhs, lhs_params = self.process_lhs(qn, connection)\\n rhs, rhs_params = self.process_rhs(qn, connection)\\n\\n field = lhs\\n # JSONField formats query values for the database by wrapping them psycopg2's\\n # JsonAdapter, but we need the raw Python dict so that we can parse the\\n # query tree. Intercept the query parameter (it'll always be the first\\n # element in the parameter list, since the custom jsonb filter only accepts one argument)\\n # and revert it back to a Python dict for tree parsing.\\n tree = rhs_params[0].adapted\\n\\n return FilterTree(tree, field).sql()\",\n \"def where(condition):\\r\\n return ('', []) if condition.clause == '' else (f'WHERE {condition.clause}', list(condition.params))\",\n \"def stock_3_query(self):\\n return f\\\"\\\"\\\"\\n SELECT '{self.stock_3}'\\n FROM closing_prices;\\\"\\\"\\\"\",\n \"def get_list_query_cond(column: str, val: list, query_params: dict):\\n if val is not None and len(val) != 0:\\n or_list = []\\n for i in range(len(val)):\\n param_name = f'{column}{i}'\\n query_params[param_name] = val[i]\\n or_list.append('AHJ.' + column + '=%(' + param_name + ')s')\\n ret_str = '(' + ' OR '.join(or_list) + ') AND '\\n return ret_str\\n return ''\",\n \"def run_sql(self, sql):\\n def mk_run_sql_q(sql):\\n return {\\n 'type' : 'run_sql',\\n 'args': {\\n 'sql' : sql\\n }\\n }\\n return self.v1q(mk_run_sql_q(sql))\",\n \"def test_raw_sql(self):\\n\\n # GIVEN raw SQL command\\n sql = 'SELECT id, date_joined from auth_user WHERE id > %s;'\\n params = ['0']\\n\\n # WHEN executing the SQL\\n cursor = TestModel.execute_sql(sql, params)\\n\\n # THEN it should succeed\\n results = cursor.fetchall()\\n self.assertEqual(len(results), 1)\\n self.assertEqual(len(results[0]), 2)\",\n \"def build_where_statement(attr_converter):\\n statements = []\\n values = []\\n # iterate over the querystring params\\n for attr, val in request.args.iteritems():\\n try:\\n statements.append(attr_converter[attr]['converter'](\\n attr_converter[attr]['column']))\\n values.append(val) # add after the possible keyerror\\n except KeyError:\\n # TODO: handle invalid params somehow or continue to ignore\\n pass\\n if statements:\\n return 'WHERE '+' AND '.join(statements), values\\n return '', []\",\n \"def expression( ):#DOUBLE CHECK THIS\\n\\t\\n\\ttok = tokens.peek( )\\n\\tif debug: print(\\\"Expression: \\\", tok)\\n\\tleft = andExpr( ) #does the left side of the grammar \\n\\ttok = tokens.peek( )\\n\\twhile tok == \\\"or\\\": #checks to see if there is the token or and will preform what is inside the curly bracket since it is a series \\n\\t\\ttokens.next()\\n\\t\\tright = andExpr( )\\n\\t\\tleft = BinaryExpr(tok, left, right) # MIGHT HAVE TO CHANGE THIS TO STRING CAUSE ITS \\\"or\\\"\\n\\t\\ttok = tokens.peek( )\\n\\treturn left\",\n \"def test_empty_condition(self):\\n\\n self.assertRaises(SyntaxError, self.table.where, '')\",\n \"def test_sqpp_quoted_expr1_and_paren_expr2_and_expr3(self):\\n self.assertEqual(self.parser.parse_query('\\\"expr1\\\" (expr2) expr3'),\\n ['+', '\\\"expr1\\\"', '+', 'expr2', '+', 'expr3'])\",\n \"def get_name_query_cond(column: str, val: str, query_params: dict):\\n if val is not None and column is not None:\\n query_params[column] = '%' + val + '%'\\n return 'AHJ.' + column + ' LIKE %(' + column + ')s AND '\\n return ''\",\n \"def stock_1_query(self):\\n return f\\\"\\\"\\\"\\n SELECT Date, '{self.stock_1}'\\n FROM closing_prices;\\\"\\\"\\\"\",\n \"def _orderby_expression(self):\\n return ''\",\n \"def test_expr(self):\\n self.common_test_expr(True)\",\n \"def execute_query(self, *args, **kwargs):\",\n \"def get_sql_str_select(self,table_name, field_names = ['*'],where_ind_name = None, where_ind_value = None, where_clause = None):\\n\\t\\tif (where_ind_name!=None) & (where_ind_value!=None):\\n\\t\\t\\tsql_str = 'SELECT %s FROM %s.%s WHERE %s = %s'%(','.join([str(x) for x in field_names]),\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tself.__schema_name,\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttable_name,\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t where_ind_name,\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t where_ind_value)\\n\\t\\telse:\\n\\t\\t\\tsql_str = 'SELECT %s FROM %s.%s %s'%(','.join([str(x) for x in field_names]),\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tself.__schema_name,\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttable_name, where_clause)\\n\\t\\t# print(sql_str)\\n\\t\\treturn sql_str\",\n \"def _valid_filter_query(self):\\n if self._output_invalid_imeis:\\n valid_filter_sql = sql.SQL('TRUE')\\n else:\\n valid_filter_sql = sql.SQL('is_valid IS TRUE')\\n return valid_filter_sql\",\n \"def test_where_clause_type_checking(self):\\r\\n stmt = BaseCQLStatement('table', [])\\r\\n with self.assertRaises(StatementException):\\r\\n stmt.add_where_clause('x=5')\",\n \"def sql_query(self, new_query):\\n self._project.sql_query = new_query\",\n \"def dynamiQ(fields, types, values, operator='or'):\\r\\n from django.db.models import Q\\r\\n\\r\\n queries = []\\r\\n q = None\\r\\n for (f, t, v) in zip(fields, types, values):\\r\\n # We only want to build a Q with a value\\r\\n if v != \\\"\\\":\\r\\n kwargs = {str('%s__%s' % (f,t)) : str('%s' % v)}\\r\\n queries.append(Q(**kwargs))\\r\\n\\r\\n # Make sure we have a list of filters\\r\\n if len(queries) > 0:\\r\\n q = Q()\\r\\n # AND/OR awareness\\r\\n for query in queries:\\r\\n if operator == \\\"and\\\":\\r\\n q = q & query\\r\\n elif operator == \\\"or\\\":\\r\\n q = q | query\\r\\n else:\\r\\n q = None\\r\\n\\r\\n return q\",\n \"def generate_update_sql(self, fieldupdate, condition):\\n return \\\"UPDATE %s SET %s WHERE %s\\\" % (self.tablename, fieldupdate, condition)\",\n \"def __generateQuery(self, query):\\n if query == None:\\n return [\\\"1=1\\\"]\\n elif type(query) is not list:\\n return [query]\\n else:\\n return query\",\n \"def where(self, column, *args):\\n\\n operator, value = self._extract_operator_value(*args)\\n\\n if value is None:\\n value = \\\"\\\"\\n elif value is True:\\n value = \\\"1\\\"\\n elif value is False:\\n value = \\\"0\\\"\\n\\n if inspect.isfunction(column):\\n builder = column(self.new())\\n self._wheres += (\\n (QueryExpression(None, operator, SubGroupExpression(builder))),\\n )\\n elif isinstance(value, QueryBuilder):\\n self._wheres += (\\n (QueryExpression(column, operator, SubSelectExpression(value))),\\n )\\n else:\\n self._wheres += ((QueryExpression(column, operator, value, \\\"value\\\")),)\\n return self\",\n \"def query(gp, *args):\\n\\n def decorator(f):\\n add_query_pattern(gp, f, args)\\n\\n return decorator\",\n \"def check_where_exist(query: str, column: object, condition: str, like: bool = False) -> str:\\n\\n if column is not None:\\n if like:\\n column = convert_to_like(column)\\n condition = condition.format(column)\\n if \\\"WHERE\\\" in query:\\n new_query = f\\\" AND ({condition}) \\\"\\n else:\\n new_query = f\\\" WHERE ({condition}) \\\"\\n return new_query\\n return \\\"\\\"\",\n \"def format_sql_in_context(sql_template, param_dict, conn):\\n if conn is not None:\\n # Postgres, secure\\n query = format_sql_postgres(sql_template, param_dict)\\n return query.as_string(conn)\\n\\n # sqlite, may not be perfectly secure, far better than nothing\\n return format_query_check_chars(sql_template, param_dict)\",\n \"def set_expr(self, expr: Expr):\\r\\n self.expr = Expr.cnf(expr)\",\n \"def prepare_expr(expr, parameter):\\n # First take out of tuple.\\n if type(expr) == tuple:\\n expr = expr[0]\\n # Strip of whitespace\\n expr = expr.strip(\\\" \\\")\\n # Do necessary replacements to Python can interpret expression.\\n expr = expr.replace('^', '**')\\n expr = expr.replace('{'+'0}', 'x')\\n expr = expr.replace('{'+'1}', 'x') ## does this need be another variable???\\n expr = expr.replace('x', str(np.float64(parameter)))\\n expr = expr.replace('X', str(np.float64(parameter)))\\n expr = expr.replace('32768', str(np.float64(32768.0)))\\n\\n return expr\",\n \"def query(self, query):\",\n \"def test_add_dummy_where_with_where_not_present_and_added(self):\\n updated_sql = add_dummy_where(self.SQL_WITHOUT_WHERE)\\n self.assertEqual(updated_sql, self.SQL_WITH_WHERE)\",\n \"def _as_mapnik_sql(self,**kwargs):\\n # running multidb available in django 1.2\\n if hasattr(self.qs.query,'get_compiler'):\\n compiler = self.qs.query.get_compiler(self.qs.db)\\n sql, args = compiler.as_sql()\\n gqn = compiler.connection.ops.geo_quote_name\\n else:\\n sql, args = self.qs.query.as_sql()\\n from django.contrib.gis.db.backends.util import gqn\\n #if qs.query.has_where\\n if args:\\n sql = sql % tuple([str(i) if hasattr(i,'ewkb') else gqn(i) for i in args])\\n return \\\"\\\"\\\"(%s) as django_table\\\"\\\"\\\" % sql\",\n \"def _build_query(self, **query):\\n\\n available_fields = list(self.model._available_fields.keys())\\n\\n q_str = ''\\n for key, val in list(query.items()):\\n # Get the field and the operator from the query\\n key_field, key_sep, key_oper = key.partition('__')\\n\\n if key_field == 'pk' and 'id' not in query:\\n key_field = 'id'\\n\\n if key_field in available_fields:\\n if q_str != '':\\n q_str += ' AND '\\n\\n if_cstm = ''\\n if key_field.endswith('_c'):\\n if_cstm = '_cstm'\\n\\n field = self.model._table + if_cstm + '.' + key_field\\n\\n if key_oper in ('exact', 'eq') or (not key_oper and not key_sep):\\n q_str += '%s = \\\"%s\\\"' % (field, val)\\n elif key_oper == 'contains':\\n q_str += '%s LIKE \\\"%%%s%%\\\"' % (field, val)\\n elif key_oper == 'startswith':\\n q_str += '%s LIKE \\\"%s%%\\\"' % (field, val)\\n elif key_oper == 'in':\\n q_str += '%s IN (' % field\\n for elem in val:\\n q_str += \\\"'%s',\\\" % elem\\n q_str = q_str.rstrip(',')\\n q_str += ')'\\n elif key_oper == 'gt':\\n q_str += '%s > \\\"%s\\\"' % (field, val)\\n elif key_oper == 'gte':\\n q_str += '%s >= \\\"%s\\\"' % (field, val)\\n elif key_oper == 'lt':\\n q_str += '%s < \\\"%s\\\"' % (field, val)\\n elif key_oper == 'lte':\\n q_str += '%s <= \\\"%s\\\"' % (field, val)\\n else:\\n raise LookupError('Unsupported operator')\\n\\n return q_str\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6696251","0.636851","0.634157","0.6295323","0.62208486","0.6195918","0.603287","0.6005952","0.59504604","0.59500873","0.5903553","0.58978915","0.5895683","0.58679605","0.5867883","0.5845525","0.5841332","0.5833717","0.57903737","0.5781723","0.57561094","0.57535756","0.5747609","0.5737029","0.57168466","0.5700761","0.56932473","0.5690577","0.5688889","0.5659401","0.565033","0.5639701","0.5628899","0.56228393","0.55997074","0.55944115","0.5558711","0.5547295","0.5542749","0.5531927","0.5492112","0.54846364","0.54804367","0.5465557","0.5457626","0.5439014","0.54315996","0.542937","0.54238224","0.5408633","0.54052055","0.5404184","0.53993684","0.53885406","0.5381344","0.5376605","0.5360737","0.5352505","0.53481597","0.5347329","0.53433543","0.5342468","0.5314625","0.5314566","0.5313919","0.5296779","0.529299","0.5284107","0.5283302","0.5278352","0.52770364","0.52742034","0.52634275","0.52568996","0.52514297","0.5246551","0.5246111","0.5241969","0.5238911","0.523749","0.52122474","0.52107185","0.5205395","0.5200798","0.5196088","0.51946825","0.5193939","0.51881903","0.5177801","0.517436","0.5168838","0.5166608","0.5165132","0.51631546","0.51596445","0.5159002","0.51581615","0.5157719","0.51561546","0.5155196","0.51503307"],"string":"[\n \"0.6696251\",\n \"0.636851\",\n \"0.634157\",\n \"0.6295323\",\n \"0.62208486\",\n \"0.6195918\",\n \"0.603287\",\n \"0.6005952\",\n \"0.59504604\",\n \"0.59500873\",\n \"0.5903553\",\n \"0.58978915\",\n \"0.5895683\",\n \"0.58679605\",\n \"0.5867883\",\n \"0.5845525\",\n \"0.5841332\",\n \"0.5833717\",\n \"0.57903737\",\n \"0.5781723\",\n \"0.57561094\",\n \"0.57535756\",\n \"0.5747609\",\n \"0.5737029\",\n \"0.57168466\",\n \"0.5700761\",\n \"0.56932473\",\n \"0.5690577\",\n \"0.5688889\",\n \"0.5659401\",\n \"0.565033\",\n \"0.5639701\",\n \"0.5628899\",\n \"0.56228393\",\n \"0.55997074\",\n \"0.55944115\",\n \"0.5558711\",\n \"0.5547295\",\n \"0.5542749\",\n \"0.5531927\",\n \"0.5492112\",\n \"0.54846364\",\n \"0.54804367\",\n \"0.5465557\",\n \"0.5457626\",\n \"0.5439014\",\n \"0.54315996\",\n \"0.542937\",\n \"0.54238224\",\n \"0.5408633\",\n \"0.54052055\",\n \"0.5404184\",\n \"0.53993684\",\n \"0.53885406\",\n \"0.5381344\",\n \"0.5376605\",\n \"0.5360737\",\n \"0.5352505\",\n \"0.53481597\",\n \"0.5347329\",\n \"0.53433543\",\n \"0.5342468\",\n \"0.5314625\",\n \"0.5314566\",\n \"0.5313919\",\n \"0.5296779\",\n \"0.529299\",\n \"0.5284107\",\n \"0.5283302\",\n \"0.5278352\",\n \"0.52770364\",\n \"0.52742034\",\n \"0.52634275\",\n \"0.52568996\",\n \"0.52514297\",\n \"0.5246551\",\n \"0.5246111\",\n \"0.5241969\",\n \"0.5238911\",\n \"0.523749\",\n \"0.52122474\",\n \"0.52107185\",\n \"0.5205395\",\n \"0.5200798\",\n \"0.5196088\",\n \"0.51946825\",\n \"0.5193939\",\n \"0.51881903\",\n \"0.5177801\",\n \"0.517436\",\n \"0.5168838\",\n \"0.5166608\",\n \"0.5165132\",\n \"0.51631546\",\n \"0.51596445\",\n \"0.5159002\",\n \"0.51581615\",\n \"0.5157719\",\n \"0.51561546\",\n \"0.5155196\",\n \"0.51503307\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84580,"cells":{"query":{"kind":"string","value":"Emulate legacy field superseeded by `patient_consent_date`. Forward to current datetime to `patient_consent_date` setter, which will set both underlying columns."},"document":{"kind":"string","value":"def patient_consent(self, value):\n self.patient_consent_date = utcnow() if value else None"},"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 patient_consent_date(self, value):\n self._patient_consent_date = value\n self._patient_consent = 1 if value else 0","def patient_consent_date(self):\n return self._patient_consent_date","def set_to_date(self):\n self.set_value_into_input_field(self.set_to_date_locator, self.get_current_date())","def _date(self, _date):\n\n self.__date = _date","def _date(self, _date):\n\n self.__date = _date","def date(self, new_date):\n self._date.date = new_date","def set_datetime(self, date):\n self.date = date","def set_from_date(self, date):\n self.set_value_into_input_field(self.set_from_date_locator, date)","def set_adjustment_charge_begin_date(self, begin_date):\n self.set_value_into_input_field(self.adjustment_begin_date_locator, begin_date)","def set_date(self, date):\n self.date = self.date_to_local(date)\n # ephem deals only in UTC\n self.site.date = ephem.Date(self.date_to_utc(self.date))","def _read_patient_consent_date(self, d: dict):\n consent_date = d.get('patient_consent_date')\n consent_bool = d.get('patient_consent')\n if consent_date is not None:\n return self._str_to_datetime(consent_date)\n elif consent_bool:\n t0 = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\n creation_date = d.get('creation_date')\n return (self._str_to_datetime(creation_date)\n if creation_date is not None\n else t0)\n else:\n return None","def set_from_date_as_current_date(self):\n self.set_value_into_input_field(self.set_from_date_locator, self.get_current_date())","def setDate(self, p_int, p_int_1, p_int_2): # real signature unknown; restored from __doc__\r\n return False","def set_date(self, date):\n self.date = date","def set_date(self, date):\n self.date = date\n return","def date_wrangler(self, date_col):\n data = self.copy() # Create a copy of the DataFrame\n\n # Convert target column to datetime\n data[date_col] = pd.to_datetime(\n data[date_col], infer_datetime_format=True\n )\n\n # Split column into datetime components\n data[f\"{date_col}_year\"] = data[date_col].dt.year\n data[f\"{date_col}_year\"] = data[date_col].dt.month\n data[f\"{date_col}_year\"] = data[date_col].dt.day\n\n # Drop original column\n data = data.drop(columns=date_col)\n\n return data","def _setVals(self, datetime=0):\n self.datetime = datetime","def date(self, date):\n self._date = date","def date(self, value):\n self.date_value = value","def mod_date(self, mod_date):\n\n self._mod_date = mod_date","def set_birthdate(self, date):\n\n if validate_date_format(self.birt):\n self.birt = date\n else:\n raise ValueError('Invalid date!')","def set_statement_issued_date(self, issued_date):\n if issued_date != \"\":\n issued_date_to_set = issued_date\n else:\n self.first_day_of_current_month = self.get_date(first_day_of_current_month=True)\n issued_date_to_set = self.first_day_of_current_month\n self.set_value_into_input_field(self.issued_date_locator, issued_date_to_set)","def set_date(self, date):\n self.data['date'] = date","def set_adjustment_charge_end_date(self, end_date):\n self.set_value_into_input_field(self.end_date_locator, end_date)","def date(self, date):\n\n self._date = date","def date(self, date):\n\n self._date = date","def date(self, date):\n\n self._date = date","def date(self, date):\n\n self._date = date","def date(self, date):\n\n self._date = date","def set_document_date(self, date):\n self.set_value_into_input_field(self.document_date_text_field_locator, date)","def set_end_date(self, date):\n pass","def set_harvest_date(self, date):\n if not date:\n return datetime.utcnow().strftime(\"%Y/%m/%d\")\n return datetime.strptime(date, \"%Y%m%d\").strftime(\"%Y/%m/%d\")","def date(self, date):\n self.value = date.strftime(\"%Y-%m-%d\") if date else \"\"","def set_idate(self, idate):\n self.__idate = idate","def date(self, date):\n if self.local_vars_configuration.client_side_validation and date is None: # noqa: E501\n raise ValueError(\"Invalid value for `date`, must not be `None`\") # noqa: E501\n\n self._date = date","def _datetime(self, _datetime):\n\n self.__datetime = _datetime","def setBaseDate(self, date=None):\n if date is None:\n date = self.oggi\n self.baseDate = QDate(date.year(), date.month(), 1)","def booger_picker(self, date_column_name):\n self.dataframe[date_column_name] = pd.to_datetime(\n self.dataframe[date_column_name],\n infer_datetime_format=True)\n self.dataframe['Year'] = self.dataframe[date_column_name].dt.year\n self.dataframe['Month'] = self.dataframe[date_column_name].dt.month\n self.dataframe['Day'] = self.dataframe[date_column_name].dt.day\n self.dataframe.drop(date_column_name, axis=1, inplace=True)\n return self.dataframe","def patient_consent(self):\n return 1 if self.patient_consent_date is not None else 0","def set_contest_date_time(contest, date_time, field):\n c = biv.load_obj(contest)\n assert type(c) == pem.E15Contest\n dt = _local_date_time_as_utc(c, date_time)\n assert hasattr(c, field), \\\n '{}: has no attr {}'.format(c, field)\n setattr(c, field, dt)\n _add_model(c)","def _fill_date(self):\n if not self.date['year']:\n self.date['year'] = self.DEFAULT_DATE['year']\n if not self.date['month']:\n self.date['month'] = self.DEFAULT_DATE['month']\n if not self.date['day']:\n self.date['day'] = self.DEFAULT_DATE['day']","def observation_date(self, observation_date):\n\n self._observation_date = observation_date","def update(self, date):\r\n self.date = date","def collect_interview_date(self, collect_interview_date):\n\n self._collect_interview_date = collect_interview_date","def set_birthday(self, year, month, day):\n self.birthday = datetime.date(year, month, day)","def set_charge_begin_date(self, charge_begin_date, first_day_of_last_month):\n self.current_charge_begin_date = charge_begin_date\n if first_day_of_last_month is True:\n if charge_begin_date == \"\":\n self.first_day_of_previous_month = self.get_date(first_day_of_last_month=True)\n charge_begin_date = self.first_day_of_previous_month\n else:\n if charge_begin_date == \"\":\n charge_begin_date = self.get_date(current_date=True)\n self.current_charge_begin_date = datetime.datetime.strptime(charge_begin_date, \"%m/%d/%Y\")\n self.set_value_in_grid_column(self.charges_grid_div_id, self.charge_begin_date_column_name, charge_begin_date, True)\n page_header_element = self.wait().until(EC.element_to_be_clickable(self.page_header_locator), 'page header locator not found before specified time out')\n page_header_element.click()","def setBirthday(self, birthdate):\r\n self.birthday = birthdate","def _date(self, _date: datetime):\n if _date is None:\n raise ValueError(\"Invalid value for `_date`, must not be `None`\") # noqa: E501\n\n self.__date = _date","def set_statement_begin_date(self, begin_date):\n begin_date_to_set = None\n if begin_date != \"\":\n begin_date_to_set = begin_date\n else:\n self.first_day_of_previous_month = self.get_date(first_day_of_last_month=True)\n begin_date_to_set = self.first_day_of_previous_month\n self.set_value_into_input_field(self.statement_begin_date_locator, begin_date_to_set)\n return begin_date_to_set","def set_add_dispute_date(self, date):\n self.set_value_into_input_field(self.add_dispute_date_inputbox_locator, date)","def set_start_date(self, date):\n pass","def _set_date(line, dirtydate, date):\n line = re.sub(dirtydate, date, line, 2)\n return line","def _update_metadata_date(self, properties):\n if \"core\" not in properties:\n properties.core = Struct()\n properties.core.metadata_date = self._backend.server_time_utc()","def model_start_date(self, model_start_date):\n\n self._model_start_date = model_start_date","def __init__(self, translator_cls=DatetimeTranslator, default=None, column_name=\"\"):\n super(Datetime, self).__init__(\n translator_cls=translator_cls,\n default=default,\n column_name=column_name)","def test_change_of_date_field_type(self):\n # Create a user, device and a heartbeat\n user = Dummy.create_user()\n device = Dummy.create_device(user)\n heartbeat_timestamp = datetime(2015, 12, 15, 1, 23, 45, tzinfo=pytz.utc)\n\n heartbeat = Dummy.create_report(\n HeartBeat, device, date=heartbeat_timestamp\n )\n\n # Assert that the date is of type datetime\n self.assertIsInstance(heartbeat.date, datetime)\n\n # Run the migration\n self.migrate_to_dest()\n\n # Assert that the date is now of type date and has the correct value\n heartbeat = HeartBeat.objects.first()\n self.assertIsInstance(heartbeat.date, date)\n self.assertEqual(heartbeat.date, heartbeat_timestamp.date())","def set_begin_date(self, begin_date):\n self.set_value_into_input_field(self.begin_date_inputbox_locator, begin_date)","def dep_date(self, dep_date):\n\n self._dep_date = dep_date","def to_date(self, value: date):\n self._to_date = value\n self._dao.to_date = value","def ts_setter(func):\n\n @wraps(func)\n def inner(self, value):\n \"\"\" Parse input value as ISO8601 date \"\"\"\n if value is None:\n return func(self, None)\n elif isinstance(value, datetime.datetime):\n return func(self, value)\n else:\n value = TS_SETTER_TRANSFORM_RE.sub(TS_SETTER_TRANSFORM_REPL, value)\n return func(self, iso8601.parse_date(value))\n\n return inner","def date_answered(self, date_answered):\n self._date_answered = date_answered","def fl_set_form_atactivate(ptr_flform, pyfn_FormAtactivate, userdata):\n #FL_FORM_ATACTIVATE = cty.CFUNCTYPE(None, cty.POINTER(xfdata.FL_FORM), \\\n # cty.c_void_p)\n _fl_set_form_atactivate = library.cfuncproto(\n library.load_so_libforms(), \"fl_set_form_atactivate\", \\\n xfdata.FL_FORM_ATACTIVATE, [cty.POINTER(xfdata.FL_FORM),\n xfdata.FL_FORM_ATACTIVATE, cty.c_void_p], \\\n \"\"\"FL_FORM_ATACTIVATE fl_set_form_atactivate(FL_FORM * form,\n FL_FORM_ATACTIVATE cb, void * data) \"\"\")\n library.check_if_flinitialized()\n library.verify_flformptr_type(ptr_flform)\n library.verify_function_type(pyfn_FormAtactivate)\n cfn_FormAtactivate = xfdata.FL_FORM_ATACTIVATE(pyfn_FormAtactivate)\n ptr_vdata = library.convert_userdata_to_ptrvoid(userdata)\n library.keep_cfunc_refs(cfn_FormAtactivate, pyfn_FormAtactivate)\n library.keep_elem_refs(ptr_flform, userdata, ptr_vdata)\n retval = _fl_set_form_atactivate(ptr_flform, cfn_FormAtactivate, \\\n ptr_vdata)\n return retval","def _convert_datetime(self) -> pd.Series:\n\n series = pd.to_datetime(self.sanitized)\n series.name = self.parent.name\n\n return series","def save(self, *args, **kwargs):\n self.expire_date = self.sent_date + timedelta(days=self.period)\n super(Referral, self).save(*args, **kwargs)","def setBirthday(self, birthdate):\n self.birthday = birthdate","def set_rdate(self, rdate):\n self.__rdate = rdate","def from_date(self, value: date):\n self._from_date = value\n self._dao.from_date = value","def as_of_date(self, as_of_date):\n\n self._as_of_date = as_of_date","def _date(self) -> datetime:\n return self.__date","def _apply_decision(self, decision, responder):\n self.responder = responder\n self.status = decision\n self.decision_datetime = timezone.now()\n self.save()","def set_date(self, date_string, date_type):\n if date_type == \"married\":\n self._married_date = datetime.strptime(date_string, '%d %b %Y')\n if date_type == \"divorced\":\n self._divorced_date = datetime.strptime(date_string, '%d %b %Y')","def update_date(self, update_date):\n\n self._update_date = update_date","def update_date(self, update_date):\n\n self._update_date = update_date","def save(self, *args, **kwargs):\n self.modify_ts = datetime.now()\n super(ModelBase, self).save(*args, **kwargs)","def setDateTime(self, datetime):\n\n year = datetime[0]\n day = datetime[1]\n month = datetime[2]\n hour = datetime[3]\n min = datetime[4]\n sec = datetime[5]\n\n # command to restore SELinux configurations\n cmd = \"date -s '%s/%s/%s %s:%s:%s' > /dev/null\" % (day, month,\n year, hour, min, sec)\n # SELinux restoration failed: error\n if subprocess.call(cmd, shell=True) != 0:\n self.__logger.critical(\"Error to set datetime using date\")\n raise RuntimeError('Error to set datetime using date')","def completion_date(self, completion_date):\n\n self._completion_date = completion_date","def payment_date(self, payment_date):\n\n self._payment_date = payment_date","def payment_date(self, payment_date):\n\n self._payment_date = payment_date","def set_statement_received_date(self, received_date):\n if received_date != \"\":\n self.set_value_into_input_field(self.received_date_locator, received_date)\n else:\n received_date_to_set = self.first_day_of_current_month\n self.set_value_into_input_field(self.received_date_locator, received_date_to_set)","def _copy_custom_attributes(self, column):\n\n column._fk = self._fk\n column._fk_on_update = self._fk_on_update\n column._fk_on_delete = self._fk_on_delete\n\n super()._copy_custom_attributes(column)","def alternative_inception_date(self, alternative_inception_date):\n\n self._alternative_inception_date = alternative_inception_date","def announcement_date(self, announcement_date):\n\n self._announcement_date = announcement_date","def __init__(self, strict=True, **kwargs):\r\n self.strict = strict\r\n super(DateTime, self).__init__(**kwargs)","def dob(self, dob):\n\n self._dob = dob","def authorization_date(self, authorization_date):\n\n self._authorization_date = authorization_date","def publish(self):\n\n\t\tself.patient_update_dt = timezone.now()\n\t\tself.save()","def date_start(self, date_start):\n\n self._date_start = date_start","def setBirthday(self,month,day,year):\n self.birthday = datetime.date(year,month,day)","def setBirthday(self,month,day,year):\n self.birthday = datetime.date(year,month,day)","def update_dt(self, data_code, dt):\n self.data_code = data_code\n self.apply_data_code()\n msg = 'update_dt not implemented in the %s class' % self.__class__.__name__\n raise RuntimeError(msg)\n #assert dt>=0.\n #print \"updating dt...dt=%s\" %(dt)\n if dt is not None:\n self.dt = dt\n self.add_new_transient()","def actual_reported_date(self, actual_reported_date):\n\n self._actual_reported_date = actual_reported_date","def setSelectedDate(self, data):\n # print('setSelectedDate ', data)\n self.currentDate = data","def callback_choosethedatefordisplay(self, attrname, old, new):\n self._update_chart(self.choosethedatefordisplay.value_as_datetime)","def copy(self):\n dnew = Date(self.month, self.day, self.year)\n return dnew","def citation_date(self, citation_date):\n\n self._citation_date = citation_date","def balance_date(self, balance_date):\n\n self._balance_date = balance_date","def date_time(self, date_time):\n\n self._date_time = date_time","def get_df(self,**kwargs):\n df = super().get_df(**kwargs)\n if self.automatically_fill_missing_columns == True:\n if df['year_of_birth'].isnull().all():\n df['year_of_birth'] = self.tools.get_year(df['birth_datetime'])\n\n if df['month_of_birth'].isnull().all():\n df['month_of_birth'] = self.tools.get_month(df['birth_datetime'])\n\n if df['day_of_birth'].isnull().all():\n df['day_of_birth'] = self.tools.get_day(df['birth_datetime'])\n \n return df","def fix_dates(self, row):\r\n for field in self.date_fields:\r\n if field in row:\r\n if not type(row[field]) is datetime:\r\n try:\r\n row[field] = datetime.fromtimestamp(float(row[field]))\r\n except Exception as e:\r\n row[field] = None","def set_date(self, date):\n\n newdate = datetime.datetime.strptime(date, \"%Y-%m-%dT%H:%M:%S\")\n self.__get_century(date)\n self.__bus.write_byte_data(self.__rtcaddress,\n self.SECONDS,\n self.__dec_bcd(newdate.second))\n self.__bus.write_byte_data(self.__rtcaddress,\n self.MINUTES,\n self.__dec_bcd(newdate.minute))\n self.__bus.write_byte_data(self.__rtcaddress,\n self.HOURS,\n self.__dec_bcd(newdate.hour))\n self.__bus.write_byte_data(self.__rtcaddress,\n self.DAYOFWEEK,\n self.__dec_bcd(newdate.weekday()))\n self.__bus.write_byte_data(self.__rtcaddress,\n self.DAY,\n self.__dec_bcd(newdate.day))\n self.__bus.write_byte_data(self.__rtcaddress,\n self.MONTH,\n self.__dec_bcd(newdate.month))\n self.__bus.write_byte_data(self.__rtcaddress,\n self.YEAR,\n self.__dec_bcd(newdate.year -\n self.__century))\n return"],"string":"[\n \"def patient_consent_date(self, value):\\n self._patient_consent_date = value\\n self._patient_consent = 1 if value else 0\",\n \"def patient_consent_date(self):\\n return self._patient_consent_date\",\n \"def set_to_date(self):\\n self.set_value_into_input_field(self.set_to_date_locator, self.get_current_date())\",\n \"def _date(self, _date):\\n\\n self.__date = _date\",\n \"def _date(self, _date):\\n\\n self.__date = _date\",\n \"def date(self, new_date):\\n self._date.date = new_date\",\n \"def set_datetime(self, date):\\n self.date = date\",\n \"def set_from_date(self, date):\\n self.set_value_into_input_field(self.set_from_date_locator, date)\",\n \"def set_adjustment_charge_begin_date(self, begin_date):\\n self.set_value_into_input_field(self.adjustment_begin_date_locator, begin_date)\",\n \"def set_date(self, date):\\n self.date = self.date_to_local(date)\\n # ephem deals only in UTC\\n self.site.date = ephem.Date(self.date_to_utc(self.date))\",\n \"def _read_patient_consent_date(self, d: dict):\\n consent_date = d.get('patient_consent_date')\\n consent_bool = d.get('patient_consent')\\n if consent_date is not None:\\n return self._str_to_datetime(consent_date)\\n elif consent_bool:\\n t0 = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\\n creation_date = d.get('creation_date')\\n return (self._str_to_datetime(creation_date)\\n if creation_date is not None\\n else t0)\\n else:\\n return None\",\n \"def set_from_date_as_current_date(self):\\n self.set_value_into_input_field(self.set_from_date_locator, self.get_current_date())\",\n \"def setDate(self, p_int, p_int_1, p_int_2): # real signature unknown; restored from __doc__\\r\\n return False\",\n \"def set_date(self, date):\\n self.date = date\",\n \"def set_date(self, date):\\n self.date = date\\n return\",\n \"def date_wrangler(self, date_col):\\n data = self.copy() # Create a copy of the DataFrame\\n\\n # Convert target column to datetime\\n data[date_col] = pd.to_datetime(\\n data[date_col], infer_datetime_format=True\\n )\\n\\n # Split column into datetime components\\n data[f\\\"{date_col}_year\\\"] = data[date_col].dt.year\\n data[f\\\"{date_col}_year\\\"] = data[date_col].dt.month\\n data[f\\\"{date_col}_year\\\"] = data[date_col].dt.day\\n\\n # Drop original column\\n data = data.drop(columns=date_col)\\n\\n return data\",\n \"def _setVals(self, datetime=0):\\n self.datetime = datetime\",\n \"def date(self, date):\\n self._date = date\",\n \"def date(self, value):\\n self.date_value = value\",\n \"def mod_date(self, mod_date):\\n\\n self._mod_date = mod_date\",\n \"def set_birthdate(self, date):\\n\\n if validate_date_format(self.birt):\\n self.birt = date\\n else:\\n raise ValueError('Invalid date!')\",\n \"def set_statement_issued_date(self, issued_date):\\n if issued_date != \\\"\\\":\\n issued_date_to_set = issued_date\\n else:\\n self.first_day_of_current_month = self.get_date(first_day_of_current_month=True)\\n issued_date_to_set = self.first_day_of_current_month\\n self.set_value_into_input_field(self.issued_date_locator, issued_date_to_set)\",\n \"def set_date(self, date):\\n self.data['date'] = date\",\n \"def set_adjustment_charge_end_date(self, end_date):\\n self.set_value_into_input_field(self.end_date_locator, end_date)\",\n \"def date(self, date):\\n\\n self._date = date\",\n \"def date(self, date):\\n\\n self._date = date\",\n \"def date(self, date):\\n\\n self._date = date\",\n \"def date(self, date):\\n\\n self._date = date\",\n \"def date(self, date):\\n\\n self._date = date\",\n \"def set_document_date(self, date):\\n self.set_value_into_input_field(self.document_date_text_field_locator, date)\",\n \"def set_end_date(self, date):\\n pass\",\n \"def set_harvest_date(self, date):\\n if not date:\\n return datetime.utcnow().strftime(\\\"%Y/%m/%d\\\")\\n return datetime.strptime(date, \\\"%Y%m%d\\\").strftime(\\\"%Y/%m/%d\\\")\",\n \"def date(self, date):\\n self.value = date.strftime(\\\"%Y-%m-%d\\\") if date else \\\"\\\"\",\n \"def set_idate(self, idate):\\n self.__idate = idate\",\n \"def date(self, date):\\n if self.local_vars_configuration.client_side_validation and date is None: # noqa: E501\\n raise ValueError(\\\"Invalid value for `date`, must not be `None`\\\") # noqa: E501\\n\\n self._date = date\",\n \"def _datetime(self, _datetime):\\n\\n self.__datetime = _datetime\",\n \"def setBaseDate(self, date=None):\\n if date is None:\\n date = self.oggi\\n self.baseDate = QDate(date.year(), date.month(), 1)\",\n \"def booger_picker(self, date_column_name):\\n self.dataframe[date_column_name] = pd.to_datetime(\\n self.dataframe[date_column_name],\\n infer_datetime_format=True)\\n self.dataframe['Year'] = self.dataframe[date_column_name].dt.year\\n self.dataframe['Month'] = self.dataframe[date_column_name].dt.month\\n self.dataframe['Day'] = self.dataframe[date_column_name].dt.day\\n self.dataframe.drop(date_column_name, axis=1, inplace=True)\\n return self.dataframe\",\n \"def patient_consent(self):\\n return 1 if self.patient_consent_date is not None else 0\",\n \"def set_contest_date_time(contest, date_time, field):\\n c = biv.load_obj(contest)\\n assert type(c) == pem.E15Contest\\n dt = _local_date_time_as_utc(c, date_time)\\n assert hasattr(c, field), \\\\\\n '{}: has no attr {}'.format(c, field)\\n setattr(c, field, dt)\\n _add_model(c)\",\n \"def _fill_date(self):\\n if not self.date['year']:\\n self.date['year'] = self.DEFAULT_DATE['year']\\n if not self.date['month']:\\n self.date['month'] = self.DEFAULT_DATE['month']\\n if not self.date['day']:\\n self.date['day'] = self.DEFAULT_DATE['day']\",\n \"def observation_date(self, observation_date):\\n\\n self._observation_date = observation_date\",\n \"def update(self, date):\\r\\n self.date = date\",\n \"def collect_interview_date(self, collect_interview_date):\\n\\n self._collect_interview_date = collect_interview_date\",\n \"def set_birthday(self, year, month, day):\\n self.birthday = datetime.date(year, month, day)\",\n \"def set_charge_begin_date(self, charge_begin_date, first_day_of_last_month):\\n self.current_charge_begin_date = charge_begin_date\\n if first_day_of_last_month is True:\\n if charge_begin_date == \\\"\\\":\\n self.first_day_of_previous_month = self.get_date(first_day_of_last_month=True)\\n charge_begin_date = self.first_day_of_previous_month\\n else:\\n if charge_begin_date == \\\"\\\":\\n charge_begin_date = self.get_date(current_date=True)\\n self.current_charge_begin_date = datetime.datetime.strptime(charge_begin_date, \\\"%m/%d/%Y\\\")\\n self.set_value_in_grid_column(self.charges_grid_div_id, self.charge_begin_date_column_name, charge_begin_date, True)\\n page_header_element = self.wait().until(EC.element_to_be_clickable(self.page_header_locator), 'page header locator not found before specified time out')\\n page_header_element.click()\",\n \"def setBirthday(self, birthdate):\\r\\n self.birthday = birthdate\",\n \"def _date(self, _date: datetime):\\n if _date is None:\\n raise ValueError(\\\"Invalid value for `_date`, must not be `None`\\\") # noqa: E501\\n\\n self.__date = _date\",\n \"def set_statement_begin_date(self, begin_date):\\n begin_date_to_set = None\\n if begin_date != \\\"\\\":\\n begin_date_to_set = begin_date\\n else:\\n self.first_day_of_previous_month = self.get_date(first_day_of_last_month=True)\\n begin_date_to_set = self.first_day_of_previous_month\\n self.set_value_into_input_field(self.statement_begin_date_locator, begin_date_to_set)\\n return begin_date_to_set\",\n \"def set_add_dispute_date(self, date):\\n self.set_value_into_input_field(self.add_dispute_date_inputbox_locator, date)\",\n \"def set_start_date(self, date):\\n pass\",\n \"def _set_date(line, dirtydate, date):\\n line = re.sub(dirtydate, date, line, 2)\\n return line\",\n \"def _update_metadata_date(self, properties):\\n if \\\"core\\\" not in properties:\\n properties.core = Struct()\\n properties.core.metadata_date = self._backend.server_time_utc()\",\n \"def model_start_date(self, model_start_date):\\n\\n self._model_start_date = model_start_date\",\n \"def __init__(self, translator_cls=DatetimeTranslator, default=None, column_name=\\\"\\\"):\\n super(Datetime, self).__init__(\\n translator_cls=translator_cls,\\n default=default,\\n column_name=column_name)\",\n \"def test_change_of_date_field_type(self):\\n # Create a user, device and a heartbeat\\n user = Dummy.create_user()\\n device = Dummy.create_device(user)\\n heartbeat_timestamp = datetime(2015, 12, 15, 1, 23, 45, tzinfo=pytz.utc)\\n\\n heartbeat = Dummy.create_report(\\n HeartBeat, device, date=heartbeat_timestamp\\n )\\n\\n # Assert that the date is of type datetime\\n self.assertIsInstance(heartbeat.date, datetime)\\n\\n # Run the migration\\n self.migrate_to_dest()\\n\\n # Assert that the date is now of type date and has the correct value\\n heartbeat = HeartBeat.objects.first()\\n self.assertIsInstance(heartbeat.date, date)\\n self.assertEqual(heartbeat.date, heartbeat_timestamp.date())\",\n \"def set_begin_date(self, begin_date):\\n self.set_value_into_input_field(self.begin_date_inputbox_locator, begin_date)\",\n \"def dep_date(self, dep_date):\\n\\n self._dep_date = dep_date\",\n \"def to_date(self, value: date):\\n self._to_date = value\\n self._dao.to_date = value\",\n \"def ts_setter(func):\\n\\n @wraps(func)\\n def inner(self, value):\\n \\\"\\\"\\\" Parse input value as ISO8601 date \\\"\\\"\\\"\\n if value is None:\\n return func(self, None)\\n elif isinstance(value, datetime.datetime):\\n return func(self, value)\\n else:\\n value = TS_SETTER_TRANSFORM_RE.sub(TS_SETTER_TRANSFORM_REPL, value)\\n return func(self, iso8601.parse_date(value))\\n\\n return inner\",\n \"def date_answered(self, date_answered):\\n self._date_answered = date_answered\",\n \"def fl_set_form_atactivate(ptr_flform, pyfn_FormAtactivate, userdata):\\n #FL_FORM_ATACTIVATE = cty.CFUNCTYPE(None, cty.POINTER(xfdata.FL_FORM), \\\\\\n # cty.c_void_p)\\n _fl_set_form_atactivate = library.cfuncproto(\\n library.load_so_libforms(), \\\"fl_set_form_atactivate\\\", \\\\\\n xfdata.FL_FORM_ATACTIVATE, [cty.POINTER(xfdata.FL_FORM),\\n xfdata.FL_FORM_ATACTIVATE, cty.c_void_p], \\\\\\n \\\"\\\"\\\"FL_FORM_ATACTIVATE fl_set_form_atactivate(FL_FORM * form,\\n FL_FORM_ATACTIVATE cb, void * data) \\\"\\\"\\\")\\n library.check_if_flinitialized()\\n library.verify_flformptr_type(ptr_flform)\\n library.verify_function_type(pyfn_FormAtactivate)\\n cfn_FormAtactivate = xfdata.FL_FORM_ATACTIVATE(pyfn_FormAtactivate)\\n ptr_vdata = library.convert_userdata_to_ptrvoid(userdata)\\n library.keep_cfunc_refs(cfn_FormAtactivate, pyfn_FormAtactivate)\\n library.keep_elem_refs(ptr_flform, userdata, ptr_vdata)\\n retval = _fl_set_form_atactivate(ptr_flform, cfn_FormAtactivate, \\\\\\n ptr_vdata)\\n return retval\",\n \"def _convert_datetime(self) -> pd.Series:\\n\\n series = pd.to_datetime(self.sanitized)\\n series.name = self.parent.name\\n\\n return series\",\n \"def save(self, *args, **kwargs):\\n self.expire_date = self.sent_date + timedelta(days=self.period)\\n super(Referral, self).save(*args, **kwargs)\",\n \"def setBirthday(self, birthdate):\\n self.birthday = birthdate\",\n \"def set_rdate(self, rdate):\\n self.__rdate = rdate\",\n \"def from_date(self, value: date):\\n self._from_date = value\\n self._dao.from_date = value\",\n \"def as_of_date(self, as_of_date):\\n\\n self._as_of_date = as_of_date\",\n \"def _date(self) -> datetime:\\n return self.__date\",\n \"def _apply_decision(self, decision, responder):\\n self.responder = responder\\n self.status = decision\\n self.decision_datetime = timezone.now()\\n self.save()\",\n \"def set_date(self, date_string, date_type):\\n if date_type == \\\"married\\\":\\n self._married_date = datetime.strptime(date_string, '%d %b %Y')\\n if date_type == \\\"divorced\\\":\\n self._divorced_date = datetime.strptime(date_string, '%d %b %Y')\",\n \"def update_date(self, update_date):\\n\\n self._update_date = update_date\",\n \"def update_date(self, update_date):\\n\\n self._update_date = update_date\",\n \"def save(self, *args, **kwargs):\\n self.modify_ts = datetime.now()\\n super(ModelBase, self).save(*args, **kwargs)\",\n \"def setDateTime(self, datetime):\\n\\n year = datetime[0]\\n day = datetime[1]\\n month = datetime[2]\\n hour = datetime[3]\\n min = datetime[4]\\n sec = datetime[5]\\n\\n # command to restore SELinux configurations\\n cmd = \\\"date -s '%s/%s/%s %s:%s:%s' > /dev/null\\\" % (day, month,\\n year, hour, min, sec)\\n # SELinux restoration failed: error\\n if subprocess.call(cmd, shell=True) != 0:\\n self.__logger.critical(\\\"Error to set datetime using date\\\")\\n raise RuntimeError('Error to set datetime using date')\",\n \"def completion_date(self, completion_date):\\n\\n self._completion_date = completion_date\",\n \"def payment_date(self, payment_date):\\n\\n self._payment_date = payment_date\",\n \"def payment_date(self, payment_date):\\n\\n self._payment_date = payment_date\",\n \"def set_statement_received_date(self, received_date):\\n if received_date != \\\"\\\":\\n self.set_value_into_input_field(self.received_date_locator, received_date)\\n else:\\n received_date_to_set = self.first_day_of_current_month\\n self.set_value_into_input_field(self.received_date_locator, received_date_to_set)\",\n \"def _copy_custom_attributes(self, column):\\n\\n column._fk = self._fk\\n column._fk_on_update = self._fk_on_update\\n column._fk_on_delete = self._fk_on_delete\\n\\n super()._copy_custom_attributes(column)\",\n \"def alternative_inception_date(self, alternative_inception_date):\\n\\n self._alternative_inception_date = alternative_inception_date\",\n \"def announcement_date(self, announcement_date):\\n\\n self._announcement_date = announcement_date\",\n \"def __init__(self, strict=True, **kwargs):\\r\\n self.strict = strict\\r\\n super(DateTime, self).__init__(**kwargs)\",\n \"def dob(self, dob):\\n\\n self._dob = dob\",\n \"def authorization_date(self, authorization_date):\\n\\n self._authorization_date = authorization_date\",\n \"def publish(self):\\n\\n\\t\\tself.patient_update_dt = timezone.now()\\n\\t\\tself.save()\",\n \"def date_start(self, date_start):\\n\\n self._date_start = date_start\",\n \"def setBirthday(self,month,day,year):\\n self.birthday = datetime.date(year,month,day)\",\n \"def setBirthday(self,month,day,year):\\n self.birthday = datetime.date(year,month,day)\",\n \"def update_dt(self, data_code, dt):\\n self.data_code = data_code\\n self.apply_data_code()\\n msg = 'update_dt not implemented in the %s class' % self.__class__.__name__\\n raise RuntimeError(msg)\\n #assert dt>=0.\\n #print \\\"updating dt...dt=%s\\\" %(dt)\\n if dt is not None:\\n self.dt = dt\\n self.add_new_transient()\",\n \"def actual_reported_date(self, actual_reported_date):\\n\\n self._actual_reported_date = actual_reported_date\",\n \"def setSelectedDate(self, data):\\n # print('setSelectedDate ', data)\\n self.currentDate = data\",\n \"def callback_choosethedatefordisplay(self, attrname, old, new):\\n self._update_chart(self.choosethedatefordisplay.value_as_datetime)\",\n \"def copy(self):\\n dnew = Date(self.month, self.day, self.year)\\n return dnew\",\n \"def citation_date(self, citation_date):\\n\\n self._citation_date = citation_date\",\n \"def balance_date(self, balance_date):\\n\\n self._balance_date = balance_date\",\n \"def date_time(self, date_time):\\n\\n self._date_time = date_time\",\n \"def get_df(self,**kwargs):\\n df = super().get_df(**kwargs)\\n if self.automatically_fill_missing_columns == True:\\n if df['year_of_birth'].isnull().all():\\n df['year_of_birth'] = self.tools.get_year(df['birth_datetime'])\\n\\n if df['month_of_birth'].isnull().all():\\n df['month_of_birth'] = self.tools.get_month(df['birth_datetime'])\\n\\n if df['day_of_birth'].isnull().all():\\n df['day_of_birth'] = self.tools.get_day(df['birth_datetime'])\\n \\n return df\",\n \"def fix_dates(self, row):\\r\\n for field in self.date_fields:\\r\\n if field in row:\\r\\n if not type(row[field]) is datetime:\\r\\n try:\\r\\n row[field] = datetime.fromtimestamp(float(row[field]))\\r\\n except Exception as e:\\r\\n row[field] = None\",\n \"def set_date(self, date):\\n\\n newdate = datetime.datetime.strptime(date, \\\"%Y-%m-%dT%H:%M:%S\\\")\\n self.__get_century(date)\\n self.__bus.write_byte_data(self.__rtcaddress,\\n self.SECONDS,\\n self.__dec_bcd(newdate.second))\\n self.__bus.write_byte_data(self.__rtcaddress,\\n self.MINUTES,\\n self.__dec_bcd(newdate.minute))\\n self.__bus.write_byte_data(self.__rtcaddress,\\n self.HOURS,\\n self.__dec_bcd(newdate.hour))\\n self.__bus.write_byte_data(self.__rtcaddress,\\n self.DAYOFWEEK,\\n self.__dec_bcd(newdate.weekday()))\\n self.__bus.write_byte_data(self.__rtcaddress,\\n self.DAY,\\n self.__dec_bcd(newdate.day))\\n self.__bus.write_byte_data(self.__rtcaddress,\\n self.MONTH,\\n self.__dec_bcd(newdate.month))\\n self.__bus.write_byte_data(self.__rtcaddress,\\n self.YEAR,\\n self.__dec_bcd(newdate.year -\\n self.__century))\\n return\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.668064","0.5796747","0.57947594","0.571031","0.571031","0.5642255","0.5556245","0.5523759","0.55139166","0.5509836","0.55023223","0.5477226","0.5464905","0.5369002","0.5365053","0.5335959","0.53224725","0.5223045","0.5208461","0.5204645","0.51883584","0.51836663","0.51673496","0.512969","0.5108179","0.5108179","0.5108179","0.5108179","0.5108179","0.50952566","0.50903773","0.5089567","0.5079945","0.5072712","0.506561","0.50548226","0.50534755","0.5026781","0.5024889","0.50036114","0.49549088","0.49527746","0.49468353","0.49199706","0.49135682","0.48960552","0.48357093","0.48304734","0.48159313","0.4811151","0.48016047","0.47960925","0.47915637","0.47756487","0.47722208","0.47674975","0.47561815","0.4753741","0.47474545","0.47450835","0.4743804","0.47327688","0.47304568","0.47295055","0.47154397","0.47137395","0.47076267","0.47002336","0.4697741","0.46947032","0.46911812","0.46831244","0.46831244","0.46768433","0.46758348","0.467495","0.46728113","0.46728113","0.4667097","0.46621594","0.46611685","0.46595573","0.4658345","0.46526247","0.46521035","0.46517673","0.46448317","0.4642018","0.4642018","0.46378842","0.46364775","0.46326476","0.4631297","0.46203828","0.46166945","0.4613358","0.46128857","0.46121395","0.46090487","0.46045762"],"string":"[\n \"0.668064\",\n \"0.5796747\",\n \"0.57947594\",\n \"0.571031\",\n \"0.571031\",\n \"0.5642255\",\n \"0.5556245\",\n \"0.5523759\",\n \"0.55139166\",\n \"0.5509836\",\n \"0.55023223\",\n \"0.5477226\",\n \"0.5464905\",\n \"0.5369002\",\n \"0.5365053\",\n \"0.5335959\",\n \"0.53224725\",\n \"0.5223045\",\n \"0.5208461\",\n \"0.5204645\",\n \"0.51883584\",\n \"0.51836663\",\n \"0.51673496\",\n \"0.512969\",\n \"0.5108179\",\n \"0.5108179\",\n \"0.5108179\",\n \"0.5108179\",\n \"0.5108179\",\n \"0.50952566\",\n \"0.50903773\",\n \"0.5089567\",\n \"0.5079945\",\n \"0.5072712\",\n \"0.506561\",\n \"0.50548226\",\n \"0.50534755\",\n \"0.5026781\",\n \"0.5024889\",\n \"0.50036114\",\n \"0.49549088\",\n \"0.49527746\",\n \"0.49468353\",\n \"0.49199706\",\n \"0.49135682\",\n \"0.48960552\",\n \"0.48357093\",\n \"0.48304734\",\n \"0.48159313\",\n \"0.4811151\",\n \"0.48016047\",\n \"0.47960925\",\n \"0.47915637\",\n \"0.47756487\",\n \"0.47722208\",\n \"0.47674975\",\n \"0.47561815\",\n \"0.4753741\",\n \"0.47474545\",\n \"0.47450835\",\n \"0.4743804\",\n \"0.47327688\",\n \"0.47304568\",\n \"0.47295055\",\n \"0.47154397\",\n \"0.47137395\",\n \"0.47076267\",\n \"0.47002336\",\n \"0.4697741\",\n \"0.46947032\",\n \"0.46911812\",\n \"0.46831244\",\n \"0.46831244\",\n \"0.46768433\",\n \"0.46758348\",\n \"0.467495\",\n \"0.46728113\",\n \"0.46728113\",\n \"0.4667097\",\n \"0.46621594\",\n \"0.46611685\",\n \"0.46595573\",\n \"0.4658345\",\n \"0.46526247\",\n \"0.46521035\",\n \"0.46517673\",\n \"0.46448317\",\n \"0.4642018\",\n \"0.4642018\",\n \"0.46378842\",\n \"0.46364775\",\n \"0.46326476\",\n \"0.4631297\",\n \"0.46203828\",\n \"0.46166945\",\n \"0.4613358\",\n \"0.46128857\",\n \"0.46121395\",\n \"0.46090487\",\n \"0.46045762\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6615058"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84581,"cells":{"query":{"kind":"string","value":"Get internal value for `patient_consent_date`."},"document":{"kind":"string","value":"def patient_consent_date(self):\n return self._patient_consent_date"},"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 _read_patient_consent_date(self, d: dict):\n consent_date = d.get('patient_consent_date')\n consent_bool = d.get('patient_consent')\n if consent_date is not None:\n return self._str_to_datetime(consent_date)\n elif consent_bool:\n t0 = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\n creation_date = d.get('creation_date')\n return (self._str_to_datetime(creation_date)\n if creation_date is not None\n else t0)\n else:\n return None","def patient_consent_date(self, value):\n self._patient_consent_date = value\n self._patient_consent = 1 if value else 0","def patient_consent(self):\n return 1 if self.patient_consent_date is not None else 0","def patient_consent(self, value):\n self.patient_consent_date = utcnow() if value else None","def patient_consent(self):\n return self.patient_consent_date != None # noqa: E711","def date(self):\n return self.date_value","def get_date(self):\n return self.date","def get_date(self):\n return self.date","def get_date(self):\n return self.date","def get_date(self):\n return self.date","def bios_date(self):\n\t\treturn self.__info_dict['info']['bios_date']['value']","def get_date(self, datetime):\n return datetime.date()","def _date(self) -> datetime:\n return self.__date","def date(self):\n return self._date","def date(self):\n return self._date","def date(self):\n return self._date","def date(self):\n return self._date","def get_date(date):\n return date","def evaluated_date(self):\n return self._evaluated_date","def date_of_birth(self):\n return self.__date_of_birth","def date(self) -> Optional[int]:\n return pulumi.get(self, \"date\")","def DefenceDate(self, default=None):\n return self.data.get('defense_date', default)","def date(self):\n # type: () -> date\n return self._date","def get_date(self):\n return self.cleaned_data['date']","def _get_date(self, relative_idx):\r\n return self.dl.dates[self._identified_date_id + relative_idx]","def birthdate_date(self):\n\n bday = self.birthdate\n if bday:\n dt = datetime.datetime.strptime(\n bday,\n \"%d %b %Y\") # not sure if this format even complies with spec\n # dt = dateutil.parser.parse(bday) # this will guess at a bunch of different formats\n # dt = arrow.get(bday)\n return dt.date()\n else:\n return bday # None","def birth_date(self) -> str:\n return self._birth_date","def date(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"date\")","def _get_report_date(self):\n if self._report_key in (ReportTypes.SEARCH_DETAIL_REPORT, ReportTypes.SEARCH_TOC_REPORT,\n ReportTypes.SEARCH_BODY_REPORT):\n return self._report_data['searchDateTime']\n return self._report_data['createDateTime']","def getValue(self):\n return qDate2Date(self.field.date())","def get(self):\n user_id = request.args.get('user_id')\n return get_birthday_if_consent(user_id)","def get_date(self):\n return self.individual_session.session_date.strftime('%A')","def date_of_birth(self, instance):\r\n return instance.user.profile.date_of_birth","def getDate(self):\n return self.date","def value_date_30V(self):\n if self._get_cash_flow_pay_day():\n return self._get_cash_flow_pay_day()\n\n return get_value_date(self.acm_obj)","def get_date(self):\n raise Unimplemented()","def get_account_created_date(self):\n return self.account_created_date","def dep_date(self):\n return self._dep_date","def date(self):\n bc = self.barcamp\n if bc.start_date and bc.end_date:\n # TODO: localize it\n return \"%s - %s\" %(\n bc.start_date.strftime('%d.%m.%Y'),\n bc.end_date.strftime('%d.%m.%Y'))\n else:\n return self.handler._(\"date to be announced\")","def get_borrow_date(self) -> str:\r\n if self.borrow_date:\r\n return datetime.datetime.strftime(self.borrow_date, \"%Y-%m-%d\")\r\n else:\r\n return None","def get_date(self):\n \n date_fields = ['Acquisition Start Date', 'acquisition_start_date', \\\n 'acquisitionStartDate', 'Date', 'date']\n \n for f in date_fields:\n found = self.metadata.get(f)\n if found is not None:\n return found","def acquisition_date(self):\n return self._acquisition_date","def get_date(self):\n return datetime.date(\n int(self.kwargs['year']),\n int(self.kwargs['month']),\n int(self.kwargs['day'])\n )","def date(self):\n return self._parse_date(self.value)","def __get_date(measurement):\n return ast.literal_eval(measurement).get('date') if measurement else 'unknown date'","def DateOfBirth(self, reg_date_of_birth = VALUE_NOT_SET):\n ael_reg_dob = None\n if reg_date_of_birth != VALUE_NOT_SET:\n try:\n ael_reg_dob = ael.date_from_string(reg_date_of_birth)\n except:\n if reg_date_of_birth not in ['', None]:\n msg = \"The value <%s> provided for DateOfBirth is invalid and hence will not be set of the DateOfBirth AdditionalInfo\"%reg_date_of_birth\n FRegulatoryLogger.ERROR(logger, msg)\n raise FRegulatoryInfoException.FRegInfoInvalidData(msg)\n if ael_reg_dob:\n self.__reg_date_of_birth = reg_date_of_birth\n else:\n self.__reg_date_of_birth = None\n try:\n self.__contact.AdditionalInfo().DateOfBirth(self.__reg_date_of_birth)\n except:\n pass\n else:\n return self.__reg_date_of_birth","def date_answered(self):\n return self._date_answered","def decommission_date(self):\n return self._decommission_date","def arr_date(self):\n return self._arr_date","def date_of_birth(self) -> str:\n return self._date_of_birth.strftime('%Y-%m-%d')","def date_ym_value(date: dt.datetime) -> int:\n return (100 * date.year) + date.month","def on_or_before(self, date):\n return (date - mod(date - self.CORRELATION - self.to_ordinal(), 365))","def numeric_date_recover(self):\n \n sp_time_zone, current_datetime = self.setup_datetime() \n converter2sptimezone = current_datetime.astimezone(sp_time_zone)\n \n return converter2sptimezone.strftime('%d-%m-%Y')","def license_date(self):\n return self._license_date","def get_birthday(self, entity):\n try:\n Pid = 'P569'\n birthday = self.get_value(entity, Pid, 0)['time']\n birthdate = self.to_datetime(birthday)\n return datetime.strftime(birthdate, '%d-%m-%Y')\n except Exception as e:\n print(e)\n return ''","def Date(self, default=None):\n return self.data.get('date', default)","def Date(self, default=None):\n return self.data.get('date', default)","def Date(self, default=None):\n return self.data.get('date', default)","def get_inbound_statement_details_issued_date(self):\n return self.get_text_from_element(self.inbound_statements_details_issued_date_locator, True)","def get_date():\n temp = pd.read_sql_query(_query['date'], connect())\n return temp.values","def date(self):\n return date(self._year, self._month, self._day)","def get_date(self):\n return self.date.strftime(\"%a %x\")","def todate(self):\n return self._date","def _period_from_date(self):\n if self.date['year']:\n if self.date['month']:\n if self.date['day']:\n self.period = Period.DAILY\n else:\n self.period = Period.MONTHLY\n else:\n self.period = Period.YEARLY\n else:\n self.period = Period.FULL","def date_active(self):\n return datetime.datetime.fromtimestamp(self.fields['activityDate'])","def current_valid_date(self):\r\n return datetime.datetime.now().strftime('%Y-%m-%d')","def date(self, date):\n if self.local_vars_configuration.client_side_validation and date is None: # noqa: E501\n raise ValueError(\"Invalid value for `date`, must not be `None`\") # noqa: E501\n\n self._date = date","def register_date(self):\n\n return self._register_date","def _get_datetime_or_error(self) -> dt:\n return dt(\n *(self.date[key] for key in ['year', 'month', 'day'] if key in self.date)\n )","def clean_birth_date(self):\n\n sent_date = self.cleaned_data['birth_date']\n current_date = localtime(now()).date()\n\n if (sent_date - current_date) > datetime.timedelta(seconds=1):\n raise ValidationError(INVALID_BIRTH_DATE_VALUE)\n else:\n return sent_date","def from_date(self):\n return self._from_date","def get_python_date(self):\n return dateutil.parser.parse(self.iso_date)","def localized_date(self):\r\n date_ = self._post['effective_date']\r\n to_localized = self.context.toLocalizedTime\r\n \r\n try:\r\n local_date = to_localized(date_)\r\n except ValueError:\r\n # An invalid date; just return nothing\r\n local_date = None\r\n \r\n return local_date","def get_date():\n now = datetime.now()\n date = now.strftime(\"%Y%m%d\")\n return date","def date(self):\n try:\n return str(self._info['meas_date'].date())\n except Exception as exc:\n return \"\"","def founding_date(self) -> datetime:\n return self._founding_date","def forecast_date(self):\n return self._forecast_date","def invalidity_date_value(self):\n\n if self._processed_extensions is False:\n self._set_extensions()\n return self._invalidity_date_value","def last_date(self):\n if self._last_date is None:\n raise ValueError(\"Run pick() method before access this property\")\n return self._last_date","def getActiveDate(self):\n dateAsQDate = self.workCalendar.selectedDate()\n dateString = str(dateAsQDate.toString('dd/MM/yyyy'))\n dateAsDateTime = OINKM.getDate(dateString)\n return dateAsDateTime","def _get_date():\n return datetime.datetime.now()","def get_date():\n dt = datetime.now()\n return dt.strftime(\"%Y-%m-%d\")","async def date(self) -> dt.date:\n now = await self.AD.sched.get_now()\n return now.astimezone(self.AD.tz).date()","def get_date_DM(): \n \n now = date.datetime.now()\n date_DM = str(now.day)+'_'+str(now.month)+'/' \n return date_DM","def process_datetime(a_date: datetime) -> str:\n\n return str(a_date.date()) if a_date else Presenter.DEFAULT","def getValue(self):\n return qDateTime2Datetime(self.field.dateTime())","def computed_startdate(self):\n return self.startdate","def set_harvest_date(self, date):\n if not date:\n return datetime.utcnow().strftime(\"%Y/%m/%d\")\n return datetime.strptime(date, \"%Y%m%d\").strftime(\"%Y/%m/%d\")","def check_surrender_date(cursor, dog_id):\n query = f\"select surrender_date from Dog where Dog.dogID = {dog_id};\"\n cursor.execute(query)\n query_result = cursor.fetchall()\n return query_result[0][0]","def to_python(self, value):\n return string_to_partialdate(value)","def to_stdlib(self) -> dt.date:\n return dt.date.fromordinal(self.toordinal())","def date(self) -> datetime.datetime:\n return self._data['Date'] - datetime.timedelta(0, float(self.exposuretime), 0)","def get_datecode():\n now = datetime.utcnow()\n return now.strftime(\"%Y%m%d\")","def _earliest_allowed_date(cls):\r\n DAYS_GOOD_FOR = settings.VERIFY_STUDENT[\"DAYS_GOOD_FOR\"]\r\n allowed_date = (\r\n datetime.now(pytz.UTC) - timedelta(days=DAYS_GOOD_FOR)\r\n )\r\n return allowed_date","def insure_date(d):\n if isinstance(d, BeautifulDate):\n return date(year=d.year, month=d.month, day=d.day)\n else:\n return d","def date(self, date):\n self.value = date.strftime(\"%Y-%m-%d\") if date else \"\"","def max_drawdown_date(self) -> dt.date:\n mdd_date = (self.tsdf / self.tsdf.expanding(min_periods=1).max()).idxmin().values[0].astype(dt.datetime)\n return dt.datetime.fromtimestamp(mdd_date / 1e9).date()","def date(self):\n if self.raw_date_str == \"Unknown\":\n return self.raw_date_str\n else:\n try:\n _date = datetime.datetime.strptime(self.raw_date_str, \"%B %d, %Y\")\n except ValueError:\n try:\n _date = datetime.datetime.strptime(self.raw_date_str, \"%B %Y\")\n except ValueError:\n logger.error(\"Unable to parse date: {}\".format(self.raw_date_str))\n return None\n return _date.date()","def expiration_date(self) -> typing.Optional[datetime.datetime]:\n return self._values.get('expiration_date')","def last_accessed_date(self) -> Optional[str]:\n return pulumi.get(self, \"last_accessed_date\")"],"string":"[\n \"def _read_patient_consent_date(self, d: dict):\\n consent_date = d.get('patient_consent_date')\\n consent_bool = d.get('patient_consent')\\n if consent_date is not None:\\n return self._str_to_datetime(consent_date)\\n elif consent_bool:\\n t0 = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\\n creation_date = d.get('creation_date')\\n return (self._str_to_datetime(creation_date)\\n if creation_date is not None\\n else t0)\\n else:\\n return None\",\n \"def patient_consent_date(self, value):\\n self._patient_consent_date = value\\n self._patient_consent = 1 if value else 0\",\n \"def patient_consent(self):\\n return 1 if self.patient_consent_date is not None else 0\",\n \"def patient_consent(self, value):\\n self.patient_consent_date = utcnow() if value else None\",\n \"def patient_consent(self):\\n return self.patient_consent_date != None # noqa: E711\",\n \"def date(self):\\n return self.date_value\",\n \"def get_date(self):\\n return self.date\",\n \"def get_date(self):\\n return self.date\",\n \"def get_date(self):\\n return self.date\",\n \"def get_date(self):\\n return self.date\",\n \"def bios_date(self):\\n\\t\\treturn self.__info_dict['info']['bios_date']['value']\",\n \"def get_date(self, datetime):\\n return datetime.date()\",\n \"def _date(self) -> datetime:\\n return self.__date\",\n \"def date(self):\\n return self._date\",\n \"def date(self):\\n return self._date\",\n \"def date(self):\\n return self._date\",\n \"def date(self):\\n return self._date\",\n \"def get_date(date):\\n return date\",\n \"def evaluated_date(self):\\n return self._evaluated_date\",\n \"def date_of_birth(self):\\n return self.__date_of_birth\",\n \"def date(self) -> Optional[int]:\\n return pulumi.get(self, \\\"date\\\")\",\n \"def DefenceDate(self, default=None):\\n return self.data.get('defense_date', default)\",\n \"def date(self):\\n # type: () -> date\\n return self._date\",\n \"def get_date(self):\\n return self.cleaned_data['date']\",\n \"def _get_date(self, relative_idx):\\r\\n return self.dl.dates[self._identified_date_id + relative_idx]\",\n \"def birthdate_date(self):\\n\\n bday = self.birthdate\\n if bday:\\n dt = datetime.datetime.strptime(\\n bday,\\n \\\"%d %b %Y\\\") # not sure if this format even complies with spec\\n # dt = dateutil.parser.parse(bday) # this will guess at a bunch of different formats\\n # dt = arrow.get(bday)\\n return dt.date()\\n else:\\n return bday # None\",\n \"def birth_date(self) -> str:\\n return self._birth_date\",\n \"def date(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"date\\\")\",\n \"def _get_report_date(self):\\n if self._report_key in (ReportTypes.SEARCH_DETAIL_REPORT, ReportTypes.SEARCH_TOC_REPORT,\\n ReportTypes.SEARCH_BODY_REPORT):\\n return self._report_data['searchDateTime']\\n return self._report_data['createDateTime']\",\n \"def getValue(self):\\n return qDate2Date(self.field.date())\",\n \"def get(self):\\n user_id = request.args.get('user_id')\\n return get_birthday_if_consent(user_id)\",\n \"def get_date(self):\\n return self.individual_session.session_date.strftime('%A')\",\n \"def date_of_birth(self, instance):\\r\\n return instance.user.profile.date_of_birth\",\n \"def getDate(self):\\n return self.date\",\n \"def value_date_30V(self):\\n if self._get_cash_flow_pay_day():\\n return self._get_cash_flow_pay_day()\\n\\n return get_value_date(self.acm_obj)\",\n \"def get_date(self):\\n raise Unimplemented()\",\n \"def get_account_created_date(self):\\n return self.account_created_date\",\n \"def dep_date(self):\\n return self._dep_date\",\n \"def date(self):\\n bc = self.barcamp\\n if bc.start_date and bc.end_date:\\n # TODO: localize it\\n return \\\"%s - %s\\\" %(\\n bc.start_date.strftime('%d.%m.%Y'),\\n bc.end_date.strftime('%d.%m.%Y'))\\n else:\\n return self.handler._(\\\"date to be announced\\\")\",\n \"def get_borrow_date(self) -> str:\\r\\n if self.borrow_date:\\r\\n return datetime.datetime.strftime(self.borrow_date, \\\"%Y-%m-%d\\\")\\r\\n else:\\r\\n return None\",\n \"def get_date(self):\\n \\n date_fields = ['Acquisition Start Date', 'acquisition_start_date', \\\\\\n 'acquisitionStartDate', 'Date', 'date']\\n \\n for f in date_fields:\\n found = self.metadata.get(f)\\n if found is not None:\\n return found\",\n \"def acquisition_date(self):\\n return self._acquisition_date\",\n \"def get_date(self):\\n return datetime.date(\\n int(self.kwargs['year']),\\n int(self.kwargs['month']),\\n int(self.kwargs['day'])\\n )\",\n \"def date(self):\\n return self._parse_date(self.value)\",\n \"def __get_date(measurement):\\n return ast.literal_eval(measurement).get('date') if measurement else 'unknown date'\",\n \"def DateOfBirth(self, reg_date_of_birth = VALUE_NOT_SET):\\n ael_reg_dob = None\\n if reg_date_of_birth != VALUE_NOT_SET:\\n try:\\n ael_reg_dob = ael.date_from_string(reg_date_of_birth)\\n except:\\n if reg_date_of_birth not in ['', None]:\\n msg = \\\"The value <%s> provided for DateOfBirth is invalid and hence will not be set of the DateOfBirth AdditionalInfo\\\"%reg_date_of_birth\\n FRegulatoryLogger.ERROR(logger, msg)\\n raise FRegulatoryInfoException.FRegInfoInvalidData(msg)\\n if ael_reg_dob:\\n self.__reg_date_of_birth = reg_date_of_birth\\n else:\\n self.__reg_date_of_birth = None\\n try:\\n self.__contact.AdditionalInfo().DateOfBirth(self.__reg_date_of_birth)\\n except:\\n pass\\n else:\\n return self.__reg_date_of_birth\",\n \"def date_answered(self):\\n return self._date_answered\",\n \"def decommission_date(self):\\n return self._decommission_date\",\n \"def arr_date(self):\\n return self._arr_date\",\n \"def date_of_birth(self) -> str:\\n return self._date_of_birth.strftime('%Y-%m-%d')\",\n \"def date_ym_value(date: dt.datetime) -> int:\\n return (100 * date.year) + date.month\",\n \"def on_or_before(self, date):\\n return (date - mod(date - self.CORRELATION - self.to_ordinal(), 365))\",\n \"def numeric_date_recover(self):\\n \\n sp_time_zone, current_datetime = self.setup_datetime() \\n converter2sptimezone = current_datetime.astimezone(sp_time_zone)\\n \\n return converter2sptimezone.strftime('%d-%m-%Y')\",\n \"def license_date(self):\\n return self._license_date\",\n \"def get_birthday(self, entity):\\n try:\\n Pid = 'P569'\\n birthday = self.get_value(entity, Pid, 0)['time']\\n birthdate = self.to_datetime(birthday)\\n return datetime.strftime(birthdate, '%d-%m-%Y')\\n except Exception as e:\\n print(e)\\n return ''\",\n \"def Date(self, default=None):\\n return self.data.get('date', default)\",\n \"def Date(self, default=None):\\n return self.data.get('date', default)\",\n \"def Date(self, default=None):\\n return self.data.get('date', default)\",\n \"def get_inbound_statement_details_issued_date(self):\\n return self.get_text_from_element(self.inbound_statements_details_issued_date_locator, True)\",\n \"def get_date():\\n temp = pd.read_sql_query(_query['date'], connect())\\n return temp.values\",\n \"def date(self):\\n return date(self._year, self._month, self._day)\",\n \"def get_date(self):\\n return self.date.strftime(\\\"%a %x\\\")\",\n \"def todate(self):\\n return self._date\",\n \"def _period_from_date(self):\\n if self.date['year']:\\n if self.date['month']:\\n if self.date['day']:\\n self.period = Period.DAILY\\n else:\\n self.period = Period.MONTHLY\\n else:\\n self.period = Period.YEARLY\\n else:\\n self.period = Period.FULL\",\n \"def date_active(self):\\n return datetime.datetime.fromtimestamp(self.fields['activityDate'])\",\n \"def current_valid_date(self):\\r\\n return datetime.datetime.now().strftime('%Y-%m-%d')\",\n \"def date(self, date):\\n if self.local_vars_configuration.client_side_validation and date is None: # noqa: E501\\n raise ValueError(\\\"Invalid value for `date`, must not be `None`\\\") # noqa: E501\\n\\n self._date = date\",\n \"def register_date(self):\\n\\n return self._register_date\",\n \"def _get_datetime_or_error(self) -> dt:\\n return dt(\\n *(self.date[key] for key in ['year', 'month', 'day'] if key in self.date)\\n )\",\n \"def clean_birth_date(self):\\n\\n sent_date = self.cleaned_data['birth_date']\\n current_date = localtime(now()).date()\\n\\n if (sent_date - current_date) > datetime.timedelta(seconds=1):\\n raise ValidationError(INVALID_BIRTH_DATE_VALUE)\\n else:\\n return sent_date\",\n \"def from_date(self):\\n return self._from_date\",\n \"def get_python_date(self):\\n return dateutil.parser.parse(self.iso_date)\",\n \"def localized_date(self):\\r\\n date_ = self._post['effective_date']\\r\\n to_localized = self.context.toLocalizedTime\\r\\n \\r\\n try:\\r\\n local_date = to_localized(date_)\\r\\n except ValueError:\\r\\n # An invalid date; just return nothing\\r\\n local_date = None\\r\\n \\r\\n return local_date\",\n \"def get_date():\\n now = datetime.now()\\n date = now.strftime(\\\"%Y%m%d\\\")\\n return date\",\n \"def date(self):\\n try:\\n return str(self._info['meas_date'].date())\\n except Exception as exc:\\n return \\\"\\\"\",\n \"def founding_date(self) -> datetime:\\n return self._founding_date\",\n \"def forecast_date(self):\\n return self._forecast_date\",\n \"def invalidity_date_value(self):\\n\\n if self._processed_extensions is False:\\n self._set_extensions()\\n return self._invalidity_date_value\",\n \"def last_date(self):\\n if self._last_date is None:\\n raise ValueError(\\\"Run pick() method before access this property\\\")\\n return self._last_date\",\n \"def getActiveDate(self):\\n dateAsQDate = self.workCalendar.selectedDate()\\n dateString = str(dateAsQDate.toString('dd/MM/yyyy'))\\n dateAsDateTime = OINKM.getDate(dateString)\\n return dateAsDateTime\",\n \"def _get_date():\\n return datetime.datetime.now()\",\n \"def get_date():\\n dt = datetime.now()\\n return dt.strftime(\\\"%Y-%m-%d\\\")\",\n \"async def date(self) -> dt.date:\\n now = await self.AD.sched.get_now()\\n return now.astimezone(self.AD.tz).date()\",\n \"def get_date_DM(): \\n \\n now = date.datetime.now()\\n date_DM = str(now.day)+'_'+str(now.month)+'/' \\n return date_DM\",\n \"def process_datetime(a_date: datetime) -> str:\\n\\n return str(a_date.date()) if a_date else Presenter.DEFAULT\",\n \"def getValue(self):\\n return qDateTime2Datetime(self.field.dateTime())\",\n \"def computed_startdate(self):\\n return self.startdate\",\n \"def set_harvest_date(self, date):\\n if not date:\\n return datetime.utcnow().strftime(\\\"%Y/%m/%d\\\")\\n return datetime.strptime(date, \\\"%Y%m%d\\\").strftime(\\\"%Y/%m/%d\\\")\",\n \"def check_surrender_date(cursor, dog_id):\\n query = f\\\"select surrender_date from Dog where Dog.dogID = {dog_id};\\\"\\n cursor.execute(query)\\n query_result = cursor.fetchall()\\n return query_result[0][0]\",\n \"def to_python(self, value):\\n return string_to_partialdate(value)\",\n \"def to_stdlib(self) -> dt.date:\\n return dt.date.fromordinal(self.toordinal())\",\n \"def date(self) -> datetime.datetime:\\n return self._data['Date'] - datetime.timedelta(0, float(self.exposuretime), 0)\",\n \"def get_datecode():\\n now = datetime.utcnow()\\n return now.strftime(\\\"%Y%m%d\\\")\",\n \"def _earliest_allowed_date(cls):\\r\\n DAYS_GOOD_FOR = settings.VERIFY_STUDENT[\\\"DAYS_GOOD_FOR\\\"]\\r\\n allowed_date = (\\r\\n datetime.now(pytz.UTC) - timedelta(days=DAYS_GOOD_FOR)\\r\\n )\\r\\n return allowed_date\",\n \"def insure_date(d):\\n if isinstance(d, BeautifulDate):\\n return date(year=d.year, month=d.month, day=d.day)\\n else:\\n return d\",\n \"def date(self, date):\\n self.value = date.strftime(\\\"%Y-%m-%d\\\") if date else \\\"\\\"\",\n \"def max_drawdown_date(self) -> dt.date:\\n mdd_date = (self.tsdf / self.tsdf.expanding(min_periods=1).max()).idxmin().values[0].astype(dt.datetime)\\n return dt.datetime.fromtimestamp(mdd_date / 1e9).date()\",\n \"def date(self):\\n if self.raw_date_str == \\\"Unknown\\\":\\n return self.raw_date_str\\n else:\\n try:\\n _date = datetime.datetime.strptime(self.raw_date_str, \\\"%B %d, %Y\\\")\\n except ValueError:\\n try:\\n _date = datetime.datetime.strptime(self.raw_date_str, \\\"%B %Y\\\")\\n except ValueError:\\n logger.error(\\\"Unable to parse date: {}\\\".format(self.raw_date_str))\\n return None\\n return _date.date()\",\n \"def expiration_date(self) -> typing.Optional[datetime.datetime]:\\n return self._values.get('expiration_date')\",\n \"def last_accessed_date(self) -> Optional[str]:\\n return pulumi.get(self, \\\"last_accessed_date\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8094495","0.7589582","0.7246536","0.71703386","0.6186469","0.60771775","0.582364","0.582364","0.582364","0.582364","0.5744298","0.57036215","0.5643021","0.56060433","0.56060433","0.56060433","0.56038517","0.5568324","0.5548201","0.55249274","0.5518372","0.54434615","0.5431232","0.54199785","0.5418384","0.54181856","0.53818977","0.5370637","0.53272986","0.53208953","0.53059745","0.528795","0.52810574","0.5276516","0.5267519","0.5261299","0.52546674","0.52318496","0.5229188","0.521973","0.5217194","0.5210877","0.5201767","0.51876354","0.517363","0.5171738","0.5169208","0.5140594","0.511732","0.51045525","0.5079829","0.5060417","0.5058026","0.5015841","0.5013119","0.5009804","0.5009804","0.5009804","0.49990758","0.49970692","0.49886173","0.49782038","0.49685398","0.49605203","0.49570966","0.4954636","0.49145824","0.49097297","0.49051675","0.48955503","0.4895076","0.4893041","0.48910388","0.4881294","0.48798028","0.48775768","0.48767826","0.48625207","0.48471624","0.48392814","0.48364252","0.48329207","0.48152873","0.48106325","0.4809485","0.4801863","0.4801108","0.47904202","0.47827214","0.47821122","0.4766409","0.4753913","0.47534767","0.47516698","0.47504333","0.47489533","0.47466874","0.47397923","0.47340384","0.47339648"],"string":"[\n \"0.8094495\",\n \"0.7589582\",\n \"0.7246536\",\n \"0.71703386\",\n \"0.6186469\",\n \"0.60771775\",\n \"0.582364\",\n \"0.582364\",\n \"0.582364\",\n \"0.582364\",\n \"0.5744298\",\n \"0.57036215\",\n \"0.5643021\",\n \"0.56060433\",\n \"0.56060433\",\n \"0.56060433\",\n \"0.56038517\",\n \"0.5568324\",\n \"0.5548201\",\n \"0.55249274\",\n \"0.5518372\",\n \"0.54434615\",\n \"0.5431232\",\n \"0.54199785\",\n \"0.5418384\",\n \"0.54181856\",\n \"0.53818977\",\n \"0.5370637\",\n \"0.53272986\",\n \"0.53208953\",\n \"0.53059745\",\n \"0.528795\",\n \"0.52810574\",\n \"0.5276516\",\n \"0.5267519\",\n \"0.5261299\",\n \"0.52546674\",\n \"0.52318496\",\n \"0.5229188\",\n \"0.521973\",\n \"0.5217194\",\n \"0.5210877\",\n \"0.5201767\",\n \"0.51876354\",\n \"0.517363\",\n \"0.5171738\",\n \"0.5169208\",\n \"0.5140594\",\n \"0.511732\",\n \"0.51045525\",\n \"0.5079829\",\n \"0.5060417\",\n \"0.5058026\",\n \"0.5015841\",\n \"0.5013119\",\n \"0.5009804\",\n \"0.5009804\",\n \"0.5009804\",\n \"0.49990758\",\n \"0.49970692\",\n \"0.49886173\",\n \"0.49782038\",\n \"0.49685398\",\n \"0.49605203\",\n \"0.49570966\",\n \"0.4954636\",\n \"0.49145824\",\n \"0.49097297\",\n \"0.49051675\",\n \"0.48955503\",\n \"0.4895076\",\n \"0.4893041\",\n \"0.48910388\",\n \"0.4881294\",\n \"0.48798028\",\n \"0.48775768\",\n \"0.48767826\",\n \"0.48625207\",\n \"0.48471624\",\n \"0.48392814\",\n \"0.48364252\",\n \"0.48329207\",\n \"0.48152873\",\n \"0.48106325\",\n \"0.4809485\",\n \"0.4801863\",\n \"0.4801108\",\n \"0.47904202\",\n \"0.47827214\",\n \"0.47821122\",\n \"0.4766409\",\n \"0.4753913\",\n \"0.47534767\",\n \"0.47516698\",\n \"0.47504333\",\n \"0.47489533\",\n \"0.47466874\",\n \"0.47397923\",\n \"0.47340384\",\n \"0.47339648\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8428358"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84582,"cells":{"query":{"kind":"string","value":"Set consent for both legacy `patient_consent` and new `patient_consent_date`. If consent is given, set the `patient_consent_date` to the current datetime in UTC. (If the real date of consent is known, one should set `patient_consent_date` directly). If consent is revoked, set the `patient_consent_date` to None."},"document":{"kind":"string","value":"def patient_consent_date(self, value):\n self._patient_consent_date = value\n self._patient_consent = 1 if value else 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 patient_consent(self, value):\n self.patient_consent_date = utcnow() if value else None","def consent(self, consent):\n if consent is None:\n raise ValueError(\"Invalid value for `consent`, must not be `None`\") # noqa: E501\n\n self._consent = consent","def patient_consent(self):\n return 1 if self.patient_consent_date is not None else 0","def patient_consent_date(self):\n return self._patient_consent_date","def _read_patient_consent_date(self, d: dict):\n consent_date = d.get('patient_consent_date')\n consent_bool = d.get('patient_consent')\n if consent_date is not None:\n return self._str_to_datetime(consent_date)\n elif consent_bool:\n t0 = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\n creation_date = d.get('creation_date')\n return (self._str_to_datetime(creation_date)\n if creation_date is not None\n else t0)\n else:\n return None","def econsent(self, econsent):\n\n self._econsent = econsent","def patient_consent(self):\n return self.patient_consent_date != None # noqa: E711","def consent(self, account_id):\n from pureport_client.commands.accounts.consent import Command\n return Command(self.client, account_id)","def _updateViewStateSync(self, consent):\n params = {'consent': consent}\n self.query(self.VIEWSTATESYNC, method=self._session.put, params=params)","def test_update(self, requests_mock, accepts_marketing):\n matcher = requests_mock.post(\n f'{settings.CONSENT_SERVICE_BASE_URL}'\n f'{consent.CONSENT_SERVICE_PERSON_PATH}',\n json={\n 'consents': [\n CONSENT_SERVICE_EMAIL_CONSENT_TYPE,\n ],\n 'modified_at': '2020-03-12T15:33:50.907000Z',\n 'email': 'foo@bar.com',\n 'phone': '',\n 'key_type': 'email',\n },\n status_code=status.HTTP_201_CREATED,\n )\n result = consent.update_consent('foo@bar.com', accepts_marketing)\n assert result is None\n assert matcher.called_once","def consent(token):\n verification_token = _get_verification_token_or_404(token)\n\n user = verification_token.user\n\n unconsented_subjects = _get_unconsented_subjects_for_user(user.id)\n\n ConsentForm = create_consent_form(unconsented_subjects)\n form = ConsentForm(request.form)\n if not form.validate():\n return consent_form(token, erroneous_form=form)\n\n subject_ids_from_form = set(map(UUID, form.subject_ids.data.split(',')))\n\n try:\n consent_subject_service.get_subjects(subject_ids_from_form)\n except consent_subject_service.UnknownSubjectIdError:\n flash_error(gettext('Unknown consent subject'))\n return consent_form(token, erroneous_form=form)\n\n expressed_at = datetime.utcnow()\n consent_service.consent_to_subjects(\n user.id, subject_ids_from_form, expressed_at\n )\n verification_token_service.delete_token(verification_token.token)\n\n flash_success(gettext('Thank you for your consent. Please log in again.'))\n return redirect_to('authentication_login.log_in_form')","def add_sharing_consent(target_dict, sharing_consent_value):\r\n target_dict['sharing_consent'] = sharing_consent_value\r\n return target_dict","def _apply_decision(self, decision, responder):\n self.responder = responder\n self.status = decision\n self.decision_datetime = timezone.now()\n self.save()","def econsent_signature(self, econsent_signature):\n\n self._econsent_signature = econsent_signature","def _handle_consent_confirmation(user, is_confirmed):\n if is_confirmed == \"yes\":\n # user has already given consent, continue flow\n response = server.create_authorization_response(grant_user=user)\n else:\n # user did not give consent\n response = server.create_authorization_response(grant_user=None)\n return response","def set_adjustment_charge_begin_date(self, begin_date):\n self.set_value_into_input_field(self.adjustment_begin_date_locator, begin_date)","def PostUserConsent(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def test_consent_2(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-smartonfhir.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_2(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_2(inst2)","async def request_inform_consent(request, patient_pkey):\n client_key = general.get_request_key_header(request)\n client_signer = general.get_signer(request, client_key)\n grant_read_ehr_permission_txn = consent_transaction.request_inform_document_consent(\n txn_signer=client_signer,\n batch_signer=client_signer,\n patient_pkey=patient_pkey)\n\n batch, batch_id = ehr_transaction.make_batch_and_id([grant_read_ehr_permission_txn], client_signer)\n\n await security_messaging.request_inform_document_consent(\n request.app.config.VAL_CONN,\n request.app.config.TIMEOUT,\n [batch], client_key)\n\n try:\n await security_messaging.check_batch_status(\n request.app.config.VAL_CONN, [batch_id])\n except (ApiBadRequest, ApiInternalError) as err:\n # await auth_query.remove_auth_entry(\n # request.app.config.DB_CONN, request.json.get('email'))\n raise err\n\n return response.json(body={'status': general.DONE},\n headers=general.get_response_headers())","def set_audience(self, claim=AUDIENCE):\n if api_settings.AUDIENCE is not None:\n self.payload[claim] = api_settings.AUDIENCE","def date_answered(self, date_answered):\n self._date_answered = date_answered","def test_consent_1(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-notThis.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_1(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_1(inst2)","def test_consent_7(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-grantor.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_7(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_7(inst2)","def store_consent(session_obj, name, value):\n Cookie.objects.create(session=session_obj, name=name, value=value)","def date(self, date):\n if self.local_vars_configuration.client_side_validation and date is None: # noqa: E501\n raise ValueError(\"Invalid value for `date`, must not be `None`\") # noqa: E501\n\n self._date = date","def test_consent_3(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-CDA.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_3(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_3(inst2)","def balance_date(self, balance_date):\n\n self._balance_date = balance_date","def set_birthdate(self, date):\n\n if validate_date_format(self.birt):\n self.birt = date\n else:\n raise ValueError('Invalid date!')","def test_create_consent(client, session, tokens, input):\n response = client.post(\n \"/consent\",\n json=input,\n headers={\"Authorization\": f\"Bearer {tokens['write']}\"},\n )\n assert response.status_code == 201\n consent_id = response.json[\"id\"]\n assert Consent.query.filter(Consent.id == consent_id).count() == 1","def set_date(self, date):\n self.date = self.date_to_local(date)\n # ephem deals only in UTC\n self.site.date = ephem.Date(self.date_to_utc(self.date))","def set_adjustment_charge_end_date(self, end_date):\n self.set_value_into_input_field(self.end_date_locator, end_date)","def set_harvest_date(self, date):\n if not date:\n return datetime.utcnow().strftime(\"%Y/%m/%d\")\n return datetime.strptime(date, \"%Y%m%d\").strftime(\"%Y/%m/%d\")","def set_statement_begin_date(self, begin_date):\n begin_date_to_set = None\n if begin_date != \"\":\n begin_date_to_set = begin_date\n else:\n self.first_day_of_previous_month = self.get_date(first_day_of_last_month=True)\n begin_date_to_set = self.first_day_of_previous_month\n self.set_value_into_input_field(self.statement_begin_date_locator, begin_date_to_set)\n return begin_date_to_set","def setDate(self, p_int, p_int_1, p_int_2): # real signature unknown; restored from __doc__\r\n return False","def citation_date(self, citation_date):\n\n self._citation_date = citation_date","def test_consent_4(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-notAuthor.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_4(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_4(inst2)","def set_datetime(self, date):\n self.date = date","def set_account_created_date(self, account_created_date):\n self.account_created_date = account_created_date","def set_date(self, date):\n self.date = date\n return","def set_contest_date_time(contest, date_time, field):\n c = biv.load_obj(contest)\n assert type(c) == pem.E15Contest\n dt = _local_date_time_as_utc(c, date_time)\n assert hasattr(c, field), \\\n '{}: has no attr {}'.format(c, field)\n setattr(c, field, dt)\n _add_model(c)","def acquisition_date(self, acquisition_date):\n\n self._acquisition_date = acquisition_date","def authorization_date(self, authorization_date):\n\n self._authorization_date = authorization_date","def set_statement_issued_date(self, issued_date):\n if issued_date != \"\":\n issued_date_to_set = issued_date\n else:\n self.first_day_of_current_month = self.get_date(first_day_of_current_month=True)\n issued_date_to_set = self.first_day_of_current_month\n self.set_value_into_input_field(self.issued_date_locator, issued_date_to_set)","def set_date(self, date):\n self.date = date","def test_consent_10(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_10(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_10(inst2)","def irb_approval_date(self, irb_approval_date):\n\n self._irb_approval_date = irb_approval_date","def set_birthday(self, year, month, day):\n self.birthday = datetime.date(year, month, day)","def setDateTime(self, datetime):\n\n year = datetime[0]\n day = datetime[1]\n month = datetime[2]\n hour = datetime[3]\n min = datetime[4]\n sec = datetime[5]\n\n # command to restore SELinux configurations\n cmd = \"date -s '%s/%s/%s %s:%s:%s' > /dev/null\" % (day, month,\n year, hour, min, sec)\n # SELinux restoration failed: error\n if subprocess.call(cmd, shell=True) != 0:\n self.__logger.critical(\"Error to set datetime using date\")\n raise RuntimeError('Error to set datetime using date')","def set_access_date(self, access_date):\n\t\t\n\t\tif (access_date.__class__ != str or access_date ==\"\") and (access_date.__class__ != time.struct_time or len(access_date) != 9 ):\n\t\t\traise InvalidParameterError(\"access_date\", \"access_date is not in a proper format\")\n\t\ttry:\n\t\t\tif access_date.__class__ == str:\n\t\t\t\ttmp_ad = time.strptime(access_date, '%S %M %H %d %m %Y')\n\t\t\telif access_date.__class__ == time.struct_time:\n\t\t\t\ttmp_ad = access_date\n\t\t\tself.__access_date = datetime(tmp_ad[0], tmp_ad[1], tmp_ad[2], tmp_ad[3], tmp_ad[4], tmp_ad[5])\n\t\texcept:\n\t\t\traise InvalidDate, \"date is not valid access_date is not in a proper format\"","def _set_dac(self, channel, mvoltage):\n proceed = True\n\n if self.check_setpoints():\n cur_val = self.get('dac{}'.format(channel))\n # dac range in mV / 16 bits FIXME make range depend on polarity\n byte_res = self.full_range / 2**16\n # eps is a magic number to correct for an offset in the values\n # the IVVI returns (i.e. setting 0 returns byte_res/2 = 0.030518\n # with rounding\n eps = 0.0001\n\n proceed = False\n\n if (mvoltage > (cur_val + byte_res / 2 + eps) or\n mvoltage < (cur_val - byte_res / 2 - eps)):\n proceed = True\n\n if self.dac_set_sleep() > 0.0:\n time.sleep(self.dac_set_sleep())\n\n # only update the value if it is different from the previous one\n # this saves time in setting values, set cmd takes ~650ms\n if proceed:\n polarity_corrected = mvoltage - self.pol_num[channel - 1]\n byte_val = self._mvoltage_to_bytes(polarity_corrected)\n message = bytes([2, 1, channel]) + byte_val\n\n reply = self.ask(message)\n self._time_last_update = 0 # ensures get command will update\n\n return reply","def test_consent_5(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-notTime.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_5(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_5(inst2)","def set_charge_begin_date(self, charge_begin_date, first_day_of_last_month):\n self.current_charge_begin_date = charge_begin_date\n if first_day_of_last_month is True:\n if charge_begin_date == \"\":\n self.first_day_of_previous_month = self.get_date(first_day_of_last_month=True)\n charge_begin_date = self.first_day_of_previous_month\n else:\n if charge_begin_date == \"\":\n charge_begin_date = self.get_date(current_date=True)\n self.current_charge_begin_date = datetime.datetime.strptime(charge_begin_date, \"%m/%d/%Y\")\n self.set_value_in_grid_column(self.charges_grid_div_id, self.charge_begin_date_column_name, charge_begin_date, True)\n page_header_element = self.wait().until(EC.element_to_be_clickable(self.page_header_locator), 'page header locator not found before specified time out')\n page_header_element.click()","def date(self, new_date):\n self._date.date = new_date","def prefect_mandate(self, prefect_mandate):\n\n self._prefect_mandate = prefect_mandate","def setClientClockDrift(self, drift):\n self.clientClockDrift = drift","def test_consent_8(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-notOrg.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_8(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_8(inst2)","def sign_date(self, sign_date):\n\n self._sign_date = sign_date","def setBirthday(self, birthdate):\r\n self.birthday = birthdate","def observation_date(self, observation_date):\n\n self._observation_date = observation_date","def announcement_date(self, announcement_date):\n\n self._announcement_date = announcement_date","def setBirthday(self, birthdate):\n self.birthday = birthdate","def election_date(self, election_date):\n\n self._election_date = election_date","def screening_e_consent_flag(self, screening_e_consent_flag):\n\n self._screening_e_consent_flag = screening_e_consent_flag","def collect_interview_date(self, collect_interview_date):\n\n self._collect_interview_date = collect_interview_date","def _date(self, _date):\n\n self.__date = _date","def _date(self, _date):\n\n self.__date = _date","def test_consent_6(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-notThem.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_6(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_6(inst2)","def set_end_date(self, date):\n pass","def accepting_referral_patients(self, accepting_referral_patients):\n\n self._accepting_referral_patients = accepting_referral_patients","def license_date(self, license_date):\n\n self._license_date = license_date","def save(self, *args, **kwargs):\n self.expire_date = self.sent_date + timedelta(days=self.period)\n super(Referral, self).save(*args, **kwargs)","def set_idate(self, idate):\n self.__idate = idate","def mod_date(self, mod_date):\n\n self._mod_date = mod_date","def set_date(self, date):\n self.data['date'] = date","def set_document_date(self, date):\n self.set_value_into_input_field(self.document_date_text_field_locator, date)","def _set_date(line, dirtydate, date):\n line = re.sub(dirtydate, date, line, 2)\n return line","def decommission_date(self, decommission_date):\n\n self._decommission_date = decommission_date","def test_consent_9(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-pkb.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_9(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_9(inst2)","def set_issued(self, dt):\n self.issued = dt_to_iso(dt)","def accepting_change_of_payor_patients(self, accepting_change_of_payor_patients):\n\n self._accepting_change_of_payor_patients = accepting_change_of_payor_patients","def setBirthday(self, month, day, year):\n self.birthday = datetime.date(year, month, day)","def set_customer_treatment_override_v1(self, skill_id, experiment_id, set_customer_treatment_override_request, **kwargs):\n # type: (str, str, SetCustomerTreatmentOverrideRequest_94022e79, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]\n operation_name = \"set_customer_treatment_override_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']):\n params[key] = val\n del params['kwargs']\n # verify the required parameter 'skill_id' is set\n if ('skill_id' not in params) or (params['skill_id'] is None):\n raise ValueError(\n \"Missing the required parameter `skill_id` when calling `\" + operation_name + \"`\")\n # verify the required parameter 'experiment_id' is set\n if ('experiment_id' not in params) or (params['experiment_id'] is None):\n raise ValueError(\n \"Missing the required parameter `experiment_id` when calling `\" + operation_name + \"`\")\n # verify the required parameter 'set_customer_treatment_override_request' is set\n if ('set_customer_treatment_override_request' not in params) or (params['set_customer_treatment_override_request'] is None):\n raise ValueError(\n \"Missing the required parameter `set_customer_treatment_override_request` when calling `\" + operation_name + \"`\")\n\n resource_path = '/v1/skills/{skillId}/experiments/{experimentId}/treatmentOverrides/~current'\n resource_path = resource_path.replace('{format}', 'json')\n\n path_params = {} # type: Dict\n if 'skill_id' in params:\n path_params['skillId'] = params['skill_id']\n if 'experiment_id' in params:\n path_params['experimentId'] = params['experiment_id']\n\n query_params = [] # type: List\n\n header_params = [] # type: List\n\n body_params = None\n if 'set_customer_treatment_override_request' in params:\n body_params = params['set_customer_treatment_override_request']\n header_params.append(('Content-type', 'application/json'))\n header_params.append(('User-Agent', self.user_agent))\n\n # Response Type\n full_response = False\n if 'full_response' in params:\n full_response = params['full_response']\n\n # Authentication setting\n access_token = self._lwa_service_client.get_access_token_from_refresh_token()\n authorization_value = \"Bearer \" + access_token\n header_params.append(('Authorization', authorization_value))\n\n error_definitions = [] # type: List\n error_definitions.append(ServiceClientResponse(response_type=None, status_code=204, message=\"Success. No content.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.bad_request_error.BadRequestError\", status_code=400, message=\"Server cannot process the request due to a client error.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\", status_code=401, message=\"The auth token is invalid/expired or doesn't have access to the resource.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.bad_request_error.BadRequestError\", status_code=403, message=\"The operation being requested is not allowed.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\", status_code=404, message=\"The resource being requested is not found.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\", status_code=409, message=\"The request could not be completed due to a conflict with the current state of the target resource.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\", status_code=429, message=\"Exceeds the permitted request limit. Throttling criteria includes total requests, per API, ClientId, and CustomerId.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\", status_code=500, message=\"Internal Server Error.\"))\n error_definitions.append(ServiceClientResponse(response_type=\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\", status_code=503, message=\"Service Unavailable.\"))\n\n api_response = self.invoke(\n method=\"PUT\",\n endpoint=self._api_endpoint,\n path=resource_path,\n path_params=path_params,\n query_params=query_params,\n header_params=header_params,\n body=body_params,\n response_definitions=error_definitions,\n response_type=None)\n\n if full_response:\n return api_response\n \n return None","def on_or_before(self, date):\n return (date - mod(date - self.CORRELATION - self.to_ordinal(), 365))","async def store_claim(self, claim_json: str) -> None: # prover\n await anoncreds.prover_store_claim(self.wallet_handle, claim_json)","def date(self, date):\n self._date = date","def form_valid(self, form):\n redirect_url = self.accept_consent_request(None)\n return HttpResponseRedirect(redirect_url)","def setBirthday(self,month,day,year):\n self.birthday = datetime.date(year,month,day)","def setBirthday(self,month,day,year):\n self.birthday = datetime.date(year,month,day)","def test_confirm_add_flow_request_confirmed_consent(self):\n self.client.login(username='duck', password='duck')\n # Gets the confirmation code installed with the test data\n c = ConsentConfirmation.objects.get(confirmation_id=CORRECT_CONFIRM_ID)\n res = self.client.get(\n '/v1/flow_requests/consents_confirmed/?success=true&consent_confirm_id={}'.format(CORRECT_CONFIRM_ID))\n\n redirect_url = '{}?process_id={}&success=true'.format(c.destination_endpoint_callback_url,\n c.flow_request.process_id)\n self.assertRedirects(res, redirect_url, fetch_redirect_response=False)\n flow_request = c.flow_request\n self.assertEqual(flow_request.status, FlowRequest.ACTIVE)\n channel = ConsentConfirmation.objects.get(confirmation_id=CORRECT_CONFIRM_ID).channel\n # It remain CR until the consent notification consumer gets the change\n self.assertEqual(channel.status, Channel.CONSENT_REQUESTED)","def completion_date(self, completion_date):\n\n self._completion_date = completion_date","def alternative_inception_date(self, alternative_inception_date):\n\n self._alternative_inception_date = alternative_inception_date","def set_date(self, date_string, date_type):\n if date_type == \"married\":\n self._married_date = datetime.strptime(date_string, '%d %b %Y')\n if date_type == \"divorced\":\n self._divorced_date = datetime.strptime(date_string, '%d %b %Y')","def date(self, date):\n\n self._date = date","def date(self, date):\n\n self._date = date","def date(self, date):\n\n self._date = date","def date(self, date):\n\n self._date = date","def date(self, date):\n\n self._date = date","def test_create_consent_fail_on_incorrect_status(client, session, tokens):\n data = {\n \"type\": \"cookie\",\n \"category\": \"strictly_necessary\",\n \"status\": \"akcepted\",\n }\n response = client.post(\n \"/consent\",\n json=data,\n headers={\"Authorization\": f\"Bearer {tokens['write']}\"},\n )\n assert response.status_code == 422","def survey_response_id(self, survey_response_id):\n\n self._survey_response_id = survey_response_id","def counterparty(self, counterparty):\n\n self._counterparty = counterparty"],"string":"[\n \"def patient_consent(self, value):\\n self.patient_consent_date = utcnow() if value else None\",\n \"def consent(self, consent):\\n if consent is None:\\n raise ValueError(\\\"Invalid value for `consent`, must not be `None`\\\") # noqa: E501\\n\\n self._consent = consent\",\n \"def patient_consent(self):\\n return 1 if self.patient_consent_date is not None else 0\",\n \"def patient_consent_date(self):\\n return self._patient_consent_date\",\n \"def _read_patient_consent_date(self, d: dict):\\n consent_date = d.get('patient_consent_date')\\n consent_bool = d.get('patient_consent')\\n if consent_date is not None:\\n return self._str_to_datetime(consent_date)\\n elif consent_bool:\\n t0 = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\\n creation_date = d.get('creation_date')\\n return (self._str_to_datetime(creation_date)\\n if creation_date is not None\\n else t0)\\n else:\\n return None\",\n \"def econsent(self, econsent):\\n\\n self._econsent = econsent\",\n \"def patient_consent(self):\\n return self.patient_consent_date != None # noqa: E711\",\n \"def consent(self, account_id):\\n from pureport_client.commands.accounts.consent import Command\\n return Command(self.client, account_id)\",\n \"def _updateViewStateSync(self, consent):\\n params = {'consent': consent}\\n self.query(self.VIEWSTATESYNC, method=self._session.put, params=params)\",\n \"def test_update(self, requests_mock, accepts_marketing):\\n matcher = requests_mock.post(\\n f'{settings.CONSENT_SERVICE_BASE_URL}'\\n f'{consent.CONSENT_SERVICE_PERSON_PATH}',\\n json={\\n 'consents': [\\n CONSENT_SERVICE_EMAIL_CONSENT_TYPE,\\n ],\\n 'modified_at': '2020-03-12T15:33:50.907000Z',\\n 'email': 'foo@bar.com',\\n 'phone': '',\\n 'key_type': 'email',\\n },\\n status_code=status.HTTP_201_CREATED,\\n )\\n result = consent.update_consent('foo@bar.com', accepts_marketing)\\n assert result is None\\n assert matcher.called_once\",\n \"def consent(token):\\n verification_token = _get_verification_token_or_404(token)\\n\\n user = verification_token.user\\n\\n unconsented_subjects = _get_unconsented_subjects_for_user(user.id)\\n\\n ConsentForm = create_consent_form(unconsented_subjects)\\n form = ConsentForm(request.form)\\n if not form.validate():\\n return consent_form(token, erroneous_form=form)\\n\\n subject_ids_from_form = set(map(UUID, form.subject_ids.data.split(',')))\\n\\n try:\\n consent_subject_service.get_subjects(subject_ids_from_form)\\n except consent_subject_service.UnknownSubjectIdError:\\n flash_error(gettext('Unknown consent subject'))\\n return consent_form(token, erroneous_form=form)\\n\\n expressed_at = datetime.utcnow()\\n consent_service.consent_to_subjects(\\n user.id, subject_ids_from_form, expressed_at\\n )\\n verification_token_service.delete_token(verification_token.token)\\n\\n flash_success(gettext('Thank you for your consent. Please log in again.'))\\n return redirect_to('authentication_login.log_in_form')\",\n \"def add_sharing_consent(target_dict, sharing_consent_value):\\r\\n target_dict['sharing_consent'] = sharing_consent_value\\r\\n return target_dict\",\n \"def _apply_decision(self, decision, responder):\\n self.responder = responder\\n self.status = decision\\n self.decision_datetime = timezone.now()\\n self.save()\",\n \"def econsent_signature(self, econsent_signature):\\n\\n self._econsent_signature = econsent_signature\",\n \"def _handle_consent_confirmation(user, is_confirmed):\\n if is_confirmed == \\\"yes\\\":\\n # user has already given consent, continue flow\\n response = server.create_authorization_response(grant_user=user)\\n else:\\n # user did not give consent\\n response = server.create_authorization_response(grant_user=None)\\n return response\",\n \"def set_adjustment_charge_begin_date(self, begin_date):\\n self.set_value_into_input_field(self.adjustment_begin_date_locator, begin_date)\",\n \"def PostUserConsent(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def test_consent_2(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-smartonfhir.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_2(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_2(inst2)\",\n \"async def request_inform_consent(request, patient_pkey):\\n client_key = general.get_request_key_header(request)\\n client_signer = general.get_signer(request, client_key)\\n grant_read_ehr_permission_txn = consent_transaction.request_inform_document_consent(\\n txn_signer=client_signer,\\n batch_signer=client_signer,\\n patient_pkey=patient_pkey)\\n\\n batch, batch_id = ehr_transaction.make_batch_and_id([grant_read_ehr_permission_txn], client_signer)\\n\\n await security_messaging.request_inform_document_consent(\\n request.app.config.VAL_CONN,\\n request.app.config.TIMEOUT,\\n [batch], client_key)\\n\\n try:\\n await security_messaging.check_batch_status(\\n request.app.config.VAL_CONN, [batch_id])\\n except (ApiBadRequest, ApiInternalError) as err:\\n # await auth_query.remove_auth_entry(\\n # request.app.config.DB_CONN, request.json.get('email'))\\n raise err\\n\\n return response.json(body={'status': general.DONE},\\n headers=general.get_response_headers())\",\n \"def set_audience(self, claim=AUDIENCE):\\n if api_settings.AUDIENCE is not None:\\n self.payload[claim] = api_settings.AUDIENCE\",\n \"def date_answered(self, date_answered):\\n self._date_answered = date_answered\",\n \"def test_consent_1(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-notThis.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_1(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_1(inst2)\",\n \"def test_consent_7(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-grantor.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_7(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_7(inst2)\",\n \"def store_consent(session_obj, name, value):\\n Cookie.objects.create(session=session_obj, name=name, value=value)\",\n \"def date(self, date):\\n if self.local_vars_configuration.client_side_validation and date is None: # noqa: E501\\n raise ValueError(\\\"Invalid value for `date`, must not be `None`\\\") # noqa: E501\\n\\n self._date = date\",\n \"def test_consent_3(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-CDA.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_3(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_3(inst2)\",\n \"def balance_date(self, balance_date):\\n\\n self._balance_date = balance_date\",\n \"def set_birthdate(self, date):\\n\\n if validate_date_format(self.birt):\\n self.birt = date\\n else:\\n raise ValueError('Invalid date!')\",\n \"def test_create_consent(client, session, tokens, input):\\n response = client.post(\\n \\\"/consent\\\",\\n json=input,\\n headers={\\\"Authorization\\\": f\\\"Bearer {tokens['write']}\\\"},\\n )\\n assert response.status_code == 201\\n consent_id = response.json[\\\"id\\\"]\\n assert Consent.query.filter(Consent.id == consent_id).count() == 1\",\n \"def set_date(self, date):\\n self.date = self.date_to_local(date)\\n # ephem deals only in UTC\\n self.site.date = ephem.Date(self.date_to_utc(self.date))\",\n \"def set_adjustment_charge_end_date(self, end_date):\\n self.set_value_into_input_field(self.end_date_locator, end_date)\",\n \"def set_harvest_date(self, date):\\n if not date:\\n return datetime.utcnow().strftime(\\\"%Y/%m/%d\\\")\\n return datetime.strptime(date, \\\"%Y%m%d\\\").strftime(\\\"%Y/%m/%d\\\")\",\n \"def set_statement_begin_date(self, begin_date):\\n begin_date_to_set = None\\n if begin_date != \\\"\\\":\\n begin_date_to_set = begin_date\\n else:\\n self.first_day_of_previous_month = self.get_date(first_day_of_last_month=True)\\n begin_date_to_set = self.first_day_of_previous_month\\n self.set_value_into_input_field(self.statement_begin_date_locator, begin_date_to_set)\\n return begin_date_to_set\",\n \"def setDate(self, p_int, p_int_1, p_int_2): # real signature unknown; restored from __doc__\\r\\n return False\",\n \"def citation_date(self, citation_date):\\n\\n self._citation_date = citation_date\",\n \"def test_consent_4(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-notAuthor.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_4(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_4(inst2)\",\n \"def set_datetime(self, date):\\n self.date = date\",\n \"def set_account_created_date(self, account_created_date):\\n self.account_created_date = account_created_date\",\n \"def set_date(self, date):\\n self.date = date\\n return\",\n \"def set_contest_date_time(contest, date_time, field):\\n c = biv.load_obj(contest)\\n assert type(c) == pem.E15Contest\\n dt = _local_date_time_as_utc(c, date_time)\\n assert hasattr(c, field), \\\\\\n '{}: has no attr {}'.format(c, field)\\n setattr(c, field, dt)\\n _add_model(c)\",\n \"def acquisition_date(self, acquisition_date):\\n\\n self._acquisition_date = acquisition_date\",\n \"def authorization_date(self, authorization_date):\\n\\n self._authorization_date = authorization_date\",\n \"def set_statement_issued_date(self, issued_date):\\n if issued_date != \\\"\\\":\\n issued_date_to_set = issued_date\\n else:\\n self.first_day_of_current_month = self.get_date(first_day_of_current_month=True)\\n issued_date_to_set = self.first_day_of_current_month\\n self.set_value_into_input_field(self.issued_date_locator, issued_date_to_set)\",\n \"def set_date(self, date):\\n self.date = date\",\n \"def test_consent_10(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_10(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_10(inst2)\",\n \"def irb_approval_date(self, irb_approval_date):\\n\\n self._irb_approval_date = irb_approval_date\",\n \"def set_birthday(self, year, month, day):\\n self.birthday = datetime.date(year, month, day)\",\n \"def setDateTime(self, datetime):\\n\\n year = datetime[0]\\n day = datetime[1]\\n month = datetime[2]\\n hour = datetime[3]\\n min = datetime[4]\\n sec = datetime[5]\\n\\n # command to restore SELinux configurations\\n cmd = \\\"date -s '%s/%s/%s %s:%s:%s' > /dev/null\\\" % (day, month,\\n year, hour, min, sec)\\n # SELinux restoration failed: error\\n if subprocess.call(cmd, shell=True) != 0:\\n self.__logger.critical(\\\"Error to set datetime using date\\\")\\n raise RuntimeError('Error to set datetime using date')\",\n \"def set_access_date(self, access_date):\\n\\t\\t\\n\\t\\tif (access_date.__class__ != str or access_date ==\\\"\\\") and (access_date.__class__ != time.struct_time or len(access_date) != 9 ):\\n\\t\\t\\traise InvalidParameterError(\\\"access_date\\\", \\\"access_date is not in a proper format\\\")\\n\\t\\ttry:\\n\\t\\t\\tif access_date.__class__ == str:\\n\\t\\t\\t\\ttmp_ad = time.strptime(access_date, '%S %M %H %d %m %Y')\\n\\t\\t\\telif access_date.__class__ == time.struct_time:\\n\\t\\t\\t\\ttmp_ad = access_date\\n\\t\\t\\tself.__access_date = datetime(tmp_ad[0], tmp_ad[1], tmp_ad[2], tmp_ad[3], tmp_ad[4], tmp_ad[5])\\n\\t\\texcept:\\n\\t\\t\\traise InvalidDate, \\\"date is not valid access_date is not in a proper format\\\"\",\n \"def _set_dac(self, channel, mvoltage):\\n proceed = True\\n\\n if self.check_setpoints():\\n cur_val = self.get('dac{}'.format(channel))\\n # dac range in mV / 16 bits FIXME make range depend on polarity\\n byte_res = self.full_range / 2**16\\n # eps is a magic number to correct for an offset in the values\\n # the IVVI returns (i.e. setting 0 returns byte_res/2 = 0.030518\\n # with rounding\\n eps = 0.0001\\n\\n proceed = False\\n\\n if (mvoltage > (cur_val + byte_res / 2 + eps) or\\n mvoltage < (cur_val - byte_res / 2 - eps)):\\n proceed = True\\n\\n if self.dac_set_sleep() > 0.0:\\n time.sleep(self.dac_set_sleep())\\n\\n # only update the value if it is different from the previous one\\n # this saves time in setting values, set cmd takes ~650ms\\n if proceed:\\n polarity_corrected = mvoltage - self.pol_num[channel - 1]\\n byte_val = self._mvoltage_to_bytes(polarity_corrected)\\n message = bytes([2, 1, channel]) + byte_val\\n\\n reply = self.ask(message)\\n self._time_last_update = 0 # ensures get command will update\\n\\n return reply\",\n \"def test_consent_5(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-notTime.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_5(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_5(inst2)\",\n \"def set_charge_begin_date(self, charge_begin_date, first_day_of_last_month):\\n self.current_charge_begin_date = charge_begin_date\\n if first_day_of_last_month is True:\\n if charge_begin_date == \\\"\\\":\\n self.first_day_of_previous_month = self.get_date(first_day_of_last_month=True)\\n charge_begin_date = self.first_day_of_previous_month\\n else:\\n if charge_begin_date == \\\"\\\":\\n charge_begin_date = self.get_date(current_date=True)\\n self.current_charge_begin_date = datetime.datetime.strptime(charge_begin_date, \\\"%m/%d/%Y\\\")\\n self.set_value_in_grid_column(self.charges_grid_div_id, self.charge_begin_date_column_name, charge_begin_date, True)\\n page_header_element = self.wait().until(EC.element_to_be_clickable(self.page_header_locator), 'page header locator not found before specified time out')\\n page_header_element.click()\",\n \"def date(self, new_date):\\n self._date.date = new_date\",\n \"def prefect_mandate(self, prefect_mandate):\\n\\n self._prefect_mandate = prefect_mandate\",\n \"def setClientClockDrift(self, drift):\\n self.clientClockDrift = drift\",\n \"def test_consent_8(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-notOrg.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_8(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_8(inst2)\",\n \"def sign_date(self, sign_date):\\n\\n self._sign_date = sign_date\",\n \"def setBirthday(self, birthdate):\\r\\n self.birthday = birthdate\",\n \"def observation_date(self, observation_date):\\n\\n self._observation_date = observation_date\",\n \"def announcement_date(self, announcement_date):\\n\\n self._announcement_date = announcement_date\",\n \"def setBirthday(self, birthdate):\\n self.birthday = birthdate\",\n \"def election_date(self, election_date):\\n\\n self._election_date = election_date\",\n \"def screening_e_consent_flag(self, screening_e_consent_flag):\\n\\n self._screening_e_consent_flag = screening_e_consent_flag\",\n \"def collect_interview_date(self, collect_interview_date):\\n\\n self._collect_interview_date = collect_interview_date\",\n \"def _date(self, _date):\\n\\n self.__date = _date\",\n \"def _date(self, _date):\\n\\n self.__date = _date\",\n \"def test_consent_6(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-notThem.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_6(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_6(inst2)\",\n \"def set_end_date(self, date):\\n pass\",\n \"def accepting_referral_patients(self, accepting_referral_patients):\\n\\n self._accepting_referral_patients = accepting_referral_patients\",\n \"def license_date(self, license_date):\\n\\n self._license_date = license_date\",\n \"def save(self, *args, **kwargs):\\n self.expire_date = self.sent_date + timedelta(days=self.period)\\n super(Referral, self).save(*args, **kwargs)\",\n \"def set_idate(self, idate):\\n self.__idate = idate\",\n \"def mod_date(self, mod_date):\\n\\n self._mod_date = mod_date\",\n \"def set_date(self, date):\\n self.data['date'] = date\",\n \"def set_document_date(self, date):\\n self.set_value_into_input_field(self.document_date_text_field_locator, date)\",\n \"def _set_date(line, dirtydate, date):\\n line = re.sub(dirtydate, date, line, 2)\\n return line\",\n \"def decommission_date(self, decommission_date):\\n\\n self._decommission_date = decommission_date\",\n \"def test_consent_9(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-pkb.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_9(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_9(inst2)\",\n \"def set_issued(self, dt):\\n self.issued = dt_to_iso(dt)\",\n \"def accepting_change_of_payor_patients(self, accepting_change_of_payor_patients):\\n\\n self._accepting_change_of_payor_patients = accepting_change_of_payor_patients\",\n \"def setBirthday(self, month, day, year):\\n self.birthday = datetime.date(year, month, day)\",\n \"def set_customer_treatment_override_v1(self, skill_id, experiment_id, set_customer_treatment_override_request, **kwargs):\\n # type: (str, str, SetCustomerTreatmentOverrideRequest_94022e79, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]\\n operation_name = \\\"set_customer_treatment_override_v1\\\"\\n params = locals()\\n for key, val in six.iteritems(params['kwargs']):\\n params[key] = val\\n del params['kwargs']\\n # verify the required parameter 'skill_id' is set\\n if ('skill_id' not in params) or (params['skill_id'] is None):\\n raise ValueError(\\n \\\"Missing the required parameter `skill_id` when calling `\\\" + operation_name + \\\"`\\\")\\n # verify the required parameter 'experiment_id' is set\\n if ('experiment_id' not in params) or (params['experiment_id'] is None):\\n raise ValueError(\\n \\\"Missing the required parameter `experiment_id` when calling `\\\" + operation_name + \\\"`\\\")\\n # verify the required parameter 'set_customer_treatment_override_request' is set\\n if ('set_customer_treatment_override_request' not in params) or (params['set_customer_treatment_override_request'] is None):\\n raise ValueError(\\n \\\"Missing the required parameter `set_customer_treatment_override_request` when calling `\\\" + operation_name + \\\"`\\\")\\n\\n resource_path = '/v1/skills/{skillId}/experiments/{experimentId}/treatmentOverrides/~current'\\n resource_path = resource_path.replace('{format}', 'json')\\n\\n path_params = {} # type: Dict\\n if 'skill_id' in params:\\n path_params['skillId'] = params['skill_id']\\n if 'experiment_id' in params:\\n path_params['experimentId'] = params['experiment_id']\\n\\n query_params = [] # type: List\\n\\n header_params = [] # type: List\\n\\n body_params = None\\n if 'set_customer_treatment_override_request' in params:\\n body_params = params['set_customer_treatment_override_request']\\n header_params.append(('Content-type', 'application/json'))\\n header_params.append(('User-Agent', self.user_agent))\\n\\n # Response Type\\n full_response = False\\n if 'full_response' in params:\\n full_response = params['full_response']\\n\\n # Authentication setting\\n access_token = self._lwa_service_client.get_access_token_from_refresh_token()\\n authorization_value = \\\"Bearer \\\" + access_token\\n header_params.append(('Authorization', authorization_value))\\n\\n error_definitions = [] # type: List\\n error_definitions.append(ServiceClientResponse(response_type=None, status_code=204, message=\\\"Success. No content.\\\"))\\n error_definitions.append(ServiceClientResponse(response_type=\\\"ask_smapi_model.v1.bad_request_error.BadRequestError\\\", status_code=400, message=\\\"Server cannot process the request due to a client error.\\\"))\\n error_definitions.append(ServiceClientResponse(response_type=\\\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\\\", status_code=401, message=\\\"The auth token is invalid/expired or doesn't have access to the resource.\\\"))\\n error_definitions.append(ServiceClientResponse(response_type=\\\"ask_smapi_model.v1.bad_request_error.BadRequestError\\\", status_code=403, message=\\\"The operation being requested is not allowed.\\\"))\\n error_definitions.append(ServiceClientResponse(response_type=\\\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\\\", status_code=404, message=\\\"The resource being requested is not found.\\\"))\\n error_definitions.append(ServiceClientResponse(response_type=\\\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\\\", status_code=409, message=\\\"The request could not be completed due to a conflict with the current state of the target resource.\\\"))\\n error_definitions.append(ServiceClientResponse(response_type=\\\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\\\", status_code=429, message=\\\"Exceeds the permitted request limit. Throttling criteria includes total requests, per API, ClientId, and CustomerId.\\\"))\\n error_definitions.append(ServiceClientResponse(response_type=\\\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\\\", status_code=500, message=\\\"Internal Server Error.\\\"))\\n error_definitions.append(ServiceClientResponse(response_type=\\\"ask_smapi_model.v1.skill.standardized_error.StandardizedError\\\", status_code=503, message=\\\"Service Unavailable.\\\"))\\n\\n api_response = self.invoke(\\n method=\\\"PUT\\\",\\n endpoint=self._api_endpoint,\\n path=resource_path,\\n path_params=path_params,\\n query_params=query_params,\\n header_params=header_params,\\n body=body_params,\\n response_definitions=error_definitions,\\n response_type=None)\\n\\n if full_response:\\n return api_response\\n \\n return None\",\n \"def on_or_before(self, date):\\n return (date - mod(date - self.CORRELATION - self.to_ordinal(), 365))\",\n \"async def store_claim(self, claim_json: str) -> None: # prover\\n await anoncreds.prover_store_claim(self.wallet_handle, claim_json)\",\n \"def date(self, date):\\n self._date = date\",\n \"def form_valid(self, form):\\n redirect_url = self.accept_consent_request(None)\\n return HttpResponseRedirect(redirect_url)\",\n \"def setBirthday(self,month,day,year):\\n self.birthday = datetime.date(year,month,day)\",\n \"def setBirthday(self,month,day,year):\\n self.birthday = datetime.date(year,month,day)\",\n \"def test_confirm_add_flow_request_confirmed_consent(self):\\n self.client.login(username='duck', password='duck')\\n # Gets the confirmation code installed with the test data\\n c = ConsentConfirmation.objects.get(confirmation_id=CORRECT_CONFIRM_ID)\\n res = self.client.get(\\n '/v1/flow_requests/consents_confirmed/?success=true&consent_confirm_id={}'.format(CORRECT_CONFIRM_ID))\\n\\n redirect_url = '{}?process_id={}&success=true'.format(c.destination_endpoint_callback_url,\\n c.flow_request.process_id)\\n self.assertRedirects(res, redirect_url, fetch_redirect_response=False)\\n flow_request = c.flow_request\\n self.assertEqual(flow_request.status, FlowRequest.ACTIVE)\\n channel = ConsentConfirmation.objects.get(confirmation_id=CORRECT_CONFIRM_ID).channel\\n # It remain CR until the consent notification consumer gets the change\\n self.assertEqual(channel.status, Channel.CONSENT_REQUESTED)\",\n \"def completion_date(self, completion_date):\\n\\n self._completion_date = completion_date\",\n \"def alternative_inception_date(self, alternative_inception_date):\\n\\n self._alternative_inception_date = alternative_inception_date\",\n \"def set_date(self, date_string, date_type):\\n if date_type == \\\"married\\\":\\n self._married_date = datetime.strptime(date_string, '%d %b %Y')\\n if date_type == \\\"divorced\\\":\\n self._divorced_date = datetime.strptime(date_string, '%d %b %Y')\",\n \"def date(self, date):\\n\\n self._date = date\",\n \"def date(self, date):\\n\\n self._date = date\",\n \"def date(self, date):\\n\\n self._date = date\",\n \"def date(self, date):\\n\\n self._date = date\",\n \"def date(self, date):\\n\\n self._date = date\",\n \"def test_create_consent_fail_on_incorrect_status(client, session, tokens):\\n data = {\\n \\\"type\\\": \\\"cookie\\\",\\n \\\"category\\\": \\\"strictly_necessary\\\",\\n \\\"status\\\": \\\"akcepted\\\",\\n }\\n response = client.post(\\n \\\"/consent\\\",\\n json=data,\\n headers={\\\"Authorization\\\": f\\\"Bearer {tokens['write']}\\\"},\\n )\\n assert response.status_code == 422\",\n \"def survey_response_id(self, survey_response_id):\\n\\n self._survey_response_id = survey_response_id\",\n \"def counterparty(self, counterparty):\\n\\n self._counterparty = counterparty\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73732257","0.6368166","0.6134412","0.5915429","0.58693725","0.56939834","0.5567969","0.5020891","0.5020535","0.48919058","0.4779866","0.4765815","0.47550648","0.47453716","0.47379932","0.47163343","0.46686274","0.4600456","0.45884106","0.45701525","0.45591342","0.45508328","0.45363402","0.4515502","0.45149282","0.45116335","0.4500566","0.44559163","0.44398478","0.4417093","0.43909606","0.43672338","0.43592635","0.43523517","0.43490136","0.4345325","0.4336064","0.43040684","0.428197","0.42552254","0.4246587","0.42455167","0.42448884","0.4242028","0.4233032","0.4215283","0.4208032","0.419404","0.41924778","0.41767538","0.4171359","0.4166782","0.41667074","0.4164732","0.41643855","0.41596118","0.41589814","0.41548926","0.4150784","0.41305986","0.41304082","0.41271326","0.41179326","0.41107363","0.41062972","0.41062972","0.41013277","0.4098715","0.4086067","0.40639654","0.40373066","0.4037211","0.40251115","0.40159705","0.40158537","0.40141642","0.4010055","0.40044641","0.39919448","0.3989846","0.39797783","0.39683673","0.39664006","0.39643016","0.3959861","0.39549413","0.39498922","0.39498922","0.39461166","0.3936191","0.39280656","0.39275357","0.39221045","0.39221045","0.39221045","0.39221045","0.39221045","0.39143583","0.39116308","0.3906993"],"string":"[\n \"0.73732257\",\n \"0.6368166\",\n \"0.6134412\",\n \"0.5915429\",\n \"0.58693725\",\n \"0.56939834\",\n \"0.5567969\",\n \"0.5020891\",\n \"0.5020535\",\n \"0.48919058\",\n \"0.4779866\",\n \"0.4765815\",\n \"0.47550648\",\n \"0.47453716\",\n \"0.47379932\",\n \"0.47163343\",\n \"0.46686274\",\n \"0.4600456\",\n \"0.45884106\",\n \"0.45701525\",\n \"0.45591342\",\n \"0.45508328\",\n \"0.45363402\",\n \"0.4515502\",\n \"0.45149282\",\n \"0.45116335\",\n \"0.4500566\",\n \"0.44559163\",\n \"0.44398478\",\n \"0.4417093\",\n \"0.43909606\",\n \"0.43672338\",\n \"0.43592635\",\n \"0.43523517\",\n \"0.43490136\",\n \"0.4345325\",\n \"0.4336064\",\n \"0.43040684\",\n \"0.428197\",\n \"0.42552254\",\n \"0.4246587\",\n \"0.42455167\",\n \"0.42448884\",\n \"0.4242028\",\n \"0.4233032\",\n \"0.4215283\",\n \"0.4208032\",\n \"0.419404\",\n \"0.41924778\",\n \"0.41767538\",\n \"0.4171359\",\n \"0.4166782\",\n \"0.41667074\",\n \"0.4164732\",\n \"0.41643855\",\n \"0.41596118\",\n \"0.41589814\",\n \"0.41548926\",\n \"0.4150784\",\n \"0.41305986\",\n \"0.41304082\",\n \"0.41271326\",\n \"0.41179326\",\n \"0.41107363\",\n \"0.41062972\",\n \"0.41062972\",\n \"0.41013277\",\n \"0.4098715\",\n \"0.4086067\",\n \"0.40639654\",\n \"0.40373066\",\n \"0.4037211\",\n \"0.40251115\",\n \"0.40159705\",\n \"0.40158537\",\n \"0.40141642\",\n \"0.4010055\",\n \"0.40044641\",\n \"0.39919448\",\n \"0.3989846\",\n \"0.39797783\",\n \"0.39683673\",\n \"0.39664006\",\n \"0.39643016\",\n \"0.3959861\",\n \"0.39549413\",\n \"0.39498922\",\n \"0.39498922\",\n \"0.39461166\",\n \"0.3936191\",\n \"0.39280656\",\n \"0.39275357\",\n \"0.39221045\",\n \"0.39221045\",\n \"0.39221045\",\n \"0.39221045\",\n \"0.39221045\",\n \"0.39143583\",\n \"0.39116308\",\n \"0.3906993\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7228571"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84583,"cells":{"query":{"kind":"string","value":"Read patient_consent information from dict serialization. For existing rows that did not record the actual consent date, if `patient_consent` is True, `ceation_date` is used if present, UNIX epoch 0 if it is missing."},"document":{"kind":"string","value":"def _read_patient_consent_date(self, d: dict):\n consent_date = d.get('patient_consent_date')\n consent_bool = d.get('patient_consent')\n if consent_date is not None:\n return self._str_to_datetime(consent_date)\n elif consent_bool:\n t0 = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)\n creation_date = d.get('creation_date')\n return (self._str_to_datetime(creation_date)\n if creation_date is not None\n else t0)\n else:\n return None"},"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 patient_consent(self):\n return 1 if self.patient_consent_date is not None else 0","def patient_consent(self, value):\n self.patient_consent_date = utcnow() if value else None","def patient_consent_date(self, value):\n self._patient_consent_date = value\n self._patient_consent = 1 if value else 0","def patient_consent(self):\n return self.patient_consent_date != None # noqa: E711","def patient_consent_date(self):\n return self._patient_consent_date","def read_dict(self, d: dict):\n self.transaction_id = d.get('transaction_id')\n\n self.study_id = d.get('study_id')\n self.patient_id = d.get('patient_id')\n self.name = d.get('name')\n birth_date = d.get('birth_date')\n self.birth_date = datetime.datetime.strptime(\n birth_date, \"%d/%m/%Y\") if birth_date else None\n self.study_date = d.get('study_date')\n self.patient_consent_date = self._read_patient_consent_date(d)\n self.institution = d.get('institution')\n\n self.start_date = self._str_to_datetime(d.get('start_date'))\n self.end_date = self._str_to_datetime(d.get('end_date'))\n self.creation_date = self._str_to_datetime(d.get('creation_date'))\n\n self.version = d.get(\"version\")\n self.analysis_type = d.get(\"analysis_type\")\n self.qa_score = d.get(\"qa_score\")\n self.product_id = d.get('product_id')\n\n self.task_state = TaskState[\n d.get('task_state')] if d.get('task_state') else None\n self.processing_state = d.get('processing_state')\n self.task_progress = d.get('task_progress')\n self.task_skipped = d.get('task_skipped')\n self.task_cancelled = d.get('task_cancelled')\n self.archived = d.get('archived')\n self.error = d.get('error')\n self.status = d.get('status')\n self.sequences = d.get('sequences')\n self.last_message = d.get('last_message')\n\n self.data_uploaded = self._str_to_datetime(d.get('data_uploaded'))\n self.billable = d.get('billable')\n self.priority = d.get('priority')\n self.site_id = d.get('site_id', 0)\n\n return self","async def request_inform_consent(request, patient_pkey):\n client_key = general.get_request_key_header(request)\n client_signer = general.get_signer(request, client_key)\n grant_read_ehr_permission_txn = consent_transaction.request_inform_document_consent(\n txn_signer=client_signer,\n batch_signer=client_signer,\n patient_pkey=patient_pkey)\n\n batch, batch_id = ehr_transaction.make_batch_and_id([grant_read_ehr_permission_txn], client_signer)\n\n await security_messaging.request_inform_document_consent(\n request.app.config.VAL_CONN,\n request.app.config.TIMEOUT,\n [batch], client_key)\n\n try:\n await security_messaging.check_batch_status(\n request.app.config.VAL_CONN, [batch_id])\n except (ApiBadRequest, ApiInternalError) as err:\n # await auth_query.remove_auth_entry(\n # request.app.config.DB_CONN, request.json.get('email'))\n raise err\n\n return response.json(body={'status': general.DONE},\n headers=general.get_response_headers())","def get_patient_dict():\r\n return common.get_dict_all(get_patient_filename(), None)","def validate(self, consentDict):\n if(consentDict == None):\n return self.composeResult(API.STATUS_CODE.FAILED, errorMessage=\"Invalid consent dictionary object (null) passed!\")\n\n missingAttrList = []\n tableAttr = CustomerConsentDataTable.TABLE.ATTRIBUTE\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CUSTOMER_MK)\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.SOURCE_MARKET)\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.COUNTRY)\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CONTACT_TYPE)\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CONSENT_STATUS)\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CONSENT_DATETIME)\n\n contactType = consentDict.get(tableAttr.CONTACT_TYPE)\n contactTypeKey = self.contactTypeKeys.get(contactType)\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, contactTypeKey)\n\n if(len(missingAttrList) > 0):\n errorMessage = f\"Consent is missing mandatory attribute(s): {missingAttrList}!\"\n return self.composeResult(API.STATUS_CODE.FAILED, errorMessage=errorMessage)\n\n return self.composeResult(API.STATUS_CODE.SUCCESS, data=consentDict)","def test_consent_4(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-notAuthor.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_4(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_4(inst2)","def test_consent_7(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-grantor.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_7(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_7(inst2)","def test_consent_3(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-CDA.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_3(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_3(inst2)","def test_consent_8(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-notOrg.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_8(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_8(inst2)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n id = dictionary.get('id')\r\n person_id = dictionary.get('personId')\r\n personality_type = dictionary.get('personalityType')\r\n insurance_centre_type = dictionary.get('insuranceCentreType')\r\n register_status = dictionary.get('registerStatus')\r\n center_name = dictionary.get('centerName')\r\n center_code = dictionary.get('centerCode')\r\n registration_number = dictionary.get('registrationNumber')\r\n free_use_golden_pack_expire_date = dictionary.get('freeUseGoldenPackExpireDate')\r\n city_id = dictionary.get('cityId')\r\n cash_payment = dictionary.get('cashPayment')\r\n show_in_easy_bimeh = dictionary.get('showInEasyBimeh')\r\n installments_payment = dictionary.get('installmentsPayment')\r\n is_initial_applicant = dictionary.get('isInitialApplicant')\r\n branchs_count = dictionary.get('branchsCount')\r\n employees_count = dictionary.get('employeesCount')\r\n white_label = dictionary.get('whiteLabel')\r\n phone = dictionary.get('phone')\r\n fax = dictionary.get('fax')\r\n address = dictionary.get('address')\r\n zip_code = dictionary.get('zipCode')\r\n email = dictionary.get('email')\r\n web_site = dictionary.get('webSite')\r\n latitude = dictionary.get('latitude')\r\n longitude = dictionary.get('longitude')\r\n is_active = dictionary.get('isActive')\r\n province_id = dictionary.get('provinceId')\r\n city_name = dictionary.get('cityName')\r\n meta_media_activity_licence_id = dictionary.get('metaMediaActivityLicenceId')\r\n create_on_persian_date = dictionary.get('createOnPersianDate')\r\n insurance_company_id = dictionary.get('insuranceCompanyId')\r\n active_package_id = dictionary.get('activePackageId')\r\n package_activation_last_date = dictionary.get('packageActivationLastDate')\r\n online_payment = dictionary.get('onlinePayment')\r\n card_to_card_payment = dictionary.get('cardToCardPayment')\r\n bank_transfer_payment = dictionary.get('bankTransferPayment')\r\n cash_on_delivery = dictionary.get('cashOnDelivery')\r\n bank_transfer_same_online_payment_info = dictionary.get('bankTransferSameOnlinePaymentInfo')\r\n bank_param_id = dictionary.get('bankParamId')\r\n account_owner = dictionary.get('accountOwner')\r\n account_number = dictionary.get('accountNumber')\r\n iban = dictionary.get('iban')\r\n card_bank_param_id = dictionary.get('cardBankParamId')\r\n card_account_owner = dictionary.get('cardAccountOwner')\r\n card_account_number = dictionary.get('cardAccountNumber')\r\n bank_transfer_param_id = dictionary.get('bankTransferParamId')\r\n bank_transfer_account_owner = dictionary.get('bankTransferAccountOwner')\r\n bank_transfer_account_number = dictionary.get('bankTransferAccountNumber')\r\n bank_transfer_iban = dictionary.get('bankTransferIBAN')\r\n branch_count = dictionary.get('branchCount')\r\n zone_id = dictionary.get('zoneId')\r\n sms_charging_stock = dictionary.get('smsChargingStock')\r\n independent_branch = dictionary.get('independentBranch')\r\n disable_reason = dictionary.get('disableReason')\r\n terms_conditions = dictionary.get('termsConditions')\r\n disable_reason_description = dictionary.get('disableReasonDescription')\r\n unlimited_account = dictionary.get('unlimitedAccount')\r\n payment_url = dictionary.get('paymentUrl')\r\n callback_url = dictionary.get('callbackUrl')\r\n callback_url_whitelabel = dictionary.get('callbackUrlWhitelabel')\r\n insurance_centre_id = dictionary.get('insuranceCentreId')\r\n city_region_id = dictionary.get('cityRegionId')\r\n meta_media_activity_licence_url = dictionary.get('metaMediaActivityLicenceUrl')\r\n license_api_key = dictionary.get('licenseApiKey')\r\n verify_request_url = dictionary.get('verifyRequestUrl')\r\n\r\n # Return an object of this model\r\n return cls(id,\r\n person_id,\r\n personality_type,\r\n insurance_centre_type,\r\n register_status,\r\n center_name,\r\n center_code,\r\n registration_number,\r\n free_use_golden_pack_expire_date,\r\n city_id,\r\n cash_payment,\r\n show_in_easy_bimeh,\r\n installments_payment,\r\n is_initial_applicant,\r\n branchs_count,\r\n employees_count,\r\n white_label,\r\n phone,\r\n fax,\r\n address,\r\n zip_code,\r\n email,\r\n web_site,\r\n latitude,\r\n longitude,\r\n is_active,\r\n province_id,\r\n city_name,\r\n meta_media_activity_licence_id,\r\n create_on_persian_date,\r\n insurance_company_id,\r\n active_package_id,\r\n package_activation_last_date,\r\n online_payment,\r\n card_to_card_payment,\r\n bank_transfer_payment,\r\n cash_on_delivery,\r\n bank_transfer_same_online_payment_info,\r\n bank_param_id,\r\n account_owner,\r\n account_number,\r\n iban,\r\n card_bank_param_id,\r\n card_account_owner,\r\n card_account_number,\r\n bank_transfer_param_id,\r\n bank_transfer_account_owner,\r\n bank_transfer_account_number,\r\n bank_transfer_iban,\r\n branch_count,\r\n zone_id,\r\n sms_charging_stock,\r\n independent_branch,\r\n disable_reason,\r\n terms_conditions,\r\n disable_reason_description,\r\n unlimited_account,\r\n payment_url,\r\n callback_url,\r\n callback_url_whitelabel,\r\n insurance_centre_id,\r\n city_region_id,\r\n meta_media_activity_licence_url,\r\n license_api_key,\r\n verify_request_url)","def test_consent_1(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-notThis.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_1(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_1(inst2)","def __init__(self, jsondict=None, strict=True):\n \n self.code = None\n \"\"\" \n T\n y\n p\n e\n o\n f\n d\n a\n t\n e\n .\n Type `CodeableConcept` (represented as `dict` in JSON). \"\"\"\n \n self.value = None\n \"\"\" \n R\n e\n c\n o\n m\n m\n e\n n\n d\n e\n d\n d\n a\n t\n e\n .\n Type `FHIRDate` (represented as `str` in JSON). \"\"\"\n \n super(ImmunizationRecommendationRecommendationDateCriterion, self).__init__(jsondict=jsondict, strict=strict)","def test_consent_10(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_10(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_10(inst2)","def __init__(self, jsondict=None, strict=True):\n \n self.appointmentType = None\n \"\"\" \n T\n h\n e\n s\n t\n y\n l\n e\n o\n f\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n o\n r\n p\n a\n t\n i\n e\n n\n t\n t\n h\n a\n t\n h\n a\n s\n b\n e\n e\n n\n b\n o\n o\n k\n e\n d\n i\n n\n t\n h\n e\n s\n l\n o\n t\n (\n n\n o\n t\n s\n e\n r\n v\n i\n c\n e\n t\n y\n p\n e\n )\n .\n Type `CodeableConcept` (represented as `dict` in JSON). \"\"\"\n \n self.basedOn = None\n \"\"\" \n T\n h\n e\n s\n e\n r\n v\n i\n c\n e\n r\n e\n q\n u\n e\n s\n t\n t\n h\n i\n s\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n i\n s\n a\n l\n l\n o\n c\n a\n t\n e\n d\n t\n o\n a\n s\n s\n e\n s\n s\n .\n List of `FHIRReference` items (represented as `dict` in JSON). \"\"\"\n \n self.cancelationReason = None\n \"\"\" \n T\n h\n e\n c\n o\n d\n e\n d\n r\n e\n a\n s\n o\n n\n f\n o\n r\n t\n h\n e\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n b\n e\n i\n n\n g\n c\n a\n n\n c\n e\n l\n l\n e\n d\n .\n Type `CodeableConcept` (represented as `dict` in JSON). \"\"\"\n \n self.comment = None\n \"\"\" \n A\n d\n d\n i\n t\n i\n o\n n\n a\n l\n c\n o\n m\n m\n e\n n\n t\n s\n .\n Type `str`. \"\"\"\n \n self.created = None\n \"\"\" \n T\n h\n e\n d\n a\n t\n e\n t\n h\n a\n t\n t\n h\n i\n s\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n w\n a\n s\n i\n n\n i\n t\n i\n a\n l\n l\n y\n c\n r\n e\n a\n t\n e\n d\n .\n Type `FHIRDate` (represented as `str` in JSON). \"\"\"\n \n self.description = None\n \"\"\" \n S\n h\n o\n w\n n\n o\n n\n a\n s\n u\n b\n j\n e\n c\n t\n l\n i\n n\n e\n i\n n\n a\n m\n e\n e\n t\n i\n n\n g\n r\n e\n q\n u\n e\n s\n t\n ,\n o\n r\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n l\n i\n s\n t\n .\n Type `str`. \"\"\"\n \n self.end = None\n \"\"\" \n W\n h\n e\n n\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n i\n s\n t\n o\n c\n o\n n\n c\n l\n u\n d\n e\n .\n Type `FHIRDate` (represented as `str` in JSON). \"\"\"\n \n self.identifier = None\n \"\"\" \n E\n x\n t\n e\n r\n n\n a\n l\n I\n d\n s\n f\n o\n r\n t\n h\n i\n s\n i\n t\n e\n m\n .\n List of `Identifier` items (represented as `dict` in JSON). \"\"\"\n \n self.minutesDuration = None\n \"\"\" \n C\n a\n n\n b\n e\n l\n e\n s\n s\n t\n h\n a\n n\n s\n t\n a\n r\n t\n /\n e\n n\n d\n (\n e\n .\n g\n .\n e\n s\n t\n i\n m\n a\n t\n e\n )\n .\n Type `int`. \"\"\"\n \n self.participant = None\n \"\"\" \n P\n a\n r\n t\n i\n c\n i\n p\n a\n n\n t\n s\n i\n n\n v\n o\n l\n v\n e\n d\n i\n n\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n .\n List of `AppointmentParticipant` items (represented as `dict` in JSON). \"\"\"\n \n self.patientInstruction = None\n \"\"\" \n D\n e\n t\n a\n i\n l\n e\n d\n i\n n\n f\n o\n r\n m\n a\n t\n i\n o\n n\n a\n n\n d\n i\n n\n s\n t\n r\n u\n c\n t\n i\n o\n n\n s\n f\n o\n r\n t\n h\n e\n p\n a\n t\n i\n e\n n\n t\n .\n Type `str`. \"\"\"\n \n self.priority = None\n \"\"\" \n U\n s\n e\n d\n t\n o\n m\n a\n k\n e\n i\n n\n f\n o\n r\n m\n e\n d\n d\n e\n c\n i\n s\n i\n o\n n\n s\n i\n f\n n\n e\n e\n d\n i\n n\n g\n t\n o\n r\n e\n -\n p\n r\n i\n o\n r\n i\n t\n i\n z\n e\n .\n Type `int`. \"\"\"\n \n self.reasonCode = None\n \"\"\" \n C\n o\n d\n e\n d\n r\n e\n a\n s\n o\n n\n t\n h\n i\n s\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n i\n s\n s\n c\n h\n e\n d\n u\n l\n e\n d\n .\n List of `CodeableConcept` items (represented as `dict` in JSON). \"\"\"\n \n self.reasonReference = None\n \"\"\" \n R\n e\n a\n s\n o\n n\n t\n h\n e\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n i\n s\n t\n o\n t\n a\n k\n e\n p\n l\n a\n c\n e\n (\n r\n e\n s\n o\n u\n r\n c\n e\n )\n .\n List of `FHIRReference` items (represented as `dict` in JSON). \"\"\"\n \n self.requestedPeriod = None\n \"\"\" \n P\n o\n t\n e\n n\n t\n i\n a\n l\n d\n a\n t\n e\n /\n t\n i\n m\n e\n i\n n\n t\n e\n r\n v\n a\n l\n (\n s\n )\n r\n e\n q\n u\n e\n s\n t\n e\n d\n t\n o\n a\n l\n l\n o\n c\n a\n t\n e\n t\n h\n e\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n w\n i\n t\n h\n i\n n\n .\n List of `Period` items (represented as `dict` in JSON). \"\"\"\n \n self.serviceCategory = None\n \"\"\" \n A\n b\n r\n o\n a\n d\n c\n a\n t\n e\n g\n o\n r\n i\n z\n a\n t\n i\n o\n n\n o\n f\n t\n h\n e\n s\n e\n r\n v\n i\n c\n e\n t\n h\n a\n t\n i\n s\n t\n o\n b\n e\n p\n e\n r\n f\n o\n r\n m\n e\n d\n d\n u\n r\n i\n n\n g\n t\n h\n i\n s\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n .\n List of `CodeableConcept` items (represented as `dict` in JSON). \"\"\"\n \n self.serviceType = None\n \"\"\" \n T\n h\n e\n s\n p\n e\n c\n i\n f\n i\n c\n s\n e\n r\n v\n i\n c\n e\n t\n h\n a\n t\n i\n s\n t\n o\n b\n e\n p\n e\n r\n f\n o\n r\n m\n e\n d\n d\n u\n r\n i\n n\n g\n t\n h\n i\n s\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n .\n List of `CodeableConcept` items (represented as `dict` in JSON). \"\"\"\n \n self.slot = None\n \"\"\" \n T\n h\n e\n s\n l\n o\n t\n s\n t\n h\n a\n t\n t\n h\n i\n s\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n i\n s\n f\n i\n l\n l\n i\n n\n g\n .\n List of `FHIRReference` items (represented as `dict` in JSON). \"\"\"\n \n self.specialty = None\n \"\"\" \n T\n h\n e\n s\n p\n e\n c\n i\n a\n l\n t\n y\n o\n f\n a\n p\n r\n a\n c\n t\n i\n t\n i\n o\n n\n e\n r\n t\n h\n a\n t\n w\n o\n u\n l\n d\n b\n e\n r\n e\n q\n u\n i\n r\n e\n d\n t\n o\n p\n e\n r\n f\n o\n r\n m\n t\n h\n e\n s\n e\n r\n v\n i\n c\n e\n r\n e\n q\n u\n e\n s\n t\n e\n d\n i\n n\n t\n h\n i\n s\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n .\n List of `CodeableConcept` items (represented as `dict` in JSON). \"\"\"\n \n self.start = None\n \"\"\" \n W\n h\n e\n n\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n i\n s\n t\n o\n t\n a\n k\n e\n p\n l\n a\n c\n e\n .\n Type `FHIRDate` (represented as `str` in JSON). \"\"\"\n \n self.status = None\n \"\"\" \n p\n r\n o\n p\n o\n s\n e\n d\n |\n p\n e\n n\n d\n i\n n\n g\n |\n b\n o\n o\n k\n e\n d\n |\n a\n r\n r\n i\n v\n e\n d\n |\n f\n u\n l\n f\n i\n l\n l\n e\n d\n |\n c\n a\n n\n c\n e\n l\n l\n e\n d\n |\n n\n o\n s\n h\n o\n w\n |\n e\n n\n t\n e\n r\n e\n d\n -\n i\n n\n -\n e\n r\n r\n o\n r\n |\n c\n h\n e\n c\n k\n e\n d\n -\n i\n n\n |\n w\n a\n i\n t\n l\n i\n s\n t\n .\n Type `str`. \"\"\"\n \n self.supportingInformation = None\n \"\"\" \n A\n d\n d\n i\n t\n i\n o\n n\n a\n l\n i\n n\n f\n o\n r\n m\n a\n t\n i\n o\n n\n t\n o\n s\n u\n p\n p\n o\n r\n t\n t\n h\n e\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n .\n List of `FHIRReference` items (represented as `dict` in JSON). \"\"\"\n \n super(Appointment, self).__init__(jsondict=jsondict, strict=strict)","def __init__(self, jsondict=None, strict=True):\n \n self.businessArrangement = None\n \"\"\" Additional provider contract number.\n Type `str`. \"\"\"\n \n self.claimResponse = None\n \"\"\" Adjudication results.\n Type `FHIRReference` (represented as `dict` in JSON). \"\"\"\n \n self.coverage = None\n \"\"\" Insurance information.\n Type `FHIRReference` (represented as `dict` in JSON). \"\"\"\n \n self.focal = None\n \"\"\" Coverage to be used for adjudication.\n Type `bool`. \"\"\"\n \n self.sequence = None\n \"\"\" Insurance instance identifier.\n Type `int`. \"\"\"\n \n super(ClaimResponseInsurance, self).__init__(jsondict=jsondict, strict=strict)","def date_returner_dict(ict):\n if \"date\" in ict.keys():\n return ict[\"date\"]\n\n if \"updated_at\" in ict.keys():\n return ict[\"updated_at\"]","def test_consent_9(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-pkb.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_9(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_9(inst2)","def precipitation():\n precip = session.query(Measurement.date, Measurement.prcp).filter(Measurement.date >= prev_year).all()\n\n # Create a dictionary from the row data and append to a list \n precip_dict = {}\n for date, prcp in precip:\n if prcp !=None:\n precip_dict.setdefault(date, []).append(prcp)\n\n return jsonify(precip_dict)","def parse_conservations(variant, parsed_transcripts=None):\n parsed_transcripts = parsed_transcripts or []\n conservations = {}\n\n conservation_keys = {\n \"info_keys\": {\n \"gerp\": \"dbNSFP_GERP___RS\",\n \"phast\": \"dbNSFP_phastCons100way_vertebrate\",\n \"phylop\": \"dbNSFP_phyloP100way_vertebrate\",\n }\n }\n\n # First check if information is in INFO\n for key in conservation_keys[\"info_keys\"]:\n value = conservation_keys[\"info_keys\"][key]\n result = None\n if value and variant.INFO.get(value):\n result = parse_conservation_info(variant, value, key)\n elif len(parsed_transcripts) > 0:\n result = parse_conservation_csq(parsed_transcripts[0], key)\n\n conservations[key] = result\n\n return conservations","def test_consent_6(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-notThem.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_6(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_6(inst2)","def precipitation():\r\n # Calculate the date 1 year ago from last date in database\r\n prev_year = dt.date(2017, 8, 23) - dt.timedelta(days=365)\r\n\r\n # Query for the date and precipitation for the last year\r\n precipitation = session.query(Measurement.date, Measurement.prcp).\\\r\n filter(Measurement.date >= prev_year).all()\r\n\r\n # Dict with date as the key and prcp as the value\r\n precip = {date: prcp for date, prcp in precipitation}\r\n return jsonify(precip)","def row_to_clinvar_submission(\n row: pandas.Series,\n assertion_criteria: dict,\n submission_name=default_submission_name()):\n # row_idx = row.name\n # misc fields\n\n local_id = row[\"A\"]\n local_key = row[\"B\"]\n record_status = row[\"CR\"]#.replace(None, \"novel\") # novel or update\n if record_status is None:\n record_status = \"novel\"\n release_status = \"public\"\n # variantSet\n variant_set = {\n \"variant\": [{\n \"gene\": [{\"symbol\": e.strip() for e in row[\"C\"].split(\";\")}],\n \"hgvs\": row[\"D\"] + \":\" + row[\"E\"]\n }]\n }\n # conditionSet\n condition_set = {\n \"condition\": [{\n \"db\": row[\"AD\"],\n \"id\": row[\"AE\"]\n }]\n }\n # clinicalSignificance\n clinsig_description = normalize_clinical_significance_description(row[\"AK\"])\n # clinsig_date_last_evaluated = serialize_date(row[\"AL\"])\n # Date has already been serialized to YYYY-mm-dd\n clinsig_date_last_evaluated = row[\"AL\"]\n clinsig_mode_of_inheritance = row[\"AO\"]\n clinsig_comment = row[\"AR\"]\n clinsig_citations = parse_citations(row[\"AP\"])\n if pandas.notnull(row[\"AQ\"]):\n clinsig_citations.append({\"url\": row[\"AQ\"]})\n # observedIn\n observed_in = [{\n \"collectionMethod\": row[\"AX\"],\n \"alleleOrigin\": row[\"AY\"],\n \"affectedStatus\": row[\"AZ\"],\n \"numberOfIndividuals\": 0\n }]\n\n # assertionCriteria is taken from caller\n doc = {\n \"assertionCriteria\": assertion_criteria,\n \"clinicalSignificance\": {\n \"citation\": clinsig_citations,\n \"clinicalSignificanceDescription\": clinsig_description,\n \"comment\": clinsig_comment,\n \"dateLastEvaluated\": clinsig_date_last_evaluated,\n \"modeOfInheritance\": clinsig_mode_of_inheritance\n },\n \"conditionSet\": condition_set,\n \"localID\": local_id,\n \"localKey\": local_key,\n \"observedIn\": observed_in,\n \"recordStatus\": record_status,\n \"releaseStatus\": release_status,\n \"variantSet\": variant_set\n }\n # if clinsig_mode_of_inheritance is not None:\n # doc[\"clinvarSubmission\"][0][\"clinicalSignificance\"][\"modeOfInheritance\"] = clinsig_mode_of_inheritance\n if record_status == \"update\":\n clinvar_accession = row[\"CQ\"]\n if clinvar_accession is None or len(clinvar_accession) == 0:\n raise RuntimeError(\"accession (column CQ) must be provided for updates (%s)\" % doc)\n doc[\"clinvarAccession\"] = clinvar_accession\n\n # Remove any fields for which the value is None, or any list elements that are None\n doc = removenone(doc)\n return doc","def precipitation():\n # Query for the dates and precipitation observations from the last year.\n # Convert the query results to a Dictionary using `date` as the key and `prcp` as the value.\n # Return the json representation of your dictionary.\n query_date = session.query(Measurement.date).order_by(Measurement.date.desc()).first() \n query_date = query_date[0]\n query_date = dt.datetime.strptime(query_date,'%Y-%m-%d').date()\n start_date_datetime = query_date - dt.timedelta(days=365)\n results= session.query(Measurement.date, Measurement.prcp).\\\n filter (Measurement.date >= start_date_datetime).all()\n prcp= {date:prcp for date,prcp in results}\n return jsonify (prcp)","def __init__(self, jsondict=None, strict=True):\n \n self.characteristicCodeableConcept = None\n \"\"\" Specific characteristic that is relevant to the administration\n guideline.\n Type `CodeableConcept` (represented as `dict` in JSON). \"\"\"\n \n self.characteristicQuantity = None\n \"\"\" Specific characteristic that is relevant to the administration\n guideline.\n Type `Quantity` (represented as `dict` in JSON). \"\"\"\n \n self.value = None\n \"\"\" The specific characteristic.\n List of `str` items. \"\"\"\n \n super(MedicationKnowledgeAdministrationGuidelinesPatientCharacteristics, self).__init__(jsondict=jsondict, strict=strict)","def test_consent_5(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-notTime.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_5(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_5(inst2)","def precip():\n date_prcp=session.query(measurements.date,measurements.prcp).all()\n date_prcp_df=pd.DataFrame(date_prcp).set_index('date')\n date_prcp_dict=date_prcp_df.to_dict()\n return jsonify(date_prcp_dict)","def get_district_data(district):\n with open(district_data_dir + 'district-data.json') as f:\n district_dict = json.load(f)\n\n district_data = []\n for date, data in district_dict.items():\n if date == \"03/02/2020\":\n continue\n if district in data:\n district_data.append((date, data[district]['infected']))\n\n return district_data","def __init__(self, jsondict=None, strict=True):\n \n self.actor = None\n \"\"\" \n P\n e\n r\n s\n o\n n\n ,\n L\n o\n c\n a\n t\n i\n o\n n\n /\n H\n e\n a\n l\n t\n h\n c\n a\n r\n e\n S\n e\n r\n v\n i\n c\n e\n o\n r\n D\n e\n v\n i\n c\n e\n .\n Type `FHIRReference` (represented as `dict` in JSON). \"\"\"\n \n self.period = None\n \"\"\" \n P\n a\n r\n t\n i\n c\n i\n p\n a\n t\n i\n o\n n\n p\n e\n r\n i\n o\n d\n o\n f\n t\n h\n e\n a\n c\n t\n o\n r\n .\n Type `Period` (represented as `dict` in JSON). \"\"\"\n \n self.required = None\n \"\"\" \n r\n e\n q\n u\n i\n r\n e\n d\n |\n o\n p\n t\n i\n o\n n\n a\n l\n |\n i\n n\n f\n o\n r\n m\n a\n t\n i\n o\n n\n -\n o\n n\n l\n y\n .\n Type `str`. \"\"\"\n \n self.status = None\n \"\"\" \n a\n c\n c\n e\n p\n t\n e\n d\n |\n d\n e\n c\n l\n i\n n\n e\n d\n |\n t\n e\n n\n t\n a\n t\n i\n v\n e\n |\n n\n e\n e\n d\n s\n -\n a\n c\n t\n i\n o\n n\n .\n Type `str`. \"\"\"\n \n self.type = None\n \"\"\" \n R\n o\n l\n e\n o\n f\n p\n a\n r\n t\n i\n c\n i\n p\n a\n n\n t\n i\n n\n t\n h\n e\n a\n p\n p\n o\n i\n n\n t\n m\n e\n n\n t\n .\n List of `CodeableConcept` items (represented as `dict` in JSON). \"\"\"\n \n super(AppointmentParticipant, self).__init__(jsondict=jsondict, strict=strict)","def __init__(self, jsondict=None, strict=True):\n \n self.addItem = None\n \"\"\" Insurer added line items.\n List of `ClaimResponseAddItem` items (represented as `dict` in JSON). \"\"\"\n \n self.adjudication = None\n \"\"\" Header-level adjudication.\n List of `ClaimResponseItemAdjudication` items (represented as `dict` in JSON). \"\"\"\n \n self.communicationRequest = None\n \"\"\" Request for additional information.\n List of `FHIRReference` items (represented as `dict` in JSON). \"\"\"\n \n self.created = None\n \"\"\" Response creation date.\n Type `FHIRDate` (represented as `str` in JSON). \"\"\"\n \n self.disposition = None\n \"\"\" Disposition Message.\n Type `str`. \"\"\"\n \n self.error = None\n \"\"\" Processing errors.\n List of `ClaimResponseError` items (represented as `dict` in JSON). \"\"\"\n \n self.form = None\n \"\"\" Printed reference or actual form.\n Type `Attachment` (represented as `dict` in JSON). \"\"\"\n \n self.formCode = None\n \"\"\" Printed form identifier.\n Type `CodeableConcept` (represented as `dict` in JSON). \"\"\"\n \n self.fundsReserve = None\n \"\"\" Funds reserved status.\n Type `CodeableConcept` (represented as `dict` in JSON). \"\"\"\n \n self.identifier = None\n \"\"\" Business Identifier for a claim response.\n List of `Identifier` items (represented as `dict` in JSON). \"\"\"\n \n self.insurance = None\n \"\"\" Patient insurance information.\n List of `ClaimResponseInsurance` items (represented as `dict` in JSON). \"\"\"\n \n self.insurer = None\n \"\"\" Party responsible for reimbursement.\n Type `FHIRReference` (represented as `dict` in JSON). \"\"\"\n \n self.item = None\n \"\"\" Adjudication for claim line items.\n List of `ClaimResponseItem` items (represented as `dict` in JSON). \"\"\"\n \n self.outcome = None\n \"\"\" queued | complete | error | partial.\n Type `str`. \"\"\"\n \n self.patient = None\n \"\"\" The recipient of the products and services.\n Type `FHIRReference` (represented as `dict` in JSON). \"\"\"\n \n self.payeeType = None\n \"\"\" Party to be paid any benefits payable.\n Type `CodeableConcept` (represented as `dict` in JSON). \"\"\"\n \n self.payment = None\n \"\"\" Payment Details.\n Type `ClaimResponsePayment` (represented as `dict` in JSON). \"\"\"\n \n self.preAuthPeriod = None\n \"\"\" Preauthorization reference effective period.\n Type `Period` (represented as `dict` in JSON). \"\"\"\n \n self.preAuthRef = None\n \"\"\" Preauthorization reference.\n Type `str`. \"\"\"\n \n self.processNote = None\n \"\"\" Note concerning adjudication.\n List of `ClaimResponseProcessNote` items (represented as `dict` in JSON). \"\"\"\n \n self.request = None\n \"\"\" Id of resource triggering adjudication.\n Type `FHIRReference` (represented as `dict` in JSON). \"\"\"\n \n self.requestor = None\n \"\"\" Party responsible for the claim.\n Type `FHIRReference` (represented as `dict` in JSON). \"\"\"\n \n self.status = None\n \"\"\" active | cancelled | draft | entered-in-error.\n Type `str`. \"\"\"\n \n self.subType = None\n \"\"\" More granular claim type.\n Type `CodeableConcept` (represented as `dict` in JSON). \"\"\"\n \n self.total = None\n \"\"\" Adjudication totals.\n List of `ClaimResponseTotal` items (represented as `dict` in JSON). \"\"\"\n \n self.type = None\n \"\"\" More granular claim type.\n Type `CodeableConcept` (represented as `dict` in JSON). \"\"\"\n \n self.use = None\n \"\"\" claim | preauthorization | predetermination.\n Type `str`. \"\"\"\n \n super(ClaimResponse, self).__init__(jsondict=jsondict, strict=strict)","def get_consent(session):\n cookie = session.session_cookies.filter(name='cookie-accepted').first()\n if cookie:\n return cookie.value\n return None","def process_single_ns_record(target_dict, sensitive_key_names, sharing_consent_value):\r\n return dict_to_minified_json_string(\r\n add_sharing_consent(\r\n sub_sensitive_key(target_dict, sensitive_key_names),\r\n sharing_consent_value\r\n )\r\n )","def test_consent_2(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"consent-example-smartonfhir.json\"\n inst = consent.Consent.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Consent\" == inst.resource_type\n\n impl_consent_2(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Consent\" == data[\"resourceType\"]\n\n inst2 = consent.Consent(**data)\n impl_consent_2(inst2)","def test_research_consent_default(self):\n file = SimpleUploadedFile(\n \"test.csv\",\n b\"msisdn,facility code,id type,id number,messaging consent,\"\n b\"research_consent,edd year,edd month,edd day,baby dob year,\"\n b\"baby dob month,baby dob day\\n\"\n b\"+27820001001,123456,said,9001010001088,true,,2021,12,1,,,\\n\",\n )\n form = MomConnectImportForm(\n data={\"source\": \"MomConnect Import\"}, files={\"file\": file}\n )\n instance = form.save()\n self.assertEqual(instance.status, MomConnectImport.Status.VALIDATING)\n self.assertEqual(instance.errors.count(), 0)\n [row] = instance.rows.all()\n self.assertFalse(row.research_consent)","def get_attribute_consent(taxCode):\n content_type = request.headers.get(\"Content-Type\", \"\")\n assert content_type.lower() == \"application/jose\"\n\n user_data = _get_user_data(taxCode)\n if not user_data:\n return problem(\n title=\"User Not Found\", status=404, detail=\"Missing user\"\n )\n\n try:\n claims = validate_token(request.data, audience=app.config[\"entityId\"])\n except jwt.exceptions.InvalidTokenError as e:\n return invalid_token_handler(e)\n except Exception as e:\n raise ValueError(e, request.data)\n\n assert claims[\"v\"] == \"0.0.1\", claims\n assert claims[\"attributes\"], claims\n\n if user_data[\"consent\"] + 30 < time():\n return problem(\n status=403,\n title=\"ConsentRequired\",\n detail=\"User consent is required for this attribute. Last given: %r\"\n % datetime.fromtimestamp(user_data[\"consent\"]),\n type=\"https://spid.gov.it/aa/problem/consent-required\",\n ext={\"consent_url\": \"https://aa/v1/consents/{taxCode}/\"},\n )\n\n aa = [\n {\"attribute\": a, \"value\": user_data[a]}\n for a in claims[\"attributes\"]\n if a in user_data\n ]\n\n token = create_token({\"v\": \"0.0.1\", \"attributes\": aa})\n token[\"iss\"] = app.config[\"entityId\"]\n token[\"aud\"] = claims[\"iss\"]\n\n signed_token = sign_request(token, app_config=app.config)\n\n return Response(\n response=signed_token, status=200, mimetype=\"application/jose\"\n )","def age_first_admission(patient_id: str) -> int:\r\n cur = con.cursor()\r\n cache: dict[str, int] = {}\r\n if patient_id in cache:\r\n return cache[patient_id]\r\n\r\n age = cur.execute(\r\n \"\"\"SELECT (JULIANDAY(Lab_Date) - JULIANDAY(Date_Of_Birth)) / ?\r\n FROM Lab l\r\n INNER JOIN Patient p ON l.Patient_ID = p.Patient_ID\r\n WHERE l.Patient_ID = ?\r\n AND Admission_ID = 1\"\"\",\r\n [DAYS_IN_YEAR, patient_id],\r\n ).fetchall()\r\n\r\n age_as_int = int(age[0][0])\r\n cache[patient_id] = age_as_int\r\n\r\n return age_as_int # O(1)\r","def sentence_data(self):\n sentence_data = pd.read_csv(self.path + 'data/sentence_data.csv')\n \n # convert date to datetime\n sentence_data['date'] = pd.to_datetime(sentence_data['date'], errors='coerce')\n sentence_data['date'] = sentence_data['date'].dt.date\n \n # filtering weird dates\n mask = (sentence_data['date'].astype('str') >= \"2020-03-01\") & (sentence_data['date'].astype('str') < \"2020-04-03\")\n sentence_data = sentence_data.loc[mask]\n \n self._sentence_data = sentence_data\n \n return self._sentence_data","def find_transcript_data(row):\n #Calls create_transcript_df which creates a df for each transcript.\n trans_df = create_transcript_df(\n row, row['teacher_handle'].strip(), \n row['student_handle'].strip(), row['transcript'].strip())\n #Finds the first response time and defines it as the First Response Time (FRT)\n rt, frt = rt_data(trans_df)\n student_response, teacher_response = response_lengths(trans_df)\n #vocab = the total number of vocab words used in the transcript.\n vocab_list = np.asarray([item for sublist in trans_df.vocab.values for item in sublist])\n session_length_secs = (trans_df.Time_Stamps.iloc[-1] - trans_df.Time_Stamps.iloc[0]).seconds\n \n #Finding student to teacher ratio, round to nearest hundreth.\n exchange_ratio = round(trans_df.Student_Bool.sum()/float((trans_df['Student_Bool']==False).sum()),2)\n #returns all of the data found above, place in new columns under plain df.\n return trans_df.to_dict(), frt, rt, trans_df.vocab_count.sum(), vocab_list, trans_df.approp_count.sum(), session_length_secs, student_response, teacher_response, exchange_ratio,trans_df.has_drag_drop.sum()","def get_patient_info(file_path):\n f = open(file_path, 'rb')\n content = f.read()\n f.close()\n\n header = content[:88]\n patient_id = header[8:88].decode('ascii')\n # the headers \"fixed\" by tuh nedc data team show a '-' right before the age of the patient. therefore add this to\n # the regex and use the absolute value of the casted age\n [age] = re.findall(\"Age:(-?\\d+)\", patient_id)\n [sex] = re.findall(\"\\s\\w\\s\", patient_id)\n\n sex_id = 0 if sex.strip() == 'M' else 1\n\n return sex_id, abs(int(age))","def precipitation():\n # Calculate teh date 1 year ago from last date in database\n prev_year = dt.date(2017, 8, 23) - dt.timedelta(days=365)\n # Query for the date and precipitation for the last year\n precipitation = session.query(Measurement.date, Measurement.prcp).\\\n filter(Measurement.date >= prev_year).all()\n \n precip = {date: prcp for date, prcp in precipitation}\n return jsonify(precip)","def load_reseq_conditions_from(json_file_or_dict):\n\n # refactor that common useage from TC io\n if isinstance(json_file_or_dict, dict):\n d = json_file_or_dict\n else:\n with open(json_file_or_dict, 'r') as f:\n d = json.loads(f.read())\n\n return ReseqConditions.from_dict(d)","def load_patient_data(db_dir, patient_id, include_labels=True, unzipped=False):\n signal = load_signal(db_dir, patient_id, unzipped=unzipped)\n if include_labels:\n labels = load_labels(db_dir, patient_id, unzipped=unzipped)\n return signal, labels\n else:\n return signal, None","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n available_balance_amount = dictionary.get('availableBalanceAmount')\r\n posted_date = dictionary.get('postedDate')\r\n open_date = dictionary.get('openDate')\r\n period_start_date = dictionary.get('periodStartDate')\r\n period_end_date = dictionary.get('periodEndDate')\r\n period_interest_rate = dictionary.get('periodInterestRate')\r\n period_deposit_amount = dictionary.get('periodDepositAmount')\r\n period_interest_amount = dictionary.get('periodInterestAmount')\r\n interest_ytd_amount = dictionary.get('interestYtdAmount')\r\n interest_prior_ytd_amount = dictionary.get('interestPriorYtdAmount')\r\n maturity_date = dictionary.get('maturityDate')\r\n interest_rate = dictionary.get('interestRate')\r\n credit_available_amount = dictionary.get('creditAvailableAmount')\r\n credit_max_amount = dictionary.get('creditMaxAmount')\r\n cash_advance_available_amount = dictionary.get('cashAdvanceAvailableAmount')\r\n cash_advance_max_amount = dictionary.get('cashAdvanceMaxAmount')\r\n cash_advance_balance = dictionary.get('cashAdvanceBalance')\r\n cash_advance_interest_rate = dictionary.get('cashAdvanceInterestRate')\r\n current_balance = dictionary.get('currentBalance')\r\n payment_min_amount = dictionary.get('paymentMinAmount')\r\n payment_due_date = dictionary.get('paymentDueDate')\r\n previous_balance = dictionary.get('previousBalance')\r\n statement_start_date = dictionary.get('statementStartDate')\r\n statement_end_date = dictionary.get('statementEndDate')\r\n statement_purchase_amount = dictionary.get('statementPurchaseAmount')\r\n statement_finance_amount = dictionary.get('statementFinanceAmount')\r\n statement_credit_amount = dictionary.get('statementCreditAmount')\r\n reward_earned_balance = dictionary.get('rewardEarnedBalance')\r\n past_due_amount = dictionary.get('pastDueAmount')\r\n last_payment_amount = dictionary.get('lastPaymentAmount')\r\n last_payment_date = dictionary.get('lastPaymentDate')\r\n statement_close_balance = dictionary.get('statementCloseBalance')\r\n term_of_ml = dictionary.get('termOfMl')\r\n ml_holder_name = dictionary.get('mlHolderName')\r\n description = dictionary.get('description')\r\n late_fee_amount = dictionary.get('lateFeeAmount')\r\n payoff_amount = dictionary.get('payoffAmount')\r\n payoff_amount_date = dictionary.get('payoffAmountDate')\r\n original_maturity_date = dictionary.get('originalMaturityDate')\r\n principal_balance = dictionary.get('principalBalance')\r\n escrow_balance = dictionary.get('escrowBalance')\r\n interest_period = dictionary.get('interestPeriod')\r\n initial_ml_amount = dictionary.get('initialMlAmount')\r\n initial_ml_date = dictionary.get('initialMlDate')\r\n next_payment_principal_amount = dictionary.get('nextPaymentPrincipalAmount')\r\n next_payment_interest_amount = dictionary.get('nextPaymentInterestAmount')\r\n next_payment = dictionary.get('nextPayment')\r\n next_payment_date = dictionary.get('nextPaymentDate')\r\n last_payment_due_date = dictionary.get('lastPaymentDueDate')\r\n last_payment_receive_date = dictionary.get('lastPaymentReceiveDate')\r\n last_payment_principal_amount = dictionary.get('lastPaymentPrincipalAmount')\r\n last_payment_interest_amount = dictionary.get('lastPaymentInterestAmount')\r\n last_payment_escrow_amount = dictionary.get('lastPaymentEscrowAmount')\r\n last_payment_last_fee_amount = dictionary.get('lastPaymentLastFeeAmount')\r\n last_payment_late_charge = dictionary.get('lastPaymentLateCharge')\r\n ytd_principal_paid = dictionary.get('ytdPrincipalPaid')\r\n ytd_interest_paid = dictionary.get('ytdInterestPaid')\r\n ytd_insurance_paid = dictionary.get('ytdInsurancePaid')\r\n ytd_tax_paid = dictionary.get('ytdTaxPaid')\r\n auto_pay_enrolled = dictionary.get('autoPayEnrolled')\r\n collateral = dictionary.get('collateral')\r\n current_school = dictionary.get('currentSchool')\r\n first_payment_date = dictionary.get('firstPaymentDate')\r\n first_mortgage = dictionary.get('firstMortgage')\r\n loan_payment_freq = dictionary.get('loanPaymentFreq')\r\n original_school = dictionary.get('originalSchool')\r\n recurring_payment_amount = dictionary.get('recurringPaymentAmount')\r\n lender = dictionary.get('lender')\r\n ending_balance_amount = dictionary.get('endingBalanceAmount')\r\n loan_term_type = dictionary.get('loanTermType')\r\n payments_made = dictionary.get('paymentsMade')\r\n balloon_amount = dictionary.get('balloonAmount')\r\n projected_interest = dictionary.get('projectedInterest')\r\n interest_paid_ltd = dictionary.get('interestPaidLtd')\r\n interest_rate_type = dictionary.get('interestRateType')\r\n loan_payment_type = dictionary.get('loanPaymentType')\r\n repayment_plan = dictionary.get('repaymentPlan')\r\n payments_remaining = dictionary.get('paymentsRemaining')\r\n interest_margin_balance = dictionary.get('interestMarginBalance')\r\n short_balance = dictionary.get('shortBalance')\r\n available_cash_balance = dictionary.get('availableCashBalance')\r\n maturity_value_amount = dictionary.get('maturityValueAmount')\r\n vested_balance = dictionary.get('vestedBalance')\r\n emp_match_amount = dictionary.get('empMatchAmount')\r\n emp_pretax_contrib_amount = dictionary.get('empPretaxContribAmount')\r\n emp_pretax_contrib_amount_ytd = dictionary.get('empPretaxContribAmountYtd')\r\n contrib_total_ytd = dictionary.get('contribTotalYtd')\r\n cash_balance_amount = dictionary.get('cashBalanceAmount')\r\n pre_tax_amount = dictionary.get('preTaxAmount')\r\n after_tax_amount = dictionary.get('afterTaxAmount')\r\n match_amount = dictionary.get('matchAmount')\r\n profit_sharing_amount = dictionary.get('profitSharingAmount')\r\n rollover_amount = dictionary.get('rolloverAmount')\r\n other_vest_amount = dictionary.get('otherVestAmount')\r\n other_nonvest_amount = dictionary.get('otherNonvestAmount')\r\n current_loan_balance = dictionary.get('currentLoanBalance')\r\n loan_rate = dictionary.get('loanRate')\r\n buy_power = dictionary.get('buyPower')\r\n rollover_ltd = dictionary.get('rolloverLtd')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(available_balance_amount,\r\n posted_date,\r\n open_date,\r\n period_start_date,\r\n period_end_date,\r\n period_interest_rate,\r\n period_deposit_amount,\r\n period_interest_amount,\r\n interest_ytd_amount,\r\n interest_prior_ytd_amount,\r\n maturity_date,\r\n interest_rate,\r\n credit_available_amount,\r\n credit_max_amount,\r\n cash_advance_available_amount,\r\n cash_advance_max_amount,\r\n cash_advance_balance,\r\n cash_advance_interest_rate,\r\n current_balance,\r\n payment_min_amount,\r\n payment_due_date,\r\n previous_balance,\r\n statement_start_date,\r\n statement_end_date,\r\n statement_purchase_amount,\r\n statement_finance_amount,\r\n statement_credit_amount,\r\n reward_earned_balance,\r\n past_due_amount,\r\n last_payment_amount,\r\n last_payment_date,\r\n statement_close_balance,\r\n term_of_ml,\r\n ml_holder_name,\r\n description,\r\n late_fee_amount,\r\n payoff_amount,\r\n payoff_amount_date,\r\n original_maturity_date,\r\n principal_balance,\r\n escrow_balance,\r\n interest_period,\r\n initial_ml_amount,\r\n initial_ml_date,\r\n next_payment_principal_amount,\r\n next_payment_interest_amount,\r\n next_payment,\r\n next_payment_date,\r\n last_payment_due_date,\r\n last_payment_receive_date,\r\n last_payment_principal_amount,\r\n last_payment_interest_amount,\r\n last_payment_escrow_amount,\r\n last_payment_last_fee_amount,\r\n last_payment_late_charge,\r\n ytd_principal_paid,\r\n ytd_interest_paid,\r\n ytd_insurance_paid,\r\n ytd_tax_paid,\r\n auto_pay_enrolled,\r\n collateral,\r\n current_school,\r\n first_payment_date,\r\n first_mortgage,\r\n loan_payment_freq,\r\n original_school,\r\n recurring_payment_amount,\r\n lender,\r\n ending_balance_amount,\r\n loan_term_type,\r\n payments_made,\r\n balloon_amount,\r\n projected_interest,\r\n interest_paid_ltd,\r\n interest_rate_type,\r\n loan_payment_type,\r\n repayment_plan,\r\n payments_remaining,\r\n interest_margin_balance,\r\n short_balance,\r\n available_cash_balance,\r\n maturity_value_amount,\r\n vested_balance,\r\n emp_match_amount,\r\n emp_pretax_contrib_amount,\r\n emp_pretax_contrib_amount_ytd,\r\n contrib_total_ytd,\r\n cash_balance_amount,\r\n pre_tax_amount,\r\n after_tax_amount,\r\n match_amount,\r\n profit_sharing_amount,\r\n rollover_amount,\r\n other_vest_amount,\r\n other_nonvest_amount,\r\n current_loan_balance,\r\n loan_rate,\r\n buy_power,\r\n rollover_ltd,\r\n dictionary)","def from_montage_json(data: Mapping):\n\n # logging.debug(pformat(data['exam_type']))\n\n # TODO: Check event flags for various event types to get ordering, study, and reading\n\n try:\n referring_physician = data['events'][0].get('provider')\n if referring_physician:\n referring_physician = referring_physician.get('name')\n\n study_datetime = None\n if len(data['events']) > 1:\n # Last event is usually read I think, take event _before_ last one\n study_event = data['events'][-2]\n if study_event.get('date'):\n study_datetime = DatetimeParser.parse(study_event['date'])\n else:\n # Otherwise just take whatever is last\n study_event = data['events'][-1]\n if study_event.get('date'):\n study_datetime = DatetimeParser.parse(study_event['date'])\n\n montage_cpts = []\n for resource in data[\"exam_type\"][\"cpts\"]:\n code = resource.split(\"/\")[-2]\n montage_cpts.append(code)\n\n tags = {\n \"AccessionNumber\": data[\"accession_number\"],\n \"PatientID\": data[\"patient_mrn\"],\n 'StudyDescription': data['exam_type']['description'],\n 'ReferringPhysicianName': referring_physician,\n 'PatientSex': data['patient_sex'],\n 'Organization': data['organization']['label'],\n \"Modality\": data['exam_type']['modality']['label']\n }\n\n meta = {\n 'BodyParts': None, # Placeholder for meta\n 'CPTCodes': None, # Placeholder for meta\n 'PatientName': \"{}^{}\".format(\n data[\"patient_last_name\"].upper(),\n data[\"patient_first_name\"].upper()),\n 'PatientAge': data['patient_age'],\n \"OrderCode\": data[\"exam_type\"][\"code\"],\n \"PatientStatus\": data[\"patient_status\"],\n \"ReportText\": Montage.clean_text(data['text']),\n \"ReadingPhysiciansName\": data['events'][-1]['provider']['name'],\n 'StudyDateTime': study_datetime,\n \"MontageCPTCodes\": montage_cpts\n }\n except KeyError:\n meta = {\n \"BodyParts\": None,\n \"CPTCodes\": None,\n \"MontageCPTCodes\": data['meta']['MontageCPTCodes'],\n \"OrderCode\": data['meta']['OrderCode'],\n \"PatientAge\": data['meta']['PatientAge'],\n \"PatientName\": data['meta']['PatientName'],\n \"PatientStatus\": data['meta']['PatientStatus'],\n \"ReadingPhysiciansName\": data['meta']['ReadingPhysiciansName'],\n \"ReportText\": data['meta']['ReportText'],\n \"StudyDateTime\": data['meta']['StudyDateTime']\n }\n tags = {\n \"AccessionNumber\": data['tags']['AccessionNumber'],\n \"Modality\": data['tags']['Modality'],\n \"Organization\": data['tags']['Organization'],\n \"PatientID\": data['tags']['PatientID'],\n \"PatientSex\": data['tags']['PatientSex'],\n \"ReferringPhysicianName\": data['tags']['ReferringPhysicianName'],\n \"StudyDescription\": data['tags']['StudyDescription']\n }\n\n d = Dixel(meta=meta,\n tags=tags,\n level=DicomLevel.STUDIES)\n d.report = RadiologyReport(meta['ReportText'])\n\n return d","def multi_filter(self, characteristic_dict):\n\n corpus_copy = self.clone()\n corpus_copy.documents = []\n\n for metadata_field in characteristic_dict:\n if metadata_field not in self.metadata_fields:\n raise MissingMetadataError([metadata_field])\n\n for this_document in self.documents:\n add_document = True\n for metadata_field in characteristic_dict:\n if metadata_field == 'date':\n if this_document.date != int(characteristic_dict['date']):\n add_document = False\n else:\n if getattr(this_document, metadata_field) != characteristic_dict[metadata_field]:\n add_document = False\n if add_document:\n corpus_copy.documents.append(this_document)\n\n if not corpus_copy:\n # displays for possible errors in field.value\n err = f'This corpus is empty. You may have mistyped something.'\n raise AttributeError(err)\n\n return corpus_copy","def precipitation():\n\n return jsonify(prcp_df)","def get_metadata(hf_patients_file, metadata_file, output_file):\n\n # Use 'dicom_id' as names for row indices\n hf_patients = pd.read_csv(hf_patients_file, sep=',', index_col=\"dicom_id\")\n\n # Use 'dicom' as name\n metadata = pd.read_csv(metadata_file, index_col=\"dicom\", dtype={\"StudyDate\": str, \"StudyTime\": str})\n\n # Disregard all columns except 'subject_id' and 'study_id'\n hf_patients = pd.concat([hf_patients['study_id'], hf_patients['subject_id']], axis=1)\n\n # Find study date/time for heart failure patients\n study_date = metadata[\"StudyDate\"][hf_patients.index]\n study_time = metadata[\"StudyTime\"][hf_patients.index]\n\n result = pd.concat([hf_patients, study_date, study_time], axis=1)\n result = result.rename(columns={\"StudyDate\": \"study_date\", \"StudyTime\": \"study_time\"})\n\n result.to_csv(output_file)","def consent(self, consent):\n if consent is None:\n raise ValueError(\"Invalid value for `consent`, must not be `None`\") # noqa: E501\n\n self._consent = consent","def transform_data(redcap_data_json):\n redcap_data = pd.DataFrame(redcap_data_json)\n redcap_data.to_csv('data.csv')\n\n # Split data by event type\n enrollment_data = redcap_data[redcap_data['redcap_event_name']=='Enrollment']\n survey_data = redcap_data[redcap_data['redcap_event_name']!='Enrollment']\n survey_data['redcap_event_name'] = survey_data['redcap_event_name'].apply(lambda x: datetime.datetime(int(x[0:4]), int(x[5:7]), int(x[8:10]), 1, 0) if x[11:13] == \"AM\" else datetime.datetime(int(x[0:4]), int(x[5:7]), int(x[8:10]), 13, 0))\n\n # Exclude/Include relevant columns\n enrollment_data = enrollment_data[\n [\n 'record_id',\n 'redcap_event_name',\n 'ministry',\n 'facility',\n 'email',\n 'am_email_1',\n 'am_email_2',\n 'am_email_3',\n 'am_email_4',\n 'am_email_5',\n 'am_email_6',\n 'pm_email_1',\n 'pm_email_2',\n 'pm_email_3',\n 'pm_email_4',\n 'pm_email_5',\n 'pm_email_6',\n 'april_trigger',\n 'may_trigger',\n 'june_trigger',\n 'july_trigger',\n 'contact_market_facility_complete'\n ]\n ]\n\n survey_data = survey_data.drop(\n [\n 'email',\n 'am_email_1',\n 'am_email_2',\n 'am_email_3',\n 'am_email_4',\n 'am_email_5',\n 'am_email_6',\n 'pm_email_1',\n 'pm_email_2',\n 'pm_email_3',\n 'pm_email_4',\n 'pm_email_5',\n 'pm_email_6',\n 'april_trigger',\n 'may_trigger',\n 'june_trigger',\n 'july_trigger',\n 'contact_market_facility_complete'\n ], axis=1)\n\n # Fill Missing Data\n survey_data = survey_data.replace(\"\", np.nan) # Replace all empty strings with nan\n survey_data = survey_data.fillna(survey_data.groupby('record_id').ffill()) # Forward fill missing data\n survey_data = survey_data.fillna(survey_data.groupby('record_id').bfill()) # Backward fill missing data\n\n # Fill in survey data ministry and facility\n facility_params = {\n '40011': {'facility': 'StV Evansville Med Ctr', 'ministry': 'ININD'},\n '40017': {'facility': 'StV Warrick Hosp', 'ministry': 'ININD'},\n '46006': {'facility': 'StV Heart Ctr Indiana', 'ministry': 'ININD'},\n '46013': {'facility': 'St Vincent Seton Spec Hosp Indianapolis', 'ministry': 'ININD'},\n '46018': {'facility': 'StV Kokomo Hosp', 'ministry': 'ININD'},\n '46019': {'facility': 'StV Anderson Reg Hosp', 'ministry': 'ININD'},\n '46024': {'facility': 'StV Carmel Hosp', 'ministry': 'ININD'},\n '46029': {'facility': 'StV Indianapolis Hosp', 'ministry': 'ININD'},\n '46033': {'facility': 'StV Jennings Hosp', 'ministry': 'ININD'},\n '46036': {'facility': 'StV Mercy Hosp', 'ministry': 'ININD'},\n '46042': {'facility': 'StV Salem Hosp', 'ministry': 'ININD'},\n '46043': {'facility': 'StV Stress Ctr', 'ministry': 'ININD'},\n '46045': {'facility': 'StV Williamsport Hosp', 'ministry': 'ININD'},\n '46047': {'facility': 'StV Clay Hosp', 'ministry': 'ININD'},\n '46048': {'facility': 'StV Randolph Hosp', 'ministry': 'ININD'},\n '46052': {'facility': 'StV Dunn Hosp', 'ministry': 'ININD'},\n '46055': {'facility': 'StV Fishers', 'ministry': 'ININD'}\n }\n\n survey_data['ministry'] = survey_data.apply(lambda x: facility_params.get(x['record_id'], {}).get('ministry'), axis=1)\n survey_data['facility'] = survey_data.apply(lambda x: facility_params.get(x['record_id'], {}).get('facility'), axis=1)\n\n return enrollment_data, survey_data","def post_patient_edit(form):\n # Extract the data from the form and add extra fields.\n\n contacted_fields = [\"Contacted\", \"Comment\"]\n disabled_fields = [\"NextURL\"] + [x for x in form.data.keys() if re.search(r\"Disabled\", x) is not None]\n data = {k: v for (k, v) in form.data.items() if k not in disabled_fields \n and k not in contacted_fields}\n data[\"UpdatedBy\"] = get_current_user()\n data[\"UpdatedDateTime\"] = get_current_datetime()\n\n for k in [\"SymptomType\" + str(n) for n in list(range(1, 11))]:\n if data[k] != []:\n # keep only values that are not \"Select...\"\n data[k] = [v for v in data[k] if v not in [\"Select...\", \" \", \"\",]]\n if data[k] != []:\n data[k] = \"; \".join(data[k])\n else:\n data[k] = None\n else:\n data[k] = None\n\n args = form.data\n cs = get_patient_contacted_status(args)\n try:\n current_cs = cs[\"current\"][\"Contacted\"]\n except:\n current_cs = \"\"\n try:\n current_comment = cs[\"current\"][\"Comment\"]\n except:\n current_comment = \"\"\n cs_user_entered = form.Contacted.data\n cs_comment_user_entered = form.Comment.data\n if current_cs != cs_user_entered or current_comment != cs_comment_user_entered:\n post_patient_contacted_status(args)\n \n # Look up key data that should not be user-changeable. XXX ideally these\n # columns would simply be excluded from PersonEntered\n q = (\"select PatientLastName, PatientSSN \" +\n \"from {schema}.PersonCrosswalk \".format(schema=app_schema) +\n \"where PersonID = ?\")\n print(\"person id\", form.PersonID.data, file=sys.stderr)\n tb = pd.read_sql(q, engine, params=[form.PersonID.data])\n assert tb.shape[0] == 1, \"Expected 1 row, but got {} rows\".format(tb.shape[0])\n d = tb.iloc[0,:].to_dict()\n data[\"LastName\"] = d[\"PatientLastName\"]\n data[\"SSN\"] = d[\"PatientSSN\"]\n\n # Get cursor.\n conn = engine.raw_connection()\n cursor = conn.cursor()\n\n # Define and execute query to insert a new row.\n keys_str = \", \".join(data.keys())\n vals_str = \", \".join(\"?\" for _ in data.keys())\n params = list(data.values())\n q = (\"insert into {schema}.PersonEntered \".format(schema=app_schema) +\n \"(\" + keys_str + \") \" +\n \"values (\" + vals_str + \")\")\n cursor.execute(q, params)\n\n conn.commit()\n \n return None","def __init__(self, jsondict=None, strict=True):\n \n self.authority = None\n \"\"\" \n W\n h\n o\n i\n s\n r\n e\n s\n p\n o\n n\n s\n i\n b\n l\n e\n f\n o\n r\n p\n r\n o\n t\n o\n c\n o\n l\n .\n Type `FHIRReference` (represented as `dict` in JSON). \"\"\"\n \n self.date = None\n \"\"\" \n D\n a\n t\n e\n r\n e\n c\n o\n m\n m\n e\n n\n d\n a\n t\n i\n o\n n\n (\n s\n )\n c\n r\n e\n a\n t\n e\n d\n .\n Type `FHIRDate` (represented as `str` in JSON). \"\"\"\n \n self.identifier = None\n \"\"\" \n B\n u\n s\n i\n n\n e\n s\n s\n i\n d\n e\n n\n t\n i\n f\n i\n e\n r\n .\n List of `Identifier` items (represented as `dict` in JSON). \"\"\"\n \n self.patient = None\n \"\"\" \n W\n h\n o\n t\n h\n i\n s\n p\n r\n o\n f\n i\n l\n e\n i\n s\n f\n o\n r\n .\n Type `FHIRReference` (represented as `dict` in JSON). \"\"\"\n \n self.recommendation = None\n \"\"\" \n V\n a\n c\n c\n i\n n\n e\n a\n d\n m\n i\n n\n i\n s\n t\n r\n a\n t\n i\n o\n n\n r\n e\n c\n o\n m\n m\n e\n n\n d\n a\n t\n i\n o\n n\n s\n .\n List of `ImmunizationRecommendationRecommendation` items (represented as `dict` in JSON). \"\"\"\n \n super(ImmunizationRecommendation, self).__init__(jsondict=jsondict, strict=strict)","def _get_consent_validation_dataframe(self, sql_template):\n if not self.db_conn:\n raise (EnvironmentError, 'No active DB connection object')\n\n df = pandas.DataFrame()\n for consent_int in CONSENTS_LIST:\n sql = sql_template\n # The tuple retrieved from the CONSENT_PARTICIPANT_SUMMARY_FIELDS dict has two elements like:\n # ('consent_for_study_enrollment', 'consent_for_study_enrollment_first_yes_authored')\n consent_status_field = CONSENT_PARTICIPANT_SUMMARY_FIELDS[ConsentType(consent_int)][0]\n consent_authored_field = CONSENT_PARTICIPANT_SUMMARY_FIELDS[ConsentType(consent_int)][1]\n sql = sql.format_map(SafeDict(consent_type=consent_int,\n status_field=consent_status_field,\n authored_field=consent_authored_field,\n missing_check_mark=ConsentOtherErrors.MISSING_CONSENT_CHECK_MARK,\n non_va_for_va=ConsentOtherErrors.NON_VETERAN_CONSENT_FOR_VETERAN,\n va_for_non_va=ConsentOtherErrors.VETERAN_CONSENT_FOR_NON_VETERAN\n ))\n consent_df = pandas.read_sql_query(sql, self.db_conn)\n # Replace any null values in the calculated error flag columns with (uint8 vs. pandas default float) zeroes\n for error_type in TRACKED_CONSENT_ERRORS:\n consent_df = consent_df.fillna({error_type: 0}).astype({error_type: 'uint8'})\n\n df = df.append(consent_df)\n\n # Temporary? Attempt to filter false positives for va_consent_for_non_va consent version errors out of the\n # generated dataframe\n df = self._remove_potential_false_positives_for_consent_version(df)\n\n return df","def json(self):\n # Response legacy data: allow for any column to be null.\n document = {\n 'mhrNumber': self.mhr_number,\n 'documentType': self.document_type,\n 'documentRegistrationNumber': self.document_reg_id,\n 'interimed': self.interimed,\n 'ownerCrossReference': self.owner_cross_reference,\n 'interestDenominator': self.interest_denominator,\n 'declaredValue': self.declared_value,\n 'ownLand': self.own_land,\n 'routingSlipNumber': self.routing_slip_number,\n 'lastService': self.last_service,\n 'bcolAccount': self.bcol_account,\n 'datNumber': self.dat_number,\n 'examinerId': self.examiner_id,\n 'updateId': self.update_id,\n 'phoneNumber': self.phone_number,\n 'attentionReference': self.attention_reference,\n 'name': self.name,\n 'legacyAddress': self.legacy_address,\n 'numberOfPages': self.number_of_pages,\n 'considerationValue': self.consideration_value,\n 'affirmByName': self.affirm_by_name,\n 'liensWithConsent': self.liens_with_consent,\n 'clientReferenceId': self.client_reference_id\n }\n if self.draft_ts:\n document['draftDateTime'] = model_utils.format_local_ts(self.draft_ts)\n if self.registration_ts:\n document['createDateTime'] = model_utils.format_local_ts(self.registration_ts)\n if self.transfer_execution_date and self.transfer_execution_date.year > 1:\n document['transferDate'] = model_utils.format_local_date(self.transfer_execution_date)\n return document","def _get_bulk_cad_assessment_data(data):\n # pylint: disable=too-many-locals\n all_cads = db.session.query(\n CAD,\n all_models.Assessment.id,\n all_models.Assessment.title,\n all_models.Assessment.assessment_type,\n all_models.Assessment.slug,\n CAV.attribute_value,\n CAV.attribute_object_id,\n ).join(\n all_models.Assessment, CAD.definition_id == all_models.Assessment.id\n ).outerjoin(\n CAV, CAD.id == CAV.custom_attribute_id,\n ).filter(\n all_models.Assessment.id.in_(data[\"ids\"]),\n CAD.definition_type == 'assessment',\n )\n response_dict = OrderedDict()\n for (cad, asmt_id, asmt_title, asmt_type, asmt_slug,\n cav_value, cav_person_id) in all_cads:\n multi_choice_options = \",\".join(\n sorted(cad.multi_choice_options.split(','))\n ).lower() if cad.multi_choice_options else cad.multi_choice_options\n item_key = (cad.title, cad.attribute_type, cad.mandatory,\n multi_choice_options, cad.multi_choice_mandatory)\n item_response = response_dict.get(\n item_key,\n {\n \"attribute\": {\n \"attribute_type\": cad.attribute_type,\n \"title\": cad.title,\n \"default_value\": cad.default_value,\n \"multi_choice_options\": cad.multi_choice_options,\n \"multi_choice_mandatory\": cad.multi_choice_mandatory,\n \"mandatory\": cad.mandatory,\n \"placeholder\": None,\n },\n \"related_assessments\": {},\n \"assessments_with_values\": [],\n }\n )\n if cav_value:\n item_response[\"assessments_with_values\"].append({\n \"id\": asmt_id,\n \"title\": asmt_title,\n \"attribute_value\": cav_value,\n \"attribute_person_id\": cav_person_id,\n })\n if not item_response[\"related_assessments\"].get(asmt_type):\n item_response[\"related_assessments\"][asmt_type] = []\n item_response[\"related_assessments\"][asmt_type].append({\n \"id\": asmt_id,\n \"attribute_definition_id\": cad.id,\n \"slug\": asmt_slug,\n })\n response_dict[item_key] = item_response\n response = []\n\n for _, cad_item in response_dict.items():\n related_assessments = cad_item[\"related_assessments\"]\n cad_item[\"related_assessments\"] = {\"values\": []}\n asmt_count = 0\n for asmt_type, assessments in related_assessments.items():\n cad_item[\"related_assessments\"][\"values\"].append({\n \"assessments_type\": asmt_type,\n \"assessments\": assessments\n })\n asmt_count += len(assessments)\n cad_item[\"related_assessments\"][\"count\"] = asmt_count\n response.append(cad_item)\n return response","def from_dict(cls, dikt) -> 'ProjectConclusionInfo':\n return util.deserialize_model(dikt, cls)","def load_evictions_data(data_path, date_col, min_year, max_year, create_geoid = True):\n ev_raw = (\n pd.read_csv(\n data_path,\n parse_dates=[date_col],\n infer_datetime_format=True,\n )\n .dropna(how=\"all\")\n .drop_duplicates()\n )\n ev_raw[\"year\"] = ev_raw[date_col].dt.year\n ev_df = ev_raw[(ev_raw.year >= min_year) & (ev_raw.year <= max_year)]\n ev_df[\"year\"] = ev_df[\"year\"].astype(int)\n ev_df[\"month\"] = get_month_as_str_col(ev_df, date_col)\n \n if create_geoid == True:\n # Convert to strings\n ev_df[\"state_code\"] = ev_df[\"state_code\"].astype(str).replace(r'\\.0', '', regex = True) \n ev_df[\"county_code\"] = ev_df[\"county_code\"].astype(str).replace(r'\\.0', '', regex = True) \n ev_df[\"tract_code\"] = ev_df[\"tract_code\"].astype(str).replace(r'\\.0', '', regex = True)\n # Add zeroes as necessary\n ev_df[\"state_code\"] = ev_df[\"state_code\"].apply(lambda x: (((2-len(x)) * \"0\") + x) if len(x) < 2 else x)\n ev_df[\"county_code\"] = ev_df[\"county_code\"].apply(lambda x: (((3-len(x)) * \"0\") + x) if len(x) < 3 else x)\n ev_df[\"tract_code\"] = ev_df[\"tract_code\"].apply(lambda x: (((6-len(x)) * \"0\") + x) if len(x) < 6 else x)\n # Finally, concat everything\n ev_df[\"GEOID\"] = (\n ev_df[\"state_code\"] + ev_df[\"county_code\"] + ev_df[\"tract_code\"]\n )\n \n return ev_df","def get_dicom_metadata_and_slice_counts(dicom_path):\n row = {\n 'dicom_path': dicom_path,\n 'dicom_metadata': {},\n 'slice_count': None,\n 'errors': []\n }\n\n # Get metadata\n try:\n row['dicom_metadata'] = get_dicom_metadata(dicom_path)\n except Exception as e:\n row['errors'].append(str(e))\n\n # Get slice count\n try:\n row['slice_count'] = get_slice_count(dicom_path)\n except Exception as e:\n row['errors'].append(str(e))\n\n return row","def as_inator(dct):\n keyset = {'ident', 'name', 'location', 'description', 'condition', 'added'}\n if set(dct.keys()) == keyset:\n try:\n new_dct = dct.copy()\n new_dct['added'] = load_time(new_dct['added'])\n new_dct['condition'] = Condition(int(new_dct['condition']))\n return new_dct\n except ValueError:\n return dct\n else:\n return dct","def oldest_person_dc(all_profile_dict: dict) -> float:\n \"\"\"Param:all_profile_dc: dictionary containing all profiles\"\"\"\n value = min(all_profile_dict.values(), key=lambda v: v['birthdate'])\n date_today = datetime.date.today()\n age = (date_today - value['birthdate']).days\n return int(age/365)","def _convert_asset_timestamp_fields(dict_):\n for key in _asset_timestamp_fields & viewkeys(dict_):\n value = pd.Timestamp(dict_[key], tz='UTC')\n dict_[key] = None if isnull(value) else value\n return dict_","def convert_attributes_to_readable(attributes: dict[str, Any]) -> dict[str, Any]:\n attributes_fields_mapper = {'nbf': 'should_not_be_retrieved_Before',\n 'exp': 'expiry_time',\n 'created': 'create_time',\n 'updated': 'update_time',\n 'recoveryLevel': 'recovery_level'\n }\n\n for key, value in attributes_fields_mapper.items():\n if key in attributes:\n if key != 'recoveryLevel':\n attributes[value] = convert_timestamp_to_readable_date(attributes.pop(key))\n else:\n attributes[value] = attributes.pop(key)\n return attributes","def from_dict(cls, dikt) -> 'TextDateAnnotationAllOf':\n return util.deserialize_model(dikt, cls)","def __init__(self, jsondict=None, strict=True):\n \n self.amount = None\n \"\"\" Monetary amount.\n Type `Money` (represented as `dict` in JSON). \"\"\"\n \n self.category = None\n \"\"\" Type of adjudication information.\n Type `CodeableConcept` (represented as `dict` in JSON). \"\"\"\n \n self.reason = None\n \"\"\" Explanation of adjudication outcome.\n Type `CodeableConcept` (represented as `dict` in JSON). \"\"\"\n \n self.value = None\n \"\"\" Non-monetary value.\n Type `float`. \"\"\"\n \n super(ClaimResponseItemAdjudication, self).__init__(jsondict=jsondict, strict=strict)","def readData(self, dataDict):\n pass","def precipitation():\r\n # Query all measurements\r\n results = session.query(Measurement).all()\r\n\r\n # Create a dictionary from the row data and append to a list of all_precipitation\r\n all_precipitation = []\r\n\r\n for row in results:\r\n precipitation_dict = { row.date : row.prcp}\r\n all_precipitation.append(precipitation_dict)\r\n # print(all_precipitation)\r\n return jsonify(all_precipitation)","def get_data(self, date_time):\n columns = ','.join(['{}'.format(col) for col in self.table_columns])\n query = \"\"\"Select {columns} from (\n {table} \n inner join \n (Select * from DISPATCHCONSTRAINT where SETTLEMENTDATE == '{datetime}')\n on GENCONID == CONSTRAINTID\n and EFFECTIVEDATE == GENCONID_EFFECTIVEDATE\n and VERSIONNO == GENCONID_VERSIONNO);\"\"\"\n query = query.format(columns=columns, table=self.table_name, datetime=date_time)\n return pd.read_sql_query(query, con=self.con)","def event_generator(study, row):\n ev = copy.deepcopy(record_template)\n ev[\"study\"][\"dbgap_id\"] = study\n ev[\"study\"][\"sample_id\"] = row[1]\n ev[\"study\"][\"consent_code\"] = row[0]\n ev[\"study\"][\"consent_short_name\"] = row[2]\n return ev","def _extract_values_from_certificate(cert):\n logger = getLogger(__name__)\n # cert and serial number\n data = {\n u'cert': cert,\n u'issuer': cert.get_issuer().der(),\n u'serial_number': cert.get_serial_number(),\n u'algorithm': rfc2437.id_sha1,\n u'algorithm_parameter': univ.Any(hexValue='0500') # magic number\n }\n # DN Hash\n data[u'name'] = cert.get_subject()\n cert_der = data[u'name'].der()\n sha1_hash = hashlib.sha1()\n sha1_hash.update(cert_der)\n data[u'name_hash'] = sha1_hash.hexdigest()\n\n # public key Hash\n data['key_hash'] = _get_pubickey_sha1_hash(cert).hexdigest()\n\n # CRL and OCSP\n data['crl'] = None\n ocsp_uris0 = []\n for idx in range(cert.get_extension_count()):\n e = cert.get_extension(idx)\n if e.get_short_name() == b'authorityInfoAccess':\n for line in str(e).split(u\"\\n\"):\n m = OCSP_RE.match(line)\n if m:\n logger.debug(u'OCSP URL: %s', m.group(1))\n ocsp_uris0.append(m.group(1))\n elif e.get_short_name() == b'crlDistributionPoints':\n for line in str(e).split(u\"\\n\"):\n m = CRL_RE.match(line)\n if m:\n logger.debug(u\"CRL: %s\", m.group(1))\n data['crl'] = m.group(1)\n\n if len(ocsp_uris0) == 1:\n data['ocsp_uri'] = ocsp_uris0[0]\n elif len(ocsp_uris0) == 0:\n data['ocsp_uri'] = u''\n else:\n raise OperationalError(\n msg=u'More than one OCSP URI entries are specified in '\n u'the certificate',\n errno=ER_FAILED_TO_GET_OCSP_URI,\n )\n data[u'is_root_ca'] = cert.get_subject() == cert.get_issuer()\n return data","def _from_dict_transform(cls: Type[TVerifiedElementSubclass], data: Dict[str, Any]) -> Dict[str, Any]:\n data = super()._from_dict_transform(data)\n\n if 'verified' in data:\n data['is_verified'] = data.pop('verified')\n\n if 'verification_code' in data:\n del data['verification_code']\n\n return data","def test_invalid_research_consent(self):\n file = SimpleUploadedFile(\n \"test.csv\",\n b\"msisdn,facility code,id type,id number,messaging consent,\"\n b\"research_consent,edd year,edd month,edd day,baby dob year,\"\n b\"baby dob month,baby dob day\\n\"\n b\"+27820001001,123456,said,9001010001088,true,foo,2021,12,1,,,\\n\",\n )\n form = MomConnectImportForm(\n data={\"source\": \"MomConnect Import\"}, files={\"file\": file}\n )\n instance = form.save()\n self.assertEqual(instance.status, MomConnectImport.Status.ERROR)\n [error] = instance.errors.all()\n self.assertEqual(\n error.error,\n \"Field research_consent failed validation: “foo” value must be either \"\n \"True or False.\",\n )\n self.assertEqual(error.row_number, 2)","def process_ns_data(ns_data_dict, sensitive_keys, sharing_consent_value):\r\n ns_data_dict.reverse()\r\n\r\n processed_list_of_data = [process_single_ns_record(d, sensitive_keys, sharing_consent_value) for d in ns_data_dict]\r\n json_string = reduce(concat, processed_list_of_data, '')\r\n\r\n return json_string","def consult_law_decree(self, text_id: str, date: Optional[datetime] = None) -> Dict[str, Any]:\n self._update_client_if_necessary()\n return _consult_law_decree(text_id, date, self._client)","def write_prescription(self, disease: Disease, patient: Patient):\n prescription = Doctor.prescribe_medicines(disease, Prescription(doctor=self, patient=patient))\n patient.prescriptions.append(prescription)\n return prescription","def extract_data():\n raw_data = pd.read_csv(\"../../../resource/DataVisualization/vaccinations.csv\")\n raw_data = raw_data[[\"location\", \"date\", \"people_fully_vaccinated_per_hundred\"]]\n raw_data.date = pd.to_datetime(raw_data.date, format=\"%Y-%m-%d\")\n min_date = raw_data.date.min()\n raw_data.date = raw_data.date-min_date\n raw_data.date = pd.Series([x.days for x in raw_data.date])\n raw_data.drop(raw_data.loc[raw_data.people_fully_vaccinated_per_hundred.isnull()].index,\n axis=0, inplace=True)\n raw_data[\"people_fully_vaccinated_per_hundred\"] /= 100\n\n data_dict = dict()\n for country in raw_data.location.unique():\n if len(raw_data.loc[raw_data.location == country]) >= 100:\n tmp_data = raw_data.loc[raw_data.location == country]\n tmp_data.drop(\"location\", axis=1, inplace=True)\n data_dict[country] = {\"data\":tmp_data}\n else:\n raw_data.drop(raw_data.loc[raw_data.location ==\n country].index, inplace=True)\n return data_dict, min_date, raw_data","def registration_json(self):\n # Response legacy data: allow for any column to be null.\n self.strip()\n document = {\n 'documentId': self.id,\n 'documentRegistrationNumber': self.document_reg_id,\n 'documentType': self.document_type,\n 'mhrNumber': self.mhr_number,\n 'declaredValue': self.declared_value,\n 'ownLand': False,\n 'consideration': self.consideration_value,\n 'attentionReference': self.attention_reference,\n 'clientReferenceId': self.client_reference_id,\n 'submittingParty': self.submitting_party(),\n 'affirmByName': self.affirm_by_name\n }\n if self.own_land == 'Y':\n document['ownLand'] = True\n if self.transfer_execution_date and self.transfer_execution_date.year > 1900:\n document['transferDate'] = model_utils.format_local_date(self.transfer_execution_date)\n if self.registration_ts:\n document['createDateTime'] = model_utils.format_local_ts(self.registration_ts)\n return document","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n identifikasjon_field = idfy_rest_client.models.identifikasjon.Identifikasjon.from_dictionary(dictionary.get('identifikasjonField')) if dictionary.get('identifikasjonField') else None\r\n navn_adresse_field = idfy_rest_client.models.navn_adresse.NavnAdresse.from_dictionary(dictionary.get('navnAdresseField')) if dictionary.get('navnAdresseField') else None\r\n rating_field = idfy_rest_client.models.rating.Rating.from_dictionary(dictionary.get('ratingField')) if dictionary.get('ratingField') else None\r\n hist_rating_field = None\r\n if dictionary.get('histRatingField') != None:\r\n hist_rating_field = list()\r\n for structure in dictionary.get('histRatingField'):\r\n hist_rating_field.append(idfy_rest_client.models.historisk_rating.HistoriskRating.from_dictionary(structure))\r\n grunnfakta_field = idfy_rest_client.models.grunnfakta.Grunnfakta.from_dictionary(dictionary.get('grunnfaktaField')) if dictionary.get('grunnfaktaField') else None\r\n juridisk_field = None\r\n if dictionary.get('juridiskField') != None:\r\n juridisk_field = list()\r\n for structure in dictionary.get('juridiskField'):\r\n juridisk_field.append(idfy_rest_client.models.juridisk.Juridisk.from_dictionary(structure))\r\n verv_field = None\r\n if dictionary.get('vervField') != None:\r\n verv_field = list()\r\n for structure in dictionary.get('vervField'):\r\n verv_field.append(idfy_rest_client.models.verv.Verv.from_dictionary(structure))\r\n aksjonar_field = None\r\n if dictionary.get('aksjonarField') != None:\r\n aksjonar_field = list()\r\n for structure in dictionary.get('aksjonarField'):\r\n aksjonar_field.append(idfy_rest_client.models.aksjonar.Aksjonar.from_dictionary(structure))\r\n datterselskap_field = None\r\n if dictionary.get('datterselskapField') != None:\r\n datterselskap_field = list()\r\n for structure in dictionary.get('datterselskapField'):\r\n datterselskap_field.append(idfy_rest_client.models.datterselskap.Datterselskap.from_dictionary(structure))\r\n okonomi_enk_field = None\r\n if dictionary.get('okonomiEnkField') != None:\r\n okonomi_enk_field = list()\r\n for structure in dictionary.get('okonomiEnkField'):\r\n okonomi_enk_field.append(idfy_rest_client.models.okonomi_enk.OkonomiEnk.from_dictionary(structure))\r\n nokkeltall_foretak_field = None\r\n if dictionary.get('nokkeltallForetakField') != None:\r\n nokkeltall_foretak_field = list()\r\n for structure in dictionary.get('nokkeltallForetakField'):\r\n nokkeltall_foretak_field.append(idfy_rest_client.models.nokkeltall_foretak.NokkeltallForetak.from_dictionary(structure))\r\n nokkeltall_bransje_field = None\r\n if dictionary.get('nokkeltallBransjeField') != None:\r\n nokkeltall_bransje_field = list()\r\n for structure in dictionary.get('nokkeltallBransjeField'):\r\n nokkeltall_bransje_field.append(idfy_rest_client.models.nokkeltall_bransje.NokkeltallBransje.from_dictionary(structure))\r\n nokkeltall_konsern_field = None\r\n if dictionary.get('nokkeltallKonsernField') != None:\r\n nokkeltall_konsern_field = list()\r\n for structure in dictionary.get('nokkeltallKonsernField'):\r\n nokkeltall_konsern_field.append(idfy_rest_client.models.nokkeltall_konsern.NokkeltallKonsern.from_dictionary(structure))\r\n beta_sammendrag_field = idfy_rest_client.models.beta_sammendrag.BetaSammendrag.from_dictionary(dictionary.get('betaSammendragField')) if dictionary.get('betaSammendragField') else None\r\n beta_detaljer_field = None\r\n if dictionary.get('betaDetaljerField') != None:\r\n beta_detaljer_field = list()\r\n for structure in dictionary.get('betaDetaljerField'):\r\n beta_detaljer_field.append(idfy_rest_client.models.beta_detaljer.BetaDetaljer.from_dictionary(structure))\r\n losore_field = None\r\n if dictionary.get('losoreField') != None:\r\n losore_field = list()\r\n for structure in dictionary.get('losoreField'):\r\n losore_field.append(idfy_rest_client.models.losore.Losore.from_dictionary(structure))\r\n eiendom_norge_field = idfy_rest_client.models.eiendom_norge.EiendomNorge.from_dictionary(dictionary.get('eiendomNorgeField')) if dictionary.get('eiendomNorgeField') else None\r\n konsern_link_field = None\r\n if dictionary.get('konsernLinkField') != None:\r\n konsern_link_field = list()\r\n for structure in dictionary.get('konsernLinkField'):\r\n konsern_link_field.append(idfy_rest_client.models.konsern_link.KonsernLink.from_dictionary(structure))\r\n scoring_field = idfy_rest_client.models.scoring.Scoring.from_dictionary(dictionary.get('scoringField')) if dictionary.get('scoringField') else None\r\n okonomi_sammendrag_foretak_field = None\r\n if dictionary.get('okonomiSammendragForetakField') != None:\r\n okonomi_sammendrag_foretak_field = list()\r\n for structure in dictionary.get('okonomiSammendragForetakField'):\r\n okonomi_sammendrag_foretak_field.append(idfy_rest_client.models.okonomi_sammendrag_foretak.OkonomiSammendragForetak.from_dictionary(structure))\r\n okonomi_sammendrag_konsern_field = None\r\n if dictionary.get('okonomiSammendragKonsernField') != None:\r\n okonomi_sammendrag_konsern_field = list()\r\n for structure in dictionary.get('okonomiSammendragKonsernField'):\r\n okonomi_sammendrag_konsern_field.append(idfy_rest_client.models.okonomi_sammendrag_konsern.OkonomiSammendragKonsern.from_dictionary(structure))\r\n okonomi_detaljer_foretak_field = None\r\n if dictionary.get('okonomiDetaljerForetakField') != None:\r\n okonomi_detaljer_foretak_field = list()\r\n for structure in dictionary.get('okonomiDetaljerForetakField'):\r\n okonomi_detaljer_foretak_field.append(idfy_rest_client.models.okonomi_detaljer_foretak.OkonomiDetaljerForetak.from_dictionary(structure))\r\n okonomi_detaljer_konsern_field = None\r\n if dictionary.get('okonomiDetaljerKonsernField') != None:\r\n okonomi_detaljer_konsern_field = list()\r\n for structure in dictionary.get('okonomiDetaljerKonsernField'):\r\n okonomi_detaljer_konsern_field.append(idfy_rest_client.models.okonomi_detaljer_konsern.OkonomiDetaljerKonsern.from_dictionary(structure))\r\n eiendeler_foretak_field = None\r\n if dictionary.get('eiendelerForetakField') != None:\r\n eiendeler_foretak_field = list()\r\n for structure in dictionary.get('eiendelerForetakField'):\r\n eiendeler_foretak_field.append(idfy_rest_client.models.eiendeler_foretak.EiendelerForetak.from_dictionary(structure))\r\n eiendeler_konsern_field = None\r\n if dictionary.get('eiendelerKonsernField') != None:\r\n eiendeler_konsern_field = list()\r\n for structure in dictionary.get('eiendelerKonsernField'):\r\n eiendeler_konsern_field.append(idfy_rest_client.models.eiendeler_konsern.EiendelerKonsern.from_dictionary(structure))\r\n gjeld_egenkapital_foretak_field = None\r\n if dictionary.get('gjeldEgenkapitalForetakField') != None:\r\n gjeld_egenkapital_foretak_field = list()\r\n for structure in dictionary.get('gjeldEgenkapitalForetakField'):\r\n gjeld_egenkapital_foretak_field.append(idfy_rest_client.models.gjeld_egenkapital_foretak.GjeldEgenkapitalForetak.from_dictionary(structure))\r\n gjeld_egenkapital_konsern_field = None\r\n if dictionary.get('gjeldEgenkapitalKonsernField') != None:\r\n gjeld_egenkapital_konsern_field = list()\r\n for structure in dictionary.get('gjeldEgenkapitalKonsernField'):\r\n gjeld_egenkapital_konsern_field.append(idfy_rest_client.models.gjeld_egenkapital_konsern.GjeldEgenkapitalKonsern.from_dictionary(structure))\r\n avdeling_data_field = idfy_rest_client.models.avdeling_data.AvdelingData.from_dictionary(dictionary.get('avdelingDataField')) if dictionary.get('avdelingDataField') else None\r\n rettighetshavere_field = None\r\n if dictionary.get('rettighetshavereField') != None:\r\n rettighetshavere_field = list()\r\n for structure in dictionary.get('rettighetshavereField'):\r\n rettighetshavere_field.append(idfy_rest_client.models.rettighetshavere.Rettighetshavere.from_dictionary(structure))\r\n eiendom_norge_liste_field = None\r\n if dictionary.get('eiendomNorgeListeField') != None:\r\n eiendom_norge_liste_field = list()\r\n for structure in dictionary.get('eiendomNorgeListeField'):\r\n eiendom_norge_liste_field.append(idfy_rest_client.models.eiendom_norge_liste.EiendomNorgeListe.from_dictionary(structure))\r\n fullmakt_foretak_field = None\r\n if dictionary.get('fullmaktForetakField') != None:\r\n fullmakt_foretak_field = list()\r\n for structure in dictionary.get('fullmaktForetakField'):\r\n fullmakt_foretak_field.append(idfy_rest_client.models.fullmakt_foretak.FullmaktForetak.from_dictionary(structure))\r\n meldinger_field = None\r\n if dictionary.get('meldingerField') != None:\r\n meldinger_field = list()\r\n for structure in dictionary.get('meldingerField'):\r\n meldinger_field.append(idfy_rest_client.models.meldinger.Meldinger.from_dictionary(structure))\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(identifikasjon_field,\r\n navn_adresse_field,\r\n rating_field,\r\n hist_rating_field,\r\n grunnfakta_field,\r\n juridisk_field,\r\n verv_field,\r\n aksjonar_field,\r\n datterselskap_field,\r\n okonomi_enk_field,\r\n nokkeltall_foretak_field,\r\n nokkeltall_bransje_field,\r\n nokkeltall_konsern_field,\r\n beta_sammendrag_field,\r\n beta_detaljer_field,\r\n losore_field,\r\n eiendom_norge_field,\r\n konsern_link_field,\r\n scoring_field,\r\n okonomi_sammendrag_foretak_field,\r\n okonomi_sammendrag_konsern_field,\r\n okonomi_detaljer_foretak_field,\r\n okonomi_detaljer_konsern_field,\r\n eiendeler_foretak_field,\r\n eiendeler_konsern_field,\r\n gjeld_egenkapital_foretak_field,\r\n gjeld_egenkapital_konsern_field,\r\n avdeling_data_field,\r\n rettighetshavere_field,\r\n eiendom_norge_liste_field,\r\n fullmakt_foretak_field,\r\n meldinger_field,\r\n dictionary)","def row_to_incident(row):\n incident = {}\n raw = {underscoreToCamelCase(k): convert_to_string_if_datetime(v) for k, v in row.items()}\n incident[\"rawJSON\"] = json.dumps(raw)\n incident_name_field = demisto.params().get(\"incident_name_field\")\n if incident_name_field and incident_name_field in raw:\n incident[\"name\"] = raw[incident_name_field]\n return incident","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n insurance_policy_type_velue = dictionary.get('insurancePolicyTypeVelue')\r\n fire_insurance_policy_extend_view = easybimehlanding.models.fire_insurance_policy_extend_view.FireInsurancePolicyExtendView.from_dictionary(dictionary.get('fireInsurancePolicyExtendView')) if dictionary.get('fireInsurancePolicyExtendView') else None\r\n fire_insurance_policy_filter = easybimehlanding.models.fire_insurance_policy_filter.FireInsurancePolicyFilter.from_dictionary(dictionary.get('fireInsurancePolicyFilter')) if dictionary.get('fireInsurancePolicyFilter') else None\r\n id = dictionary.get('id')\r\n selected_insurance_policy_has_been_changed = dictionary.get('selectedInsurancePolicyHasBeenChanged')\r\n is_paymented = dictionary.get('isPaymented')\r\n has_conflict_document = dictionary.get('hasConflictDocument')\r\n is_insurance_centre_admin = dictionary.get('isInsuranceCentreAdmin')\r\n insurance_policy_payment_documents = dictionary.get('insurancePolicyPaymentDocuments')\r\n payable = dictionary.get('payable')\r\n paymented = dictionary.get('paymented')\r\n conflict = dictionary.get('conflict')\r\n initial_price = dictionary.get('initialPrice')\r\n final_price = dictionary.get('finalPrice')\r\n insurance_company_name = dictionary.get('insuranceCompanyName')\r\n insurance_centre_name = dictionary.get('insuranceCentreName')\r\n insurance_policy_conflict = dictionary.get('insurancePolicyConflict')\r\n insurance_policy_condition = dictionary.get('insurancePolicyCondition')\r\n person = dictionary.get('person')\r\n insurance_policy = dictionary.get('insurancePolicy')\r\n shopping_card = dictionary.get('shoppingCard')\r\n shopping_card_postal_packet = dictionary.get('shoppingCardPostalPacket')\r\n\r\n # Return an object of this model\r\n return cls(insurance_policy_type_velue,\r\n fire_insurance_policy_extend_view,\r\n fire_insurance_policy_filter,\r\n id,\r\n selected_insurance_policy_has_been_changed,\r\n is_paymented,\r\n has_conflict_document,\r\n is_insurance_centre_admin,\r\n insurance_policy_payment_documents,\r\n payable,\r\n paymented,\r\n conflict,\r\n initial_price,\r\n final_price,\r\n insurance_company_name,\r\n insurance_centre_name,\r\n insurance_policy_conflict,\r\n insurance_policy_condition,\r\n person,\r\n insurance_policy,\r\n shopping_card,\r\n shopping_card_postal_packet)","def precipitation():\n # Query \n results = session.query(Measurement.date, Measurement.prcp).all()\n \n dict = {}\n for result in results:\n dict[result.date] = result.prcp\n\n return jsonify(dict)","def precipitation():\n \n # Create session\n session = Session(engine)\n \n # Retrieve the most recent date\n result = session.query(Measurement).order_by(Measurement.date.desc()).limit(1)\n for row in result:\n latest_date = row.date\n\n # Convert to datetime format\n conv_latest_date = dt.datetime.strptime(latest_date , '%Y-%m-%d')\n \n # Calculate the date 1 year ago from the last data point in the database\n last_12_months = conv_latest_date - dt.timedelta(days=365)\n\n # Convert datetime to string\n conv_last_12_months = last_12_months.strftime('%Y-%m-%d')\n \n # Query\n precipitation = session.query(Measurement.date, Measurement.prcp).filter(Measurement.date <= latest_date).filter(Measurement.date >= conv_last_12_months).all()\n\n return jsonify(dict(precipitation))","def from_dict(cls, dikt) -> 'AcknowledgeClaimRequest':\n return util.deserialize_model(dikt, cls)","def convert_patient_to_feature(\n patient_data: Dict[str, object]\n) -> Dict[str, tf.train.Feature]:\n # TODO: Maybe prefix with \"patient/\" for post processing ease.\n return {\n \"patient_id\": int64_feature(patient_data.get(\"patient_id\")),\n \"age\": float_feature(patient_data.get(\"demographic_metadata\").get(\"age\")),\n \"race\": int64_feature(patient_data.get(\"demographic_metadata\").get(\"race\")),\n \"ERpos\": int64_feature(patient_data.get(\"clinical\").get(\"ERpos\")),\n \"Pgpos\": int64_feature(patient_data.get(\"clinical\").get(\"Pgpos\")),\n \"HRpos\": int64_feature(patient_data.get(\"clinical\").get(\"HRpos\")),\n \"HER_two_status\": int64_feature(\n patient_data.get(\"clinical\").get(\"HER_two_status\")\n ),\n \"three_level_HER\": int64_feature(\n patient_data.get(\"clinical\").get(\"three_level_HER\")\n ),\n \"Bilateral\": int64_feature(patient_data.get(\"clinical\").get(\"Bilateral\")),\n \"Laterality\": int64_feature(patient_data.get(\"clinical\").get(\"Laterality\")),\n # Outcomes\n \"Sstat\": int64_feature(patient_data.get(\"outcome\").get(\"Sstat\")),\n \"survival_duration\": int64_feature(\n patient_data.get(\"outcome\").get(\"survival_duration\")\n ),\n \"rfs_ind\": int64_feature(patient_data.get(\"outcome\").get(\"rfs_ind\")),\n \"rfs_duration\": int64_feature(patient_data.get(\"outcome\").get(\"rfs_duration\")),\n \"pCR\": int64_feature(patient_data.get(\"outcome\").get(\"pCR\")),\n \"RCB\": int64_feature(patient_data.get(\"outcome\").get(\"RCB\")),\n \"LD\": int64List_feature(patient_data.get(\"LD\")),\n }","def verify_and_clean_input(input_dict):\n \n output_dict = {}\n try:\n output_dict[\"Account ID\"] = int(input_dict[\"Account ID\"])\n if output_dict[\"Account ID\"] < 0:\n return False, {}, \"not a valid account id\"\n except ValueError:\n return False, {}, \"not a valid account id\"\n \n try:\n output_dict[\"Created On\"] = to_datetime(input_dict[\"Created On\"], errors='coerce').strftime(\"%x\")\n except ValueError:\n output_dict[\"Created On\"] = \"\"\n \n output_dict[\"First Name\"] = input_dict[\"First Name\"]\n \n return True, output_dict, \"\"","def get_contact_date(chat_id):\n # Reads the customers.json\n with open(json_dir + 'customers.json') as f:\n data = json.load(f)\n contact = None\n for d in data:\n # Searches the correct customer and returns all his values\n if d['contact']['chat_id'] == chat_id:\n contact = {'name': d['contact']['name'], 'postcode': d['contact']['postcode'],\n 'street': d['contact']['street'], 'city': d['contact']['city'], 'nr': d['contact']['nr'],\n 'phone': d['contact']['phone'], 'chat_id': d['contact']['chat_id']}\n break\n\n return contact","def precipitation():\n results = session.query(Measurement.date, Measurement.prcp).filter(Measurement.date >= '2016-08-23').order_by(Measurement.date)\n precipitation_values = []\n for p in results:\n prcp_dict = {}\n prcp_dict[\"date\"] = p.date\n prcp_dict[\"prcp\"] = p.prcp\n precipitation_values.append(prcp_dict)\n\n return jsonify(precipitation_values)","def get_bank_annotation(bank_id, bank_annotations_path):\n df = pd.read_csv(bank_annotations_path)\n df = df.set_index('bank_id')\n annotation_id = df.loc[bank_id, 'annotation_id']\n question_id = df.loc[bank_id, 'question_id']\n question_text = df.loc[bank_id, 'question_text']\n decomposition_accepted = df.loc[bank_id, 'decomposition_accepted']\n decomposition = df.loc[bank_id, 'decomposition']\n return BankAnnotationInfo(bank_id, annotation_id, question_id, question_text, decomposition, decomposition_accepted)","def from_dict(cls, dikt) -> 'AllOfCreateClaimResponseClaim':\n return util.deserialize_model(dikt, cls)","def ConferenceRecord(self, default={}):\n return HEP.JSONReferenceObject(self.data.get('conference_record', default))","def get_patients_dict(table):\n\tf = open(table)\n\tpatients = f.readline().strip().split(\"\\t\")[1:]\n\t\t \n\tpatients_dict = {}\n\tfor i in patients:\n\t\tpatients_dict[i.replace('\"', '')] = {}\n\t\t \n\tfor i in f:\n\t\tl = i.strip().split(\"\\t\")\n\t\tgene = l[0]\n\n\t\tfor j in range(len(l[1:])):\n\t\t\tpatients_dict[patients[j]][gene] = int(l[1:][j])\n\treturn patients_dict","def precipitation():\n \n # Obtain the current year from the date and using that date determine the previous year appending 01-01 and 12-31\n \n compare_date = dt.date.today()\n start_date = f\"{compare_date.year - 1}-01-01\"\n end_date = f\"{compare_date.year - 1}-12-31\"\n precipitation_result = session.query(Measurement).filter((Measurement.date >= start_date) & (Measurement.date <= end_date)\n ).order_by(Measurement.date).all()\n \n precipitation = []\n \n for row in precipitation_result:\n precipitation_dict = {}\n precipitation_dict[\"date\"] = row.date\n precipitation_dict[\"tobs\"] = row.tobs\n precipitation.append(precipitation_dict)\n \n return jsonify(precipitation)","def precip():\n # Query Measurement data\n session = Session(engine)\n results = session.query(Measurement.date, Measurement.prcp).all()\n\n # Create a dictionary from the row data and append to a list of precipitation data\n precip_data = []\n for date, prcp in results:\n precip_dict = {}\n precip_dict[\"date\"] = date\n precip_dict[\"Precipitation\"] = prcp\n precip_data.append(precip_dict)\n\n return jsonify(precip_data)","def precipitation():\n\n # Open sessions\n session = Session(bind=engine)\n\n # Find out what is the latest date with data\n lastDate=session.query(Measurement.date).order_by(Measurement.date.desc()).first()\n for date in lastDate:\n dataArray = date.split(\"-\")\n (year,month,day) = dataArray\n \n # Calculate the sate 1 year ago of the latest date\n year_ago = dt.date(int(year),int(month),int(day)) - dt.timedelta(days=365)\n\n # Define the varialbles for start and end date\n latestPrcpDate=f'{year}-{month}-{day}'\n oldestPrcpDate=year_ago.isoformat()\n\n # Initiating an empty dictionary\n precipitation={}\n\n # Query DB for preciitation values from start date to end date\n results=session.query(Measurement).filter(Measurement.date >= year_ago).all()\n for row in results:\n prcp={row.date:row.prcp} #storing the date and the measured value in a dictionary\n precipitation.update(prcp) #updating the main dictionary with the previous smaller dictionary\n\n # Calculating the main API dictionary with an info key, a date interval and the results/observations \n precipitationAPI={'info':'Last 12 months of precipitation data in inches',\n 'date interval':{'from':oldestPrcpDate,'to':latestPrcpDate},\n 'results':precipitation\n }\n\n # Returing the main dictionary in a JSON format API response \n return jsonify(precipitationAPI)","def precipitation():\n\n # first select the latest date\n latest_date, new_date = get_latest_date()\n\n # select date and precip for last 12 months\n results = session.query(Measurement.date, Measurement.prcp). \\\n filter(Measurement.date >= new_date). \\\n order_by(Measurement.date).all()\n\n # convert results to dictionary\n prec_dict = {}\n\n for r in results:\n prec_dict[r.date] = r.prcp\n\n return jsonify(prec_dict)","def form_data(self):\n from couchforms import XMLSyntaxError\n from .utils import convert_xform_to_json, adjust_datetimes\n from corehq.form_processor.utils.metadata import scrub_form_meta\n xml = self.get_xml()\n try:\n form_json = convert_xform_to_json(xml)\n except XMLSyntaxError:\n return {}\n # we can assume all sql domains are new timezone domains\n with force_phone_timezones_should_be_processed():\n adjust_datetimes(form_json)\n\n scrub_form_meta(self.form_id, form_json)\n return form_json","def create_patient(patient):\n\n pat = {\n 'resourceType': 'Patient',\n 'identifier': [\n {\n 'hosp_no': patient.pat_no\n }\n ],\n 'name': [\n {\n 'family': patient.sname,\n 'given': patient.fname\n }\n ],\n 'birthDate': patient.dob,\n 'gender': patient.gender,\n 'estimatedDischarge': patient.edd\n }\n\n return pat","def parse_patient_data(input_file, output_file):\n rows = []\n if os.path.exists(input_file):\n with open(input_file) as f:\n data = json.loads(f.read())\n for entry in data.get('entry', []):\n url = entry.get('fullUrl', '')\n resource = entry.get('resource', {})\n if not resource:\n print('resource not found for url %s in %s: please check' % (url, in_file), file=sys.stderr)\n continue\n\n resource_type = resource.get('resourceType', '').lower()\n if resource_type != 'patient':\n print('resource type is not patient for url %s in %s: please check' % (url, in_file), file=sys.stderr)\n continue\n\n resource_id = resource.get('id', '')\n last_updated = resource.get('meta', {}).get('lastUpdated', '')\n status = resource.get('text', {}).get('status', '').lower()\n system_id = resource.get('text', {}).get('value')\n active = resource.get('active', False)\n first_name = resource.get('name', {})[0].get('given', [''])[0]\n last_name = resource.get('name', {})[0].get('family', [''])\n phone = resource.get('telecom', [{}])[0].get('value', '')\n gender = resource.get('gender', '')\n address = resource.get('address', [{}])[0].get('value', '')\n\n rows.append([url, resource_id, last_updated, status, system_id, active, first_name, last_name, phone, gender, address])\n\n with open(output_file, 'w') as f:\n writer = csv.writer(f, dialect=csv.excel)\n writer.writerow(['url', 'resource_id', 'last_updated', 'status', 'system_id', 'active', 'first_name', 'last_name', 'phone', 'gender', 'address'])\n for row in rows:\n writer.writerow(row)","def get_patient_for_editing(args):\n\n q = (\"select coalesce(p.StreetAddress1, StreetAddress2, StreetAddress3) as StreetAddress, p.City, p.County, p.State, p.Zip \" +\n \"from {schema}.PersonCrosswalk x \".format(schema=app_schema) +\n \"left join {schema}.PersonCDW p on p.PersonID = x.PersonID \".format(schema=staging_schema) +\n \"where x.PersonID = ?\")\n tb = pd.read_sql(q, engine, params=[args[\"PersonID\"]])\n\n if tb.shape[0] != 1:\n person_cdw_dict = None\n else:\n person_cdw_dict = tb.iloc[0,:].to_dict()\n\n # Get person information from PersonCombined.\n tb = get_table_by_person_id(\"PersonCombined\", args[\"PersonID\"], schema=app_schema, fields=\"Edit\")\n if tb.shape[0] != 1:\n person_combined_dict = {} # Set to empty dict\n else:\n person_combined_dict = tb.iloc[0,:].to_dict() \n\n # Convert Symptomtype entries to be in a list b/c in the form these fields are multi select fields\n # For situations where we selected multiple symptoms, create a list\n symptoms_fields = [\"SymptomType\" + str(n) for n in list(range(1, 11))]\n\n if not person_combined_dict: # for newly added patients w/o VISTA data\n for k in symptoms_fields:\n person_combined_dict[k] = [None]\n else:\n for k in symptoms_fields:\n if person_combined_dict.get(k, None) is None: # if they have no existing values\n person_combined_dict[k] = [None] \n else:\n if person_combined_dict[k].count(\"; \"): # if they have more than one symptom listed\n person_combined_dict[k] = person_combined_dict[k].split(\"; \")\n else:\n person_combined_dict[k] = [person_combined_dict[k]]\n \n # Get test data from CDW/FileMan via TestCombined.\n q = (\"select * \" +\n \"from {schema}.TestCombined \".format(schema=app_schema) +\n \"where PersonID = ? and Source in ('CDW', 'FileMan')\")\n test_cdw_tb = pd.read_sql(q, engine, params=[args[\"PersonID\"]])\n test_simplified = coalesce_test_results.combine_results(test_cdw_tb)\n \n # Get Contacted Status - just for displaying on edit page\n person_contacted_dict = get_patient_contacted_status(args)\n if person_contacted_dict[\"current\"] is None:\n person_combined_dict[\"Contacted\"] = \"\"\n person_combined_dict[\"Comment\"] = \"\"\n else:\n person_combined_dict[\"Contacted\"] = person_contacted_dict[\"current\"][\"Contacted\"]\n person_combined_dict[\"Comment\"] = person_contacted_dict[\"current\"][\"Comment\"]\n\n # Get LastName and SSN from PersonCrosswalk (new Persons are anchored here initially).\n q = (\"select PatientLastName, PatientSSN \" +\n \"from {schema}.PersonCrosswalk \".format(schema=app_schema) +\n \"where PersonID = ?\")\n pxwalk_tb = pd.read_sql(q, engine, params=[args[\"PersonID\"]])\n pxwalk_dict = pxwalk_tb.iloc[0,:].to_dict() \n\n return {\"PersonCombined\": person_combined_dict,\n \"PersonCrosswalk\": pxwalk_dict,\n \"TestCDW\": test_simplified, \n \"HistoricalContact\": person_contacted_dict[\"historical\"],\n \"PersonCDW\": person_cdw_dict}"],"string":"[\n \"def patient_consent(self):\\n return 1 if self.patient_consent_date is not None else 0\",\n \"def patient_consent(self, value):\\n self.patient_consent_date = utcnow() if value else None\",\n \"def patient_consent_date(self, value):\\n self._patient_consent_date = value\\n self._patient_consent = 1 if value else 0\",\n \"def patient_consent(self):\\n return self.patient_consent_date != None # noqa: E711\",\n \"def patient_consent_date(self):\\n return self._patient_consent_date\",\n \"def read_dict(self, d: dict):\\n self.transaction_id = d.get('transaction_id')\\n\\n self.study_id = d.get('study_id')\\n self.patient_id = d.get('patient_id')\\n self.name = d.get('name')\\n birth_date = d.get('birth_date')\\n self.birth_date = datetime.datetime.strptime(\\n birth_date, \\\"%d/%m/%Y\\\") if birth_date else None\\n self.study_date = d.get('study_date')\\n self.patient_consent_date = self._read_patient_consent_date(d)\\n self.institution = d.get('institution')\\n\\n self.start_date = self._str_to_datetime(d.get('start_date'))\\n self.end_date = self._str_to_datetime(d.get('end_date'))\\n self.creation_date = self._str_to_datetime(d.get('creation_date'))\\n\\n self.version = d.get(\\\"version\\\")\\n self.analysis_type = d.get(\\\"analysis_type\\\")\\n self.qa_score = d.get(\\\"qa_score\\\")\\n self.product_id = d.get('product_id')\\n\\n self.task_state = TaskState[\\n d.get('task_state')] if d.get('task_state') else None\\n self.processing_state = d.get('processing_state')\\n self.task_progress = d.get('task_progress')\\n self.task_skipped = d.get('task_skipped')\\n self.task_cancelled = d.get('task_cancelled')\\n self.archived = d.get('archived')\\n self.error = d.get('error')\\n self.status = d.get('status')\\n self.sequences = d.get('sequences')\\n self.last_message = d.get('last_message')\\n\\n self.data_uploaded = self._str_to_datetime(d.get('data_uploaded'))\\n self.billable = d.get('billable')\\n self.priority = d.get('priority')\\n self.site_id = d.get('site_id', 0)\\n\\n return self\",\n \"async def request_inform_consent(request, patient_pkey):\\n client_key = general.get_request_key_header(request)\\n client_signer = general.get_signer(request, client_key)\\n grant_read_ehr_permission_txn = consent_transaction.request_inform_document_consent(\\n txn_signer=client_signer,\\n batch_signer=client_signer,\\n patient_pkey=patient_pkey)\\n\\n batch, batch_id = ehr_transaction.make_batch_and_id([grant_read_ehr_permission_txn], client_signer)\\n\\n await security_messaging.request_inform_document_consent(\\n request.app.config.VAL_CONN,\\n request.app.config.TIMEOUT,\\n [batch], client_key)\\n\\n try:\\n await security_messaging.check_batch_status(\\n request.app.config.VAL_CONN, [batch_id])\\n except (ApiBadRequest, ApiInternalError) as err:\\n # await auth_query.remove_auth_entry(\\n # request.app.config.DB_CONN, request.json.get('email'))\\n raise err\\n\\n return response.json(body={'status': general.DONE},\\n headers=general.get_response_headers())\",\n \"def get_patient_dict():\\r\\n return common.get_dict_all(get_patient_filename(), None)\",\n \"def validate(self, consentDict):\\n if(consentDict == None):\\n return self.composeResult(API.STATUS_CODE.FAILED, errorMessage=\\\"Invalid consent dictionary object (null) passed!\\\")\\n\\n missingAttrList = []\\n tableAttr = CustomerConsentDataTable.TABLE.ATTRIBUTE\\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CUSTOMER_MK)\\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.SOURCE_MARKET)\\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.COUNTRY)\\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CONTACT_TYPE)\\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CONSENT_STATUS)\\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, tableAttr.CONSENT_DATETIME)\\n\\n contactType = consentDict.get(tableAttr.CONTACT_TYPE)\\n contactTypeKey = self.contactTypeKeys.get(contactType)\\n self.__validate_checkAndAddToMissingAttrList(consentDict, missingAttrList, contactTypeKey)\\n\\n if(len(missingAttrList) > 0):\\n errorMessage = f\\\"Consent is missing mandatory attribute(s): {missingAttrList}!\\\"\\n return self.composeResult(API.STATUS_CODE.FAILED, errorMessage=errorMessage)\\n\\n return self.composeResult(API.STATUS_CODE.SUCCESS, data=consentDict)\",\n \"def test_consent_4(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-notAuthor.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_4(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_4(inst2)\",\n \"def test_consent_7(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-grantor.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_7(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_7(inst2)\",\n \"def test_consent_3(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-CDA.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_3(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_3(inst2)\",\n \"def test_consent_8(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-notOrg.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_8(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_8(inst2)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n id = dictionary.get('id')\\r\\n person_id = dictionary.get('personId')\\r\\n personality_type = dictionary.get('personalityType')\\r\\n insurance_centre_type = dictionary.get('insuranceCentreType')\\r\\n register_status = dictionary.get('registerStatus')\\r\\n center_name = dictionary.get('centerName')\\r\\n center_code = dictionary.get('centerCode')\\r\\n registration_number = dictionary.get('registrationNumber')\\r\\n free_use_golden_pack_expire_date = dictionary.get('freeUseGoldenPackExpireDate')\\r\\n city_id = dictionary.get('cityId')\\r\\n cash_payment = dictionary.get('cashPayment')\\r\\n show_in_easy_bimeh = dictionary.get('showInEasyBimeh')\\r\\n installments_payment = dictionary.get('installmentsPayment')\\r\\n is_initial_applicant = dictionary.get('isInitialApplicant')\\r\\n branchs_count = dictionary.get('branchsCount')\\r\\n employees_count = dictionary.get('employeesCount')\\r\\n white_label = dictionary.get('whiteLabel')\\r\\n phone = dictionary.get('phone')\\r\\n fax = dictionary.get('fax')\\r\\n address = dictionary.get('address')\\r\\n zip_code = dictionary.get('zipCode')\\r\\n email = dictionary.get('email')\\r\\n web_site = dictionary.get('webSite')\\r\\n latitude = dictionary.get('latitude')\\r\\n longitude = dictionary.get('longitude')\\r\\n is_active = dictionary.get('isActive')\\r\\n province_id = dictionary.get('provinceId')\\r\\n city_name = dictionary.get('cityName')\\r\\n meta_media_activity_licence_id = dictionary.get('metaMediaActivityLicenceId')\\r\\n create_on_persian_date = dictionary.get('createOnPersianDate')\\r\\n insurance_company_id = dictionary.get('insuranceCompanyId')\\r\\n active_package_id = dictionary.get('activePackageId')\\r\\n package_activation_last_date = dictionary.get('packageActivationLastDate')\\r\\n online_payment = dictionary.get('onlinePayment')\\r\\n card_to_card_payment = dictionary.get('cardToCardPayment')\\r\\n bank_transfer_payment = dictionary.get('bankTransferPayment')\\r\\n cash_on_delivery = dictionary.get('cashOnDelivery')\\r\\n bank_transfer_same_online_payment_info = dictionary.get('bankTransferSameOnlinePaymentInfo')\\r\\n bank_param_id = dictionary.get('bankParamId')\\r\\n account_owner = dictionary.get('accountOwner')\\r\\n account_number = dictionary.get('accountNumber')\\r\\n iban = dictionary.get('iban')\\r\\n card_bank_param_id = dictionary.get('cardBankParamId')\\r\\n card_account_owner = dictionary.get('cardAccountOwner')\\r\\n card_account_number = dictionary.get('cardAccountNumber')\\r\\n bank_transfer_param_id = dictionary.get('bankTransferParamId')\\r\\n bank_transfer_account_owner = dictionary.get('bankTransferAccountOwner')\\r\\n bank_transfer_account_number = dictionary.get('bankTransferAccountNumber')\\r\\n bank_transfer_iban = dictionary.get('bankTransferIBAN')\\r\\n branch_count = dictionary.get('branchCount')\\r\\n zone_id = dictionary.get('zoneId')\\r\\n sms_charging_stock = dictionary.get('smsChargingStock')\\r\\n independent_branch = dictionary.get('independentBranch')\\r\\n disable_reason = dictionary.get('disableReason')\\r\\n terms_conditions = dictionary.get('termsConditions')\\r\\n disable_reason_description = dictionary.get('disableReasonDescription')\\r\\n unlimited_account = dictionary.get('unlimitedAccount')\\r\\n payment_url = dictionary.get('paymentUrl')\\r\\n callback_url = dictionary.get('callbackUrl')\\r\\n callback_url_whitelabel = dictionary.get('callbackUrlWhitelabel')\\r\\n insurance_centre_id = dictionary.get('insuranceCentreId')\\r\\n city_region_id = dictionary.get('cityRegionId')\\r\\n meta_media_activity_licence_url = dictionary.get('metaMediaActivityLicenceUrl')\\r\\n license_api_key = dictionary.get('licenseApiKey')\\r\\n verify_request_url = dictionary.get('verifyRequestUrl')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(id,\\r\\n person_id,\\r\\n personality_type,\\r\\n insurance_centre_type,\\r\\n register_status,\\r\\n center_name,\\r\\n center_code,\\r\\n registration_number,\\r\\n free_use_golden_pack_expire_date,\\r\\n city_id,\\r\\n cash_payment,\\r\\n show_in_easy_bimeh,\\r\\n installments_payment,\\r\\n is_initial_applicant,\\r\\n branchs_count,\\r\\n employees_count,\\r\\n white_label,\\r\\n phone,\\r\\n fax,\\r\\n address,\\r\\n zip_code,\\r\\n email,\\r\\n web_site,\\r\\n latitude,\\r\\n longitude,\\r\\n is_active,\\r\\n province_id,\\r\\n city_name,\\r\\n meta_media_activity_licence_id,\\r\\n create_on_persian_date,\\r\\n insurance_company_id,\\r\\n active_package_id,\\r\\n package_activation_last_date,\\r\\n online_payment,\\r\\n card_to_card_payment,\\r\\n bank_transfer_payment,\\r\\n cash_on_delivery,\\r\\n bank_transfer_same_online_payment_info,\\r\\n bank_param_id,\\r\\n account_owner,\\r\\n account_number,\\r\\n iban,\\r\\n card_bank_param_id,\\r\\n card_account_owner,\\r\\n card_account_number,\\r\\n bank_transfer_param_id,\\r\\n bank_transfer_account_owner,\\r\\n bank_transfer_account_number,\\r\\n bank_transfer_iban,\\r\\n branch_count,\\r\\n zone_id,\\r\\n sms_charging_stock,\\r\\n independent_branch,\\r\\n disable_reason,\\r\\n terms_conditions,\\r\\n disable_reason_description,\\r\\n unlimited_account,\\r\\n payment_url,\\r\\n callback_url,\\r\\n callback_url_whitelabel,\\r\\n insurance_centre_id,\\r\\n city_region_id,\\r\\n meta_media_activity_licence_url,\\r\\n license_api_key,\\r\\n verify_request_url)\",\n \"def test_consent_1(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-notThis.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_1(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_1(inst2)\",\n \"def __init__(self, jsondict=None, strict=True):\\n \\n self.code = None\\n \\\"\\\"\\\" \\n T\\n y\\n p\\n e\\n o\\n f\\n d\\n a\\n t\\n e\\n .\\n Type `CodeableConcept` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.value = None\\n \\\"\\\"\\\" \\n R\\n e\\n c\\n o\\n m\\n m\\n e\\n n\\n d\\n e\\n d\\n d\\n a\\n t\\n e\\n .\\n Type `FHIRDate` (represented as `str` in JSON). \\\"\\\"\\\"\\n \\n super(ImmunizationRecommendationRecommendationDateCriterion, self).__init__(jsondict=jsondict, strict=strict)\",\n \"def test_consent_10(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_10(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_10(inst2)\",\n \"def __init__(self, jsondict=None, strict=True):\\n \\n self.appointmentType = None\\n \\\"\\\"\\\" \\n T\\n h\\n e\\n s\\n t\\n y\\n l\\n e\\n o\\n f\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n o\\n r\\n p\\n a\\n t\\n i\\n e\\n n\\n t\\n t\\n h\\n a\\n t\\n h\\n a\\n s\\n b\\n e\\n e\\n n\\n b\\n o\\n o\\n k\\n e\\n d\\n i\\n n\\n t\\n h\\n e\\n s\\n l\\n o\\n t\\n (\\n n\\n o\\n t\\n s\\n e\\n r\\n v\\n i\\n c\\n e\\n t\\n y\\n p\\n e\\n )\\n .\\n Type `CodeableConcept` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.basedOn = None\\n \\\"\\\"\\\" \\n T\\n h\\n e\\n s\\n e\\n r\\n v\\n i\\n c\\n e\\n r\\n e\\n q\\n u\\n e\\n s\\n t\\n t\\n h\\n i\\n s\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n i\\n s\\n a\\n l\\n l\\n o\\n c\\n a\\n t\\n e\\n d\\n t\\n o\\n a\\n s\\n s\\n e\\n s\\n s\\n .\\n List of `FHIRReference` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.cancelationReason = None\\n \\\"\\\"\\\" \\n T\\n h\\n e\\n c\\n o\\n d\\n e\\n d\\n r\\n e\\n a\\n s\\n o\\n n\\n f\\n o\\n r\\n t\\n h\\n e\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n b\\n e\\n i\\n n\\n g\\n c\\n a\\n n\\n c\\n e\\n l\\n l\\n e\\n d\\n .\\n Type `CodeableConcept` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.comment = None\\n \\\"\\\"\\\" \\n A\\n d\\n d\\n i\\n t\\n i\\n o\\n n\\n a\\n l\\n c\\n o\\n m\\n m\\n e\\n n\\n t\\n s\\n .\\n Type `str`. \\\"\\\"\\\"\\n \\n self.created = None\\n \\\"\\\"\\\" \\n T\\n h\\n e\\n d\\n a\\n t\\n e\\n t\\n h\\n a\\n t\\n t\\n h\\n i\\n s\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n w\\n a\\n s\\n i\\n n\\n i\\n t\\n i\\n a\\n l\\n l\\n y\\n c\\n r\\n e\\n a\\n t\\n e\\n d\\n .\\n Type `FHIRDate` (represented as `str` in JSON). \\\"\\\"\\\"\\n \\n self.description = None\\n \\\"\\\"\\\" \\n S\\n h\\n o\\n w\\n n\\n o\\n n\\n a\\n s\\n u\\n b\\n j\\n e\\n c\\n t\\n l\\n i\\n n\\n e\\n i\\n n\\n a\\n m\\n e\\n e\\n t\\n i\\n n\\n g\\n r\\n e\\n q\\n u\\n e\\n s\\n t\\n ,\\n o\\n r\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n l\\n i\\n s\\n t\\n .\\n Type `str`. \\\"\\\"\\\"\\n \\n self.end = None\\n \\\"\\\"\\\" \\n W\\n h\\n e\\n n\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n i\\n s\\n t\\n o\\n c\\n o\\n n\\n c\\n l\\n u\\n d\\n e\\n .\\n Type `FHIRDate` (represented as `str` in JSON). \\\"\\\"\\\"\\n \\n self.identifier = None\\n \\\"\\\"\\\" \\n E\\n x\\n t\\n e\\n r\\n n\\n a\\n l\\n I\\n d\\n s\\n f\\n o\\n r\\n t\\n h\\n i\\n s\\n i\\n t\\n e\\n m\\n .\\n List of `Identifier` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.minutesDuration = None\\n \\\"\\\"\\\" \\n C\\n a\\n n\\n b\\n e\\n l\\n e\\n s\\n s\\n t\\n h\\n a\\n n\\n s\\n t\\n a\\n r\\n t\\n /\\n e\\n n\\n d\\n (\\n e\\n .\\n g\\n .\\n e\\n s\\n t\\n i\\n m\\n a\\n t\\n e\\n )\\n .\\n Type `int`. \\\"\\\"\\\"\\n \\n self.participant = None\\n \\\"\\\"\\\" \\n P\\n a\\n r\\n t\\n i\\n c\\n i\\n p\\n a\\n n\\n t\\n s\\n i\\n n\\n v\\n o\\n l\\n v\\n e\\n d\\n i\\n n\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n .\\n List of `AppointmentParticipant` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.patientInstruction = None\\n \\\"\\\"\\\" \\n D\\n e\\n t\\n a\\n i\\n l\\n e\\n d\\n i\\n n\\n f\\n o\\n r\\n m\\n a\\n t\\n i\\n o\\n n\\n a\\n n\\n d\\n i\\n n\\n s\\n t\\n r\\n u\\n c\\n t\\n i\\n o\\n n\\n s\\n f\\n o\\n r\\n t\\n h\\n e\\n p\\n a\\n t\\n i\\n e\\n n\\n t\\n .\\n Type `str`. \\\"\\\"\\\"\\n \\n self.priority = None\\n \\\"\\\"\\\" \\n U\\n s\\n e\\n d\\n t\\n o\\n m\\n a\\n k\\n e\\n i\\n n\\n f\\n o\\n r\\n m\\n e\\n d\\n d\\n e\\n c\\n i\\n s\\n i\\n o\\n n\\n s\\n i\\n f\\n n\\n e\\n e\\n d\\n i\\n n\\n g\\n t\\n o\\n r\\n e\\n -\\n p\\n r\\n i\\n o\\n r\\n i\\n t\\n i\\n z\\n e\\n .\\n Type `int`. \\\"\\\"\\\"\\n \\n self.reasonCode = None\\n \\\"\\\"\\\" \\n C\\n o\\n d\\n e\\n d\\n r\\n e\\n a\\n s\\n o\\n n\\n t\\n h\\n i\\n s\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n i\\n s\\n s\\n c\\n h\\n e\\n d\\n u\\n l\\n e\\n d\\n .\\n List of `CodeableConcept` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.reasonReference = None\\n \\\"\\\"\\\" \\n R\\n e\\n a\\n s\\n o\\n n\\n t\\n h\\n e\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n i\\n s\\n t\\n o\\n t\\n a\\n k\\n e\\n p\\n l\\n a\\n c\\n e\\n (\\n r\\n e\\n s\\n o\\n u\\n r\\n c\\n e\\n )\\n .\\n List of `FHIRReference` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.requestedPeriod = None\\n \\\"\\\"\\\" \\n P\\n o\\n t\\n e\\n n\\n t\\n i\\n a\\n l\\n d\\n a\\n t\\n e\\n /\\n t\\n i\\n m\\n e\\n i\\n n\\n t\\n e\\n r\\n v\\n a\\n l\\n (\\n s\\n )\\n r\\n e\\n q\\n u\\n e\\n s\\n t\\n e\\n d\\n t\\n o\\n a\\n l\\n l\\n o\\n c\\n a\\n t\\n e\\n t\\n h\\n e\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n w\\n i\\n t\\n h\\n i\\n n\\n .\\n List of `Period` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.serviceCategory = None\\n \\\"\\\"\\\" \\n A\\n b\\n r\\n o\\n a\\n d\\n c\\n a\\n t\\n e\\n g\\n o\\n r\\n i\\n z\\n a\\n t\\n i\\n o\\n n\\n o\\n f\\n t\\n h\\n e\\n s\\n e\\n r\\n v\\n i\\n c\\n e\\n t\\n h\\n a\\n t\\n i\\n s\\n t\\n o\\n b\\n e\\n p\\n e\\n r\\n f\\n o\\n r\\n m\\n e\\n d\\n d\\n u\\n r\\n i\\n n\\n g\\n t\\n h\\n i\\n s\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n .\\n List of `CodeableConcept` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.serviceType = None\\n \\\"\\\"\\\" \\n T\\n h\\n e\\n s\\n p\\n e\\n c\\n i\\n f\\n i\\n c\\n s\\n e\\n r\\n v\\n i\\n c\\n e\\n t\\n h\\n a\\n t\\n i\\n s\\n t\\n o\\n b\\n e\\n p\\n e\\n r\\n f\\n o\\n r\\n m\\n e\\n d\\n d\\n u\\n r\\n i\\n n\\n g\\n t\\n h\\n i\\n s\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n .\\n List of `CodeableConcept` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.slot = None\\n \\\"\\\"\\\" \\n T\\n h\\n e\\n s\\n l\\n o\\n t\\n s\\n t\\n h\\n a\\n t\\n t\\n h\\n i\\n s\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n i\\n s\\n f\\n i\\n l\\n l\\n i\\n n\\n g\\n .\\n List of `FHIRReference` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.specialty = None\\n \\\"\\\"\\\" \\n T\\n h\\n e\\n s\\n p\\n e\\n c\\n i\\n a\\n l\\n t\\n y\\n o\\n f\\n a\\n p\\n r\\n a\\n c\\n t\\n i\\n t\\n i\\n o\\n n\\n e\\n r\\n t\\n h\\n a\\n t\\n w\\n o\\n u\\n l\\n d\\n b\\n e\\n r\\n e\\n q\\n u\\n i\\n r\\n e\\n d\\n t\\n o\\n p\\n e\\n r\\n f\\n o\\n r\\n m\\n t\\n h\\n e\\n s\\n e\\n r\\n v\\n i\\n c\\n e\\n r\\n e\\n q\\n u\\n e\\n s\\n t\\n e\\n d\\n i\\n n\\n t\\n h\\n i\\n s\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n .\\n List of `CodeableConcept` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.start = None\\n \\\"\\\"\\\" \\n W\\n h\\n e\\n n\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n i\\n s\\n t\\n o\\n t\\n a\\n k\\n e\\n p\\n l\\n a\\n c\\n e\\n .\\n Type `FHIRDate` (represented as `str` in JSON). \\\"\\\"\\\"\\n \\n self.status = None\\n \\\"\\\"\\\" \\n p\\n r\\n o\\n p\\n o\\n s\\n e\\n d\\n |\\n p\\n e\\n n\\n d\\n i\\n n\\n g\\n |\\n b\\n o\\n o\\n k\\n e\\n d\\n |\\n a\\n r\\n r\\n i\\n v\\n e\\n d\\n |\\n f\\n u\\n l\\n f\\n i\\n l\\n l\\n e\\n d\\n |\\n c\\n a\\n n\\n c\\n e\\n l\\n l\\n e\\n d\\n |\\n n\\n o\\n s\\n h\\n o\\n w\\n |\\n e\\n n\\n t\\n e\\n r\\n e\\n d\\n -\\n i\\n n\\n -\\n e\\n r\\n r\\n o\\n r\\n |\\n c\\n h\\n e\\n c\\n k\\n e\\n d\\n -\\n i\\n n\\n |\\n w\\n a\\n i\\n t\\n l\\n i\\n s\\n t\\n .\\n Type `str`. \\\"\\\"\\\"\\n \\n self.supportingInformation = None\\n \\\"\\\"\\\" \\n A\\n d\\n d\\n i\\n t\\n i\\n o\\n n\\n a\\n l\\n i\\n n\\n f\\n o\\n r\\n m\\n a\\n t\\n i\\n o\\n n\\n t\\n o\\n s\\n u\\n p\\n p\\n o\\n r\\n t\\n t\\n h\\n e\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n .\\n List of `FHIRReference` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n super(Appointment, self).__init__(jsondict=jsondict, strict=strict)\",\n \"def __init__(self, jsondict=None, strict=True):\\n \\n self.businessArrangement = None\\n \\\"\\\"\\\" Additional provider contract number.\\n Type `str`. \\\"\\\"\\\"\\n \\n self.claimResponse = None\\n \\\"\\\"\\\" Adjudication results.\\n Type `FHIRReference` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.coverage = None\\n \\\"\\\"\\\" Insurance information.\\n Type `FHIRReference` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.focal = None\\n \\\"\\\"\\\" Coverage to be used for adjudication.\\n Type `bool`. \\\"\\\"\\\"\\n \\n self.sequence = None\\n \\\"\\\"\\\" Insurance instance identifier.\\n Type `int`. \\\"\\\"\\\"\\n \\n super(ClaimResponseInsurance, self).__init__(jsondict=jsondict, strict=strict)\",\n \"def date_returner_dict(ict):\\n if \\\"date\\\" in ict.keys():\\n return ict[\\\"date\\\"]\\n\\n if \\\"updated_at\\\" in ict.keys():\\n return ict[\\\"updated_at\\\"]\",\n \"def test_consent_9(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-pkb.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_9(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_9(inst2)\",\n \"def precipitation():\\n precip = session.query(Measurement.date, Measurement.prcp).filter(Measurement.date >= prev_year).all()\\n\\n # Create a dictionary from the row data and append to a list \\n precip_dict = {}\\n for date, prcp in precip:\\n if prcp !=None:\\n precip_dict.setdefault(date, []).append(prcp)\\n\\n return jsonify(precip_dict)\",\n \"def parse_conservations(variant, parsed_transcripts=None):\\n parsed_transcripts = parsed_transcripts or []\\n conservations = {}\\n\\n conservation_keys = {\\n \\\"info_keys\\\": {\\n \\\"gerp\\\": \\\"dbNSFP_GERP___RS\\\",\\n \\\"phast\\\": \\\"dbNSFP_phastCons100way_vertebrate\\\",\\n \\\"phylop\\\": \\\"dbNSFP_phyloP100way_vertebrate\\\",\\n }\\n }\\n\\n # First check if information is in INFO\\n for key in conservation_keys[\\\"info_keys\\\"]:\\n value = conservation_keys[\\\"info_keys\\\"][key]\\n result = None\\n if value and variant.INFO.get(value):\\n result = parse_conservation_info(variant, value, key)\\n elif len(parsed_transcripts) > 0:\\n result = parse_conservation_csq(parsed_transcripts[0], key)\\n\\n conservations[key] = result\\n\\n return conservations\",\n \"def test_consent_6(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-notThem.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_6(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_6(inst2)\",\n \"def precipitation():\\r\\n # Calculate the date 1 year ago from last date in database\\r\\n prev_year = dt.date(2017, 8, 23) - dt.timedelta(days=365)\\r\\n\\r\\n # Query for the date and precipitation for the last year\\r\\n precipitation = session.query(Measurement.date, Measurement.prcp).\\\\\\r\\n filter(Measurement.date >= prev_year).all()\\r\\n\\r\\n # Dict with date as the key and prcp as the value\\r\\n precip = {date: prcp for date, prcp in precipitation}\\r\\n return jsonify(precip)\",\n \"def row_to_clinvar_submission(\\n row: pandas.Series,\\n assertion_criteria: dict,\\n submission_name=default_submission_name()):\\n # row_idx = row.name\\n # misc fields\\n\\n local_id = row[\\\"A\\\"]\\n local_key = row[\\\"B\\\"]\\n record_status = row[\\\"CR\\\"]#.replace(None, \\\"novel\\\") # novel or update\\n if record_status is None:\\n record_status = \\\"novel\\\"\\n release_status = \\\"public\\\"\\n # variantSet\\n variant_set = {\\n \\\"variant\\\": [{\\n \\\"gene\\\": [{\\\"symbol\\\": e.strip() for e in row[\\\"C\\\"].split(\\\";\\\")}],\\n \\\"hgvs\\\": row[\\\"D\\\"] + \\\":\\\" + row[\\\"E\\\"]\\n }]\\n }\\n # conditionSet\\n condition_set = {\\n \\\"condition\\\": [{\\n \\\"db\\\": row[\\\"AD\\\"],\\n \\\"id\\\": row[\\\"AE\\\"]\\n }]\\n }\\n # clinicalSignificance\\n clinsig_description = normalize_clinical_significance_description(row[\\\"AK\\\"])\\n # clinsig_date_last_evaluated = serialize_date(row[\\\"AL\\\"])\\n # Date has already been serialized to YYYY-mm-dd\\n clinsig_date_last_evaluated = row[\\\"AL\\\"]\\n clinsig_mode_of_inheritance = row[\\\"AO\\\"]\\n clinsig_comment = row[\\\"AR\\\"]\\n clinsig_citations = parse_citations(row[\\\"AP\\\"])\\n if pandas.notnull(row[\\\"AQ\\\"]):\\n clinsig_citations.append({\\\"url\\\": row[\\\"AQ\\\"]})\\n # observedIn\\n observed_in = [{\\n \\\"collectionMethod\\\": row[\\\"AX\\\"],\\n \\\"alleleOrigin\\\": row[\\\"AY\\\"],\\n \\\"affectedStatus\\\": row[\\\"AZ\\\"],\\n \\\"numberOfIndividuals\\\": 0\\n }]\\n\\n # assertionCriteria is taken from caller\\n doc = {\\n \\\"assertionCriteria\\\": assertion_criteria,\\n \\\"clinicalSignificance\\\": {\\n \\\"citation\\\": clinsig_citations,\\n \\\"clinicalSignificanceDescription\\\": clinsig_description,\\n \\\"comment\\\": clinsig_comment,\\n \\\"dateLastEvaluated\\\": clinsig_date_last_evaluated,\\n \\\"modeOfInheritance\\\": clinsig_mode_of_inheritance\\n },\\n \\\"conditionSet\\\": condition_set,\\n \\\"localID\\\": local_id,\\n \\\"localKey\\\": local_key,\\n \\\"observedIn\\\": observed_in,\\n \\\"recordStatus\\\": record_status,\\n \\\"releaseStatus\\\": release_status,\\n \\\"variantSet\\\": variant_set\\n }\\n # if clinsig_mode_of_inheritance is not None:\\n # doc[\\\"clinvarSubmission\\\"][0][\\\"clinicalSignificance\\\"][\\\"modeOfInheritance\\\"] = clinsig_mode_of_inheritance\\n if record_status == \\\"update\\\":\\n clinvar_accession = row[\\\"CQ\\\"]\\n if clinvar_accession is None or len(clinvar_accession) == 0:\\n raise RuntimeError(\\\"accession (column CQ) must be provided for updates (%s)\\\" % doc)\\n doc[\\\"clinvarAccession\\\"] = clinvar_accession\\n\\n # Remove any fields for which the value is None, or any list elements that are None\\n doc = removenone(doc)\\n return doc\",\n \"def precipitation():\\n # Query for the dates and precipitation observations from the last year.\\n # Convert the query results to a Dictionary using `date` as the key and `prcp` as the value.\\n # Return the json representation of your dictionary.\\n query_date = session.query(Measurement.date).order_by(Measurement.date.desc()).first() \\n query_date = query_date[0]\\n query_date = dt.datetime.strptime(query_date,'%Y-%m-%d').date()\\n start_date_datetime = query_date - dt.timedelta(days=365)\\n results= session.query(Measurement.date, Measurement.prcp).\\\\\\n filter (Measurement.date >= start_date_datetime).all()\\n prcp= {date:prcp for date,prcp in results}\\n return jsonify (prcp)\",\n \"def __init__(self, jsondict=None, strict=True):\\n \\n self.characteristicCodeableConcept = None\\n \\\"\\\"\\\" Specific characteristic that is relevant to the administration\\n guideline.\\n Type `CodeableConcept` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.characteristicQuantity = None\\n \\\"\\\"\\\" Specific characteristic that is relevant to the administration\\n guideline.\\n Type `Quantity` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.value = None\\n \\\"\\\"\\\" The specific characteristic.\\n List of `str` items. \\\"\\\"\\\"\\n \\n super(MedicationKnowledgeAdministrationGuidelinesPatientCharacteristics, self).__init__(jsondict=jsondict, strict=strict)\",\n \"def test_consent_5(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-notTime.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_5(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_5(inst2)\",\n \"def precip():\\n date_prcp=session.query(measurements.date,measurements.prcp).all()\\n date_prcp_df=pd.DataFrame(date_prcp).set_index('date')\\n date_prcp_dict=date_prcp_df.to_dict()\\n return jsonify(date_prcp_dict)\",\n \"def get_district_data(district):\\n with open(district_data_dir + 'district-data.json') as f:\\n district_dict = json.load(f)\\n\\n district_data = []\\n for date, data in district_dict.items():\\n if date == \\\"03/02/2020\\\":\\n continue\\n if district in data:\\n district_data.append((date, data[district]['infected']))\\n\\n return district_data\",\n \"def __init__(self, jsondict=None, strict=True):\\n \\n self.actor = None\\n \\\"\\\"\\\" \\n P\\n e\\n r\\n s\\n o\\n n\\n ,\\n L\\n o\\n c\\n a\\n t\\n i\\n o\\n n\\n /\\n H\\n e\\n a\\n l\\n t\\n h\\n c\\n a\\n r\\n e\\n S\\n e\\n r\\n v\\n i\\n c\\n e\\n o\\n r\\n D\\n e\\n v\\n i\\n c\\n e\\n .\\n Type `FHIRReference` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.period = None\\n \\\"\\\"\\\" \\n P\\n a\\n r\\n t\\n i\\n c\\n i\\n p\\n a\\n t\\n i\\n o\\n n\\n p\\n e\\n r\\n i\\n o\\n d\\n o\\n f\\n t\\n h\\n e\\n a\\n c\\n t\\n o\\n r\\n .\\n Type `Period` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.required = None\\n \\\"\\\"\\\" \\n r\\n e\\n q\\n u\\n i\\n r\\n e\\n d\\n |\\n o\\n p\\n t\\n i\\n o\\n n\\n a\\n l\\n |\\n i\\n n\\n f\\n o\\n r\\n m\\n a\\n t\\n i\\n o\\n n\\n -\\n o\\n n\\n l\\n y\\n .\\n Type `str`. \\\"\\\"\\\"\\n \\n self.status = None\\n \\\"\\\"\\\" \\n a\\n c\\n c\\n e\\n p\\n t\\n e\\n d\\n |\\n d\\n e\\n c\\n l\\n i\\n n\\n e\\n d\\n |\\n t\\n e\\n n\\n t\\n a\\n t\\n i\\n v\\n e\\n |\\n n\\n e\\n e\\n d\\n s\\n -\\n a\\n c\\n t\\n i\\n o\\n n\\n .\\n Type `str`. \\\"\\\"\\\"\\n \\n self.type = None\\n \\\"\\\"\\\" \\n R\\n o\\n l\\n e\\n o\\n f\\n p\\n a\\n r\\n t\\n i\\n c\\n i\\n p\\n a\\n n\\n t\\n i\\n n\\n t\\n h\\n e\\n a\\n p\\n p\\n o\\n i\\n n\\n t\\n m\\n e\\n n\\n t\\n .\\n List of `CodeableConcept` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n super(AppointmentParticipant, self).__init__(jsondict=jsondict, strict=strict)\",\n \"def __init__(self, jsondict=None, strict=True):\\n \\n self.addItem = None\\n \\\"\\\"\\\" Insurer added line items.\\n List of `ClaimResponseAddItem` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.adjudication = None\\n \\\"\\\"\\\" Header-level adjudication.\\n List of `ClaimResponseItemAdjudication` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.communicationRequest = None\\n \\\"\\\"\\\" Request for additional information.\\n List of `FHIRReference` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.created = None\\n \\\"\\\"\\\" Response creation date.\\n Type `FHIRDate` (represented as `str` in JSON). \\\"\\\"\\\"\\n \\n self.disposition = None\\n \\\"\\\"\\\" Disposition Message.\\n Type `str`. \\\"\\\"\\\"\\n \\n self.error = None\\n \\\"\\\"\\\" Processing errors.\\n List of `ClaimResponseError` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.form = None\\n \\\"\\\"\\\" Printed reference or actual form.\\n Type `Attachment` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.formCode = None\\n \\\"\\\"\\\" Printed form identifier.\\n Type `CodeableConcept` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.fundsReserve = None\\n \\\"\\\"\\\" Funds reserved status.\\n Type `CodeableConcept` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.identifier = None\\n \\\"\\\"\\\" Business Identifier for a claim response.\\n List of `Identifier` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.insurance = None\\n \\\"\\\"\\\" Patient insurance information.\\n List of `ClaimResponseInsurance` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.insurer = None\\n \\\"\\\"\\\" Party responsible for reimbursement.\\n Type `FHIRReference` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.item = None\\n \\\"\\\"\\\" Adjudication for claim line items.\\n List of `ClaimResponseItem` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.outcome = None\\n \\\"\\\"\\\" queued | complete | error | partial.\\n Type `str`. \\\"\\\"\\\"\\n \\n self.patient = None\\n \\\"\\\"\\\" The recipient of the products and services.\\n Type `FHIRReference` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.payeeType = None\\n \\\"\\\"\\\" Party to be paid any benefits payable.\\n Type `CodeableConcept` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.payment = None\\n \\\"\\\"\\\" Payment Details.\\n Type `ClaimResponsePayment` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.preAuthPeriod = None\\n \\\"\\\"\\\" Preauthorization reference effective period.\\n Type `Period` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.preAuthRef = None\\n \\\"\\\"\\\" Preauthorization reference.\\n Type `str`. \\\"\\\"\\\"\\n \\n self.processNote = None\\n \\\"\\\"\\\" Note concerning adjudication.\\n List of `ClaimResponseProcessNote` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.request = None\\n \\\"\\\"\\\" Id of resource triggering adjudication.\\n Type `FHIRReference` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.requestor = None\\n \\\"\\\"\\\" Party responsible for the claim.\\n Type `FHIRReference` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.status = None\\n \\\"\\\"\\\" active | cancelled | draft | entered-in-error.\\n Type `str`. \\\"\\\"\\\"\\n \\n self.subType = None\\n \\\"\\\"\\\" More granular claim type.\\n Type `CodeableConcept` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.total = None\\n \\\"\\\"\\\" Adjudication totals.\\n List of `ClaimResponseTotal` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.type = None\\n \\\"\\\"\\\" More granular claim type.\\n Type `CodeableConcept` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.use = None\\n \\\"\\\"\\\" claim | preauthorization | predetermination.\\n Type `str`. \\\"\\\"\\\"\\n \\n super(ClaimResponse, self).__init__(jsondict=jsondict, strict=strict)\",\n \"def get_consent(session):\\n cookie = session.session_cookies.filter(name='cookie-accepted').first()\\n if cookie:\\n return cookie.value\\n return None\",\n \"def process_single_ns_record(target_dict, sensitive_key_names, sharing_consent_value):\\r\\n return dict_to_minified_json_string(\\r\\n add_sharing_consent(\\r\\n sub_sensitive_key(target_dict, sensitive_key_names),\\r\\n sharing_consent_value\\r\\n )\\r\\n )\",\n \"def test_consent_2(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"consent-example-smartonfhir.json\\\"\\n inst = consent.Consent.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Consent\\\" == inst.resource_type\\n\\n impl_consent_2(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Consent\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = consent.Consent(**data)\\n impl_consent_2(inst2)\",\n \"def test_research_consent_default(self):\\n file = SimpleUploadedFile(\\n \\\"test.csv\\\",\\n b\\\"msisdn,facility code,id type,id number,messaging consent,\\\"\\n b\\\"research_consent,edd year,edd month,edd day,baby dob year,\\\"\\n b\\\"baby dob month,baby dob day\\\\n\\\"\\n b\\\"+27820001001,123456,said,9001010001088,true,,2021,12,1,,,\\\\n\\\",\\n )\\n form = MomConnectImportForm(\\n data={\\\"source\\\": \\\"MomConnect Import\\\"}, files={\\\"file\\\": file}\\n )\\n instance = form.save()\\n self.assertEqual(instance.status, MomConnectImport.Status.VALIDATING)\\n self.assertEqual(instance.errors.count(), 0)\\n [row] = instance.rows.all()\\n self.assertFalse(row.research_consent)\",\n \"def get_attribute_consent(taxCode):\\n content_type = request.headers.get(\\\"Content-Type\\\", \\\"\\\")\\n assert content_type.lower() == \\\"application/jose\\\"\\n\\n user_data = _get_user_data(taxCode)\\n if not user_data:\\n return problem(\\n title=\\\"User Not Found\\\", status=404, detail=\\\"Missing user\\\"\\n )\\n\\n try:\\n claims = validate_token(request.data, audience=app.config[\\\"entityId\\\"])\\n except jwt.exceptions.InvalidTokenError as e:\\n return invalid_token_handler(e)\\n except Exception as e:\\n raise ValueError(e, request.data)\\n\\n assert claims[\\\"v\\\"] == \\\"0.0.1\\\", claims\\n assert claims[\\\"attributes\\\"], claims\\n\\n if user_data[\\\"consent\\\"] + 30 < time():\\n return problem(\\n status=403,\\n title=\\\"ConsentRequired\\\",\\n detail=\\\"User consent is required for this attribute. Last given: %r\\\"\\n % datetime.fromtimestamp(user_data[\\\"consent\\\"]),\\n type=\\\"https://spid.gov.it/aa/problem/consent-required\\\",\\n ext={\\\"consent_url\\\": \\\"https://aa/v1/consents/{taxCode}/\\\"},\\n )\\n\\n aa = [\\n {\\\"attribute\\\": a, \\\"value\\\": user_data[a]}\\n for a in claims[\\\"attributes\\\"]\\n if a in user_data\\n ]\\n\\n token = create_token({\\\"v\\\": \\\"0.0.1\\\", \\\"attributes\\\": aa})\\n token[\\\"iss\\\"] = app.config[\\\"entityId\\\"]\\n token[\\\"aud\\\"] = claims[\\\"iss\\\"]\\n\\n signed_token = sign_request(token, app_config=app.config)\\n\\n return Response(\\n response=signed_token, status=200, mimetype=\\\"application/jose\\\"\\n )\",\n \"def age_first_admission(patient_id: str) -> int:\\r\\n cur = con.cursor()\\r\\n cache: dict[str, int] = {}\\r\\n if patient_id in cache:\\r\\n return cache[patient_id]\\r\\n\\r\\n age = cur.execute(\\r\\n \\\"\\\"\\\"SELECT (JULIANDAY(Lab_Date) - JULIANDAY(Date_Of_Birth)) / ?\\r\\n FROM Lab l\\r\\n INNER JOIN Patient p ON l.Patient_ID = p.Patient_ID\\r\\n WHERE l.Patient_ID = ?\\r\\n AND Admission_ID = 1\\\"\\\"\\\",\\r\\n [DAYS_IN_YEAR, patient_id],\\r\\n ).fetchall()\\r\\n\\r\\n age_as_int = int(age[0][0])\\r\\n cache[patient_id] = age_as_int\\r\\n\\r\\n return age_as_int # O(1)\\r\",\n \"def sentence_data(self):\\n sentence_data = pd.read_csv(self.path + 'data/sentence_data.csv')\\n \\n # convert date to datetime\\n sentence_data['date'] = pd.to_datetime(sentence_data['date'], errors='coerce')\\n sentence_data['date'] = sentence_data['date'].dt.date\\n \\n # filtering weird dates\\n mask = (sentence_data['date'].astype('str') >= \\\"2020-03-01\\\") & (sentence_data['date'].astype('str') < \\\"2020-04-03\\\")\\n sentence_data = sentence_data.loc[mask]\\n \\n self._sentence_data = sentence_data\\n \\n return self._sentence_data\",\n \"def find_transcript_data(row):\\n #Calls create_transcript_df which creates a df for each transcript.\\n trans_df = create_transcript_df(\\n row, row['teacher_handle'].strip(), \\n row['student_handle'].strip(), row['transcript'].strip())\\n #Finds the first response time and defines it as the First Response Time (FRT)\\n rt, frt = rt_data(trans_df)\\n student_response, teacher_response = response_lengths(trans_df)\\n #vocab = the total number of vocab words used in the transcript.\\n vocab_list = np.asarray([item for sublist in trans_df.vocab.values for item in sublist])\\n session_length_secs = (trans_df.Time_Stamps.iloc[-1] - trans_df.Time_Stamps.iloc[0]).seconds\\n \\n #Finding student to teacher ratio, round to nearest hundreth.\\n exchange_ratio = round(trans_df.Student_Bool.sum()/float((trans_df['Student_Bool']==False).sum()),2)\\n #returns all of the data found above, place in new columns under plain df.\\n return trans_df.to_dict(), frt, rt, trans_df.vocab_count.sum(), vocab_list, trans_df.approp_count.sum(), session_length_secs, student_response, teacher_response, exchange_ratio,trans_df.has_drag_drop.sum()\",\n \"def get_patient_info(file_path):\\n f = open(file_path, 'rb')\\n content = f.read()\\n f.close()\\n\\n header = content[:88]\\n patient_id = header[8:88].decode('ascii')\\n # the headers \\\"fixed\\\" by tuh nedc data team show a '-' right before the age of the patient. therefore add this to\\n # the regex and use the absolute value of the casted age\\n [age] = re.findall(\\\"Age:(-?\\\\d+)\\\", patient_id)\\n [sex] = re.findall(\\\"\\\\s\\\\w\\\\s\\\", patient_id)\\n\\n sex_id = 0 if sex.strip() == 'M' else 1\\n\\n return sex_id, abs(int(age))\",\n \"def precipitation():\\n # Calculate teh date 1 year ago from last date in database\\n prev_year = dt.date(2017, 8, 23) - dt.timedelta(days=365)\\n # Query for the date and precipitation for the last year\\n precipitation = session.query(Measurement.date, Measurement.prcp).\\\\\\n filter(Measurement.date >= prev_year).all()\\n \\n precip = {date: prcp for date, prcp in precipitation}\\n return jsonify(precip)\",\n \"def load_reseq_conditions_from(json_file_or_dict):\\n\\n # refactor that common useage from TC io\\n if isinstance(json_file_or_dict, dict):\\n d = json_file_or_dict\\n else:\\n with open(json_file_or_dict, 'r') as f:\\n d = json.loads(f.read())\\n\\n return ReseqConditions.from_dict(d)\",\n \"def load_patient_data(db_dir, patient_id, include_labels=True, unzipped=False):\\n signal = load_signal(db_dir, patient_id, unzipped=unzipped)\\n if include_labels:\\n labels = load_labels(db_dir, patient_id, unzipped=unzipped)\\n return signal, labels\\n else:\\n return signal, None\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n available_balance_amount = dictionary.get('availableBalanceAmount')\\r\\n posted_date = dictionary.get('postedDate')\\r\\n open_date = dictionary.get('openDate')\\r\\n period_start_date = dictionary.get('periodStartDate')\\r\\n period_end_date = dictionary.get('periodEndDate')\\r\\n period_interest_rate = dictionary.get('periodInterestRate')\\r\\n period_deposit_amount = dictionary.get('periodDepositAmount')\\r\\n period_interest_amount = dictionary.get('periodInterestAmount')\\r\\n interest_ytd_amount = dictionary.get('interestYtdAmount')\\r\\n interest_prior_ytd_amount = dictionary.get('interestPriorYtdAmount')\\r\\n maturity_date = dictionary.get('maturityDate')\\r\\n interest_rate = dictionary.get('interestRate')\\r\\n credit_available_amount = dictionary.get('creditAvailableAmount')\\r\\n credit_max_amount = dictionary.get('creditMaxAmount')\\r\\n cash_advance_available_amount = dictionary.get('cashAdvanceAvailableAmount')\\r\\n cash_advance_max_amount = dictionary.get('cashAdvanceMaxAmount')\\r\\n cash_advance_balance = dictionary.get('cashAdvanceBalance')\\r\\n cash_advance_interest_rate = dictionary.get('cashAdvanceInterestRate')\\r\\n current_balance = dictionary.get('currentBalance')\\r\\n payment_min_amount = dictionary.get('paymentMinAmount')\\r\\n payment_due_date = dictionary.get('paymentDueDate')\\r\\n previous_balance = dictionary.get('previousBalance')\\r\\n statement_start_date = dictionary.get('statementStartDate')\\r\\n statement_end_date = dictionary.get('statementEndDate')\\r\\n statement_purchase_amount = dictionary.get('statementPurchaseAmount')\\r\\n statement_finance_amount = dictionary.get('statementFinanceAmount')\\r\\n statement_credit_amount = dictionary.get('statementCreditAmount')\\r\\n reward_earned_balance = dictionary.get('rewardEarnedBalance')\\r\\n past_due_amount = dictionary.get('pastDueAmount')\\r\\n last_payment_amount = dictionary.get('lastPaymentAmount')\\r\\n last_payment_date = dictionary.get('lastPaymentDate')\\r\\n statement_close_balance = dictionary.get('statementCloseBalance')\\r\\n term_of_ml = dictionary.get('termOfMl')\\r\\n ml_holder_name = dictionary.get('mlHolderName')\\r\\n description = dictionary.get('description')\\r\\n late_fee_amount = dictionary.get('lateFeeAmount')\\r\\n payoff_amount = dictionary.get('payoffAmount')\\r\\n payoff_amount_date = dictionary.get('payoffAmountDate')\\r\\n original_maturity_date = dictionary.get('originalMaturityDate')\\r\\n principal_balance = dictionary.get('principalBalance')\\r\\n escrow_balance = dictionary.get('escrowBalance')\\r\\n interest_period = dictionary.get('interestPeriod')\\r\\n initial_ml_amount = dictionary.get('initialMlAmount')\\r\\n initial_ml_date = dictionary.get('initialMlDate')\\r\\n next_payment_principal_amount = dictionary.get('nextPaymentPrincipalAmount')\\r\\n next_payment_interest_amount = dictionary.get('nextPaymentInterestAmount')\\r\\n next_payment = dictionary.get('nextPayment')\\r\\n next_payment_date = dictionary.get('nextPaymentDate')\\r\\n last_payment_due_date = dictionary.get('lastPaymentDueDate')\\r\\n last_payment_receive_date = dictionary.get('lastPaymentReceiveDate')\\r\\n last_payment_principal_amount = dictionary.get('lastPaymentPrincipalAmount')\\r\\n last_payment_interest_amount = dictionary.get('lastPaymentInterestAmount')\\r\\n last_payment_escrow_amount = dictionary.get('lastPaymentEscrowAmount')\\r\\n last_payment_last_fee_amount = dictionary.get('lastPaymentLastFeeAmount')\\r\\n last_payment_late_charge = dictionary.get('lastPaymentLateCharge')\\r\\n ytd_principal_paid = dictionary.get('ytdPrincipalPaid')\\r\\n ytd_interest_paid = dictionary.get('ytdInterestPaid')\\r\\n ytd_insurance_paid = dictionary.get('ytdInsurancePaid')\\r\\n ytd_tax_paid = dictionary.get('ytdTaxPaid')\\r\\n auto_pay_enrolled = dictionary.get('autoPayEnrolled')\\r\\n collateral = dictionary.get('collateral')\\r\\n current_school = dictionary.get('currentSchool')\\r\\n first_payment_date = dictionary.get('firstPaymentDate')\\r\\n first_mortgage = dictionary.get('firstMortgage')\\r\\n loan_payment_freq = dictionary.get('loanPaymentFreq')\\r\\n original_school = dictionary.get('originalSchool')\\r\\n recurring_payment_amount = dictionary.get('recurringPaymentAmount')\\r\\n lender = dictionary.get('lender')\\r\\n ending_balance_amount = dictionary.get('endingBalanceAmount')\\r\\n loan_term_type = dictionary.get('loanTermType')\\r\\n payments_made = dictionary.get('paymentsMade')\\r\\n balloon_amount = dictionary.get('balloonAmount')\\r\\n projected_interest = dictionary.get('projectedInterest')\\r\\n interest_paid_ltd = dictionary.get('interestPaidLtd')\\r\\n interest_rate_type = dictionary.get('interestRateType')\\r\\n loan_payment_type = dictionary.get('loanPaymentType')\\r\\n repayment_plan = dictionary.get('repaymentPlan')\\r\\n payments_remaining = dictionary.get('paymentsRemaining')\\r\\n interest_margin_balance = dictionary.get('interestMarginBalance')\\r\\n short_balance = dictionary.get('shortBalance')\\r\\n available_cash_balance = dictionary.get('availableCashBalance')\\r\\n maturity_value_amount = dictionary.get('maturityValueAmount')\\r\\n vested_balance = dictionary.get('vestedBalance')\\r\\n emp_match_amount = dictionary.get('empMatchAmount')\\r\\n emp_pretax_contrib_amount = dictionary.get('empPretaxContribAmount')\\r\\n emp_pretax_contrib_amount_ytd = dictionary.get('empPretaxContribAmountYtd')\\r\\n contrib_total_ytd = dictionary.get('contribTotalYtd')\\r\\n cash_balance_amount = dictionary.get('cashBalanceAmount')\\r\\n pre_tax_amount = dictionary.get('preTaxAmount')\\r\\n after_tax_amount = dictionary.get('afterTaxAmount')\\r\\n match_amount = dictionary.get('matchAmount')\\r\\n profit_sharing_amount = dictionary.get('profitSharingAmount')\\r\\n rollover_amount = dictionary.get('rolloverAmount')\\r\\n other_vest_amount = dictionary.get('otherVestAmount')\\r\\n other_nonvest_amount = dictionary.get('otherNonvestAmount')\\r\\n current_loan_balance = dictionary.get('currentLoanBalance')\\r\\n loan_rate = dictionary.get('loanRate')\\r\\n buy_power = dictionary.get('buyPower')\\r\\n rollover_ltd = dictionary.get('rolloverLtd')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(available_balance_amount,\\r\\n posted_date,\\r\\n open_date,\\r\\n period_start_date,\\r\\n period_end_date,\\r\\n period_interest_rate,\\r\\n period_deposit_amount,\\r\\n period_interest_amount,\\r\\n interest_ytd_amount,\\r\\n interest_prior_ytd_amount,\\r\\n maturity_date,\\r\\n interest_rate,\\r\\n credit_available_amount,\\r\\n credit_max_amount,\\r\\n cash_advance_available_amount,\\r\\n cash_advance_max_amount,\\r\\n cash_advance_balance,\\r\\n cash_advance_interest_rate,\\r\\n current_balance,\\r\\n payment_min_amount,\\r\\n payment_due_date,\\r\\n previous_balance,\\r\\n statement_start_date,\\r\\n statement_end_date,\\r\\n statement_purchase_amount,\\r\\n statement_finance_amount,\\r\\n statement_credit_amount,\\r\\n reward_earned_balance,\\r\\n past_due_amount,\\r\\n last_payment_amount,\\r\\n last_payment_date,\\r\\n statement_close_balance,\\r\\n term_of_ml,\\r\\n ml_holder_name,\\r\\n description,\\r\\n late_fee_amount,\\r\\n payoff_amount,\\r\\n payoff_amount_date,\\r\\n original_maturity_date,\\r\\n principal_balance,\\r\\n escrow_balance,\\r\\n interest_period,\\r\\n initial_ml_amount,\\r\\n initial_ml_date,\\r\\n next_payment_principal_amount,\\r\\n next_payment_interest_amount,\\r\\n next_payment,\\r\\n next_payment_date,\\r\\n last_payment_due_date,\\r\\n last_payment_receive_date,\\r\\n last_payment_principal_amount,\\r\\n last_payment_interest_amount,\\r\\n last_payment_escrow_amount,\\r\\n last_payment_last_fee_amount,\\r\\n last_payment_late_charge,\\r\\n ytd_principal_paid,\\r\\n ytd_interest_paid,\\r\\n ytd_insurance_paid,\\r\\n ytd_tax_paid,\\r\\n auto_pay_enrolled,\\r\\n collateral,\\r\\n current_school,\\r\\n first_payment_date,\\r\\n first_mortgage,\\r\\n loan_payment_freq,\\r\\n original_school,\\r\\n recurring_payment_amount,\\r\\n lender,\\r\\n ending_balance_amount,\\r\\n loan_term_type,\\r\\n payments_made,\\r\\n balloon_amount,\\r\\n projected_interest,\\r\\n interest_paid_ltd,\\r\\n interest_rate_type,\\r\\n loan_payment_type,\\r\\n repayment_plan,\\r\\n payments_remaining,\\r\\n interest_margin_balance,\\r\\n short_balance,\\r\\n available_cash_balance,\\r\\n maturity_value_amount,\\r\\n vested_balance,\\r\\n emp_match_amount,\\r\\n emp_pretax_contrib_amount,\\r\\n emp_pretax_contrib_amount_ytd,\\r\\n contrib_total_ytd,\\r\\n cash_balance_amount,\\r\\n pre_tax_amount,\\r\\n after_tax_amount,\\r\\n match_amount,\\r\\n profit_sharing_amount,\\r\\n rollover_amount,\\r\\n other_vest_amount,\\r\\n other_nonvest_amount,\\r\\n current_loan_balance,\\r\\n loan_rate,\\r\\n buy_power,\\r\\n rollover_ltd,\\r\\n dictionary)\",\n \"def from_montage_json(data: Mapping):\\n\\n # logging.debug(pformat(data['exam_type']))\\n\\n # TODO: Check event flags for various event types to get ordering, study, and reading\\n\\n try:\\n referring_physician = data['events'][0].get('provider')\\n if referring_physician:\\n referring_physician = referring_physician.get('name')\\n\\n study_datetime = None\\n if len(data['events']) > 1:\\n # Last event is usually read I think, take event _before_ last one\\n study_event = data['events'][-2]\\n if study_event.get('date'):\\n study_datetime = DatetimeParser.parse(study_event['date'])\\n else:\\n # Otherwise just take whatever is last\\n study_event = data['events'][-1]\\n if study_event.get('date'):\\n study_datetime = DatetimeParser.parse(study_event['date'])\\n\\n montage_cpts = []\\n for resource in data[\\\"exam_type\\\"][\\\"cpts\\\"]:\\n code = resource.split(\\\"/\\\")[-2]\\n montage_cpts.append(code)\\n\\n tags = {\\n \\\"AccessionNumber\\\": data[\\\"accession_number\\\"],\\n \\\"PatientID\\\": data[\\\"patient_mrn\\\"],\\n 'StudyDescription': data['exam_type']['description'],\\n 'ReferringPhysicianName': referring_physician,\\n 'PatientSex': data['patient_sex'],\\n 'Organization': data['organization']['label'],\\n \\\"Modality\\\": data['exam_type']['modality']['label']\\n }\\n\\n meta = {\\n 'BodyParts': None, # Placeholder for meta\\n 'CPTCodes': None, # Placeholder for meta\\n 'PatientName': \\\"{}^{}\\\".format(\\n data[\\\"patient_last_name\\\"].upper(),\\n data[\\\"patient_first_name\\\"].upper()),\\n 'PatientAge': data['patient_age'],\\n \\\"OrderCode\\\": data[\\\"exam_type\\\"][\\\"code\\\"],\\n \\\"PatientStatus\\\": data[\\\"patient_status\\\"],\\n \\\"ReportText\\\": Montage.clean_text(data['text']),\\n \\\"ReadingPhysiciansName\\\": data['events'][-1]['provider']['name'],\\n 'StudyDateTime': study_datetime,\\n \\\"MontageCPTCodes\\\": montage_cpts\\n }\\n except KeyError:\\n meta = {\\n \\\"BodyParts\\\": None,\\n \\\"CPTCodes\\\": None,\\n \\\"MontageCPTCodes\\\": data['meta']['MontageCPTCodes'],\\n \\\"OrderCode\\\": data['meta']['OrderCode'],\\n \\\"PatientAge\\\": data['meta']['PatientAge'],\\n \\\"PatientName\\\": data['meta']['PatientName'],\\n \\\"PatientStatus\\\": data['meta']['PatientStatus'],\\n \\\"ReadingPhysiciansName\\\": data['meta']['ReadingPhysiciansName'],\\n \\\"ReportText\\\": data['meta']['ReportText'],\\n \\\"StudyDateTime\\\": data['meta']['StudyDateTime']\\n }\\n tags = {\\n \\\"AccessionNumber\\\": data['tags']['AccessionNumber'],\\n \\\"Modality\\\": data['tags']['Modality'],\\n \\\"Organization\\\": data['tags']['Organization'],\\n \\\"PatientID\\\": data['tags']['PatientID'],\\n \\\"PatientSex\\\": data['tags']['PatientSex'],\\n \\\"ReferringPhysicianName\\\": data['tags']['ReferringPhysicianName'],\\n \\\"StudyDescription\\\": data['tags']['StudyDescription']\\n }\\n\\n d = Dixel(meta=meta,\\n tags=tags,\\n level=DicomLevel.STUDIES)\\n d.report = RadiologyReport(meta['ReportText'])\\n\\n return d\",\n \"def multi_filter(self, characteristic_dict):\\n\\n corpus_copy = self.clone()\\n corpus_copy.documents = []\\n\\n for metadata_field in characteristic_dict:\\n if metadata_field not in self.metadata_fields:\\n raise MissingMetadataError([metadata_field])\\n\\n for this_document in self.documents:\\n add_document = True\\n for metadata_field in characteristic_dict:\\n if metadata_field == 'date':\\n if this_document.date != int(characteristic_dict['date']):\\n add_document = False\\n else:\\n if getattr(this_document, metadata_field) != characteristic_dict[metadata_field]:\\n add_document = False\\n if add_document:\\n corpus_copy.documents.append(this_document)\\n\\n if not corpus_copy:\\n # displays for possible errors in field.value\\n err = f'This corpus is empty. You may have mistyped something.'\\n raise AttributeError(err)\\n\\n return corpus_copy\",\n \"def precipitation():\\n\\n return jsonify(prcp_df)\",\n \"def get_metadata(hf_patients_file, metadata_file, output_file):\\n\\n # Use 'dicom_id' as names for row indices\\n hf_patients = pd.read_csv(hf_patients_file, sep=',', index_col=\\\"dicom_id\\\")\\n\\n # Use 'dicom' as name\\n metadata = pd.read_csv(metadata_file, index_col=\\\"dicom\\\", dtype={\\\"StudyDate\\\": str, \\\"StudyTime\\\": str})\\n\\n # Disregard all columns except 'subject_id' and 'study_id'\\n hf_patients = pd.concat([hf_patients['study_id'], hf_patients['subject_id']], axis=1)\\n\\n # Find study date/time for heart failure patients\\n study_date = metadata[\\\"StudyDate\\\"][hf_patients.index]\\n study_time = metadata[\\\"StudyTime\\\"][hf_patients.index]\\n\\n result = pd.concat([hf_patients, study_date, study_time], axis=1)\\n result = result.rename(columns={\\\"StudyDate\\\": \\\"study_date\\\", \\\"StudyTime\\\": \\\"study_time\\\"})\\n\\n result.to_csv(output_file)\",\n \"def consent(self, consent):\\n if consent is None:\\n raise ValueError(\\\"Invalid value for `consent`, must not be `None`\\\") # noqa: E501\\n\\n self._consent = consent\",\n \"def transform_data(redcap_data_json):\\n redcap_data = pd.DataFrame(redcap_data_json)\\n redcap_data.to_csv('data.csv')\\n\\n # Split data by event type\\n enrollment_data = redcap_data[redcap_data['redcap_event_name']=='Enrollment']\\n survey_data = redcap_data[redcap_data['redcap_event_name']!='Enrollment']\\n survey_data['redcap_event_name'] = survey_data['redcap_event_name'].apply(lambda x: datetime.datetime(int(x[0:4]), int(x[5:7]), int(x[8:10]), 1, 0) if x[11:13] == \\\"AM\\\" else datetime.datetime(int(x[0:4]), int(x[5:7]), int(x[8:10]), 13, 0))\\n\\n # Exclude/Include relevant columns\\n enrollment_data = enrollment_data[\\n [\\n 'record_id',\\n 'redcap_event_name',\\n 'ministry',\\n 'facility',\\n 'email',\\n 'am_email_1',\\n 'am_email_2',\\n 'am_email_3',\\n 'am_email_4',\\n 'am_email_5',\\n 'am_email_6',\\n 'pm_email_1',\\n 'pm_email_2',\\n 'pm_email_3',\\n 'pm_email_4',\\n 'pm_email_5',\\n 'pm_email_6',\\n 'april_trigger',\\n 'may_trigger',\\n 'june_trigger',\\n 'july_trigger',\\n 'contact_market_facility_complete'\\n ]\\n ]\\n\\n survey_data = survey_data.drop(\\n [\\n 'email',\\n 'am_email_1',\\n 'am_email_2',\\n 'am_email_3',\\n 'am_email_4',\\n 'am_email_5',\\n 'am_email_6',\\n 'pm_email_1',\\n 'pm_email_2',\\n 'pm_email_3',\\n 'pm_email_4',\\n 'pm_email_5',\\n 'pm_email_6',\\n 'april_trigger',\\n 'may_trigger',\\n 'june_trigger',\\n 'july_trigger',\\n 'contact_market_facility_complete'\\n ], axis=1)\\n\\n # Fill Missing Data\\n survey_data = survey_data.replace(\\\"\\\", np.nan) # Replace all empty strings with nan\\n survey_data = survey_data.fillna(survey_data.groupby('record_id').ffill()) # Forward fill missing data\\n survey_data = survey_data.fillna(survey_data.groupby('record_id').bfill()) # Backward fill missing data\\n\\n # Fill in survey data ministry and facility\\n facility_params = {\\n '40011': {'facility': 'StV Evansville Med Ctr', 'ministry': 'ININD'},\\n '40017': {'facility': 'StV Warrick Hosp', 'ministry': 'ININD'},\\n '46006': {'facility': 'StV Heart Ctr Indiana', 'ministry': 'ININD'},\\n '46013': {'facility': 'St Vincent Seton Spec Hosp Indianapolis', 'ministry': 'ININD'},\\n '46018': {'facility': 'StV Kokomo Hosp', 'ministry': 'ININD'},\\n '46019': {'facility': 'StV Anderson Reg Hosp', 'ministry': 'ININD'},\\n '46024': {'facility': 'StV Carmel Hosp', 'ministry': 'ININD'},\\n '46029': {'facility': 'StV Indianapolis Hosp', 'ministry': 'ININD'},\\n '46033': {'facility': 'StV Jennings Hosp', 'ministry': 'ININD'},\\n '46036': {'facility': 'StV Mercy Hosp', 'ministry': 'ININD'},\\n '46042': {'facility': 'StV Salem Hosp', 'ministry': 'ININD'},\\n '46043': {'facility': 'StV Stress Ctr', 'ministry': 'ININD'},\\n '46045': {'facility': 'StV Williamsport Hosp', 'ministry': 'ININD'},\\n '46047': {'facility': 'StV Clay Hosp', 'ministry': 'ININD'},\\n '46048': {'facility': 'StV Randolph Hosp', 'ministry': 'ININD'},\\n '46052': {'facility': 'StV Dunn Hosp', 'ministry': 'ININD'},\\n '46055': {'facility': 'StV Fishers', 'ministry': 'ININD'}\\n }\\n\\n survey_data['ministry'] = survey_data.apply(lambda x: facility_params.get(x['record_id'], {}).get('ministry'), axis=1)\\n survey_data['facility'] = survey_data.apply(lambda x: facility_params.get(x['record_id'], {}).get('facility'), axis=1)\\n\\n return enrollment_data, survey_data\",\n \"def post_patient_edit(form):\\n # Extract the data from the form and add extra fields.\\n\\n contacted_fields = [\\\"Contacted\\\", \\\"Comment\\\"]\\n disabled_fields = [\\\"NextURL\\\"] + [x for x in form.data.keys() if re.search(r\\\"Disabled\\\", x) is not None]\\n data = {k: v for (k, v) in form.data.items() if k not in disabled_fields \\n and k not in contacted_fields}\\n data[\\\"UpdatedBy\\\"] = get_current_user()\\n data[\\\"UpdatedDateTime\\\"] = get_current_datetime()\\n\\n for k in [\\\"SymptomType\\\" + str(n) for n in list(range(1, 11))]:\\n if data[k] != []:\\n # keep only values that are not \\\"Select...\\\"\\n data[k] = [v for v in data[k] if v not in [\\\"Select...\\\", \\\" \\\", \\\"\\\",]]\\n if data[k] != []:\\n data[k] = \\\"; \\\".join(data[k])\\n else:\\n data[k] = None\\n else:\\n data[k] = None\\n\\n args = form.data\\n cs = get_patient_contacted_status(args)\\n try:\\n current_cs = cs[\\\"current\\\"][\\\"Contacted\\\"]\\n except:\\n current_cs = \\\"\\\"\\n try:\\n current_comment = cs[\\\"current\\\"][\\\"Comment\\\"]\\n except:\\n current_comment = \\\"\\\"\\n cs_user_entered = form.Contacted.data\\n cs_comment_user_entered = form.Comment.data\\n if current_cs != cs_user_entered or current_comment != cs_comment_user_entered:\\n post_patient_contacted_status(args)\\n \\n # Look up key data that should not be user-changeable. XXX ideally these\\n # columns would simply be excluded from PersonEntered\\n q = (\\\"select PatientLastName, PatientSSN \\\" +\\n \\\"from {schema}.PersonCrosswalk \\\".format(schema=app_schema) +\\n \\\"where PersonID = ?\\\")\\n print(\\\"person id\\\", form.PersonID.data, file=sys.stderr)\\n tb = pd.read_sql(q, engine, params=[form.PersonID.data])\\n assert tb.shape[0] == 1, \\\"Expected 1 row, but got {} rows\\\".format(tb.shape[0])\\n d = tb.iloc[0,:].to_dict()\\n data[\\\"LastName\\\"] = d[\\\"PatientLastName\\\"]\\n data[\\\"SSN\\\"] = d[\\\"PatientSSN\\\"]\\n\\n # Get cursor.\\n conn = engine.raw_connection()\\n cursor = conn.cursor()\\n\\n # Define and execute query to insert a new row.\\n keys_str = \\\", \\\".join(data.keys())\\n vals_str = \\\", \\\".join(\\\"?\\\" for _ in data.keys())\\n params = list(data.values())\\n q = (\\\"insert into {schema}.PersonEntered \\\".format(schema=app_schema) +\\n \\\"(\\\" + keys_str + \\\") \\\" +\\n \\\"values (\\\" + vals_str + \\\")\\\")\\n cursor.execute(q, params)\\n\\n conn.commit()\\n \\n return None\",\n \"def __init__(self, jsondict=None, strict=True):\\n \\n self.authority = None\\n \\\"\\\"\\\" \\n W\\n h\\n o\\n i\\n s\\n r\\n e\\n s\\n p\\n o\\n n\\n s\\n i\\n b\\n l\\n e\\n f\\n o\\n r\\n p\\n r\\n o\\n t\\n o\\n c\\n o\\n l\\n .\\n Type `FHIRReference` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.date = None\\n \\\"\\\"\\\" \\n D\\n a\\n t\\n e\\n r\\n e\\n c\\n o\\n m\\n m\\n e\\n n\\n d\\n a\\n t\\n i\\n o\\n n\\n (\\n s\\n )\\n c\\n r\\n e\\n a\\n t\\n e\\n d\\n .\\n Type `FHIRDate` (represented as `str` in JSON). \\\"\\\"\\\"\\n \\n self.identifier = None\\n \\\"\\\"\\\" \\n B\\n u\\n s\\n i\\n n\\n e\\n s\\n s\\n i\\n d\\n e\\n n\\n t\\n i\\n f\\n i\\n e\\n r\\n .\\n List of `Identifier` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.patient = None\\n \\\"\\\"\\\" \\n W\\n h\\n o\\n t\\n h\\n i\\n s\\n p\\n r\\n o\\n f\\n i\\n l\\n e\\n i\\n s\\n f\\n o\\n r\\n .\\n Type `FHIRReference` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.recommendation = None\\n \\\"\\\"\\\" \\n V\\n a\\n c\\n c\\n i\\n n\\n e\\n a\\n d\\n m\\n i\\n n\\n i\\n s\\n t\\n r\\n a\\n t\\n i\\n o\\n n\\n r\\n e\\n c\\n o\\n m\\n m\\n e\\n n\\n d\\n a\\n t\\n i\\n o\\n n\\n s\\n .\\n List of `ImmunizationRecommendationRecommendation` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n super(ImmunizationRecommendation, self).__init__(jsondict=jsondict, strict=strict)\",\n \"def _get_consent_validation_dataframe(self, sql_template):\\n if not self.db_conn:\\n raise (EnvironmentError, 'No active DB connection object')\\n\\n df = pandas.DataFrame()\\n for consent_int in CONSENTS_LIST:\\n sql = sql_template\\n # The tuple retrieved from the CONSENT_PARTICIPANT_SUMMARY_FIELDS dict has two elements like:\\n # ('consent_for_study_enrollment', 'consent_for_study_enrollment_first_yes_authored')\\n consent_status_field = CONSENT_PARTICIPANT_SUMMARY_FIELDS[ConsentType(consent_int)][0]\\n consent_authored_field = CONSENT_PARTICIPANT_SUMMARY_FIELDS[ConsentType(consent_int)][1]\\n sql = sql.format_map(SafeDict(consent_type=consent_int,\\n status_field=consent_status_field,\\n authored_field=consent_authored_field,\\n missing_check_mark=ConsentOtherErrors.MISSING_CONSENT_CHECK_MARK,\\n non_va_for_va=ConsentOtherErrors.NON_VETERAN_CONSENT_FOR_VETERAN,\\n va_for_non_va=ConsentOtherErrors.VETERAN_CONSENT_FOR_NON_VETERAN\\n ))\\n consent_df = pandas.read_sql_query(sql, self.db_conn)\\n # Replace any null values in the calculated error flag columns with (uint8 vs. pandas default float) zeroes\\n for error_type in TRACKED_CONSENT_ERRORS:\\n consent_df = consent_df.fillna({error_type: 0}).astype({error_type: 'uint8'})\\n\\n df = df.append(consent_df)\\n\\n # Temporary? Attempt to filter false positives for va_consent_for_non_va consent version errors out of the\\n # generated dataframe\\n df = self._remove_potential_false_positives_for_consent_version(df)\\n\\n return df\",\n \"def json(self):\\n # Response legacy data: allow for any column to be null.\\n document = {\\n 'mhrNumber': self.mhr_number,\\n 'documentType': self.document_type,\\n 'documentRegistrationNumber': self.document_reg_id,\\n 'interimed': self.interimed,\\n 'ownerCrossReference': self.owner_cross_reference,\\n 'interestDenominator': self.interest_denominator,\\n 'declaredValue': self.declared_value,\\n 'ownLand': self.own_land,\\n 'routingSlipNumber': self.routing_slip_number,\\n 'lastService': self.last_service,\\n 'bcolAccount': self.bcol_account,\\n 'datNumber': self.dat_number,\\n 'examinerId': self.examiner_id,\\n 'updateId': self.update_id,\\n 'phoneNumber': self.phone_number,\\n 'attentionReference': self.attention_reference,\\n 'name': self.name,\\n 'legacyAddress': self.legacy_address,\\n 'numberOfPages': self.number_of_pages,\\n 'considerationValue': self.consideration_value,\\n 'affirmByName': self.affirm_by_name,\\n 'liensWithConsent': self.liens_with_consent,\\n 'clientReferenceId': self.client_reference_id\\n }\\n if self.draft_ts:\\n document['draftDateTime'] = model_utils.format_local_ts(self.draft_ts)\\n if self.registration_ts:\\n document['createDateTime'] = model_utils.format_local_ts(self.registration_ts)\\n if self.transfer_execution_date and self.transfer_execution_date.year > 1:\\n document['transferDate'] = model_utils.format_local_date(self.transfer_execution_date)\\n return document\",\n \"def _get_bulk_cad_assessment_data(data):\\n # pylint: disable=too-many-locals\\n all_cads = db.session.query(\\n CAD,\\n all_models.Assessment.id,\\n all_models.Assessment.title,\\n all_models.Assessment.assessment_type,\\n all_models.Assessment.slug,\\n CAV.attribute_value,\\n CAV.attribute_object_id,\\n ).join(\\n all_models.Assessment, CAD.definition_id == all_models.Assessment.id\\n ).outerjoin(\\n CAV, CAD.id == CAV.custom_attribute_id,\\n ).filter(\\n all_models.Assessment.id.in_(data[\\\"ids\\\"]),\\n CAD.definition_type == 'assessment',\\n )\\n response_dict = OrderedDict()\\n for (cad, asmt_id, asmt_title, asmt_type, asmt_slug,\\n cav_value, cav_person_id) in all_cads:\\n multi_choice_options = \\\",\\\".join(\\n sorted(cad.multi_choice_options.split(','))\\n ).lower() if cad.multi_choice_options else cad.multi_choice_options\\n item_key = (cad.title, cad.attribute_type, cad.mandatory,\\n multi_choice_options, cad.multi_choice_mandatory)\\n item_response = response_dict.get(\\n item_key,\\n {\\n \\\"attribute\\\": {\\n \\\"attribute_type\\\": cad.attribute_type,\\n \\\"title\\\": cad.title,\\n \\\"default_value\\\": cad.default_value,\\n \\\"multi_choice_options\\\": cad.multi_choice_options,\\n \\\"multi_choice_mandatory\\\": cad.multi_choice_mandatory,\\n \\\"mandatory\\\": cad.mandatory,\\n \\\"placeholder\\\": None,\\n },\\n \\\"related_assessments\\\": {},\\n \\\"assessments_with_values\\\": [],\\n }\\n )\\n if cav_value:\\n item_response[\\\"assessments_with_values\\\"].append({\\n \\\"id\\\": asmt_id,\\n \\\"title\\\": asmt_title,\\n \\\"attribute_value\\\": cav_value,\\n \\\"attribute_person_id\\\": cav_person_id,\\n })\\n if not item_response[\\\"related_assessments\\\"].get(asmt_type):\\n item_response[\\\"related_assessments\\\"][asmt_type] = []\\n item_response[\\\"related_assessments\\\"][asmt_type].append({\\n \\\"id\\\": asmt_id,\\n \\\"attribute_definition_id\\\": cad.id,\\n \\\"slug\\\": asmt_slug,\\n })\\n response_dict[item_key] = item_response\\n response = []\\n\\n for _, cad_item in response_dict.items():\\n related_assessments = cad_item[\\\"related_assessments\\\"]\\n cad_item[\\\"related_assessments\\\"] = {\\\"values\\\": []}\\n asmt_count = 0\\n for asmt_type, assessments in related_assessments.items():\\n cad_item[\\\"related_assessments\\\"][\\\"values\\\"].append({\\n \\\"assessments_type\\\": asmt_type,\\n \\\"assessments\\\": assessments\\n })\\n asmt_count += len(assessments)\\n cad_item[\\\"related_assessments\\\"][\\\"count\\\"] = asmt_count\\n response.append(cad_item)\\n return response\",\n \"def from_dict(cls, dikt) -> 'ProjectConclusionInfo':\\n return util.deserialize_model(dikt, cls)\",\n \"def load_evictions_data(data_path, date_col, min_year, max_year, create_geoid = True):\\n ev_raw = (\\n pd.read_csv(\\n data_path,\\n parse_dates=[date_col],\\n infer_datetime_format=True,\\n )\\n .dropna(how=\\\"all\\\")\\n .drop_duplicates()\\n )\\n ev_raw[\\\"year\\\"] = ev_raw[date_col].dt.year\\n ev_df = ev_raw[(ev_raw.year >= min_year) & (ev_raw.year <= max_year)]\\n ev_df[\\\"year\\\"] = ev_df[\\\"year\\\"].astype(int)\\n ev_df[\\\"month\\\"] = get_month_as_str_col(ev_df, date_col)\\n \\n if create_geoid == True:\\n # Convert to strings\\n ev_df[\\\"state_code\\\"] = ev_df[\\\"state_code\\\"].astype(str).replace(r'\\\\.0', '', regex = True) \\n ev_df[\\\"county_code\\\"] = ev_df[\\\"county_code\\\"].astype(str).replace(r'\\\\.0', '', regex = True) \\n ev_df[\\\"tract_code\\\"] = ev_df[\\\"tract_code\\\"].astype(str).replace(r'\\\\.0', '', regex = True)\\n # Add zeroes as necessary\\n ev_df[\\\"state_code\\\"] = ev_df[\\\"state_code\\\"].apply(lambda x: (((2-len(x)) * \\\"0\\\") + x) if len(x) < 2 else x)\\n ev_df[\\\"county_code\\\"] = ev_df[\\\"county_code\\\"].apply(lambda x: (((3-len(x)) * \\\"0\\\") + x) if len(x) < 3 else x)\\n ev_df[\\\"tract_code\\\"] = ev_df[\\\"tract_code\\\"].apply(lambda x: (((6-len(x)) * \\\"0\\\") + x) if len(x) < 6 else x)\\n # Finally, concat everything\\n ev_df[\\\"GEOID\\\"] = (\\n ev_df[\\\"state_code\\\"] + ev_df[\\\"county_code\\\"] + ev_df[\\\"tract_code\\\"]\\n )\\n \\n return ev_df\",\n \"def get_dicom_metadata_and_slice_counts(dicom_path):\\n row = {\\n 'dicom_path': dicom_path,\\n 'dicom_metadata': {},\\n 'slice_count': None,\\n 'errors': []\\n }\\n\\n # Get metadata\\n try:\\n row['dicom_metadata'] = get_dicom_metadata(dicom_path)\\n except Exception as e:\\n row['errors'].append(str(e))\\n\\n # Get slice count\\n try:\\n row['slice_count'] = get_slice_count(dicom_path)\\n except Exception as e:\\n row['errors'].append(str(e))\\n\\n return row\",\n \"def as_inator(dct):\\n keyset = {'ident', 'name', 'location', 'description', 'condition', 'added'}\\n if set(dct.keys()) == keyset:\\n try:\\n new_dct = dct.copy()\\n new_dct['added'] = load_time(new_dct['added'])\\n new_dct['condition'] = Condition(int(new_dct['condition']))\\n return new_dct\\n except ValueError:\\n return dct\\n else:\\n return dct\",\n \"def oldest_person_dc(all_profile_dict: dict) -> float:\\n \\\"\\\"\\\"Param:all_profile_dc: dictionary containing all profiles\\\"\\\"\\\"\\n value = min(all_profile_dict.values(), key=lambda v: v['birthdate'])\\n date_today = datetime.date.today()\\n age = (date_today - value['birthdate']).days\\n return int(age/365)\",\n \"def _convert_asset_timestamp_fields(dict_):\\n for key in _asset_timestamp_fields & viewkeys(dict_):\\n value = pd.Timestamp(dict_[key], tz='UTC')\\n dict_[key] = None if isnull(value) else value\\n return dict_\",\n \"def convert_attributes_to_readable(attributes: dict[str, Any]) -> dict[str, Any]:\\n attributes_fields_mapper = {'nbf': 'should_not_be_retrieved_Before',\\n 'exp': 'expiry_time',\\n 'created': 'create_time',\\n 'updated': 'update_time',\\n 'recoveryLevel': 'recovery_level'\\n }\\n\\n for key, value in attributes_fields_mapper.items():\\n if key in attributes:\\n if key != 'recoveryLevel':\\n attributes[value] = convert_timestamp_to_readable_date(attributes.pop(key))\\n else:\\n attributes[value] = attributes.pop(key)\\n return attributes\",\n \"def from_dict(cls, dikt) -> 'TextDateAnnotationAllOf':\\n return util.deserialize_model(dikt, cls)\",\n \"def __init__(self, jsondict=None, strict=True):\\n \\n self.amount = None\\n \\\"\\\"\\\" Monetary amount.\\n Type `Money` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.category = None\\n \\\"\\\"\\\" Type of adjudication information.\\n Type `CodeableConcept` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.reason = None\\n \\\"\\\"\\\" Explanation of adjudication outcome.\\n Type `CodeableConcept` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.value = None\\n \\\"\\\"\\\" Non-monetary value.\\n Type `float`. \\\"\\\"\\\"\\n \\n super(ClaimResponseItemAdjudication, self).__init__(jsondict=jsondict, strict=strict)\",\n \"def readData(self, dataDict):\\n pass\",\n \"def precipitation():\\r\\n # Query all measurements\\r\\n results = session.query(Measurement).all()\\r\\n\\r\\n # Create a dictionary from the row data and append to a list of all_precipitation\\r\\n all_precipitation = []\\r\\n\\r\\n for row in results:\\r\\n precipitation_dict = { row.date : row.prcp}\\r\\n all_precipitation.append(precipitation_dict)\\r\\n # print(all_precipitation)\\r\\n return jsonify(all_precipitation)\",\n \"def get_data(self, date_time):\\n columns = ','.join(['{}'.format(col) for col in self.table_columns])\\n query = \\\"\\\"\\\"Select {columns} from (\\n {table} \\n inner join \\n (Select * from DISPATCHCONSTRAINT where SETTLEMENTDATE == '{datetime}')\\n on GENCONID == CONSTRAINTID\\n and EFFECTIVEDATE == GENCONID_EFFECTIVEDATE\\n and VERSIONNO == GENCONID_VERSIONNO);\\\"\\\"\\\"\\n query = query.format(columns=columns, table=self.table_name, datetime=date_time)\\n return pd.read_sql_query(query, con=self.con)\",\n \"def event_generator(study, row):\\n ev = copy.deepcopy(record_template)\\n ev[\\\"study\\\"][\\\"dbgap_id\\\"] = study\\n ev[\\\"study\\\"][\\\"sample_id\\\"] = row[1]\\n ev[\\\"study\\\"][\\\"consent_code\\\"] = row[0]\\n ev[\\\"study\\\"][\\\"consent_short_name\\\"] = row[2]\\n return ev\",\n \"def _extract_values_from_certificate(cert):\\n logger = getLogger(__name__)\\n # cert and serial number\\n data = {\\n u'cert': cert,\\n u'issuer': cert.get_issuer().der(),\\n u'serial_number': cert.get_serial_number(),\\n u'algorithm': rfc2437.id_sha1,\\n u'algorithm_parameter': univ.Any(hexValue='0500') # magic number\\n }\\n # DN Hash\\n data[u'name'] = cert.get_subject()\\n cert_der = data[u'name'].der()\\n sha1_hash = hashlib.sha1()\\n sha1_hash.update(cert_der)\\n data[u'name_hash'] = sha1_hash.hexdigest()\\n\\n # public key Hash\\n data['key_hash'] = _get_pubickey_sha1_hash(cert).hexdigest()\\n\\n # CRL and OCSP\\n data['crl'] = None\\n ocsp_uris0 = []\\n for idx in range(cert.get_extension_count()):\\n e = cert.get_extension(idx)\\n if e.get_short_name() == b'authorityInfoAccess':\\n for line in str(e).split(u\\\"\\\\n\\\"):\\n m = OCSP_RE.match(line)\\n if m:\\n logger.debug(u'OCSP URL: %s', m.group(1))\\n ocsp_uris0.append(m.group(1))\\n elif e.get_short_name() == b'crlDistributionPoints':\\n for line in str(e).split(u\\\"\\\\n\\\"):\\n m = CRL_RE.match(line)\\n if m:\\n logger.debug(u\\\"CRL: %s\\\", m.group(1))\\n data['crl'] = m.group(1)\\n\\n if len(ocsp_uris0) == 1:\\n data['ocsp_uri'] = ocsp_uris0[0]\\n elif len(ocsp_uris0) == 0:\\n data['ocsp_uri'] = u''\\n else:\\n raise OperationalError(\\n msg=u'More than one OCSP URI entries are specified in '\\n u'the certificate',\\n errno=ER_FAILED_TO_GET_OCSP_URI,\\n )\\n data[u'is_root_ca'] = cert.get_subject() == cert.get_issuer()\\n return data\",\n \"def _from_dict_transform(cls: Type[TVerifiedElementSubclass], data: Dict[str, Any]) -> Dict[str, Any]:\\n data = super()._from_dict_transform(data)\\n\\n if 'verified' in data:\\n data['is_verified'] = data.pop('verified')\\n\\n if 'verification_code' in data:\\n del data['verification_code']\\n\\n return data\",\n \"def test_invalid_research_consent(self):\\n file = SimpleUploadedFile(\\n \\\"test.csv\\\",\\n b\\\"msisdn,facility code,id type,id number,messaging consent,\\\"\\n b\\\"research_consent,edd year,edd month,edd day,baby dob year,\\\"\\n b\\\"baby dob month,baby dob day\\\\n\\\"\\n b\\\"+27820001001,123456,said,9001010001088,true,foo,2021,12,1,,,\\\\n\\\",\\n )\\n form = MomConnectImportForm(\\n data={\\\"source\\\": \\\"MomConnect Import\\\"}, files={\\\"file\\\": file}\\n )\\n instance = form.save()\\n self.assertEqual(instance.status, MomConnectImport.Status.ERROR)\\n [error] = instance.errors.all()\\n self.assertEqual(\\n error.error,\\n \\\"Field research_consent failed validation: “foo” value must be either \\\"\\n \\\"True or False.\\\",\\n )\\n self.assertEqual(error.row_number, 2)\",\n \"def process_ns_data(ns_data_dict, sensitive_keys, sharing_consent_value):\\r\\n ns_data_dict.reverse()\\r\\n\\r\\n processed_list_of_data = [process_single_ns_record(d, sensitive_keys, sharing_consent_value) for d in ns_data_dict]\\r\\n json_string = reduce(concat, processed_list_of_data, '')\\r\\n\\r\\n return json_string\",\n \"def consult_law_decree(self, text_id: str, date: Optional[datetime] = None) -> Dict[str, Any]:\\n self._update_client_if_necessary()\\n return _consult_law_decree(text_id, date, self._client)\",\n \"def write_prescription(self, disease: Disease, patient: Patient):\\n prescription = Doctor.prescribe_medicines(disease, Prescription(doctor=self, patient=patient))\\n patient.prescriptions.append(prescription)\\n return prescription\",\n \"def extract_data():\\n raw_data = pd.read_csv(\\\"../../../resource/DataVisualization/vaccinations.csv\\\")\\n raw_data = raw_data[[\\\"location\\\", \\\"date\\\", \\\"people_fully_vaccinated_per_hundred\\\"]]\\n raw_data.date = pd.to_datetime(raw_data.date, format=\\\"%Y-%m-%d\\\")\\n min_date = raw_data.date.min()\\n raw_data.date = raw_data.date-min_date\\n raw_data.date = pd.Series([x.days for x in raw_data.date])\\n raw_data.drop(raw_data.loc[raw_data.people_fully_vaccinated_per_hundred.isnull()].index,\\n axis=0, inplace=True)\\n raw_data[\\\"people_fully_vaccinated_per_hundred\\\"] /= 100\\n\\n data_dict = dict()\\n for country in raw_data.location.unique():\\n if len(raw_data.loc[raw_data.location == country]) >= 100:\\n tmp_data = raw_data.loc[raw_data.location == country]\\n tmp_data.drop(\\\"location\\\", axis=1, inplace=True)\\n data_dict[country] = {\\\"data\\\":tmp_data}\\n else:\\n raw_data.drop(raw_data.loc[raw_data.location ==\\n country].index, inplace=True)\\n return data_dict, min_date, raw_data\",\n \"def registration_json(self):\\n # Response legacy data: allow for any column to be null.\\n self.strip()\\n document = {\\n 'documentId': self.id,\\n 'documentRegistrationNumber': self.document_reg_id,\\n 'documentType': self.document_type,\\n 'mhrNumber': self.mhr_number,\\n 'declaredValue': self.declared_value,\\n 'ownLand': False,\\n 'consideration': self.consideration_value,\\n 'attentionReference': self.attention_reference,\\n 'clientReferenceId': self.client_reference_id,\\n 'submittingParty': self.submitting_party(),\\n 'affirmByName': self.affirm_by_name\\n }\\n if self.own_land == 'Y':\\n document['ownLand'] = True\\n if self.transfer_execution_date and self.transfer_execution_date.year > 1900:\\n document['transferDate'] = model_utils.format_local_date(self.transfer_execution_date)\\n if self.registration_ts:\\n document['createDateTime'] = model_utils.format_local_ts(self.registration_ts)\\n return document\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n identifikasjon_field = idfy_rest_client.models.identifikasjon.Identifikasjon.from_dictionary(dictionary.get('identifikasjonField')) if dictionary.get('identifikasjonField') else None\\r\\n navn_adresse_field = idfy_rest_client.models.navn_adresse.NavnAdresse.from_dictionary(dictionary.get('navnAdresseField')) if dictionary.get('navnAdresseField') else None\\r\\n rating_field = idfy_rest_client.models.rating.Rating.from_dictionary(dictionary.get('ratingField')) if dictionary.get('ratingField') else None\\r\\n hist_rating_field = None\\r\\n if dictionary.get('histRatingField') != None:\\r\\n hist_rating_field = list()\\r\\n for structure in dictionary.get('histRatingField'):\\r\\n hist_rating_field.append(idfy_rest_client.models.historisk_rating.HistoriskRating.from_dictionary(structure))\\r\\n grunnfakta_field = idfy_rest_client.models.grunnfakta.Grunnfakta.from_dictionary(dictionary.get('grunnfaktaField')) if dictionary.get('grunnfaktaField') else None\\r\\n juridisk_field = None\\r\\n if dictionary.get('juridiskField') != None:\\r\\n juridisk_field = list()\\r\\n for structure in dictionary.get('juridiskField'):\\r\\n juridisk_field.append(idfy_rest_client.models.juridisk.Juridisk.from_dictionary(structure))\\r\\n verv_field = None\\r\\n if dictionary.get('vervField') != None:\\r\\n verv_field = list()\\r\\n for structure in dictionary.get('vervField'):\\r\\n verv_field.append(idfy_rest_client.models.verv.Verv.from_dictionary(structure))\\r\\n aksjonar_field = None\\r\\n if dictionary.get('aksjonarField') != None:\\r\\n aksjonar_field = list()\\r\\n for structure in dictionary.get('aksjonarField'):\\r\\n aksjonar_field.append(idfy_rest_client.models.aksjonar.Aksjonar.from_dictionary(structure))\\r\\n datterselskap_field = None\\r\\n if dictionary.get('datterselskapField') != None:\\r\\n datterselskap_field = list()\\r\\n for structure in dictionary.get('datterselskapField'):\\r\\n datterselskap_field.append(idfy_rest_client.models.datterselskap.Datterselskap.from_dictionary(structure))\\r\\n okonomi_enk_field = None\\r\\n if dictionary.get('okonomiEnkField') != None:\\r\\n okonomi_enk_field = list()\\r\\n for structure in dictionary.get('okonomiEnkField'):\\r\\n okonomi_enk_field.append(idfy_rest_client.models.okonomi_enk.OkonomiEnk.from_dictionary(structure))\\r\\n nokkeltall_foretak_field = None\\r\\n if dictionary.get('nokkeltallForetakField') != None:\\r\\n nokkeltall_foretak_field = list()\\r\\n for structure in dictionary.get('nokkeltallForetakField'):\\r\\n nokkeltall_foretak_field.append(idfy_rest_client.models.nokkeltall_foretak.NokkeltallForetak.from_dictionary(structure))\\r\\n nokkeltall_bransje_field = None\\r\\n if dictionary.get('nokkeltallBransjeField') != None:\\r\\n nokkeltall_bransje_field = list()\\r\\n for structure in dictionary.get('nokkeltallBransjeField'):\\r\\n nokkeltall_bransje_field.append(idfy_rest_client.models.nokkeltall_bransje.NokkeltallBransje.from_dictionary(structure))\\r\\n nokkeltall_konsern_field = None\\r\\n if dictionary.get('nokkeltallKonsernField') != None:\\r\\n nokkeltall_konsern_field = list()\\r\\n for structure in dictionary.get('nokkeltallKonsernField'):\\r\\n nokkeltall_konsern_field.append(idfy_rest_client.models.nokkeltall_konsern.NokkeltallKonsern.from_dictionary(structure))\\r\\n beta_sammendrag_field = idfy_rest_client.models.beta_sammendrag.BetaSammendrag.from_dictionary(dictionary.get('betaSammendragField')) if dictionary.get('betaSammendragField') else None\\r\\n beta_detaljer_field = None\\r\\n if dictionary.get('betaDetaljerField') != None:\\r\\n beta_detaljer_field = list()\\r\\n for structure in dictionary.get('betaDetaljerField'):\\r\\n beta_detaljer_field.append(idfy_rest_client.models.beta_detaljer.BetaDetaljer.from_dictionary(structure))\\r\\n losore_field = None\\r\\n if dictionary.get('losoreField') != None:\\r\\n losore_field = list()\\r\\n for structure in dictionary.get('losoreField'):\\r\\n losore_field.append(idfy_rest_client.models.losore.Losore.from_dictionary(structure))\\r\\n eiendom_norge_field = idfy_rest_client.models.eiendom_norge.EiendomNorge.from_dictionary(dictionary.get('eiendomNorgeField')) if dictionary.get('eiendomNorgeField') else None\\r\\n konsern_link_field = None\\r\\n if dictionary.get('konsernLinkField') != None:\\r\\n konsern_link_field = list()\\r\\n for structure in dictionary.get('konsernLinkField'):\\r\\n konsern_link_field.append(idfy_rest_client.models.konsern_link.KonsernLink.from_dictionary(structure))\\r\\n scoring_field = idfy_rest_client.models.scoring.Scoring.from_dictionary(dictionary.get('scoringField')) if dictionary.get('scoringField') else None\\r\\n okonomi_sammendrag_foretak_field = None\\r\\n if dictionary.get('okonomiSammendragForetakField') != None:\\r\\n okonomi_sammendrag_foretak_field = list()\\r\\n for structure in dictionary.get('okonomiSammendragForetakField'):\\r\\n okonomi_sammendrag_foretak_field.append(idfy_rest_client.models.okonomi_sammendrag_foretak.OkonomiSammendragForetak.from_dictionary(structure))\\r\\n okonomi_sammendrag_konsern_field = None\\r\\n if dictionary.get('okonomiSammendragKonsernField') != None:\\r\\n okonomi_sammendrag_konsern_field = list()\\r\\n for structure in dictionary.get('okonomiSammendragKonsernField'):\\r\\n okonomi_sammendrag_konsern_field.append(idfy_rest_client.models.okonomi_sammendrag_konsern.OkonomiSammendragKonsern.from_dictionary(structure))\\r\\n okonomi_detaljer_foretak_field = None\\r\\n if dictionary.get('okonomiDetaljerForetakField') != None:\\r\\n okonomi_detaljer_foretak_field = list()\\r\\n for structure in dictionary.get('okonomiDetaljerForetakField'):\\r\\n okonomi_detaljer_foretak_field.append(idfy_rest_client.models.okonomi_detaljer_foretak.OkonomiDetaljerForetak.from_dictionary(structure))\\r\\n okonomi_detaljer_konsern_field = None\\r\\n if dictionary.get('okonomiDetaljerKonsernField') != None:\\r\\n okonomi_detaljer_konsern_field = list()\\r\\n for structure in dictionary.get('okonomiDetaljerKonsernField'):\\r\\n okonomi_detaljer_konsern_field.append(idfy_rest_client.models.okonomi_detaljer_konsern.OkonomiDetaljerKonsern.from_dictionary(structure))\\r\\n eiendeler_foretak_field = None\\r\\n if dictionary.get('eiendelerForetakField') != None:\\r\\n eiendeler_foretak_field = list()\\r\\n for structure in dictionary.get('eiendelerForetakField'):\\r\\n eiendeler_foretak_field.append(idfy_rest_client.models.eiendeler_foretak.EiendelerForetak.from_dictionary(structure))\\r\\n eiendeler_konsern_field = None\\r\\n if dictionary.get('eiendelerKonsernField') != None:\\r\\n eiendeler_konsern_field = list()\\r\\n for structure in dictionary.get('eiendelerKonsernField'):\\r\\n eiendeler_konsern_field.append(idfy_rest_client.models.eiendeler_konsern.EiendelerKonsern.from_dictionary(structure))\\r\\n gjeld_egenkapital_foretak_field = None\\r\\n if dictionary.get('gjeldEgenkapitalForetakField') != None:\\r\\n gjeld_egenkapital_foretak_field = list()\\r\\n for structure in dictionary.get('gjeldEgenkapitalForetakField'):\\r\\n gjeld_egenkapital_foretak_field.append(idfy_rest_client.models.gjeld_egenkapital_foretak.GjeldEgenkapitalForetak.from_dictionary(structure))\\r\\n gjeld_egenkapital_konsern_field = None\\r\\n if dictionary.get('gjeldEgenkapitalKonsernField') != None:\\r\\n gjeld_egenkapital_konsern_field = list()\\r\\n for structure in dictionary.get('gjeldEgenkapitalKonsernField'):\\r\\n gjeld_egenkapital_konsern_field.append(idfy_rest_client.models.gjeld_egenkapital_konsern.GjeldEgenkapitalKonsern.from_dictionary(structure))\\r\\n avdeling_data_field = idfy_rest_client.models.avdeling_data.AvdelingData.from_dictionary(dictionary.get('avdelingDataField')) if dictionary.get('avdelingDataField') else None\\r\\n rettighetshavere_field = None\\r\\n if dictionary.get('rettighetshavereField') != None:\\r\\n rettighetshavere_field = list()\\r\\n for structure in dictionary.get('rettighetshavereField'):\\r\\n rettighetshavere_field.append(idfy_rest_client.models.rettighetshavere.Rettighetshavere.from_dictionary(structure))\\r\\n eiendom_norge_liste_field = None\\r\\n if dictionary.get('eiendomNorgeListeField') != None:\\r\\n eiendom_norge_liste_field = list()\\r\\n for structure in dictionary.get('eiendomNorgeListeField'):\\r\\n eiendom_norge_liste_field.append(idfy_rest_client.models.eiendom_norge_liste.EiendomNorgeListe.from_dictionary(structure))\\r\\n fullmakt_foretak_field = None\\r\\n if dictionary.get('fullmaktForetakField') != None:\\r\\n fullmakt_foretak_field = list()\\r\\n for structure in dictionary.get('fullmaktForetakField'):\\r\\n fullmakt_foretak_field.append(idfy_rest_client.models.fullmakt_foretak.FullmaktForetak.from_dictionary(structure))\\r\\n meldinger_field = None\\r\\n if dictionary.get('meldingerField') != None:\\r\\n meldinger_field = list()\\r\\n for structure in dictionary.get('meldingerField'):\\r\\n meldinger_field.append(idfy_rest_client.models.meldinger.Meldinger.from_dictionary(structure))\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(identifikasjon_field,\\r\\n navn_adresse_field,\\r\\n rating_field,\\r\\n hist_rating_field,\\r\\n grunnfakta_field,\\r\\n juridisk_field,\\r\\n verv_field,\\r\\n aksjonar_field,\\r\\n datterselskap_field,\\r\\n okonomi_enk_field,\\r\\n nokkeltall_foretak_field,\\r\\n nokkeltall_bransje_field,\\r\\n nokkeltall_konsern_field,\\r\\n beta_sammendrag_field,\\r\\n beta_detaljer_field,\\r\\n losore_field,\\r\\n eiendom_norge_field,\\r\\n konsern_link_field,\\r\\n scoring_field,\\r\\n okonomi_sammendrag_foretak_field,\\r\\n okonomi_sammendrag_konsern_field,\\r\\n okonomi_detaljer_foretak_field,\\r\\n okonomi_detaljer_konsern_field,\\r\\n eiendeler_foretak_field,\\r\\n eiendeler_konsern_field,\\r\\n gjeld_egenkapital_foretak_field,\\r\\n gjeld_egenkapital_konsern_field,\\r\\n avdeling_data_field,\\r\\n rettighetshavere_field,\\r\\n eiendom_norge_liste_field,\\r\\n fullmakt_foretak_field,\\r\\n meldinger_field,\\r\\n dictionary)\",\n \"def row_to_incident(row):\\n incident = {}\\n raw = {underscoreToCamelCase(k): convert_to_string_if_datetime(v) for k, v in row.items()}\\n incident[\\\"rawJSON\\\"] = json.dumps(raw)\\n incident_name_field = demisto.params().get(\\\"incident_name_field\\\")\\n if incident_name_field and incident_name_field in raw:\\n incident[\\\"name\\\"] = raw[incident_name_field]\\n return incident\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n insurance_policy_type_velue = dictionary.get('insurancePolicyTypeVelue')\\r\\n fire_insurance_policy_extend_view = easybimehlanding.models.fire_insurance_policy_extend_view.FireInsurancePolicyExtendView.from_dictionary(dictionary.get('fireInsurancePolicyExtendView')) if dictionary.get('fireInsurancePolicyExtendView') else None\\r\\n fire_insurance_policy_filter = easybimehlanding.models.fire_insurance_policy_filter.FireInsurancePolicyFilter.from_dictionary(dictionary.get('fireInsurancePolicyFilter')) if dictionary.get('fireInsurancePolicyFilter') else None\\r\\n id = dictionary.get('id')\\r\\n selected_insurance_policy_has_been_changed = dictionary.get('selectedInsurancePolicyHasBeenChanged')\\r\\n is_paymented = dictionary.get('isPaymented')\\r\\n has_conflict_document = dictionary.get('hasConflictDocument')\\r\\n is_insurance_centre_admin = dictionary.get('isInsuranceCentreAdmin')\\r\\n insurance_policy_payment_documents = dictionary.get('insurancePolicyPaymentDocuments')\\r\\n payable = dictionary.get('payable')\\r\\n paymented = dictionary.get('paymented')\\r\\n conflict = dictionary.get('conflict')\\r\\n initial_price = dictionary.get('initialPrice')\\r\\n final_price = dictionary.get('finalPrice')\\r\\n insurance_company_name = dictionary.get('insuranceCompanyName')\\r\\n insurance_centre_name = dictionary.get('insuranceCentreName')\\r\\n insurance_policy_conflict = dictionary.get('insurancePolicyConflict')\\r\\n insurance_policy_condition = dictionary.get('insurancePolicyCondition')\\r\\n person = dictionary.get('person')\\r\\n insurance_policy = dictionary.get('insurancePolicy')\\r\\n shopping_card = dictionary.get('shoppingCard')\\r\\n shopping_card_postal_packet = dictionary.get('shoppingCardPostalPacket')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(insurance_policy_type_velue,\\r\\n fire_insurance_policy_extend_view,\\r\\n fire_insurance_policy_filter,\\r\\n id,\\r\\n selected_insurance_policy_has_been_changed,\\r\\n is_paymented,\\r\\n has_conflict_document,\\r\\n is_insurance_centre_admin,\\r\\n insurance_policy_payment_documents,\\r\\n payable,\\r\\n paymented,\\r\\n conflict,\\r\\n initial_price,\\r\\n final_price,\\r\\n insurance_company_name,\\r\\n insurance_centre_name,\\r\\n insurance_policy_conflict,\\r\\n insurance_policy_condition,\\r\\n person,\\r\\n insurance_policy,\\r\\n shopping_card,\\r\\n shopping_card_postal_packet)\",\n \"def precipitation():\\n # Query \\n results = session.query(Measurement.date, Measurement.prcp).all()\\n \\n dict = {}\\n for result in results:\\n dict[result.date] = result.prcp\\n\\n return jsonify(dict)\",\n \"def precipitation():\\n \\n # Create session\\n session = Session(engine)\\n \\n # Retrieve the most recent date\\n result = session.query(Measurement).order_by(Measurement.date.desc()).limit(1)\\n for row in result:\\n latest_date = row.date\\n\\n # Convert to datetime format\\n conv_latest_date = dt.datetime.strptime(latest_date , '%Y-%m-%d')\\n \\n # Calculate the date 1 year ago from the last data point in the database\\n last_12_months = conv_latest_date - dt.timedelta(days=365)\\n\\n # Convert datetime to string\\n conv_last_12_months = last_12_months.strftime('%Y-%m-%d')\\n \\n # Query\\n precipitation = session.query(Measurement.date, Measurement.prcp).filter(Measurement.date <= latest_date).filter(Measurement.date >= conv_last_12_months).all()\\n\\n return jsonify(dict(precipitation))\",\n \"def from_dict(cls, dikt) -> 'AcknowledgeClaimRequest':\\n return util.deserialize_model(dikt, cls)\",\n \"def convert_patient_to_feature(\\n patient_data: Dict[str, object]\\n) -> Dict[str, tf.train.Feature]:\\n # TODO: Maybe prefix with \\\"patient/\\\" for post processing ease.\\n return {\\n \\\"patient_id\\\": int64_feature(patient_data.get(\\\"patient_id\\\")),\\n \\\"age\\\": float_feature(patient_data.get(\\\"demographic_metadata\\\").get(\\\"age\\\")),\\n \\\"race\\\": int64_feature(patient_data.get(\\\"demographic_metadata\\\").get(\\\"race\\\")),\\n \\\"ERpos\\\": int64_feature(patient_data.get(\\\"clinical\\\").get(\\\"ERpos\\\")),\\n \\\"Pgpos\\\": int64_feature(patient_data.get(\\\"clinical\\\").get(\\\"Pgpos\\\")),\\n \\\"HRpos\\\": int64_feature(patient_data.get(\\\"clinical\\\").get(\\\"HRpos\\\")),\\n \\\"HER_two_status\\\": int64_feature(\\n patient_data.get(\\\"clinical\\\").get(\\\"HER_two_status\\\")\\n ),\\n \\\"three_level_HER\\\": int64_feature(\\n patient_data.get(\\\"clinical\\\").get(\\\"three_level_HER\\\")\\n ),\\n \\\"Bilateral\\\": int64_feature(patient_data.get(\\\"clinical\\\").get(\\\"Bilateral\\\")),\\n \\\"Laterality\\\": int64_feature(patient_data.get(\\\"clinical\\\").get(\\\"Laterality\\\")),\\n # Outcomes\\n \\\"Sstat\\\": int64_feature(patient_data.get(\\\"outcome\\\").get(\\\"Sstat\\\")),\\n \\\"survival_duration\\\": int64_feature(\\n patient_data.get(\\\"outcome\\\").get(\\\"survival_duration\\\")\\n ),\\n \\\"rfs_ind\\\": int64_feature(patient_data.get(\\\"outcome\\\").get(\\\"rfs_ind\\\")),\\n \\\"rfs_duration\\\": int64_feature(patient_data.get(\\\"outcome\\\").get(\\\"rfs_duration\\\")),\\n \\\"pCR\\\": int64_feature(patient_data.get(\\\"outcome\\\").get(\\\"pCR\\\")),\\n \\\"RCB\\\": int64_feature(patient_data.get(\\\"outcome\\\").get(\\\"RCB\\\")),\\n \\\"LD\\\": int64List_feature(patient_data.get(\\\"LD\\\")),\\n }\",\n \"def verify_and_clean_input(input_dict):\\n \\n output_dict = {}\\n try:\\n output_dict[\\\"Account ID\\\"] = int(input_dict[\\\"Account ID\\\"])\\n if output_dict[\\\"Account ID\\\"] < 0:\\n return False, {}, \\\"not a valid account id\\\"\\n except ValueError:\\n return False, {}, \\\"not a valid account id\\\"\\n \\n try:\\n output_dict[\\\"Created On\\\"] = to_datetime(input_dict[\\\"Created On\\\"], errors='coerce').strftime(\\\"%x\\\")\\n except ValueError:\\n output_dict[\\\"Created On\\\"] = \\\"\\\"\\n \\n output_dict[\\\"First Name\\\"] = input_dict[\\\"First Name\\\"]\\n \\n return True, output_dict, \\\"\\\"\",\n \"def get_contact_date(chat_id):\\n # Reads the customers.json\\n with open(json_dir + 'customers.json') as f:\\n data = json.load(f)\\n contact = None\\n for d in data:\\n # Searches the correct customer and returns all his values\\n if d['contact']['chat_id'] == chat_id:\\n contact = {'name': d['contact']['name'], 'postcode': d['contact']['postcode'],\\n 'street': d['contact']['street'], 'city': d['contact']['city'], 'nr': d['contact']['nr'],\\n 'phone': d['contact']['phone'], 'chat_id': d['contact']['chat_id']}\\n break\\n\\n return contact\",\n \"def precipitation():\\n results = session.query(Measurement.date, Measurement.prcp).filter(Measurement.date >= '2016-08-23').order_by(Measurement.date)\\n precipitation_values = []\\n for p in results:\\n prcp_dict = {}\\n prcp_dict[\\\"date\\\"] = p.date\\n prcp_dict[\\\"prcp\\\"] = p.prcp\\n precipitation_values.append(prcp_dict)\\n\\n return jsonify(precipitation_values)\",\n \"def get_bank_annotation(bank_id, bank_annotations_path):\\n df = pd.read_csv(bank_annotations_path)\\n df = df.set_index('bank_id')\\n annotation_id = df.loc[bank_id, 'annotation_id']\\n question_id = df.loc[bank_id, 'question_id']\\n question_text = df.loc[bank_id, 'question_text']\\n decomposition_accepted = df.loc[bank_id, 'decomposition_accepted']\\n decomposition = df.loc[bank_id, 'decomposition']\\n return BankAnnotationInfo(bank_id, annotation_id, question_id, question_text, decomposition, decomposition_accepted)\",\n \"def from_dict(cls, dikt) -> 'AllOfCreateClaimResponseClaim':\\n return util.deserialize_model(dikt, cls)\",\n \"def ConferenceRecord(self, default={}):\\n return HEP.JSONReferenceObject(self.data.get('conference_record', default))\",\n \"def get_patients_dict(table):\\n\\tf = open(table)\\n\\tpatients = f.readline().strip().split(\\\"\\\\t\\\")[1:]\\n\\t\\t \\n\\tpatients_dict = {}\\n\\tfor i in patients:\\n\\t\\tpatients_dict[i.replace('\\\"', '')] = {}\\n\\t\\t \\n\\tfor i in f:\\n\\t\\tl = i.strip().split(\\\"\\\\t\\\")\\n\\t\\tgene = l[0]\\n\\n\\t\\tfor j in range(len(l[1:])):\\n\\t\\t\\tpatients_dict[patients[j]][gene] = int(l[1:][j])\\n\\treturn patients_dict\",\n \"def precipitation():\\n \\n # Obtain the current year from the date and using that date determine the previous year appending 01-01 and 12-31\\n \\n compare_date = dt.date.today()\\n start_date = f\\\"{compare_date.year - 1}-01-01\\\"\\n end_date = f\\\"{compare_date.year - 1}-12-31\\\"\\n precipitation_result = session.query(Measurement).filter((Measurement.date >= start_date) & (Measurement.date <= end_date)\\n ).order_by(Measurement.date).all()\\n \\n precipitation = []\\n \\n for row in precipitation_result:\\n precipitation_dict = {}\\n precipitation_dict[\\\"date\\\"] = row.date\\n precipitation_dict[\\\"tobs\\\"] = row.tobs\\n precipitation.append(precipitation_dict)\\n \\n return jsonify(precipitation)\",\n \"def precip():\\n # Query Measurement data\\n session = Session(engine)\\n results = session.query(Measurement.date, Measurement.prcp).all()\\n\\n # Create a dictionary from the row data and append to a list of precipitation data\\n precip_data = []\\n for date, prcp in results:\\n precip_dict = {}\\n precip_dict[\\\"date\\\"] = date\\n precip_dict[\\\"Precipitation\\\"] = prcp\\n precip_data.append(precip_dict)\\n\\n return jsonify(precip_data)\",\n \"def precipitation():\\n\\n # Open sessions\\n session = Session(bind=engine)\\n\\n # Find out what is the latest date with data\\n lastDate=session.query(Measurement.date).order_by(Measurement.date.desc()).first()\\n for date in lastDate:\\n dataArray = date.split(\\\"-\\\")\\n (year,month,day) = dataArray\\n \\n # Calculate the sate 1 year ago of the latest date\\n year_ago = dt.date(int(year),int(month),int(day)) - dt.timedelta(days=365)\\n\\n # Define the varialbles for start and end date\\n latestPrcpDate=f'{year}-{month}-{day}'\\n oldestPrcpDate=year_ago.isoformat()\\n\\n # Initiating an empty dictionary\\n precipitation={}\\n\\n # Query DB for preciitation values from start date to end date\\n results=session.query(Measurement).filter(Measurement.date >= year_ago).all()\\n for row in results:\\n prcp={row.date:row.prcp} #storing the date and the measured value in a dictionary\\n precipitation.update(prcp) #updating the main dictionary with the previous smaller dictionary\\n\\n # Calculating the main API dictionary with an info key, a date interval and the results/observations \\n precipitationAPI={'info':'Last 12 months of precipitation data in inches',\\n 'date interval':{'from':oldestPrcpDate,'to':latestPrcpDate},\\n 'results':precipitation\\n }\\n\\n # Returing the main dictionary in a JSON format API response \\n return jsonify(precipitationAPI)\",\n \"def precipitation():\\n\\n # first select the latest date\\n latest_date, new_date = get_latest_date()\\n\\n # select date and precip for last 12 months\\n results = session.query(Measurement.date, Measurement.prcp). \\\\\\n filter(Measurement.date >= new_date). \\\\\\n order_by(Measurement.date).all()\\n\\n # convert results to dictionary\\n prec_dict = {}\\n\\n for r in results:\\n prec_dict[r.date] = r.prcp\\n\\n return jsonify(prec_dict)\",\n \"def form_data(self):\\n from couchforms import XMLSyntaxError\\n from .utils import convert_xform_to_json, adjust_datetimes\\n from corehq.form_processor.utils.metadata import scrub_form_meta\\n xml = self.get_xml()\\n try:\\n form_json = convert_xform_to_json(xml)\\n except XMLSyntaxError:\\n return {}\\n # we can assume all sql domains are new timezone domains\\n with force_phone_timezones_should_be_processed():\\n adjust_datetimes(form_json)\\n\\n scrub_form_meta(self.form_id, form_json)\\n return form_json\",\n \"def create_patient(patient):\\n\\n pat = {\\n 'resourceType': 'Patient',\\n 'identifier': [\\n {\\n 'hosp_no': patient.pat_no\\n }\\n ],\\n 'name': [\\n {\\n 'family': patient.sname,\\n 'given': patient.fname\\n }\\n ],\\n 'birthDate': patient.dob,\\n 'gender': patient.gender,\\n 'estimatedDischarge': patient.edd\\n }\\n\\n return pat\",\n \"def parse_patient_data(input_file, output_file):\\n rows = []\\n if os.path.exists(input_file):\\n with open(input_file) as f:\\n data = json.loads(f.read())\\n for entry in data.get('entry', []):\\n url = entry.get('fullUrl', '')\\n resource = entry.get('resource', {})\\n if not resource:\\n print('resource not found for url %s in %s: please check' % (url, in_file), file=sys.stderr)\\n continue\\n\\n resource_type = resource.get('resourceType', '').lower()\\n if resource_type != 'patient':\\n print('resource type is not patient for url %s in %s: please check' % (url, in_file), file=sys.stderr)\\n continue\\n\\n resource_id = resource.get('id', '')\\n last_updated = resource.get('meta', {}).get('lastUpdated', '')\\n status = resource.get('text', {}).get('status', '').lower()\\n system_id = resource.get('text', {}).get('value')\\n active = resource.get('active', False)\\n first_name = resource.get('name', {})[0].get('given', [''])[0]\\n last_name = resource.get('name', {})[0].get('family', [''])\\n phone = resource.get('telecom', [{}])[0].get('value', '')\\n gender = resource.get('gender', '')\\n address = resource.get('address', [{}])[0].get('value', '')\\n\\n rows.append([url, resource_id, last_updated, status, system_id, active, first_name, last_name, phone, gender, address])\\n\\n with open(output_file, 'w') as f:\\n writer = csv.writer(f, dialect=csv.excel)\\n writer.writerow(['url', 'resource_id', 'last_updated', 'status', 'system_id', 'active', 'first_name', 'last_name', 'phone', 'gender', 'address'])\\n for row in rows:\\n writer.writerow(row)\",\n \"def get_patient_for_editing(args):\\n\\n q = (\\\"select coalesce(p.StreetAddress1, StreetAddress2, StreetAddress3) as StreetAddress, p.City, p.County, p.State, p.Zip \\\" +\\n \\\"from {schema}.PersonCrosswalk x \\\".format(schema=app_schema) +\\n \\\"left join {schema}.PersonCDW p on p.PersonID = x.PersonID \\\".format(schema=staging_schema) +\\n \\\"where x.PersonID = ?\\\")\\n tb = pd.read_sql(q, engine, params=[args[\\\"PersonID\\\"]])\\n\\n if tb.shape[0] != 1:\\n person_cdw_dict = None\\n else:\\n person_cdw_dict = tb.iloc[0,:].to_dict()\\n\\n # Get person information from PersonCombined.\\n tb = get_table_by_person_id(\\\"PersonCombined\\\", args[\\\"PersonID\\\"], schema=app_schema, fields=\\\"Edit\\\")\\n if tb.shape[0] != 1:\\n person_combined_dict = {} # Set to empty dict\\n else:\\n person_combined_dict = tb.iloc[0,:].to_dict() \\n\\n # Convert Symptomtype entries to be in a list b/c in the form these fields are multi select fields\\n # For situations where we selected multiple symptoms, create a list\\n symptoms_fields = [\\\"SymptomType\\\" + str(n) for n in list(range(1, 11))]\\n\\n if not person_combined_dict: # for newly added patients w/o VISTA data\\n for k in symptoms_fields:\\n person_combined_dict[k] = [None]\\n else:\\n for k in symptoms_fields:\\n if person_combined_dict.get(k, None) is None: # if they have no existing values\\n person_combined_dict[k] = [None] \\n else:\\n if person_combined_dict[k].count(\\\"; \\\"): # if they have more than one symptom listed\\n person_combined_dict[k] = person_combined_dict[k].split(\\\"; \\\")\\n else:\\n person_combined_dict[k] = [person_combined_dict[k]]\\n \\n # Get test data from CDW/FileMan via TestCombined.\\n q = (\\\"select * \\\" +\\n \\\"from {schema}.TestCombined \\\".format(schema=app_schema) +\\n \\\"where PersonID = ? and Source in ('CDW', 'FileMan')\\\")\\n test_cdw_tb = pd.read_sql(q, engine, params=[args[\\\"PersonID\\\"]])\\n test_simplified = coalesce_test_results.combine_results(test_cdw_tb)\\n \\n # Get Contacted Status - just for displaying on edit page\\n person_contacted_dict = get_patient_contacted_status(args)\\n if person_contacted_dict[\\\"current\\\"] is None:\\n person_combined_dict[\\\"Contacted\\\"] = \\\"\\\"\\n person_combined_dict[\\\"Comment\\\"] = \\\"\\\"\\n else:\\n person_combined_dict[\\\"Contacted\\\"] = person_contacted_dict[\\\"current\\\"][\\\"Contacted\\\"]\\n person_combined_dict[\\\"Comment\\\"] = person_contacted_dict[\\\"current\\\"][\\\"Comment\\\"]\\n\\n # Get LastName and SSN from PersonCrosswalk (new Persons are anchored here initially).\\n q = (\\\"select PatientLastName, PatientSSN \\\" +\\n \\\"from {schema}.PersonCrosswalk \\\".format(schema=app_schema) +\\n \\\"where PersonID = ?\\\")\\n pxwalk_tb = pd.read_sql(q, engine, params=[args[\\\"PersonID\\\"]])\\n pxwalk_dict = pxwalk_tb.iloc[0,:].to_dict() \\n\\n return {\\\"PersonCombined\\\": person_combined_dict,\\n \\\"PersonCrosswalk\\\": pxwalk_dict,\\n \\\"TestCDW\\\": test_simplified, \\n \\\"HistoricalContact\\\": person_contacted_dict[\\\"historical\\\"],\\n \\\"PersonCDW\\\": person_cdw_dict}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5926589","0.5809377","0.5732567","0.56433344","0.55838776","0.5239948","0.514208","0.5133141","0.4684602","0.45138747","0.44812942","0.44552103","0.44459537","0.44308993","0.44297066","0.4419778","0.43893576","0.4386389","0.43847585","0.4346647","0.43109578","0.430297","0.42564926","0.4255986","0.4253754","0.42494524","0.42355248","0.422037","0.4218554","0.42183602","0.42129737","0.4199968","0.41949922","0.4187784","0.41676304","0.41644505","0.41563752","0.41506937","0.41439325","0.41416964","0.41407126","0.41370973","0.41363886","0.41347483","0.4128587","0.41245922","0.41045484","0.41018447","0.4092078","0.40854684","0.4082158","0.4081259","0.40782773","0.40761817","0.40728724","0.40651062","0.40631792","0.40520912","0.40341046","0.4032791","0.40244526","0.40224764","0.40139338","0.4013033","0.4012178","0.40073296","0.39769042","0.39721793","0.39706188","0.39653632","0.39636394","0.39616504","0.39528498","0.39322993","0.39306533","0.39302474","0.39289224","0.3928669","0.3925717","0.39198133","0.3914417","0.39142764","0.39106357","0.39088112","0.3906808","0.39043057","0.39038414","0.38973075","0.38944578","0.3888213","0.38844025","0.3883306","0.38797596","0.3876556","0.38755578","0.38753402","0.3869239","0.38635108","0.38626003","0.3859675"],"string":"[\n \"0.5926589\",\n \"0.5809377\",\n \"0.5732567\",\n \"0.56433344\",\n \"0.55838776\",\n \"0.5239948\",\n \"0.514208\",\n \"0.5133141\",\n \"0.4684602\",\n \"0.45138747\",\n \"0.44812942\",\n \"0.44552103\",\n \"0.44459537\",\n \"0.44308993\",\n \"0.44297066\",\n \"0.4419778\",\n \"0.43893576\",\n \"0.4386389\",\n \"0.43847585\",\n \"0.4346647\",\n \"0.43109578\",\n \"0.430297\",\n \"0.42564926\",\n \"0.4255986\",\n \"0.4253754\",\n \"0.42494524\",\n \"0.42355248\",\n \"0.422037\",\n \"0.4218554\",\n \"0.42183602\",\n \"0.42129737\",\n \"0.4199968\",\n \"0.41949922\",\n \"0.4187784\",\n \"0.41676304\",\n \"0.41644505\",\n \"0.41563752\",\n \"0.41506937\",\n \"0.41439325\",\n \"0.41416964\",\n \"0.41407126\",\n \"0.41370973\",\n \"0.41363886\",\n \"0.41347483\",\n \"0.4128587\",\n \"0.41245922\",\n \"0.41045484\",\n \"0.41018447\",\n \"0.4092078\",\n \"0.40854684\",\n \"0.4082158\",\n \"0.4081259\",\n \"0.40782773\",\n \"0.40761817\",\n \"0.40728724\",\n \"0.40651062\",\n \"0.40631792\",\n \"0.40520912\",\n \"0.40341046\",\n \"0.4032791\",\n \"0.40244526\",\n \"0.40224764\",\n \"0.40139338\",\n \"0.4013033\",\n \"0.4012178\",\n \"0.40073296\",\n \"0.39769042\",\n \"0.39721793\",\n \"0.39706188\",\n \"0.39653632\",\n \"0.39636394\",\n \"0.39616504\",\n \"0.39528498\",\n \"0.39322993\",\n \"0.39306533\",\n \"0.39302474\",\n \"0.39289224\",\n \"0.3928669\",\n \"0.3925717\",\n \"0.39198133\",\n \"0.3914417\",\n \"0.39142764\",\n \"0.39106357\",\n \"0.39088112\",\n \"0.3906808\",\n \"0.39043057\",\n \"0.39038414\",\n \"0.38973075\",\n \"0.38944578\",\n \"0.3888213\",\n \"0.38844025\",\n \"0.3883306\",\n \"0.38797596\",\n \"0.3876556\",\n \"0.38755578\",\n \"0.38753402\",\n \"0.3869239\",\n \"0.38635108\",\n \"0.38626003\",\n \"0.3859675\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73424447"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84584,"cells":{"query":{"kind":"string","value":"Read transaction from dictionary"},"document":{"kind":"string","value":"def read_dict(self, d: dict):\n self.transaction_id = d.get('transaction_id')\n\n self.study_id = d.get('study_id')\n self.patient_id = d.get('patient_id')\n self.name = d.get('name')\n birth_date = d.get('birth_date')\n self.birth_date = datetime.datetime.strptime(\n birth_date, \"%d/%m/%Y\") if birth_date else None\n self.study_date = d.get('study_date')\n self.patient_consent_date = self._read_patient_consent_date(d)\n self.institution = d.get('institution')\n\n self.start_date = self._str_to_datetime(d.get('start_date'))\n self.end_date = self._str_to_datetime(d.get('end_date'))\n self.creation_date = self._str_to_datetime(d.get('creation_date'))\n\n self.version = d.get(\"version\")\n self.analysis_type = d.get(\"analysis_type\")\n self.qa_score = d.get(\"qa_score\")\n self.product_id = d.get('product_id')\n\n self.task_state = TaskState[\n d.get('task_state')] if d.get('task_state') else None\n self.processing_state = d.get('processing_state')\n self.task_progress = d.get('task_progress')\n self.task_skipped = d.get('task_skipped')\n self.task_cancelled = d.get('task_cancelled')\n self.archived = d.get('archived')\n self.error = d.get('error')\n self.status = d.get('status')\n self.sequences = d.get('sequences')\n self.last_message = d.get('last_message')\n\n self.data_uploaded = self._str_to_datetime(d.get('data_uploaded'))\n self.billable = d.get('billable')\n self.priority = d.get('priority')\n self.site_id = d.get('site_id', 0)\n\n return self"},"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_transactions(self):\r\n\t\tlogger.debug(\"Enter\")\r\n\t\ttry:\r\n\t\t\twith open(self._state_file, 'rb') as tmp:\r\n\t\t\t\tlogger.debug(\"There is a file.\")\r\n\t\t\t\ttmp_dict = pickle.load(tmp)\r\n\t\t\t\tlogger.debug(\"Dictionary loaded from file: %s\" % tmp_dict)\r\n\t\texcept IOError as e: # File doesn't exists\r\n\t\t\tlogger.debug(\"Exit - No file. Error message: %s\" % e)\r\n\t\t\ttmp_dict = {}\r\n\t\t\t\r\n\t\treturn tmp_dict","def read_trade() -> dict:\n try:\n ddb_table.get_item(Key = data_to_get)\n except Exception as e:\n _LOGGER.error('Problem updating dynamodb trade data. {0}'.format(e))\n raise Exception('Problem updating dynamodb trade data. {0}'.format(e))","def from_dict(d: dict):\n result: Transaction = Transaction()\n result.id = int(d[\"id\"])\n result.time = int(d[\"time\"])\n result.action = string_to_action(d[\"action\"])\n result.acting_username = d[\"acting_username\"]\n result.source_account_id = int(d[\"source_account_id\"])\n result.destination_account_id = int(d[\"destination_account_id\"])\n result.funds_amount = int(d[\"funds_amount\"])\n return result","def decoderawtransaction(self, hexstring):\n return dict(self.proxy.decoderawtransaction(hexstring))","def load_data():\n dataFile = open('transactions.json', 'r')\n data = json.load(dataFile)\n transactions = data['transactions']#TID\n items = data['items']#item sets\n return items, transactions","def ReadTransaction(self, request, context):\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)","def load_transaction(uid, bucket=None):\n if bucket is None:\n bucket = _login_to_service_account()\n\n data = _ObjectStore.get_object_from_json(bucket, Ledger.get_key(uid))\n\n if data is None:\n raise LedgerError(\"There is no transaction recorded in the \"\n \"ledger with UID=%s (at key %s)\" %\n (uid, Ledger.get_key(uid)))\n\n return _TransactionRecord.from_data(data)","def deserialize(cls, raw_transaction: bytes) -> Transaction:\n return cls.from_solders(SoldersTx.from_bytes(raw_transaction))","def transaction_base() -> Dict[str, Any]:\n return {\n \"first_name\": \"Donald\",\n \"last_name\": \"Duck\",\n \"company\": \"Duck Co\",\n \"email\": \"donald.duck@duckburg.inv\",\n \"telephone\": \"991234567\",\n \"mobile\": \"+358991234567\",\n \"street\": \"1313 Webfoot Walk\",\n \"postal_code\": \"00000\",\n \"city\": \"Duckburg\",\n \"country\": \"US\",\n \"information\": \"Quack, damn you!\",\n \"items\": [],\n }","def readData(self, dataDict):\n pass","def _read_transaction(self, tx_fun, **kwargs):\n # Wrapper for neo4j.Session.read_transaction\n with self._driver.session() as session:\n result = session.read_transaction(tx_fun, **kwargs)\n return result","def readData(self, key, context):\n\n print(\"key: {}\".format(key))\n address = _make_benchcontract_address(\"key_{}\".format(key))\n print(\"address: {}\".format(address))\n data = context.get_state(\n [address],\n timeout=self.timeout)\n print(\"readData obtained {} --> {} from state\".format(key, data[\"data\"]))\n return 0","def load_file(filename):\n with open(filename, 'r', encoding='utf-8') as fin:\n reader = csv.DictReader(fin, delimiter=',')\n purchases = []\n for row in reader:\n # print(type(row), row)\n p = Purchase.create_from_dict(row)\n purchases.append(p)\n return purchases","def dict(dict: Dict[str, Pin], /) -> None:","def transaction(self, transaction):\n # Allow for a list of blocks..\n transaction = utils.request_type(transaction)\n\n res = r.get(self.url + self.tx_info + str(transaction))\n return self.execute(res)","def load(self):\n def load_transaction_info(info):\n description = info.description\n payee = info.payee\n checkno = info.checkno\n date = info.date\n transaction = Transaction(date, description, payee, checkno)\n transaction.notes = nonone(info.notes, '')\n for split_info in info.splits:\n account = split_info.account\n amount = split_info.amount\n if split_info.amount_reversed:\n amount = -amount\n memo = nonone(split_info.memo, '')\n split = Split(transaction, account, amount)\n split.memo = memo\n if split_info.reconciliation_date is not None:\n split.reconciliation_date = split_info.reconciliation_date \n elif split_info.reconciled: # legacy\n split.reconciliation_date = transaction.date\n split.reference = split_info.reference\n transaction.splits.append(split)\n while len(transaction.splits) < 2:\n transaction.splits.append(Split(transaction, None, 0))\n transaction.balance()\n transaction.mtime = info.mtime\n if info.reference is not None:\n for split in transaction.splits:\n if split.reference is None:\n split.reference = info.reference\n return transaction\n \n self._load()\n self.flush_account() # Implicit\n # Now, we take the info we have and transform it into model instances\n currencies = set()\n start_date = datetime.date.max\n for info in self.group_infos:\n group = Group(info.name, info.type)\n self.groups.append(group)\n for info in self.account_infos:\n account_type = info.type\n if account_type not in AccountType.All:\n account_type = AccountType.Asset\n account_currency = self.default_currency\n try:\n if info.currency:\n account_currency = Currency(info.currency)\n except ValueError:\n pass # keep account_currency as self.default_currency\n account = Account(info.name, account_currency, account_type)\n if info.group:\n account.group = self.groups.find(info.group, account_type)\n if info.budget:\n self.budget_infos.append(BudgetInfo(info.name, info.budget_target, info.budget))\n account.reference = info.reference\n account.account_number = info.account_number\n account.notes = info.notes\n currencies.add(account.currency)\n self.accounts.add(account)\n \n # Pre-parse transaction info. We bring all relevant info recorded at the txn level into the split level\n all_txn = self.transaction_infos + [r.transaction_info for r in self.recurrence_infos] +\\\n flatten([stripfalse(r.date2exception.values()) for r in self.recurrence_infos]) +\\\n flatten([r.date2globalchange.values() for r in self.recurrence_infos])\n for info in all_txn:\n split_accounts = [s.account for s in info.splits]\n if info.account and info.account not in split_accounts:\n info.splits.insert(0, SplitInfo(info.account, info.amount, info.currency, False))\n if info.transfer and info.transfer not in split_accounts:\n info.splits.append(SplitInfo(info.transfer, info.amount, info.currency, True))\n for split_info in info.splits:\n # this amount is just to determine the auto_create_type\n str_amount = split_info.amount\n if split_info.currency:\n str_amount += split_info.currency\n amount = self.parse_amount(str_amount, self.default_currency)\n auto_create_type = AccountType.Income if amount >= 0 else AccountType.Expense\n split_info.account = self.accounts.find(split_info.account, auto_create_type) if split_info.account else None\n currency = split_info.account.currency if split_info.account is not None else self.default_currency\n split_info.amount = self.parse_amount(str_amount, currency)\n if split_info.amount:\n currencies.add(split_info.amount.currency)\n \n self.transaction_infos.sort(key=attrgetter('date'))\n for date, transaction_infos in groupby(self.transaction_infos, attrgetter('date')):\n start_date = min(start_date, date)\n for position, info in enumerate(transaction_infos, start=1):\n transaction = load_transaction_info(info)\n self.transactions.add(transaction, position=position)\n \n # Scheduled\n for info in self.recurrence_infos:\n ref = load_transaction_info(info.transaction_info)\n recurrence = Recurrence(ref, info.repeat_type, info.repeat_every)\n recurrence.stop_date = info.stop_date\n for date, transaction_info in info.date2exception.items():\n if transaction_info is not None:\n exception = load_transaction_info(transaction_info)\n spawn = Spawn(recurrence, exception, date, exception.date)\n recurrence.date2exception[date] = spawn\n else:\n recurrence.delete_at(date)\n for date, transaction_info in info.date2globalchange.items():\n change = load_transaction_info(transaction_info)\n spawn = Spawn(recurrence, change, date, change.date)\n recurrence.date2globalchange[date] = spawn\n self.schedules.append(recurrence)\n # Budgets\n TODAY = datetime.date.today()\n fallback_start_date = datetime.date(TODAY.year, TODAY.month, 1)\n for info in self.budget_infos:\n account = self.accounts.find(info.account)\n if account is None:\n continue\n target = self.accounts.find(info.target) if info.target else None\n amount = self.parse_amount(info.amount, account.currency)\n start_date = nonone(info.start_date, fallback_start_date)\n budget = Budget(account, target, amount, start_date, repeat_type=info.repeat_type)\n budget.notes = nonone(info.notes, '')\n budget.stop_date = info.stop_date\n if info.repeat_every:\n budget.repeat_every = info.repeat_every\n self.budgets.append(budget)\n self._post_load()\n self.oven.cook(datetime.date.min, until_date=None)\n Currency.get_rates_db().ensure_rates(start_date, [x.code for x in currencies])","def ReadTransaction(self, request, timeout, metadata=None, with_call=False, protocol_options=None):\n raise NotImplementedError()","def getTxnFromData(self, oid, back):\n h = self._read_data_header(back, oid)\n return h.tid","def load_dict(self, dct):\n pass","def read_dic():\n # should return the original format\n dic = OrdDic()\n dic.update(json.load(open(\"resources/files/serials.csv\", \"r\")))\n\n\n # OLD CODE\n # logging.log(logging.INFO, \"File path: \"+os.path.realpath(__file__))\n # r = reader(open(\"resources/files/serials.csv\", \"r\", newline=\"\\n\"))\n # i = 0\n # for row in r:\n # if i:\n # inner_dic = OrdDic()\n # for serial in row[1].split(';;,,,;;'):\n # serial = serial.split(';;:::;;')\n # sub_dic = OrdDic()\n # for sub_serial in serial[1].split(';;!!!;;'):\n # sub_serial = sub_serial.split(\";;@@;;\")\n # if sub_serial[0] == 'options':\n # options = sub_serial[1].split(\";;##;;\")\n # sub_dic.update({sub_serial[0]: options})\n # else:\n # sub_dic.update(\n # {sub_serial[0]: sub_serial[1]})\n # inner_dic.update({serial[0]: sub_dic})\n # # lst = row[1].split('\\\\')\n # dic.update({row[0]: inner_dic})\n # else:\n # i += 1\n # # print(\" * Read Dictionary\")\n return dic","def getTransaction(hash, config):\n platon = get_eth_obj(config)\n try:\n # 交易信息\n transaction = dict(platon.getTransaction(hash))\n HexBytes_to_str(transaction)\n # 交易回执信息\n transaction_receipt = dict(platon.getTransactionReceipt(hash))\n HexBytes_to_str(transaction_receipt)\n except Exception as e:\n cust_print('Failed to query transaction information,error message:{}.'.format(e))\n sys.exit(1)\n cust_print('query transaction information successful!', fg='g')\n info = \"transaction:\\n\"\n info += \"{}\\n\".format(json.dumps(dict(transaction), indent=2))\n info += \"\\n\\ntransaction receipt:\\n\"\n info += \"{}\".format(json.dumps(dict(transaction_receipt), indent=2))\n cust_print('{}'.format(info), fg='g')","def transaction(self, transaction_id: str):\n return get_from_list(self.transactions, \"id\", transaction_id)","def _get_transaction(self, hash_bytes: bytes) -> BaseTransaction:\n raise NotImplementedError","def _retrieve_dict(self, object_key):\n return json.loads(self._retrieve_blob(object_key).decode('utf-8'))","def gettransaction(self, txid):\n return TransactionInfo(**self.proxy.gettransaction(txid))","def _decode(self, input_dict):\n pass","def transaction_data(self):\n return list(map(lambda transaction:transaction.to_json(), self.transaction_map.values()))","def from_dict(cls, dikt) -> 'Debt':\n return util.deserialize_model(dikt, cls)","def _read_input(self, in_file):\n result = {}\n with open(in_file, \"r\") as f:\n reader = csv.DictReader(f, delimiter=str(\"\\t\"))\n for row in reader:\n result[row[\"accession\"]] = {\n \"transcript_sequence\": row[\"transcript_sequence\"],\n \"cds_start_i\": int(row[\"cds_start_i\"]),\n \"cds_end_i\": int(row[\"cds_end_i\"]),\n }\n\n return result","def ReadTransaction(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def ReadTransaction(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def get_transaction(self, i):\n\t\treturn self.transactions[i]","def get_transaction(self, i):\n\t\treturn self.transactions[i]","def raw_get_transaction(cls, txid):\n r = requests.get(cls.MAIN_TX_API.format(txid), timeout=DEFAULT_TIMEOUT)\n r.raise_for_status() # pragma: no cover\n return r.json()","def load_from_state_dict(self, state_dict):\n raise NotImplementedError","def test_wallets_get_transaction_list(self):\n pass","def handleTransaction(self, trans_str):\n # pharse the trans_str \n trans = Transaction()\n trans.parseJson(trans_str)\n new_block = self.nextBlock(trans)\n \n # Do not generate Block\n if not new_block:\n return True\n \n self.boradBlock(new_block)\n\n return True # Temporae","def get_transaction(self, transaction_id):\n url = self.base_url + 'transactions/' + str(transaction_id)\n self.session.headers.update(self.sign(url))\n resp = self.session.get(url)\n return resp.json()","async def test_tx_metadata(self):\n data_hex = pkg_resources.resource_string(__name__, os.path.join('data', 'tx_metadata_01.txt'))\n data_bin = binascii.unhexlify(data_hex)\n reader = x.MemoryReaderWriter(bytearray(data_bin))\n ar = xmrb.Archive(reader, False, xmr.hf_versions(9))\n\n msg = xmr.PendingTransaction()\n await ar.root()\n await ar.message(msg)\n\n self.assertEqual(msg.tx_key,\n binascii.unhexlify(b'a0a50810dbc38101a79525823428b500ac936dfea613c73b4864f7260ff26a0b'))\n self.assertEqual(msg.change_dts.amount, 99972803971000)\n self.assertEqual(msg.fee, 9119110000)\n self.assertEqual(msg.construction_data.use_rct, 1)\n self.assertEqual(len(msg.construction_data.extra), 44)\n self.assertEqual(len(msg.construction_data.sources), 1)\n self.assertEqual(msg.construction_data.sources[0].amount, 100000000000000)\n self.assertEqual(msg.construction_data.sources[0].mask,\n binascii.unhexlify(b'2dea8778cf4e89a7f32b5659d674d44795a370a00f79ee9b2ea37c1fcb005c0d'))\n self.assertEqual(len(msg.construction_data.sources[0].outputs), 7)\n self.assertEqual(msg.construction_data.sources[0].outputs[6][0], 1727)\n self.assertEqual(msg.construction_data.sources[0].outputs[6][1].mask,\n binascii.unhexlify(b'2eeec82a970bfa54c35b0b740f6fb0585de14818e3c6dceed75c76fe69e3e449'))\n\n self.assertEqual(len(msg.construction_data.dests), 1)\n self.assertEqual(len(msg.construction_data.splitted_dsts), 2)\n self.assertEqual(msg.construction_data.splitted_dsts[0].amount, 18076919000)\n self.assertEqual(msg.construction_data.splitted_dsts[1].amount, 99972803971000)\n self.assertEqual(len(msg.construction_data.subaddr_indices), 1)\n\n writer = x.MemoryReaderWriter()\n ar2 = xmrb.Archive(writer, True, xmr.hf_versions(9))\n await ar2.root()\n await ar2.message(msg)\n self.assertEqual(data_bin, bytearray(writer.get_buffer()))\n\n msg.construction_data.use_bulletproofs = False\n writer = x.MemoryReaderWriter()\n ar2 = xmrb.Archive(writer, True, xmr.hf_versions(9))\n await ar2.root()\n await ar2.message(msg)","def read(self, key):\n raise NotImplementedError","def recordTransaction(self, loop, transaction):\n\n a = {}\n a['time'] = transaction.transactionTime\n a['atm'] = transaction.transactionATM.atmID\n a['transaction'] = transaction.transactionType\n a['cash'] = transaction.transactionATM.atmCash\n a['status'] = transaction.transactionStatus\n self._atmDict[loop] = a\n\n c = {}\n c['time'] = transaction.transactionTime\n c['client'] = transaction.transactionCard.cardAccount.accountClient.clientID\n c['account'] = transaction.transactionCard.cardAccount.accountNumber\n c['transaction'] = transaction.transactionType\n c['balance'] = transaction.transactionCard.cardAccount.accountBalance\n c['status'] = transaction.transactionStatus\n self._clientDict[loop] = c\n\n t = {}\n t['time'] = transaction.transactionTime\n t['transaction'] = transaction.transactionType\n t['amount'] = transaction.transactionAmount\n t['status'] = transaction.transactionStatus\n self._transactionDict[loop] = t","def _retrieve_transaction_table_input(self, execution_arn: str) -> Dict:\n response = self.client.get_execution_history(executionArn=execution_arn,maxResults=1000)\n events = response[\"events\"]\n record_purchase_entered_events = [\n event\n for event in events\n if event[\"type\"] == \"TaskStateEntered\" and event[\"stateEnteredEventDetails\"][\"name\"] == \"InsertPurchase\"\n ]\n\n record_refund_entered_events = [\n event\n for event in events\n if event[\"type\"] == \"TaskStateEntered\" and event[\"stateEnteredEventDetails\"][\"name\"] == \"InsertRefund\"\n ]\n\n record_error_entered_events = [\n event\n for event in events\n if event[\"type\"] == \"TaskStateEntered\" and event[\"stateEnteredEventDetails\"][\"name\"] == \"InsertError\"\n ]\n \n self.assertTrue(\n record_purchase_entered_events,\n \"Cannot find InsertPurchase TaskStateEntered event\",\n )\n self.assertTrue(\n record_refund_entered_events,\n \"Cannot find InsertPurchase TaskStateEntered event\",\n )\n self.assertTrue(\n record_error_entered_events,\n \"Cannot find InsertPurchase TaskStateEntered event\",\n )\n purchase_table_input=[] #PurchaseTable inputs\n refund_table_input=[] # RefundTable inputs\n error_table_input=[] # ErrorTable inputs\n for transaction in record_purchase_entered_events:\n transaction_input = json.loads(transaction[\"stateEnteredEventDetails\"][\"input\"])\n\n purchase_table_input.append(transaction_input)\n self.inserted_purchase_record_id.append(transaction_input[\"TransactionId\"]) # save this ID for cleaning up PurchaseTable\n\n for transaction in record_refund_entered_events:\n transaction_input = json.loads(transaction[\"stateEnteredEventDetails\"][\"input\"])\n\n refund_table_input.append(transaction_input)\n self.inserted_refund_record_id.append(transaction_input[\"TransactionId\"]) # save this ID for cleaning up RefundTable\n\n for transaction in record_error_entered_events:\n transaction_input = json.loads(transaction[\"stateEnteredEventDetails\"][\"input\"])\n\n error_table_input.append(transaction_input)\n self.inserted_error_record_id.append(transaction_input[\"TransactionId\"]) # save this ID for cleaning up ErrorTable\n\n return purchase_table_input, refund_table_input, error_table_input","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n available_balance_amount = dictionary.get('availableBalanceAmount')\r\n posted_date = dictionary.get('postedDate')\r\n open_date = dictionary.get('openDate')\r\n period_start_date = dictionary.get('periodStartDate')\r\n period_end_date = dictionary.get('periodEndDate')\r\n period_interest_rate = dictionary.get('periodInterestRate')\r\n period_deposit_amount = dictionary.get('periodDepositAmount')\r\n period_interest_amount = dictionary.get('periodInterestAmount')\r\n interest_ytd_amount = dictionary.get('interestYtdAmount')\r\n interest_prior_ytd_amount = dictionary.get('interestPriorYtdAmount')\r\n maturity_date = dictionary.get('maturityDate')\r\n interest_rate = dictionary.get('interestRate')\r\n credit_available_amount = dictionary.get('creditAvailableAmount')\r\n credit_max_amount = dictionary.get('creditMaxAmount')\r\n cash_advance_available_amount = dictionary.get('cashAdvanceAvailableAmount')\r\n cash_advance_max_amount = dictionary.get('cashAdvanceMaxAmount')\r\n cash_advance_balance = dictionary.get('cashAdvanceBalance')\r\n cash_advance_interest_rate = dictionary.get('cashAdvanceInterestRate')\r\n current_balance = dictionary.get('currentBalance')\r\n payment_min_amount = dictionary.get('paymentMinAmount')\r\n payment_due_date = dictionary.get('paymentDueDate')\r\n previous_balance = dictionary.get('previousBalance')\r\n statement_start_date = dictionary.get('statementStartDate')\r\n statement_end_date = dictionary.get('statementEndDate')\r\n statement_purchase_amount = dictionary.get('statementPurchaseAmount')\r\n statement_finance_amount = dictionary.get('statementFinanceAmount')\r\n statement_credit_amount = dictionary.get('statementCreditAmount')\r\n reward_earned_balance = dictionary.get('rewardEarnedBalance')\r\n past_due_amount = dictionary.get('pastDueAmount')\r\n last_payment_amount = dictionary.get('lastPaymentAmount')\r\n last_payment_date = dictionary.get('lastPaymentDate')\r\n statement_close_balance = dictionary.get('statementCloseBalance')\r\n term_of_ml = dictionary.get('termOfMl')\r\n ml_holder_name = dictionary.get('mlHolderName')\r\n description = dictionary.get('description')\r\n late_fee_amount = dictionary.get('lateFeeAmount')\r\n payoff_amount = dictionary.get('payoffAmount')\r\n payoff_amount_date = dictionary.get('payoffAmountDate')\r\n original_maturity_date = dictionary.get('originalMaturityDate')\r\n principal_balance = dictionary.get('principalBalance')\r\n escrow_balance = dictionary.get('escrowBalance')\r\n interest_period = dictionary.get('interestPeriod')\r\n initial_ml_amount = dictionary.get('initialMlAmount')\r\n initial_ml_date = dictionary.get('initialMlDate')\r\n next_payment_principal_amount = dictionary.get('nextPaymentPrincipalAmount')\r\n next_payment_interest_amount = dictionary.get('nextPaymentInterestAmount')\r\n next_payment = dictionary.get('nextPayment')\r\n next_payment_date = dictionary.get('nextPaymentDate')\r\n last_payment_due_date = dictionary.get('lastPaymentDueDate')\r\n last_payment_receive_date = dictionary.get('lastPaymentReceiveDate')\r\n last_payment_principal_amount = dictionary.get('lastPaymentPrincipalAmount')\r\n last_payment_interest_amount = dictionary.get('lastPaymentInterestAmount')\r\n last_payment_escrow_amount = dictionary.get('lastPaymentEscrowAmount')\r\n last_payment_last_fee_amount = dictionary.get('lastPaymentLastFeeAmount')\r\n last_payment_late_charge = dictionary.get('lastPaymentLateCharge')\r\n ytd_principal_paid = dictionary.get('ytdPrincipalPaid')\r\n ytd_interest_paid = dictionary.get('ytdInterestPaid')\r\n ytd_insurance_paid = dictionary.get('ytdInsurancePaid')\r\n ytd_tax_paid = dictionary.get('ytdTaxPaid')\r\n auto_pay_enrolled = dictionary.get('autoPayEnrolled')\r\n collateral = dictionary.get('collateral')\r\n current_school = dictionary.get('currentSchool')\r\n first_payment_date = dictionary.get('firstPaymentDate')\r\n first_mortgage = dictionary.get('firstMortgage')\r\n loan_payment_freq = dictionary.get('loanPaymentFreq')\r\n original_school = dictionary.get('originalSchool')\r\n recurring_payment_amount = dictionary.get('recurringPaymentAmount')\r\n lender = dictionary.get('lender')\r\n ending_balance_amount = dictionary.get('endingBalanceAmount')\r\n loan_term_type = dictionary.get('loanTermType')\r\n payments_made = dictionary.get('paymentsMade')\r\n balloon_amount = dictionary.get('balloonAmount')\r\n projected_interest = dictionary.get('projectedInterest')\r\n interest_paid_ltd = dictionary.get('interestPaidLtd')\r\n interest_rate_type = dictionary.get('interestRateType')\r\n loan_payment_type = dictionary.get('loanPaymentType')\r\n repayment_plan = dictionary.get('repaymentPlan')\r\n payments_remaining = dictionary.get('paymentsRemaining')\r\n interest_margin_balance = dictionary.get('interestMarginBalance')\r\n short_balance = dictionary.get('shortBalance')\r\n available_cash_balance = dictionary.get('availableCashBalance')\r\n maturity_value_amount = dictionary.get('maturityValueAmount')\r\n vested_balance = dictionary.get('vestedBalance')\r\n emp_match_amount = dictionary.get('empMatchAmount')\r\n emp_pretax_contrib_amount = dictionary.get('empPretaxContribAmount')\r\n emp_pretax_contrib_amount_ytd = dictionary.get('empPretaxContribAmountYtd')\r\n contrib_total_ytd = dictionary.get('contribTotalYtd')\r\n cash_balance_amount = dictionary.get('cashBalanceAmount')\r\n pre_tax_amount = dictionary.get('preTaxAmount')\r\n after_tax_amount = dictionary.get('afterTaxAmount')\r\n match_amount = dictionary.get('matchAmount')\r\n profit_sharing_amount = dictionary.get('profitSharingAmount')\r\n rollover_amount = dictionary.get('rolloverAmount')\r\n other_vest_amount = dictionary.get('otherVestAmount')\r\n other_nonvest_amount = dictionary.get('otherNonvestAmount')\r\n current_loan_balance = dictionary.get('currentLoanBalance')\r\n loan_rate = dictionary.get('loanRate')\r\n buy_power = dictionary.get('buyPower')\r\n rollover_ltd = dictionary.get('rolloverLtd')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(available_balance_amount,\r\n posted_date,\r\n open_date,\r\n period_start_date,\r\n period_end_date,\r\n period_interest_rate,\r\n period_deposit_amount,\r\n period_interest_amount,\r\n interest_ytd_amount,\r\n interest_prior_ytd_amount,\r\n maturity_date,\r\n interest_rate,\r\n credit_available_amount,\r\n credit_max_amount,\r\n cash_advance_available_amount,\r\n cash_advance_max_amount,\r\n cash_advance_balance,\r\n cash_advance_interest_rate,\r\n current_balance,\r\n payment_min_amount,\r\n payment_due_date,\r\n previous_balance,\r\n statement_start_date,\r\n statement_end_date,\r\n statement_purchase_amount,\r\n statement_finance_amount,\r\n statement_credit_amount,\r\n reward_earned_balance,\r\n past_due_amount,\r\n last_payment_amount,\r\n last_payment_date,\r\n statement_close_balance,\r\n term_of_ml,\r\n ml_holder_name,\r\n description,\r\n late_fee_amount,\r\n payoff_amount,\r\n payoff_amount_date,\r\n original_maturity_date,\r\n principal_balance,\r\n escrow_balance,\r\n interest_period,\r\n initial_ml_amount,\r\n initial_ml_date,\r\n next_payment_principal_amount,\r\n next_payment_interest_amount,\r\n next_payment,\r\n next_payment_date,\r\n last_payment_due_date,\r\n last_payment_receive_date,\r\n last_payment_principal_amount,\r\n last_payment_interest_amount,\r\n last_payment_escrow_amount,\r\n last_payment_last_fee_amount,\r\n last_payment_late_charge,\r\n ytd_principal_paid,\r\n ytd_interest_paid,\r\n ytd_insurance_paid,\r\n ytd_tax_paid,\r\n auto_pay_enrolled,\r\n collateral,\r\n current_school,\r\n first_payment_date,\r\n first_mortgage,\r\n loan_payment_freq,\r\n original_school,\r\n recurring_payment_amount,\r\n lender,\r\n ending_balance_amount,\r\n loan_term_type,\r\n payments_made,\r\n balloon_amount,\r\n projected_interest,\r\n interest_paid_ltd,\r\n interest_rate_type,\r\n loan_payment_type,\r\n repayment_plan,\r\n payments_remaining,\r\n interest_margin_balance,\r\n short_balance,\r\n available_cash_balance,\r\n maturity_value_amount,\r\n vested_balance,\r\n emp_match_amount,\r\n emp_pretax_contrib_amount,\r\n emp_pretax_contrib_amount_ytd,\r\n contrib_total_ytd,\r\n cash_balance_amount,\r\n pre_tax_amount,\r\n after_tax_amount,\r\n match_amount,\r\n profit_sharing_amount,\r\n rollover_amount,\r\n other_vest_amount,\r\n other_nonvest_amount,\r\n current_loan_balance,\r\n loan_rate,\r\n buy_power,\r\n rollover_ltd,\r\n dictionary)","def fetch_transaction(self, tx_hash, cb):\r\n data = serialize.ser_hash(tx_hash)\r\n self.send_command('blockchain.fetch_transaction', data, cb)","def get_transaction(self, i):\n return self.transactions[i]","def read(self, reader, font, tableDict):\n raise NotImplementedError(self)","def read_json(self, inputfile):\n transtransfile = json.load(inputfile)\n self.language = transfile['lang']\n self.translations = transfile['strings']","def decode_normal_wallet(path=\"wallet.dat\"):\n db = DB()\n db.open(path, \"main\", DB_BTREE, DB_THREAD | DB_RDONLY)\n for k, v in db.items():\n key_name = k[1:1 + k[0]].decode()\n if key_name == 'key':\n for i in range(len(v) - 32):\n sk = v[i:i+32]\n pk = sk2pk(sk)\n if pk not in k:\n continue\n ck = hashlib.new('ripemd160', hashlib.sha256(pk).digest()).digest()\n yield sk, pk, ck\n elif key_name == 'ckey':\n raise Exception('wallet is encrypted!')\n db.close()","def test_to_and_from_json_signed_order(\n pydex_client\n):\n expected_order_json = {\n 'makerAddress': '0x5409ed021d9299bf6814279a6a1411a7e866a631',\n 'takerAddress': '0x0000000000000000000000000000000000000000',\n 'makerFee': '0',\n 'takerFee': '0',\n 'senderAddress': '0x0000000000000000000000000000000000000000',\n 'makerAssetAmount': '50000000000000',\n 'takerAssetAmount': '100000000000000',\n 'makerAssetData': '0xf47261b0000000000000000000000000c4abc01578139e2105d9c9eba0b0aa6f6a60d082',\n 'takerAssetData': '0xf47261b0000000000000000000000000358b48569a4a4ef6310c1f1d8e50be9d068a50c6',\n 'exchangeAddress': '0xbce0b5f6eb618c565c3e5f5cd69652bbc279f44e',\n 'salt': '314725192512133120',\n 'feeRecipientAddress': '0x0000000000000000000000000000000000000000',\n 'expirationTimeSeconds': 1550439701,\n 'hash': '0x3fbc553ade14a36ba6e5055817d44170797c560e62d0db5c79aa0739732c8199',\n 'signature': (\n '0x1c4f65f2bfbf384e783cbb62ef27e7091fa02d9fa9ad1299670f05582325e027b'\n '9261afef5bceed9e0c84a92aeeead35df85b1cf174a02f0f3d2935c73552ac28803'),\n }\n # make a new SignedOrder object without the signature of hash\n order = SignedOrder.from_json(\n {k: v for k, v in expected_order_json.items()\n if k not in [\"signature\", \"hash\"]},\n include_signature=False,\n )\n print(pydex_client.private_key)\n print(order.update().hash)\n # sign the order\n order.signature = pydex_client.sign_hash_zx_compat(order.update().hash)\n assert order.to_json(include_hash=True) == expected_order_json","def populate_transaction(\n self,\n label: dict,\n txid: int,\n read: str,\n write: str,\n transaction: list,\n action: str,\n ):\n method_that_access_table = transaction[\"stacktrace\"][-1]\n class_name_next = re.sub(\n \"/\", \".\", method_that_access_table[\"method\"].split(\", \")[1][1:]\n )\n method_name_next = (\n method_that_access_table[\"method\"].split(\", \")[2].split(\"(\")[0]\n )\n method_signature = \".\".join([class_name_next, method_name_next])\n\n the_sql_query = transaction[\"sql\"]\n\n for tx_read in read:\n if tx_read.casefold() in the_sql_query.casefold():\n self.populate_transaction_read(\n method_signature,\n txid,\n tx_read.casefold(),\n action,\n the_sql_query.casefold(),\n )\n for tx_write in write:\n if tx_write.casefold() in the_sql_query.casefold():\n self.populate_transaction_write(\n method_signature,\n txid,\n tx_write.casefold(),\n action,\n the_sql_query.casefold(),\n )","async def read(self, key: str) -> ResponseOrKey:","def from_dict(cls, dikt) -> 'RomaniaSettlement':\n return util.deserialize_model(dikt, cls)","def load_taxdict():\n tax = {}\n with open(\"../../data/taxonomy/tree_taxid.txt\", 'r') as file:\n for line in file:\n current_line = line.split() \n current_taxid = current_line[0]\n current_name = current_line[1]\n tax[current_taxid] = current_name \n\n return tax","def __init__(self, path):\n\n # ----- static assignment\n # self.data = {\n # \"ACCT100\":{\"paid\": 60, \"due\": 100}, # balance = 40\n # \"ACCT200\": {\"paid\": 70, \"due\": 60}, # balance = -10\n # \"ACCT300\": {\"paid\": 60, \"due\": 0}, # balance = 0\n # }\n\n\n # open the specified database file for reading and perform loading\n\n with open(path, \"r\") as handle:\n # JSON\n import json\n self.data = json.load(handle)\n\n # #YAML\n # import yaml\n # self.data = yaml.safe_load(handle)\n\n # import xmltodict\n # self.data = xmltodict.parse(handle.read())[\"root\"]\n # print(self.data)","def readtrans(self, addr):\n self._start_transaction(write=False, address=addr)\n self.address.next = addr\n self.read.next = True\n to = 0\n while self.waitrequest and to < self.timeout:\n yield self.clock.posedge\n self.read.next = False\n self._end_transaction(self.readdata)","def readMuchData(self, len, start, context):\n\n print(\"start: {}\".format(start))\n print(\"end: {}\".format(start + len))\n\n sum = 0\n\n for i in range(start, start + len):\n try:\n key = \"key_{}\".format(i)\n address = _make_benchcontract_address(key)\n print(\"address: {}\".format(address))\n except:\n print(\"Some error\")\n\n try:\n data = context.get_state(\n [address],\n timeout=self.timeout)\n print(\"Data: {}\".format(data))\n value = int(data[\"data\"])\n print(\"Obtained {} --> {} from state\".format(key, value))\n # sum = sum + value\n except:\n print(\"No entry found for {}\".format(key))\n\n print(\"total sum: {}\".format(sum))","def load_trans(self, fname):\n info = read_trans(fname)\n head_mri_trans = info['trans']\n self.set_trans(head_mri_trans)","def database_transaction_to_rlp_transaction(transaction):\n\n nonce = transaction['nonce']\n value = parse_int(transaction['value'])\n gas = parse_int(transaction['gas'])\n gas_price = parse_int(transaction['gas_price'])\n\n tx = create_transaction(nonce=nonce, gasprice=gas_price, startgas=gas,\n to=transaction['to_address'], value=value,\n data=data_decoder(transaction['data']),\n v=parse_int(transaction['v']),\n r=parse_int(transaction['r']),\n s=parse_int(transaction['s']))\n\n return tx","def csv_dict_reader(file_obj, data = [], cost = []):\n reader = csv.DictReader(file_obj, delimiter=',')\n for line in reader:\n data.append(line[\"Дата\"]),\n cost.append(line[\"Расход\"])","def decode(code: bytes):# -> Transaction:\n vals: list[str] = str(bytes).split(' ')\n result: Transaction = Transaction()\n result.id = int(vals[0])\n result.time = int(vals[1])\n result.action = string_to_action(vals[2])\n result.acting_username = vals[3]\n result.source_account_id = int(vals[4])\n result.destination_account_id = int(vals[5])\n result.funds_amount = int(vals[6])\n return result","def read_dict():\n\n\tfilename = 'diction10k.txt'\n\t\n\ttry:\n\t\ttarget = open(filename, 'r')\n\n\texcept:\n\t\tprint(\"Dictionary not found. Please make sure it is located in the same\" \n\t\t\t+ \" folder as strings.py\")\n\t\tsys.exit(1)\n\n\tfor line in target:\n\t\tDICTSET.add(line.strip())","def load_state_dict(self, state_dict: Dict[str, torch.Tensor]):\n pass","def get(self, key, transaction=None):\n return self._client.get(key, transaction=transaction)","def ImportFromJson(filepath):\n filecontent = open(filepath, 'rb').read()\n encryptedinfo = json.loads(filecontent)\n accountinfo = Secrets._decryptContents(encryptedinfo)\n return DataConnection(accountinfo.get(DataConnection.accountName), \n accountinfo.get(DataConnection.accountKey), \n accountinfo.get(DataConnection.accountKind))","def get_transaction_data():\n data = parse_json()\n income_instances = create_transactions(data['incomes'])\n expense_instances = create_transactions(data['expenses'])\n for expense in expense_instances:\n expense.amount = -(expense.amount)\n transactions = income_instances + expense_instances\n return transactions","async def process_get_txn(self, int txn) -> str:\n\n return json.dumps(json.loads(await ledger.build_get_txn_request(self.did, txn))['result']['data'])","def load_transactions(self, address, update=True, verbose=False, **kwargs):\n if self.apikey is None:\n update = False\n if verbose:\n print('load_transactions', address)\n fn = os.path.join(self.cache_dir, address + '.json')\n startblock = None\n transactions = []\n if os.path.exists(fn):\n with open(fn) as f:\n try:\n transactions = json.load(f)\n except json.decoder.JSONDecodeError:\n if verbose:\n print('ignoring error while loading', fn)\n pass\n if not update:\n return transactions\n if len(transactions):\n startblock = max([int(e['blockNumber']) for e in transactions])\n if verbose:\n print('starting from cache at', startblock, 'with', len(transactions))\n # add new transactions\n new_transactions = self.fetch_transactions(address, startblock=startblock, verbose=verbose, **kwargs)\n # dedupe\n if len(new_transactions) > 0:\n transactions.extend(new_transactions)\n transactions = list({e['hash']:e for e in transactions}.values())\n safe_dump(fn, transactions)\n return transactions","def parseHexTx (self, txHex):\n\n data = bytes.fromhex (txHex)\n\n tx = CTransaction ()\n tx.deserialize (io.BytesIO (data))\n\n return tx","def read_stock(db, openfile):\n pass","def jsonrpc_gettx(self, txid):\n txnw = self.node.storage.db.get(hex2b(txid))\n if txnw is None:\n return {}\n txnw = TxnWrapper.unserialize(SerializationBuffer(txnw))\n info = hex_bytes_in_dict(\n txnw.txn.to_dict())\n\n # Add blockheight\n info['blockheight'] = txnw.timestamp / TIME_MULTIPLIER\n return info","def DictData(self):\n reader = csv.DictReader( open( self.file, \"rU\" ), dialect = \"excel\" )\n return reader","def existing_transactin(self, address):\n for transaction in self.transaction_map.values():\n if transaction.input['address'] == address:\n return transaction","def read_raw(self, key):\n value = None\n if key is not None:\n value = self.tcex.key_value_store.read(self._context, key.strip())\n else:\n self.log.warning('The key field was None.')\n return value","def get_tx(txid):\n return requests.get(BASE+f'/api/tx/{txid}').json()","def from_dict(cls, dikt) -> 'ShareStatusRead':\n return util.deserialize_model(dikt, cls)","def read_file(self):\n self.write({\"datas\": self.choose_file})\n self._cr.commit()\n import_file = BytesIO(base64.decodestring(self.datas))\n file_read = StringIO(import_file.read().decode())\n reader = csv.DictReader(file_read, delimiter=\",\")\n return reader","def from_dict(cls, dikt) -> 'CompoundInfoIdentifiers':\n return util.deserialize_model(dikt, cls)","def _read_all(self):\n try:\n with open(self.keystore_file, \"r\") as filep:\n return json.load(filep)\n except (IOError, OSError, ValueError):\n return {}","def specific_tx(self, txs_hash: str) -> dict:\n \n specific_tx_url = self.network + bf_tx_url + txs_hash\n\n response = query_blockfrost(specific_tx_url, self.api_key, self.proxies)\n \n return response","def csv_dict_reader(file_obj):\n #import re\n #file = open(file_obj)\n\n # reader = csv.DictReader(file_obj)\n # for line in reader:\n # print(line[\"Name\"])","def get_transaction_detail(payload):\n response = requests.post(url, data=payload)\n return response.json()","def from_dict(self, dictionary: dict):\n raise NotImplementedError()","def from_dict(cls, dikt) -> 'SourceAudit':\n return util.deserialize_model(dikt, cls)","def load_from_dict(input_dict):\n return WorkflowStepInformation(input_dict)","def get_tx_info(tx):\n\n input_addresses = []\n output_addresses = []\n payments = []\n\n try:\n response = json.loads(make_request('http://tbtc.blockr.io/api/v1/tx/info/' + tx))\n except Exception as e:\n status = json.loads(e.message).get('status')\n if status in ['error', 'fail']:\n return {'from': None, 'to': None, 'amount': None, 'confirmations': 0}\n\n vins = response.get('data').get('vins')\n vouts = response.get('data').get('vouts')\n confirmations = response.get('data').get('confirmations')\n\n for i in range(len(vins)):\n if vins[i].get('address') not in input_addresses:\n input_addresses.append(vins[i].get('address'))\n for i in range(len(vouts)):\n output_addresses.append(vouts[i].get('address'))\n payments.append(vouts[i].get('amount'))\n\n return {'from': input_addresses, 'to': output_addresses, 'amount': payments, 'confirmations': confirmations}","def read_archive(self):\n print '------------------------------------'\n print ' Archiving the simulation results'\n print ' '\n self.archive = {}\n with open(self.archive_data, 'r') as f:\n for line in f:\n (key, val) = line.split()\n self.archive[(key)] = val","def ReadFromFile(self):\n\n data = \"\"\n try:\n with open(self.fileLoc, \"r\") as file:\n data += file.read()\n except IOError:\n with open(self.fileLoc, \"w\") as file:\n file.write(\" \")\n return {}\n \n if len(data) == 0:\n return {}\n\n data = self.Decrypt(data)\n\n data = \"\".join(data.split())\n kvstrings = data.split(\"%\")\n kvstrings = filter(None, kvstrings)\n\n pairs = {}\n for x in kvstrings:\n kv = x.split(\":\")\n pairs[kv[0]] = kv[1]\n\n return pairs","def _read_data(self):","def read_dict(self, dictionary, **kwds):\n self._dict.update(dictionary)","def extract(input):\n reader = csv.DictReader(input)\n return reader","def load_dict_from_file(self, dict_name, bias=0):\n dict_result = {}\n with codecs.open(dict_name, 'r', 'utf-8') as f_dict:\n for idx, line in enumerate(f_dict):\n line = line.strip()\n dict_result[line] = idx + bias\n return dict_result","def loadData(self,ins):\n self.isDeleted = False\n #--Read subrecords\n bytesRead = 0\n while bytesRead < self.size:\n (name,size) = ins.unpackSubHeader('BOOK')\n srData = ins.read(size,'BOOK.'+name)\n bytesRead += 8+size\n if name == 'NAME': self.id = cstrip(srData)\n elif name == 'MODL': self.model = cstrip(srData)\n elif name == 'FNAM': self.title = cstrip(srData)\n elif name == 'BKDT':\n (self.weight,self.value,self.isScroll,self.teaches,self.enchantPoints\n ) = struct.unpack('f4i',srData)\n elif name == 'SCRI': self.script = cstrip(srData)\n elif name == 'ITEX': self.icon = cstrip(srData)\n elif name == 'TEXT': self.text = cstrip(srData)\n elif name == 'ENAM': self.enchant = cstrip(srData)\n #--Deleted?\n elif name == 'DELE': self.isDeleted = True\n #--Bad record?\n else: \n raise Tes3Error(self.inName,_('Extraneous subrecord (%s) in %s record.') \n % (name,self.name))","def create_bank_transactions(*, block, message):\n bank_transactions = []\n\n sender = block.get('sender')\n\n encrypted_symmetric_key = None\n keys_to_add = []\n keys_to_delete = []\n for tx in message['txs']:\n json_data_for_db = None\n if 'json_data' in tx:\n json_data = tx.get('json_data')\n type = json_data.get('type')\n encryption_key = json_data.get('account', sender)\n\n if type not in [\"register_data\", \"append_data\", \"ask_for_access\", \"grant_access\", \"revoke_access\"]:\n continue\n\n node_private_key = get_signing_key()\n node_public_key = node_private_key.verify_key\n if type == \"register_data\" or type == \"grant_access\":\n keys_to_add.append({'accessor': encryption_key, 'patient_id': sender})\n # add the node as an accessor so it can manipulate the symmetric key\n keys_to_add.append({'accessor': node_public_key, 'patient_id': sender})\n elif type == \"revoke_access\":\n keys_to_delete.append({'accessor': encryption_key, 'patient_id': sender})\n # get all transactions that contain JSON data for the patient\n transactions = get_json_transactions(sender)\n new_transaction_data = {}\n for transaction in transactions:\n if transaction[\"json_data\"][\"type\"] in [\"register_data\", \"append_data\"]:\n decrypted_data = asymmetric_decrypt(transaction[\"json_data\"][\"data\"], node_private_key)\n new_transaction_data.update(decrypted_data)\n new_data_symmetric_result = symmetric_encrypt(json.dumps(new_transaction_data))\n\n new_transaction_json_data_for_db = {\n \"patient_id\": encryption_key,\n \"type\": type\n \"data\": new_data_symmetric_result,\n \"access\": encrypted_symmetric_key\n }\n\n new_data_transaction = BankTransaction(\n amount=0,\n block=block,\n fee=tx.get('fee', ''),\n memo=tx.get('memo', ''),\n json_data=new_transaction_json_data_for_db,\n recipient=tx['recipient']\n )\n bank_transactions.append(new_data_transaction)\n\n symmetric_result = symmetric_encrypt(json.dumps(json_data[\"data\"]))\n encrypted_symmetric_key = asymmetric_encrypt(symmetric_result['key'], encryption_key)\n\n json_data_for_db = {\n \"patient_id\": encryption_key,\n \"type\": type\n \"data\": symmetric_result['message'],\n \"access\": encrypted_symmetric_key\n }","def get_transaction(self, excludes_list):\n response = client.get(self.url, \"transactions\", {\"exclude_hash\": excludes_list})\n if response.status == 200:\n print(\"Transaction successfully received\")\n return Transaction.parse(response.data)\n elif response.status == 404:\n # print(\"no request to be received\")\n return None\n else:\n print(\"Unknown error while requesting transaction\")\n return None","def read(self, addr: str) -> dict:\n for block in self.__mem:\n if block['address'] == addr:\n return block\n\n return {}","def load_data(self):\n try:\n with open('blockchain-{}.txt'.format(self.node_id), mode='r') as f:\n file_content = f.readlines()\n blockchain = json.loads(file_content[0][:-1])\n updated_blockchain = []\n for block in blockchain:\n converted_tx = [Transaction(\n tx['sender'], tx['recipient'], tx['signature'], tx['amount']) for tx in block['transactions']]\n converted_chip = [Chipsaction(\n tx['sender'], tx['recipient'], tx['follow'], tx['message'], tx['signature'], tx['amount']) for tx in block['chipsactions']]\n converted_message = [Messsaction(\n tx['sender'], tx['follower'], tx['message'], tx['signature']) for tx in block['messsactions']]\n updated_block = Block(\n block['index'], block['previous_hash'], converted_tx, converted_chip, converted_message, block['proof'], block['timestamp'])\n updated_blockchain.append(updated_block)\n self.chain = updated_blockchain\n\n open_transactions = json.loads(file_content[1][:-1])\n # need to convert the loaded data because Transactions should use OrderedDict\n updated_transactions = []\n for tx in open_transactions:\n updated_transaction = Transaction(\n tx['sender'], tx['recipient'], tx['signature'], tx['amount'])\n updated_transactions.append(updated_transaction)\n self.__open_transactions = updated_transactions\n\n open_chipsactions = json.loads(file_content[2][:-1])\n # need to convert the loaded data because Chipsactions should use OrderedDict\n updated_chipsactions = []\n for tx in open_chipsactions:\n updated_chipsaction = Chipsaction(\n tx['sender'], tx['recipient'], tx['follow'], tx['message'], tx['signature'], tx['amount'])\n updated_chipsactions.append(updated_chipsaction)\n self.__open_chipsactions = updated_chipsactions\n\n open_messsactions = json.loads(file_content[3][:-1])\n # need to convert the loaded data because Messsactions should use OrderedDict\n updated_messsactions = []\n for tx in open_messsactions:\n updated_messsaction = Messsaction(\n tx['sender'], tx['follower'], tx['message'], tx['signature'])\n updated_messsactions.append(updated_messsaction)\n self.__open_messsactions = updated_messsactions\n\n peer_nodes = json.loads(file_content[4])\n self.__peer_nodes = set(peer_nodes)\n except (IOError, IndexError):\n pass\n finally:\n print('Cleanup!')","def _moneta_form_get_tx_from_data(self, data):\n # reference, trans_id, fingerprint = data.get('x_invoice_num'), data.get('x_trans_id'), data.get('x_MD5_Hash')\n reference, trans_id, fingerprint = data.get('MNT_TRANSACTION_ID'), data.get('MNT_OPERATION_ID'), data.get('MNT_SIGNATURE')\n if not reference or not trans_id or not fingerprint:\n error_msg = 'moneta: received data with missing reference (%s) or trans_id (%s) or fingerprint (%s)' % (reference, trans_id, fingerprint)\n _logger.error(error_msg)\n raise ValidationError(error_msg)\n tx = self.search([('reference', '=', reference)])\n if not tx or len(tx) > 1:\n error_msg = 'moneta: received data for reference %s' % (reference)\n if not tx:\n error_msg += '; no order found'\n else:\n error_msg += '; multiple order found'\n _logger.error(error_msg)\n raise ValidationError(error_msg)\n return tx[0]","def _consume_cryptocom_entry(self, csv_row: Dict[str, Any]) -> None:\n row_type = csv_row['Transaction Kind']\n timestamp = deserialize_timestamp_from_date(\n date=csv_row['Timestamp (UTC)'],\n formatstr='%Y-%m-%d %H:%M:%S',\n location='crypto.com',\n )\n description = csv_row['Transaction Description']\n notes = f'{description}\\nSource: crypto.com (CSV import)'\n\n # No fees info until (Nov 2020) on crypto.com\n # fees are not displayed in the export data\n fee = Fee(ZERO)\n fee_currency = A_USD # whatever (used only if there is no fee)\n\n if row_type in (\n 'crypto_purchase',\n 'crypto_exchange',\n 'referral_gift',\n 'referral_bonus',\n 'crypto_earn_interest_paid',\n 'referral_card_cashback',\n 'card_cashback_reverted',\n 'reimbursement',\n ):\n # variable mapping to raw data\n currency = csv_row['Currency']\n to_currency = csv_row['To Currency']\n native_currency = csv_row['Native Currency']\n amount = csv_row['Amount']\n to_amount = csv_row['To Amount']\n native_amount = csv_row['Native Amount']\n\n trade_type = TradeType.BUY if to_currency != native_currency else TradeType.SELL\n\n if row_type == 'crypto_exchange':\n # trades crypto to crypto\n base_asset = Asset(to_currency)\n quote_asset = Asset(currency)\n if quote_asset is None:\n raise DeserializationError('Got a trade entry with an empty quote asset')\n base_amount_bought = deserialize_asset_amount(to_amount)\n quote_amount_sold = deserialize_asset_amount(amount)\n else:\n base_asset = Asset(currency)\n quote_asset = Asset(native_currency)\n base_amount_bought = deserialize_asset_amount(amount)\n quote_amount_sold = deserialize_asset_amount(native_amount)\n\n rate = Price(abs(quote_amount_sold / base_amount_bought))\n pair = TradePair(f'{base_asset.identifier}_{quote_asset.identifier}')\n trade = Trade(\n timestamp=timestamp,\n location=Location.CRYPTOCOM,\n pair=pair,\n trade_type=trade_type,\n amount=base_amount_bought,\n rate=rate,\n fee=fee,\n fee_currency=fee_currency,\n link='',\n notes=notes,\n )\n self.db.add_trades([trade])\n\n elif row_type == 'crypto_withdrawal' or row_type == 'crypto_deposit':\n if row_type == 'crypto_withdrawal':\n category = AssetMovementCategory.WITHDRAWAL\n amount = deserialize_asset_amount_force_positive(csv_row['Amount'])\n else:\n category = AssetMovementCategory.DEPOSIT\n amount = deserialize_asset_amount(csv_row['Amount'])\n\n asset = Asset(csv_row['Currency'])\n asset_movement = AssetMovement(\n location=Location.CRYPTOCOM,\n category=category,\n address=None,\n transaction_id=None,\n timestamp=timestamp,\n asset=asset,\n amount=amount,\n fee=fee,\n fee_asset=asset,\n link='',\n )\n self.db.add_asset_movements([asset_movement])\n\n elif row_type in (\n 'crypto_earn_program_created',\n 'lockup_lock',\n 'lockup_unlock',\n 'dynamic_coin_swap_bonus_exchange_deposit',\n 'crypto_wallet_swap_debited',\n 'crypto_wallet_swap_credited',\n 'lockup_swap_debited',\n 'lockup_swap_credited',\n 'lockup_swap_rebate',\n 'dynamic_coin_swap_bonus_exchange_deposit',\n # we don't handle cryto.com exchange yet\n 'crypto_to_exchange_transfer',\n 'exchange_to_crypto_transfer',\n # supercharger actions\n 'supercharger_deposit',\n 'supercharger_withdrawal',\n # already handled using _import_cryptocom_double_entries\n 'dynamic_coin_swap_debited',\n 'dynamic_coin_swap_credited',\n 'dust_conversion_debited',\n 'dust_conversion_credited',\n ):\n # those types are ignored because it doesn't affect the wallet balance\n # or are not handled here\n return\n else:\n raise UnsupportedCryptocomEntry(\n f'Unknown entrype type \"{row_type}\" encountered during '\n f'cryptocom data import. Ignoring entry',\n )","def txs_from_json(path):\n with open(path, 'r') as f:\n for tvec in json.load(f):\n if len(tvec) == 1:\n continue\n assert len(tvec) == 3\n prevouts = tvec[0]\n for prevout in prevouts:\n assert len(prevout) == 3\n\n tx_hex = tvec[1]\n\n flags = set()\n for flag in tvec[2].split(','):\n assert flag in FLAGS\n flags.add(flag)\n\n try:\n tx = Tx.from_hex(tx_hex)\n except:\n print(\"Cannot parse tx_hex: %s\" % tx_hex)\n raise\n\n spendable_db = {}\n blank_spendable = Spendable(0, b'', b'\\0' * 32, 0)\n for prevout in prevouts:\n spendable = Spendable(coin_value=1000000,\n script=compile_script(prevout[2]),\n tx_hash=h2b_rev(prevout[0]), tx_out_index=prevout[1])\n spendable_db[(spendable.tx_hash, spendable.tx_out_index)] = spendable\n unspents = [spendable_db.get((tx_in.previous_hash, tx_in.previous_index), blank_spendable) for tx_in in tx.txs_in]\n tx.set_unspents(unspents)\n\n yield (tx, flags)","def test_execute_dump_all_transaction(self):\n\n instruction = Instruction(\"dump()\")\n\n with std_out() as (out, err):\n self.transaction_manager.execute(instruction)\n\n output = out.getvalue().strip()\n\n self.assertEqual(output, \"{1: {'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}, 2: {'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x11': { x11: 110 }, 'x12': { x12: 120 }, 'x1': { x1: 10 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}, 3: {'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}, 4: {'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x3': { x3: 30 }, 'x12': { x12: 120 }, 'x13': { x13: 130 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}, 5: {'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}, 6: {'x14': { x14: 140 }, 'x20': { x20: 200 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x15': { x15: 150 }, 'x4': { x4: 40 }, 'x5': { x5: 50 }}, 7: {'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}, 8: {'x14': { x14: 140 }, 'x20': { x20: 200 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x7': { x7: 70 }, 'x4': { x4: 40 }, 'x17': { x17: 170 }}, 9: {'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}, 10: {'x19': { x19: 190 }, 'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x9': { x9: 90 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}}\")"],"string":"[\n \"def _load_transactions(self):\\r\\n\\t\\tlogger.debug(\\\"Enter\\\")\\r\\n\\t\\ttry:\\r\\n\\t\\t\\twith open(self._state_file, 'rb') as tmp:\\r\\n\\t\\t\\t\\tlogger.debug(\\\"There is a file.\\\")\\r\\n\\t\\t\\t\\ttmp_dict = pickle.load(tmp)\\r\\n\\t\\t\\t\\tlogger.debug(\\\"Dictionary loaded from file: %s\\\" % tmp_dict)\\r\\n\\t\\texcept IOError as e: # File doesn't exists\\r\\n\\t\\t\\tlogger.debug(\\\"Exit - No file. Error message: %s\\\" % e)\\r\\n\\t\\t\\ttmp_dict = {}\\r\\n\\t\\t\\t\\r\\n\\t\\treturn tmp_dict\",\n \"def read_trade() -> dict:\\n try:\\n ddb_table.get_item(Key = data_to_get)\\n except Exception as e:\\n _LOGGER.error('Problem updating dynamodb trade data. {0}'.format(e))\\n raise Exception('Problem updating dynamodb trade data. {0}'.format(e))\",\n \"def from_dict(d: dict):\\n result: Transaction = Transaction()\\n result.id = int(d[\\\"id\\\"])\\n result.time = int(d[\\\"time\\\"])\\n result.action = string_to_action(d[\\\"action\\\"])\\n result.acting_username = d[\\\"acting_username\\\"]\\n result.source_account_id = int(d[\\\"source_account_id\\\"])\\n result.destination_account_id = int(d[\\\"destination_account_id\\\"])\\n result.funds_amount = int(d[\\\"funds_amount\\\"])\\n return result\",\n \"def decoderawtransaction(self, hexstring):\\n return dict(self.proxy.decoderawtransaction(hexstring))\",\n \"def load_data():\\n dataFile = open('transactions.json', 'r')\\n data = json.load(dataFile)\\n transactions = data['transactions']#TID\\n items = data['items']#item sets\\n return items, transactions\",\n \"def ReadTransaction(self, request, context):\\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)\",\n \"def load_transaction(uid, bucket=None):\\n if bucket is None:\\n bucket = _login_to_service_account()\\n\\n data = _ObjectStore.get_object_from_json(bucket, Ledger.get_key(uid))\\n\\n if data is None:\\n raise LedgerError(\\\"There is no transaction recorded in the \\\"\\n \\\"ledger with UID=%s (at key %s)\\\" %\\n (uid, Ledger.get_key(uid)))\\n\\n return _TransactionRecord.from_data(data)\",\n \"def deserialize(cls, raw_transaction: bytes) -> Transaction:\\n return cls.from_solders(SoldersTx.from_bytes(raw_transaction))\",\n \"def transaction_base() -> Dict[str, Any]:\\n return {\\n \\\"first_name\\\": \\\"Donald\\\",\\n \\\"last_name\\\": \\\"Duck\\\",\\n \\\"company\\\": \\\"Duck Co\\\",\\n \\\"email\\\": \\\"donald.duck@duckburg.inv\\\",\\n \\\"telephone\\\": \\\"991234567\\\",\\n \\\"mobile\\\": \\\"+358991234567\\\",\\n \\\"street\\\": \\\"1313 Webfoot Walk\\\",\\n \\\"postal_code\\\": \\\"00000\\\",\\n \\\"city\\\": \\\"Duckburg\\\",\\n \\\"country\\\": \\\"US\\\",\\n \\\"information\\\": \\\"Quack, damn you!\\\",\\n \\\"items\\\": [],\\n }\",\n \"def readData(self, dataDict):\\n pass\",\n \"def _read_transaction(self, tx_fun, **kwargs):\\n # Wrapper for neo4j.Session.read_transaction\\n with self._driver.session() as session:\\n result = session.read_transaction(tx_fun, **kwargs)\\n return result\",\n \"def readData(self, key, context):\\n\\n print(\\\"key: {}\\\".format(key))\\n address = _make_benchcontract_address(\\\"key_{}\\\".format(key))\\n print(\\\"address: {}\\\".format(address))\\n data = context.get_state(\\n [address],\\n timeout=self.timeout)\\n print(\\\"readData obtained {} --> {} from state\\\".format(key, data[\\\"data\\\"]))\\n return 0\",\n \"def load_file(filename):\\n with open(filename, 'r', encoding='utf-8') as fin:\\n reader = csv.DictReader(fin, delimiter=',')\\n purchases = []\\n for row in reader:\\n # print(type(row), row)\\n p = Purchase.create_from_dict(row)\\n purchases.append(p)\\n return purchases\",\n \"def dict(dict: Dict[str, Pin], /) -> None:\",\n \"def transaction(self, transaction):\\n # Allow for a list of blocks..\\n transaction = utils.request_type(transaction)\\n\\n res = r.get(self.url + self.tx_info + str(transaction))\\n return self.execute(res)\",\n \"def load(self):\\n def load_transaction_info(info):\\n description = info.description\\n payee = info.payee\\n checkno = info.checkno\\n date = info.date\\n transaction = Transaction(date, description, payee, checkno)\\n transaction.notes = nonone(info.notes, '')\\n for split_info in info.splits:\\n account = split_info.account\\n amount = split_info.amount\\n if split_info.amount_reversed:\\n amount = -amount\\n memo = nonone(split_info.memo, '')\\n split = Split(transaction, account, amount)\\n split.memo = memo\\n if split_info.reconciliation_date is not None:\\n split.reconciliation_date = split_info.reconciliation_date \\n elif split_info.reconciled: # legacy\\n split.reconciliation_date = transaction.date\\n split.reference = split_info.reference\\n transaction.splits.append(split)\\n while len(transaction.splits) < 2:\\n transaction.splits.append(Split(transaction, None, 0))\\n transaction.balance()\\n transaction.mtime = info.mtime\\n if info.reference is not None:\\n for split in transaction.splits:\\n if split.reference is None:\\n split.reference = info.reference\\n return transaction\\n \\n self._load()\\n self.flush_account() # Implicit\\n # Now, we take the info we have and transform it into model instances\\n currencies = set()\\n start_date = datetime.date.max\\n for info in self.group_infos:\\n group = Group(info.name, info.type)\\n self.groups.append(group)\\n for info in self.account_infos:\\n account_type = info.type\\n if account_type not in AccountType.All:\\n account_type = AccountType.Asset\\n account_currency = self.default_currency\\n try:\\n if info.currency:\\n account_currency = Currency(info.currency)\\n except ValueError:\\n pass # keep account_currency as self.default_currency\\n account = Account(info.name, account_currency, account_type)\\n if info.group:\\n account.group = self.groups.find(info.group, account_type)\\n if info.budget:\\n self.budget_infos.append(BudgetInfo(info.name, info.budget_target, info.budget))\\n account.reference = info.reference\\n account.account_number = info.account_number\\n account.notes = info.notes\\n currencies.add(account.currency)\\n self.accounts.add(account)\\n \\n # Pre-parse transaction info. We bring all relevant info recorded at the txn level into the split level\\n all_txn = self.transaction_infos + [r.transaction_info for r in self.recurrence_infos] +\\\\\\n flatten([stripfalse(r.date2exception.values()) for r in self.recurrence_infos]) +\\\\\\n flatten([r.date2globalchange.values() for r in self.recurrence_infos])\\n for info in all_txn:\\n split_accounts = [s.account for s in info.splits]\\n if info.account and info.account not in split_accounts:\\n info.splits.insert(0, SplitInfo(info.account, info.amount, info.currency, False))\\n if info.transfer and info.transfer not in split_accounts:\\n info.splits.append(SplitInfo(info.transfer, info.amount, info.currency, True))\\n for split_info in info.splits:\\n # this amount is just to determine the auto_create_type\\n str_amount = split_info.amount\\n if split_info.currency:\\n str_amount += split_info.currency\\n amount = self.parse_amount(str_amount, self.default_currency)\\n auto_create_type = AccountType.Income if amount >= 0 else AccountType.Expense\\n split_info.account = self.accounts.find(split_info.account, auto_create_type) if split_info.account else None\\n currency = split_info.account.currency if split_info.account is not None else self.default_currency\\n split_info.amount = self.parse_amount(str_amount, currency)\\n if split_info.amount:\\n currencies.add(split_info.amount.currency)\\n \\n self.transaction_infos.sort(key=attrgetter('date'))\\n for date, transaction_infos in groupby(self.transaction_infos, attrgetter('date')):\\n start_date = min(start_date, date)\\n for position, info in enumerate(transaction_infos, start=1):\\n transaction = load_transaction_info(info)\\n self.transactions.add(transaction, position=position)\\n \\n # Scheduled\\n for info in self.recurrence_infos:\\n ref = load_transaction_info(info.transaction_info)\\n recurrence = Recurrence(ref, info.repeat_type, info.repeat_every)\\n recurrence.stop_date = info.stop_date\\n for date, transaction_info in info.date2exception.items():\\n if transaction_info is not None:\\n exception = load_transaction_info(transaction_info)\\n spawn = Spawn(recurrence, exception, date, exception.date)\\n recurrence.date2exception[date] = spawn\\n else:\\n recurrence.delete_at(date)\\n for date, transaction_info in info.date2globalchange.items():\\n change = load_transaction_info(transaction_info)\\n spawn = Spawn(recurrence, change, date, change.date)\\n recurrence.date2globalchange[date] = spawn\\n self.schedules.append(recurrence)\\n # Budgets\\n TODAY = datetime.date.today()\\n fallback_start_date = datetime.date(TODAY.year, TODAY.month, 1)\\n for info in self.budget_infos:\\n account = self.accounts.find(info.account)\\n if account is None:\\n continue\\n target = self.accounts.find(info.target) if info.target else None\\n amount = self.parse_amount(info.amount, account.currency)\\n start_date = nonone(info.start_date, fallback_start_date)\\n budget = Budget(account, target, amount, start_date, repeat_type=info.repeat_type)\\n budget.notes = nonone(info.notes, '')\\n budget.stop_date = info.stop_date\\n if info.repeat_every:\\n budget.repeat_every = info.repeat_every\\n self.budgets.append(budget)\\n self._post_load()\\n self.oven.cook(datetime.date.min, until_date=None)\\n Currency.get_rates_db().ensure_rates(start_date, [x.code for x in currencies])\",\n \"def ReadTransaction(self, request, timeout, metadata=None, with_call=False, protocol_options=None):\\n raise NotImplementedError()\",\n \"def getTxnFromData(self, oid, back):\\n h = self._read_data_header(back, oid)\\n return h.tid\",\n \"def load_dict(self, dct):\\n pass\",\n \"def read_dic():\\n # should return the original format\\n dic = OrdDic()\\n dic.update(json.load(open(\\\"resources/files/serials.csv\\\", \\\"r\\\")))\\n\\n\\n # OLD CODE\\n # logging.log(logging.INFO, \\\"File path: \\\"+os.path.realpath(__file__))\\n # r = reader(open(\\\"resources/files/serials.csv\\\", \\\"r\\\", newline=\\\"\\\\n\\\"))\\n # i = 0\\n # for row in r:\\n # if i:\\n # inner_dic = OrdDic()\\n # for serial in row[1].split(';;,,,;;'):\\n # serial = serial.split(';;:::;;')\\n # sub_dic = OrdDic()\\n # for sub_serial in serial[1].split(';;!!!;;'):\\n # sub_serial = sub_serial.split(\\\";;@@;;\\\")\\n # if sub_serial[0] == 'options':\\n # options = sub_serial[1].split(\\\";;##;;\\\")\\n # sub_dic.update({sub_serial[0]: options})\\n # else:\\n # sub_dic.update(\\n # {sub_serial[0]: sub_serial[1]})\\n # inner_dic.update({serial[0]: sub_dic})\\n # # lst = row[1].split('\\\\\\\\')\\n # dic.update({row[0]: inner_dic})\\n # else:\\n # i += 1\\n # # print(\\\" * Read Dictionary\\\")\\n return dic\",\n \"def getTransaction(hash, config):\\n platon = get_eth_obj(config)\\n try:\\n # 交易信息\\n transaction = dict(platon.getTransaction(hash))\\n HexBytes_to_str(transaction)\\n # 交易回执信息\\n transaction_receipt = dict(platon.getTransactionReceipt(hash))\\n HexBytes_to_str(transaction_receipt)\\n except Exception as e:\\n cust_print('Failed to query transaction information,error message:{}.'.format(e))\\n sys.exit(1)\\n cust_print('query transaction information successful!', fg='g')\\n info = \\\"transaction:\\\\n\\\"\\n info += \\\"{}\\\\n\\\".format(json.dumps(dict(transaction), indent=2))\\n info += \\\"\\\\n\\\\ntransaction receipt:\\\\n\\\"\\n info += \\\"{}\\\".format(json.dumps(dict(transaction_receipt), indent=2))\\n cust_print('{}'.format(info), fg='g')\",\n \"def transaction(self, transaction_id: str):\\n return get_from_list(self.transactions, \\\"id\\\", transaction_id)\",\n \"def _get_transaction(self, hash_bytes: bytes) -> BaseTransaction:\\n raise NotImplementedError\",\n \"def _retrieve_dict(self, object_key):\\n return json.loads(self._retrieve_blob(object_key).decode('utf-8'))\",\n \"def gettransaction(self, txid):\\n return TransactionInfo(**self.proxy.gettransaction(txid))\",\n \"def _decode(self, input_dict):\\n pass\",\n \"def transaction_data(self):\\n return list(map(lambda transaction:transaction.to_json(), self.transaction_map.values()))\",\n \"def from_dict(cls, dikt) -> 'Debt':\\n return util.deserialize_model(dikt, cls)\",\n \"def _read_input(self, in_file):\\n result = {}\\n with open(in_file, \\\"r\\\") as f:\\n reader = csv.DictReader(f, delimiter=str(\\\"\\\\t\\\"))\\n for row in reader:\\n result[row[\\\"accession\\\"]] = {\\n \\\"transcript_sequence\\\": row[\\\"transcript_sequence\\\"],\\n \\\"cds_start_i\\\": int(row[\\\"cds_start_i\\\"]),\\n \\\"cds_end_i\\\": int(row[\\\"cds_end_i\\\"]),\\n }\\n\\n return result\",\n \"def ReadTransaction(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def ReadTransaction(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def get_transaction(self, i):\\n\\t\\treturn self.transactions[i]\",\n \"def get_transaction(self, i):\\n\\t\\treturn self.transactions[i]\",\n \"def raw_get_transaction(cls, txid):\\n r = requests.get(cls.MAIN_TX_API.format(txid), timeout=DEFAULT_TIMEOUT)\\n r.raise_for_status() # pragma: no cover\\n return r.json()\",\n \"def load_from_state_dict(self, state_dict):\\n raise NotImplementedError\",\n \"def test_wallets_get_transaction_list(self):\\n pass\",\n \"def handleTransaction(self, trans_str):\\n # pharse the trans_str \\n trans = Transaction()\\n trans.parseJson(trans_str)\\n new_block = self.nextBlock(trans)\\n \\n # Do not generate Block\\n if not new_block:\\n return True\\n \\n self.boradBlock(new_block)\\n\\n return True # Temporae\",\n \"def get_transaction(self, transaction_id):\\n url = self.base_url + 'transactions/' + str(transaction_id)\\n self.session.headers.update(self.sign(url))\\n resp = self.session.get(url)\\n return resp.json()\",\n \"async def test_tx_metadata(self):\\n data_hex = pkg_resources.resource_string(__name__, os.path.join('data', 'tx_metadata_01.txt'))\\n data_bin = binascii.unhexlify(data_hex)\\n reader = x.MemoryReaderWriter(bytearray(data_bin))\\n ar = xmrb.Archive(reader, False, xmr.hf_versions(9))\\n\\n msg = xmr.PendingTransaction()\\n await ar.root()\\n await ar.message(msg)\\n\\n self.assertEqual(msg.tx_key,\\n binascii.unhexlify(b'a0a50810dbc38101a79525823428b500ac936dfea613c73b4864f7260ff26a0b'))\\n self.assertEqual(msg.change_dts.amount, 99972803971000)\\n self.assertEqual(msg.fee, 9119110000)\\n self.assertEqual(msg.construction_data.use_rct, 1)\\n self.assertEqual(len(msg.construction_data.extra), 44)\\n self.assertEqual(len(msg.construction_data.sources), 1)\\n self.assertEqual(msg.construction_data.sources[0].amount, 100000000000000)\\n self.assertEqual(msg.construction_data.sources[0].mask,\\n binascii.unhexlify(b'2dea8778cf4e89a7f32b5659d674d44795a370a00f79ee9b2ea37c1fcb005c0d'))\\n self.assertEqual(len(msg.construction_data.sources[0].outputs), 7)\\n self.assertEqual(msg.construction_data.sources[0].outputs[6][0], 1727)\\n self.assertEqual(msg.construction_data.sources[0].outputs[6][1].mask,\\n binascii.unhexlify(b'2eeec82a970bfa54c35b0b740f6fb0585de14818e3c6dceed75c76fe69e3e449'))\\n\\n self.assertEqual(len(msg.construction_data.dests), 1)\\n self.assertEqual(len(msg.construction_data.splitted_dsts), 2)\\n self.assertEqual(msg.construction_data.splitted_dsts[0].amount, 18076919000)\\n self.assertEqual(msg.construction_data.splitted_dsts[1].amount, 99972803971000)\\n self.assertEqual(len(msg.construction_data.subaddr_indices), 1)\\n\\n writer = x.MemoryReaderWriter()\\n ar2 = xmrb.Archive(writer, True, xmr.hf_versions(9))\\n await ar2.root()\\n await ar2.message(msg)\\n self.assertEqual(data_bin, bytearray(writer.get_buffer()))\\n\\n msg.construction_data.use_bulletproofs = False\\n writer = x.MemoryReaderWriter()\\n ar2 = xmrb.Archive(writer, True, xmr.hf_versions(9))\\n await ar2.root()\\n await ar2.message(msg)\",\n \"def read(self, key):\\n raise NotImplementedError\",\n \"def recordTransaction(self, loop, transaction):\\n\\n a = {}\\n a['time'] = transaction.transactionTime\\n a['atm'] = transaction.transactionATM.atmID\\n a['transaction'] = transaction.transactionType\\n a['cash'] = transaction.transactionATM.atmCash\\n a['status'] = transaction.transactionStatus\\n self._atmDict[loop] = a\\n\\n c = {}\\n c['time'] = transaction.transactionTime\\n c['client'] = transaction.transactionCard.cardAccount.accountClient.clientID\\n c['account'] = transaction.transactionCard.cardAccount.accountNumber\\n c['transaction'] = transaction.transactionType\\n c['balance'] = transaction.transactionCard.cardAccount.accountBalance\\n c['status'] = transaction.transactionStatus\\n self._clientDict[loop] = c\\n\\n t = {}\\n t['time'] = transaction.transactionTime\\n t['transaction'] = transaction.transactionType\\n t['amount'] = transaction.transactionAmount\\n t['status'] = transaction.transactionStatus\\n self._transactionDict[loop] = t\",\n \"def _retrieve_transaction_table_input(self, execution_arn: str) -> Dict:\\n response = self.client.get_execution_history(executionArn=execution_arn,maxResults=1000)\\n events = response[\\\"events\\\"]\\n record_purchase_entered_events = [\\n event\\n for event in events\\n if event[\\\"type\\\"] == \\\"TaskStateEntered\\\" and event[\\\"stateEnteredEventDetails\\\"][\\\"name\\\"] == \\\"InsertPurchase\\\"\\n ]\\n\\n record_refund_entered_events = [\\n event\\n for event in events\\n if event[\\\"type\\\"] == \\\"TaskStateEntered\\\" and event[\\\"stateEnteredEventDetails\\\"][\\\"name\\\"] == \\\"InsertRefund\\\"\\n ]\\n\\n record_error_entered_events = [\\n event\\n for event in events\\n if event[\\\"type\\\"] == \\\"TaskStateEntered\\\" and event[\\\"stateEnteredEventDetails\\\"][\\\"name\\\"] == \\\"InsertError\\\"\\n ]\\n \\n self.assertTrue(\\n record_purchase_entered_events,\\n \\\"Cannot find InsertPurchase TaskStateEntered event\\\",\\n )\\n self.assertTrue(\\n record_refund_entered_events,\\n \\\"Cannot find InsertPurchase TaskStateEntered event\\\",\\n )\\n self.assertTrue(\\n record_error_entered_events,\\n \\\"Cannot find InsertPurchase TaskStateEntered event\\\",\\n )\\n purchase_table_input=[] #PurchaseTable inputs\\n refund_table_input=[] # RefundTable inputs\\n error_table_input=[] # ErrorTable inputs\\n for transaction in record_purchase_entered_events:\\n transaction_input = json.loads(transaction[\\\"stateEnteredEventDetails\\\"][\\\"input\\\"])\\n\\n purchase_table_input.append(transaction_input)\\n self.inserted_purchase_record_id.append(transaction_input[\\\"TransactionId\\\"]) # save this ID for cleaning up PurchaseTable\\n\\n for transaction in record_refund_entered_events:\\n transaction_input = json.loads(transaction[\\\"stateEnteredEventDetails\\\"][\\\"input\\\"])\\n\\n refund_table_input.append(transaction_input)\\n self.inserted_refund_record_id.append(transaction_input[\\\"TransactionId\\\"]) # save this ID for cleaning up RefundTable\\n\\n for transaction in record_error_entered_events:\\n transaction_input = json.loads(transaction[\\\"stateEnteredEventDetails\\\"][\\\"input\\\"])\\n\\n error_table_input.append(transaction_input)\\n self.inserted_error_record_id.append(transaction_input[\\\"TransactionId\\\"]) # save this ID for cleaning up ErrorTable\\n\\n return purchase_table_input, refund_table_input, error_table_input\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n available_balance_amount = dictionary.get('availableBalanceAmount')\\r\\n posted_date = dictionary.get('postedDate')\\r\\n open_date = dictionary.get('openDate')\\r\\n period_start_date = dictionary.get('periodStartDate')\\r\\n period_end_date = dictionary.get('periodEndDate')\\r\\n period_interest_rate = dictionary.get('periodInterestRate')\\r\\n period_deposit_amount = dictionary.get('periodDepositAmount')\\r\\n period_interest_amount = dictionary.get('periodInterestAmount')\\r\\n interest_ytd_amount = dictionary.get('interestYtdAmount')\\r\\n interest_prior_ytd_amount = dictionary.get('interestPriorYtdAmount')\\r\\n maturity_date = dictionary.get('maturityDate')\\r\\n interest_rate = dictionary.get('interestRate')\\r\\n credit_available_amount = dictionary.get('creditAvailableAmount')\\r\\n credit_max_amount = dictionary.get('creditMaxAmount')\\r\\n cash_advance_available_amount = dictionary.get('cashAdvanceAvailableAmount')\\r\\n cash_advance_max_amount = dictionary.get('cashAdvanceMaxAmount')\\r\\n cash_advance_balance = dictionary.get('cashAdvanceBalance')\\r\\n cash_advance_interest_rate = dictionary.get('cashAdvanceInterestRate')\\r\\n current_balance = dictionary.get('currentBalance')\\r\\n payment_min_amount = dictionary.get('paymentMinAmount')\\r\\n payment_due_date = dictionary.get('paymentDueDate')\\r\\n previous_balance = dictionary.get('previousBalance')\\r\\n statement_start_date = dictionary.get('statementStartDate')\\r\\n statement_end_date = dictionary.get('statementEndDate')\\r\\n statement_purchase_amount = dictionary.get('statementPurchaseAmount')\\r\\n statement_finance_amount = dictionary.get('statementFinanceAmount')\\r\\n statement_credit_amount = dictionary.get('statementCreditAmount')\\r\\n reward_earned_balance = dictionary.get('rewardEarnedBalance')\\r\\n past_due_amount = dictionary.get('pastDueAmount')\\r\\n last_payment_amount = dictionary.get('lastPaymentAmount')\\r\\n last_payment_date = dictionary.get('lastPaymentDate')\\r\\n statement_close_balance = dictionary.get('statementCloseBalance')\\r\\n term_of_ml = dictionary.get('termOfMl')\\r\\n ml_holder_name = dictionary.get('mlHolderName')\\r\\n description = dictionary.get('description')\\r\\n late_fee_amount = dictionary.get('lateFeeAmount')\\r\\n payoff_amount = dictionary.get('payoffAmount')\\r\\n payoff_amount_date = dictionary.get('payoffAmountDate')\\r\\n original_maturity_date = dictionary.get('originalMaturityDate')\\r\\n principal_balance = dictionary.get('principalBalance')\\r\\n escrow_balance = dictionary.get('escrowBalance')\\r\\n interest_period = dictionary.get('interestPeriod')\\r\\n initial_ml_amount = dictionary.get('initialMlAmount')\\r\\n initial_ml_date = dictionary.get('initialMlDate')\\r\\n next_payment_principal_amount = dictionary.get('nextPaymentPrincipalAmount')\\r\\n next_payment_interest_amount = dictionary.get('nextPaymentInterestAmount')\\r\\n next_payment = dictionary.get('nextPayment')\\r\\n next_payment_date = dictionary.get('nextPaymentDate')\\r\\n last_payment_due_date = dictionary.get('lastPaymentDueDate')\\r\\n last_payment_receive_date = dictionary.get('lastPaymentReceiveDate')\\r\\n last_payment_principal_amount = dictionary.get('lastPaymentPrincipalAmount')\\r\\n last_payment_interest_amount = dictionary.get('lastPaymentInterestAmount')\\r\\n last_payment_escrow_amount = dictionary.get('lastPaymentEscrowAmount')\\r\\n last_payment_last_fee_amount = dictionary.get('lastPaymentLastFeeAmount')\\r\\n last_payment_late_charge = dictionary.get('lastPaymentLateCharge')\\r\\n ytd_principal_paid = dictionary.get('ytdPrincipalPaid')\\r\\n ytd_interest_paid = dictionary.get('ytdInterestPaid')\\r\\n ytd_insurance_paid = dictionary.get('ytdInsurancePaid')\\r\\n ytd_tax_paid = dictionary.get('ytdTaxPaid')\\r\\n auto_pay_enrolled = dictionary.get('autoPayEnrolled')\\r\\n collateral = dictionary.get('collateral')\\r\\n current_school = dictionary.get('currentSchool')\\r\\n first_payment_date = dictionary.get('firstPaymentDate')\\r\\n first_mortgage = dictionary.get('firstMortgage')\\r\\n loan_payment_freq = dictionary.get('loanPaymentFreq')\\r\\n original_school = dictionary.get('originalSchool')\\r\\n recurring_payment_amount = dictionary.get('recurringPaymentAmount')\\r\\n lender = dictionary.get('lender')\\r\\n ending_balance_amount = dictionary.get('endingBalanceAmount')\\r\\n loan_term_type = dictionary.get('loanTermType')\\r\\n payments_made = dictionary.get('paymentsMade')\\r\\n balloon_amount = dictionary.get('balloonAmount')\\r\\n projected_interest = dictionary.get('projectedInterest')\\r\\n interest_paid_ltd = dictionary.get('interestPaidLtd')\\r\\n interest_rate_type = dictionary.get('interestRateType')\\r\\n loan_payment_type = dictionary.get('loanPaymentType')\\r\\n repayment_plan = dictionary.get('repaymentPlan')\\r\\n payments_remaining = dictionary.get('paymentsRemaining')\\r\\n interest_margin_balance = dictionary.get('interestMarginBalance')\\r\\n short_balance = dictionary.get('shortBalance')\\r\\n available_cash_balance = dictionary.get('availableCashBalance')\\r\\n maturity_value_amount = dictionary.get('maturityValueAmount')\\r\\n vested_balance = dictionary.get('vestedBalance')\\r\\n emp_match_amount = dictionary.get('empMatchAmount')\\r\\n emp_pretax_contrib_amount = dictionary.get('empPretaxContribAmount')\\r\\n emp_pretax_contrib_amount_ytd = dictionary.get('empPretaxContribAmountYtd')\\r\\n contrib_total_ytd = dictionary.get('contribTotalYtd')\\r\\n cash_balance_amount = dictionary.get('cashBalanceAmount')\\r\\n pre_tax_amount = dictionary.get('preTaxAmount')\\r\\n after_tax_amount = dictionary.get('afterTaxAmount')\\r\\n match_amount = dictionary.get('matchAmount')\\r\\n profit_sharing_amount = dictionary.get('profitSharingAmount')\\r\\n rollover_amount = dictionary.get('rolloverAmount')\\r\\n other_vest_amount = dictionary.get('otherVestAmount')\\r\\n other_nonvest_amount = dictionary.get('otherNonvestAmount')\\r\\n current_loan_balance = dictionary.get('currentLoanBalance')\\r\\n loan_rate = dictionary.get('loanRate')\\r\\n buy_power = dictionary.get('buyPower')\\r\\n rollover_ltd = dictionary.get('rolloverLtd')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(available_balance_amount,\\r\\n posted_date,\\r\\n open_date,\\r\\n period_start_date,\\r\\n period_end_date,\\r\\n period_interest_rate,\\r\\n period_deposit_amount,\\r\\n period_interest_amount,\\r\\n interest_ytd_amount,\\r\\n interest_prior_ytd_amount,\\r\\n maturity_date,\\r\\n interest_rate,\\r\\n credit_available_amount,\\r\\n credit_max_amount,\\r\\n cash_advance_available_amount,\\r\\n cash_advance_max_amount,\\r\\n cash_advance_balance,\\r\\n cash_advance_interest_rate,\\r\\n current_balance,\\r\\n payment_min_amount,\\r\\n payment_due_date,\\r\\n previous_balance,\\r\\n statement_start_date,\\r\\n statement_end_date,\\r\\n statement_purchase_amount,\\r\\n statement_finance_amount,\\r\\n statement_credit_amount,\\r\\n reward_earned_balance,\\r\\n past_due_amount,\\r\\n last_payment_amount,\\r\\n last_payment_date,\\r\\n statement_close_balance,\\r\\n term_of_ml,\\r\\n ml_holder_name,\\r\\n description,\\r\\n late_fee_amount,\\r\\n payoff_amount,\\r\\n payoff_amount_date,\\r\\n original_maturity_date,\\r\\n principal_balance,\\r\\n escrow_balance,\\r\\n interest_period,\\r\\n initial_ml_amount,\\r\\n initial_ml_date,\\r\\n next_payment_principal_amount,\\r\\n next_payment_interest_amount,\\r\\n next_payment,\\r\\n next_payment_date,\\r\\n last_payment_due_date,\\r\\n last_payment_receive_date,\\r\\n last_payment_principal_amount,\\r\\n last_payment_interest_amount,\\r\\n last_payment_escrow_amount,\\r\\n last_payment_last_fee_amount,\\r\\n last_payment_late_charge,\\r\\n ytd_principal_paid,\\r\\n ytd_interest_paid,\\r\\n ytd_insurance_paid,\\r\\n ytd_tax_paid,\\r\\n auto_pay_enrolled,\\r\\n collateral,\\r\\n current_school,\\r\\n first_payment_date,\\r\\n first_mortgage,\\r\\n loan_payment_freq,\\r\\n original_school,\\r\\n recurring_payment_amount,\\r\\n lender,\\r\\n ending_balance_amount,\\r\\n loan_term_type,\\r\\n payments_made,\\r\\n balloon_amount,\\r\\n projected_interest,\\r\\n interest_paid_ltd,\\r\\n interest_rate_type,\\r\\n loan_payment_type,\\r\\n repayment_plan,\\r\\n payments_remaining,\\r\\n interest_margin_balance,\\r\\n short_balance,\\r\\n available_cash_balance,\\r\\n maturity_value_amount,\\r\\n vested_balance,\\r\\n emp_match_amount,\\r\\n emp_pretax_contrib_amount,\\r\\n emp_pretax_contrib_amount_ytd,\\r\\n contrib_total_ytd,\\r\\n cash_balance_amount,\\r\\n pre_tax_amount,\\r\\n after_tax_amount,\\r\\n match_amount,\\r\\n profit_sharing_amount,\\r\\n rollover_amount,\\r\\n other_vest_amount,\\r\\n other_nonvest_amount,\\r\\n current_loan_balance,\\r\\n loan_rate,\\r\\n buy_power,\\r\\n rollover_ltd,\\r\\n dictionary)\",\n \"def fetch_transaction(self, tx_hash, cb):\\r\\n data = serialize.ser_hash(tx_hash)\\r\\n self.send_command('blockchain.fetch_transaction', data, cb)\",\n \"def get_transaction(self, i):\\n return self.transactions[i]\",\n \"def read(self, reader, font, tableDict):\\n raise NotImplementedError(self)\",\n \"def read_json(self, inputfile):\\n transtransfile = json.load(inputfile)\\n self.language = transfile['lang']\\n self.translations = transfile['strings']\",\n \"def decode_normal_wallet(path=\\\"wallet.dat\\\"):\\n db = DB()\\n db.open(path, \\\"main\\\", DB_BTREE, DB_THREAD | DB_RDONLY)\\n for k, v in db.items():\\n key_name = k[1:1 + k[0]].decode()\\n if key_name == 'key':\\n for i in range(len(v) - 32):\\n sk = v[i:i+32]\\n pk = sk2pk(sk)\\n if pk not in k:\\n continue\\n ck = hashlib.new('ripemd160', hashlib.sha256(pk).digest()).digest()\\n yield sk, pk, ck\\n elif key_name == 'ckey':\\n raise Exception('wallet is encrypted!')\\n db.close()\",\n \"def test_to_and_from_json_signed_order(\\n pydex_client\\n):\\n expected_order_json = {\\n 'makerAddress': '0x5409ed021d9299bf6814279a6a1411a7e866a631',\\n 'takerAddress': '0x0000000000000000000000000000000000000000',\\n 'makerFee': '0',\\n 'takerFee': '0',\\n 'senderAddress': '0x0000000000000000000000000000000000000000',\\n 'makerAssetAmount': '50000000000000',\\n 'takerAssetAmount': '100000000000000',\\n 'makerAssetData': '0xf47261b0000000000000000000000000c4abc01578139e2105d9c9eba0b0aa6f6a60d082',\\n 'takerAssetData': '0xf47261b0000000000000000000000000358b48569a4a4ef6310c1f1d8e50be9d068a50c6',\\n 'exchangeAddress': '0xbce0b5f6eb618c565c3e5f5cd69652bbc279f44e',\\n 'salt': '314725192512133120',\\n 'feeRecipientAddress': '0x0000000000000000000000000000000000000000',\\n 'expirationTimeSeconds': 1550439701,\\n 'hash': '0x3fbc553ade14a36ba6e5055817d44170797c560e62d0db5c79aa0739732c8199',\\n 'signature': (\\n '0x1c4f65f2bfbf384e783cbb62ef27e7091fa02d9fa9ad1299670f05582325e027b'\\n '9261afef5bceed9e0c84a92aeeead35df85b1cf174a02f0f3d2935c73552ac28803'),\\n }\\n # make a new SignedOrder object without the signature of hash\\n order = SignedOrder.from_json(\\n {k: v for k, v in expected_order_json.items()\\n if k not in [\\\"signature\\\", \\\"hash\\\"]},\\n include_signature=False,\\n )\\n print(pydex_client.private_key)\\n print(order.update().hash)\\n # sign the order\\n order.signature = pydex_client.sign_hash_zx_compat(order.update().hash)\\n assert order.to_json(include_hash=True) == expected_order_json\",\n \"def populate_transaction(\\n self,\\n label: dict,\\n txid: int,\\n read: str,\\n write: str,\\n transaction: list,\\n action: str,\\n ):\\n method_that_access_table = transaction[\\\"stacktrace\\\"][-1]\\n class_name_next = re.sub(\\n \\\"/\\\", \\\".\\\", method_that_access_table[\\\"method\\\"].split(\\\", \\\")[1][1:]\\n )\\n method_name_next = (\\n method_that_access_table[\\\"method\\\"].split(\\\", \\\")[2].split(\\\"(\\\")[0]\\n )\\n method_signature = \\\".\\\".join([class_name_next, method_name_next])\\n\\n the_sql_query = transaction[\\\"sql\\\"]\\n\\n for tx_read in read:\\n if tx_read.casefold() in the_sql_query.casefold():\\n self.populate_transaction_read(\\n method_signature,\\n txid,\\n tx_read.casefold(),\\n action,\\n the_sql_query.casefold(),\\n )\\n for tx_write in write:\\n if tx_write.casefold() in the_sql_query.casefold():\\n self.populate_transaction_write(\\n method_signature,\\n txid,\\n tx_write.casefold(),\\n action,\\n the_sql_query.casefold(),\\n )\",\n \"async def read(self, key: str) -> ResponseOrKey:\",\n \"def from_dict(cls, dikt) -> 'RomaniaSettlement':\\n return util.deserialize_model(dikt, cls)\",\n \"def load_taxdict():\\n tax = {}\\n with open(\\\"../../data/taxonomy/tree_taxid.txt\\\", 'r') as file:\\n for line in file:\\n current_line = line.split() \\n current_taxid = current_line[0]\\n current_name = current_line[1]\\n tax[current_taxid] = current_name \\n\\n return tax\",\n \"def __init__(self, path):\\n\\n # ----- static assignment\\n # self.data = {\\n # \\\"ACCT100\\\":{\\\"paid\\\": 60, \\\"due\\\": 100}, # balance = 40\\n # \\\"ACCT200\\\": {\\\"paid\\\": 70, \\\"due\\\": 60}, # balance = -10\\n # \\\"ACCT300\\\": {\\\"paid\\\": 60, \\\"due\\\": 0}, # balance = 0\\n # }\\n\\n\\n # open the specified database file for reading and perform loading\\n\\n with open(path, \\\"r\\\") as handle:\\n # JSON\\n import json\\n self.data = json.load(handle)\\n\\n # #YAML\\n # import yaml\\n # self.data = yaml.safe_load(handle)\\n\\n # import xmltodict\\n # self.data = xmltodict.parse(handle.read())[\\\"root\\\"]\\n # print(self.data)\",\n \"def readtrans(self, addr):\\n self._start_transaction(write=False, address=addr)\\n self.address.next = addr\\n self.read.next = True\\n to = 0\\n while self.waitrequest and to < self.timeout:\\n yield self.clock.posedge\\n self.read.next = False\\n self._end_transaction(self.readdata)\",\n \"def readMuchData(self, len, start, context):\\n\\n print(\\\"start: {}\\\".format(start))\\n print(\\\"end: {}\\\".format(start + len))\\n\\n sum = 0\\n\\n for i in range(start, start + len):\\n try:\\n key = \\\"key_{}\\\".format(i)\\n address = _make_benchcontract_address(key)\\n print(\\\"address: {}\\\".format(address))\\n except:\\n print(\\\"Some error\\\")\\n\\n try:\\n data = context.get_state(\\n [address],\\n timeout=self.timeout)\\n print(\\\"Data: {}\\\".format(data))\\n value = int(data[\\\"data\\\"])\\n print(\\\"Obtained {} --> {} from state\\\".format(key, value))\\n # sum = sum + value\\n except:\\n print(\\\"No entry found for {}\\\".format(key))\\n\\n print(\\\"total sum: {}\\\".format(sum))\",\n \"def load_trans(self, fname):\\n info = read_trans(fname)\\n head_mri_trans = info['trans']\\n self.set_trans(head_mri_trans)\",\n \"def database_transaction_to_rlp_transaction(transaction):\\n\\n nonce = transaction['nonce']\\n value = parse_int(transaction['value'])\\n gas = parse_int(transaction['gas'])\\n gas_price = parse_int(transaction['gas_price'])\\n\\n tx = create_transaction(nonce=nonce, gasprice=gas_price, startgas=gas,\\n to=transaction['to_address'], value=value,\\n data=data_decoder(transaction['data']),\\n v=parse_int(transaction['v']),\\n r=parse_int(transaction['r']),\\n s=parse_int(transaction['s']))\\n\\n return tx\",\n \"def csv_dict_reader(file_obj, data = [], cost = []):\\n reader = csv.DictReader(file_obj, delimiter=',')\\n for line in reader:\\n data.append(line[\\\"Дата\\\"]),\\n cost.append(line[\\\"Расход\\\"])\",\n \"def decode(code: bytes):# -> Transaction:\\n vals: list[str] = str(bytes).split(' ')\\n result: Transaction = Transaction()\\n result.id = int(vals[0])\\n result.time = int(vals[1])\\n result.action = string_to_action(vals[2])\\n result.acting_username = vals[3]\\n result.source_account_id = int(vals[4])\\n result.destination_account_id = int(vals[5])\\n result.funds_amount = int(vals[6])\\n return result\",\n \"def read_dict():\\n\\n\\tfilename = 'diction10k.txt'\\n\\t\\n\\ttry:\\n\\t\\ttarget = open(filename, 'r')\\n\\n\\texcept:\\n\\t\\tprint(\\\"Dictionary not found. Please make sure it is located in the same\\\" \\n\\t\\t\\t+ \\\" folder as strings.py\\\")\\n\\t\\tsys.exit(1)\\n\\n\\tfor line in target:\\n\\t\\tDICTSET.add(line.strip())\",\n \"def load_state_dict(self, state_dict: Dict[str, torch.Tensor]):\\n pass\",\n \"def get(self, key, transaction=None):\\n return self._client.get(key, transaction=transaction)\",\n \"def ImportFromJson(filepath):\\n filecontent = open(filepath, 'rb').read()\\n encryptedinfo = json.loads(filecontent)\\n accountinfo = Secrets._decryptContents(encryptedinfo)\\n return DataConnection(accountinfo.get(DataConnection.accountName), \\n accountinfo.get(DataConnection.accountKey), \\n accountinfo.get(DataConnection.accountKind))\",\n \"def get_transaction_data():\\n data = parse_json()\\n income_instances = create_transactions(data['incomes'])\\n expense_instances = create_transactions(data['expenses'])\\n for expense in expense_instances:\\n expense.amount = -(expense.amount)\\n transactions = income_instances + expense_instances\\n return transactions\",\n \"async def process_get_txn(self, int txn) -> str:\\n\\n return json.dumps(json.loads(await ledger.build_get_txn_request(self.did, txn))['result']['data'])\",\n \"def load_transactions(self, address, update=True, verbose=False, **kwargs):\\n if self.apikey is None:\\n update = False\\n if verbose:\\n print('load_transactions', address)\\n fn = os.path.join(self.cache_dir, address + '.json')\\n startblock = None\\n transactions = []\\n if os.path.exists(fn):\\n with open(fn) as f:\\n try:\\n transactions = json.load(f)\\n except json.decoder.JSONDecodeError:\\n if verbose:\\n print('ignoring error while loading', fn)\\n pass\\n if not update:\\n return transactions\\n if len(transactions):\\n startblock = max([int(e['blockNumber']) for e in transactions])\\n if verbose:\\n print('starting from cache at', startblock, 'with', len(transactions))\\n # add new transactions\\n new_transactions = self.fetch_transactions(address, startblock=startblock, verbose=verbose, **kwargs)\\n # dedupe\\n if len(new_transactions) > 0:\\n transactions.extend(new_transactions)\\n transactions = list({e['hash']:e for e in transactions}.values())\\n safe_dump(fn, transactions)\\n return transactions\",\n \"def parseHexTx (self, txHex):\\n\\n data = bytes.fromhex (txHex)\\n\\n tx = CTransaction ()\\n tx.deserialize (io.BytesIO (data))\\n\\n return tx\",\n \"def read_stock(db, openfile):\\n pass\",\n \"def jsonrpc_gettx(self, txid):\\n txnw = self.node.storage.db.get(hex2b(txid))\\n if txnw is None:\\n return {}\\n txnw = TxnWrapper.unserialize(SerializationBuffer(txnw))\\n info = hex_bytes_in_dict(\\n txnw.txn.to_dict())\\n\\n # Add blockheight\\n info['blockheight'] = txnw.timestamp / TIME_MULTIPLIER\\n return info\",\n \"def DictData(self):\\n reader = csv.DictReader( open( self.file, \\\"rU\\\" ), dialect = \\\"excel\\\" )\\n return reader\",\n \"def existing_transactin(self, address):\\n for transaction in self.transaction_map.values():\\n if transaction.input['address'] == address:\\n return transaction\",\n \"def read_raw(self, key):\\n value = None\\n if key is not None:\\n value = self.tcex.key_value_store.read(self._context, key.strip())\\n else:\\n self.log.warning('The key field was None.')\\n return value\",\n \"def get_tx(txid):\\n return requests.get(BASE+f'/api/tx/{txid}').json()\",\n \"def from_dict(cls, dikt) -> 'ShareStatusRead':\\n return util.deserialize_model(dikt, cls)\",\n \"def read_file(self):\\n self.write({\\\"datas\\\": self.choose_file})\\n self._cr.commit()\\n import_file = BytesIO(base64.decodestring(self.datas))\\n file_read = StringIO(import_file.read().decode())\\n reader = csv.DictReader(file_read, delimiter=\\\",\\\")\\n return reader\",\n \"def from_dict(cls, dikt) -> 'CompoundInfoIdentifiers':\\n return util.deserialize_model(dikt, cls)\",\n \"def _read_all(self):\\n try:\\n with open(self.keystore_file, \\\"r\\\") as filep:\\n return json.load(filep)\\n except (IOError, OSError, ValueError):\\n return {}\",\n \"def specific_tx(self, txs_hash: str) -> dict:\\n \\n specific_tx_url = self.network + bf_tx_url + txs_hash\\n\\n response = query_blockfrost(specific_tx_url, self.api_key, self.proxies)\\n \\n return response\",\n \"def csv_dict_reader(file_obj):\\n #import re\\n #file = open(file_obj)\\n\\n # reader = csv.DictReader(file_obj)\\n # for line in reader:\\n # print(line[\\\"Name\\\"])\",\n \"def get_transaction_detail(payload):\\n response = requests.post(url, data=payload)\\n return response.json()\",\n \"def from_dict(self, dictionary: dict):\\n raise NotImplementedError()\",\n \"def from_dict(cls, dikt) -> 'SourceAudit':\\n return util.deserialize_model(dikt, cls)\",\n \"def load_from_dict(input_dict):\\n return WorkflowStepInformation(input_dict)\",\n \"def get_tx_info(tx):\\n\\n input_addresses = []\\n output_addresses = []\\n payments = []\\n\\n try:\\n response = json.loads(make_request('http://tbtc.blockr.io/api/v1/tx/info/' + tx))\\n except Exception as e:\\n status = json.loads(e.message).get('status')\\n if status in ['error', 'fail']:\\n return {'from': None, 'to': None, 'amount': None, 'confirmations': 0}\\n\\n vins = response.get('data').get('vins')\\n vouts = response.get('data').get('vouts')\\n confirmations = response.get('data').get('confirmations')\\n\\n for i in range(len(vins)):\\n if vins[i].get('address') not in input_addresses:\\n input_addresses.append(vins[i].get('address'))\\n for i in range(len(vouts)):\\n output_addresses.append(vouts[i].get('address'))\\n payments.append(vouts[i].get('amount'))\\n\\n return {'from': input_addresses, 'to': output_addresses, 'amount': payments, 'confirmations': confirmations}\",\n \"def read_archive(self):\\n print '------------------------------------'\\n print ' Archiving the simulation results'\\n print ' '\\n self.archive = {}\\n with open(self.archive_data, 'r') as f:\\n for line in f:\\n (key, val) = line.split()\\n self.archive[(key)] = val\",\n \"def ReadFromFile(self):\\n\\n data = \\\"\\\"\\n try:\\n with open(self.fileLoc, \\\"r\\\") as file:\\n data += file.read()\\n except IOError:\\n with open(self.fileLoc, \\\"w\\\") as file:\\n file.write(\\\" \\\")\\n return {}\\n \\n if len(data) == 0:\\n return {}\\n\\n data = self.Decrypt(data)\\n\\n data = \\\"\\\".join(data.split())\\n kvstrings = data.split(\\\"%\\\")\\n kvstrings = filter(None, kvstrings)\\n\\n pairs = {}\\n for x in kvstrings:\\n kv = x.split(\\\":\\\")\\n pairs[kv[0]] = kv[1]\\n\\n return pairs\",\n \"def _read_data(self):\",\n \"def read_dict(self, dictionary, **kwds):\\n self._dict.update(dictionary)\",\n \"def extract(input):\\n reader = csv.DictReader(input)\\n return reader\",\n \"def load_dict_from_file(self, dict_name, bias=0):\\n dict_result = {}\\n with codecs.open(dict_name, 'r', 'utf-8') as f_dict:\\n for idx, line in enumerate(f_dict):\\n line = line.strip()\\n dict_result[line] = idx + bias\\n return dict_result\",\n \"def loadData(self,ins):\\n self.isDeleted = False\\n #--Read subrecords\\n bytesRead = 0\\n while bytesRead < self.size:\\n (name,size) = ins.unpackSubHeader('BOOK')\\n srData = ins.read(size,'BOOK.'+name)\\n bytesRead += 8+size\\n if name == 'NAME': self.id = cstrip(srData)\\n elif name == 'MODL': self.model = cstrip(srData)\\n elif name == 'FNAM': self.title = cstrip(srData)\\n elif name == 'BKDT':\\n (self.weight,self.value,self.isScroll,self.teaches,self.enchantPoints\\n ) = struct.unpack('f4i',srData)\\n elif name == 'SCRI': self.script = cstrip(srData)\\n elif name == 'ITEX': self.icon = cstrip(srData)\\n elif name == 'TEXT': self.text = cstrip(srData)\\n elif name == 'ENAM': self.enchant = cstrip(srData)\\n #--Deleted?\\n elif name == 'DELE': self.isDeleted = True\\n #--Bad record?\\n else: \\n raise Tes3Error(self.inName,_('Extraneous subrecord (%s) in %s record.') \\n % (name,self.name))\",\n \"def create_bank_transactions(*, block, message):\\n bank_transactions = []\\n\\n sender = block.get('sender')\\n\\n encrypted_symmetric_key = None\\n keys_to_add = []\\n keys_to_delete = []\\n for tx in message['txs']:\\n json_data_for_db = None\\n if 'json_data' in tx:\\n json_data = tx.get('json_data')\\n type = json_data.get('type')\\n encryption_key = json_data.get('account', sender)\\n\\n if type not in [\\\"register_data\\\", \\\"append_data\\\", \\\"ask_for_access\\\", \\\"grant_access\\\", \\\"revoke_access\\\"]:\\n continue\\n\\n node_private_key = get_signing_key()\\n node_public_key = node_private_key.verify_key\\n if type == \\\"register_data\\\" or type == \\\"grant_access\\\":\\n keys_to_add.append({'accessor': encryption_key, 'patient_id': sender})\\n # add the node as an accessor so it can manipulate the symmetric key\\n keys_to_add.append({'accessor': node_public_key, 'patient_id': sender})\\n elif type == \\\"revoke_access\\\":\\n keys_to_delete.append({'accessor': encryption_key, 'patient_id': sender})\\n # get all transactions that contain JSON data for the patient\\n transactions = get_json_transactions(sender)\\n new_transaction_data = {}\\n for transaction in transactions:\\n if transaction[\\\"json_data\\\"][\\\"type\\\"] in [\\\"register_data\\\", \\\"append_data\\\"]:\\n decrypted_data = asymmetric_decrypt(transaction[\\\"json_data\\\"][\\\"data\\\"], node_private_key)\\n new_transaction_data.update(decrypted_data)\\n new_data_symmetric_result = symmetric_encrypt(json.dumps(new_transaction_data))\\n\\n new_transaction_json_data_for_db = {\\n \\\"patient_id\\\": encryption_key,\\n \\\"type\\\": type\\n \\\"data\\\": new_data_symmetric_result,\\n \\\"access\\\": encrypted_symmetric_key\\n }\\n\\n new_data_transaction = BankTransaction(\\n amount=0,\\n block=block,\\n fee=tx.get('fee', ''),\\n memo=tx.get('memo', ''),\\n json_data=new_transaction_json_data_for_db,\\n recipient=tx['recipient']\\n )\\n bank_transactions.append(new_data_transaction)\\n\\n symmetric_result = symmetric_encrypt(json.dumps(json_data[\\\"data\\\"]))\\n encrypted_symmetric_key = asymmetric_encrypt(symmetric_result['key'], encryption_key)\\n\\n json_data_for_db = {\\n \\\"patient_id\\\": encryption_key,\\n \\\"type\\\": type\\n \\\"data\\\": symmetric_result['message'],\\n \\\"access\\\": encrypted_symmetric_key\\n }\",\n \"def get_transaction(self, excludes_list):\\n response = client.get(self.url, \\\"transactions\\\", {\\\"exclude_hash\\\": excludes_list})\\n if response.status == 200:\\n print(\\\"Transaction successfully received\\\")\\n return Transaction.parse(response.data)\\n elif response.status == 404:\\n # print(\\\"no request to be received\\\")\\n return None\\n else:\\n print(\\\"Unknown error while requesting transaction\\\")\\n return None\",\n \"def read(self, addr: str) -> dict:\\n for block in self.__mem:\\n if block['address'] == addr:\\n return block\\n\\n return {}\",\n \"def load_data(self):\\n try:\\n with open('blockchain-{}.txt'.format(self.node_id), mode='r') as f:\\n file_content = f.readlines()\\n blockchain = json.loads(file_content[0][:-1])\\n updated_blockchain = []\\n for block in blockchain:\\n converted_tx = [Transaction(\\n tx['sender'], tx['recipient'], tx['signature'], tx['amount']) for tx in block['transactions']]\\n converted_chip = [Chipsaction(\\n tx['sender'], tx['recipient'], tx['follow'], tx['message'], tx['signature'], tx['amount']) for tx in block['chipsactions']]\\n converted_message = [Messsaction(\\n tx['sender'], tx['follower'], tx['message'], tx['signature']) for tx in block['messsactions']]\\n updated_block = Block(\\n block['index'], block['previous_hash'], converted_tx, converted_chip, converted_message, block['proof'], block['timestamp'])\\n updated_blockchain.append(updated_block)\\n self.chain = updated_blockchain\\n\\n open_transactions = json.loads(file_content[1][:-1])\\n # need to convert the loaded data because Transactions should use OrderedDict\\n updated_transactions = []\\n for tx in open_transactions:\\n updated_transaction = Transaction(\\n tx['sender'], tx['recipient'], tx['signature'], tx['amount'])\\n updated_transactions.append(updated_transaction)\\n self.__open_transactions = updated_transactions\\n\\n open_chipsactions = json.loads(file_content[2][:-1])\\n # need to convert the loaded data because Chipsactions should use OrderedDict\\n updated_chipsactions = []\\n for tx in open_chipsactions:\\n updated_chipsaction = Chipsaction(\\n tx['sender'], tx['recipient'], tx['follow'], tx['message'], tx['signature'], tx['amount'])\\n updated_chipsactions.append(updated_chipsaction)\\n self.__open_chipsactions = updated_chipsactions\\n\\n open_messsactions = json.loads(file_content[3][:-1])\\n # need to convert the loaded data because Messsactions should use OrderedDict\\n updated_messsactions = []\\n for tx in open_messsactions:\\n updated_messsaction = Messsaction(\\n tx['sender'], tx['follower'], tx['message'], tx['signature'])\\n updated_messsactions.append(updated_messsaction)\\n self.__open_messsactions = updated_messsactions\\n\\n peer_nodes = json.loads(file_content[4])\\n self.__peer_nodes = set(peer_nodes)\\n except (IOError, IndexError):\\n pass\\n finally:\\n print('Cleanup!')\",\n \"def _moneta_form_get_tx_from_data(self, data):\\n # reference, trans_id, fingerprint = data.get('x_invoice_num'), data.get('x_trans_id'), data.get('x_MD5_Hash')\\n reference, trans_id, fingerprint = data.get('MNT_TRANSACTION_ID'), data.get('MNT_OPERATION_ID'), data.get('MNT_SIGNATURE')\\n if not reference or not trans_id or not fingerprint:\\n error_msg = 'moneta: received data with missing reference (%s) or trans_id (%s) or fingerprint (%s)' % (reference, trans_id, fingerprint)\\n _logger.error(error_msg)\\n raise ValidationError(error_msg)\\n tx = self.search([('reference', '=', reference)])\\n if not tx or len(tx) > 1:\\n error_msg = 'moneta: received data for reference %s' % (reference)\\n if not tx:\\n error_msg += '; no order found'\\n else:\\n error_msg += '; multiple order found'\\n _logger.error(error_msg)\\n raise ValidationError(error_msg)\\n return tx[0]\",\n \"def _consume_cryptocom_entry(self, csv_row: Dict[str, Any]) -> None:\\n row_type = csv_row['Transaction Kind']\\n timestamp = deserialize_timestamp_from_date(\\n date=csv_row['Timestamp (UTC)'],\\n formatstr='%Y-%m-%d %H:%M:%S',\\n location='crypto.com',\\n )\\n description = csv_row['Transaction Description']\\n notes = f'{description}\\\\nSource: crypto.com (CSV import)'\\n\\n # No fees info until (Nov 2020) on crypto.com\\n # fees are not displayed in the export data\\n fee = Fee(ZERO)\\n fee_currency = A_USD # whatever (used only if there is no fee)\\n\\n if row_type in (\\n 'crypto_purchase',\\n 'crypto_exchange',\\n 'referral_gift',\\n 'referral_bonus',\\n 'crypto_earn_interest_paid',\\n 'referral_card_cashback',\\n 'card_cashback_reverted',\\n 'reimbursement',\\n ):\\n # variable mapping to raw data\\n currency = csv_row['Currency']\\n to_currency = csv_row['To Currency']\\n native_currency = csv_row['Native Currency']\\n amount = csv_row['Amount']\\n to_amount = csv_row['To Amount']\\n native_amount = csv_row['Native Amount']\\n\\n trade_type = TradeType.BUY if to_currency != native_currency else TradeType.SELL\\n\\n if row_type == 'crypto_exchange':\\n # trades crypto to crypto\\n base_asset = Asset(to_currency)\\n quote_asset = Asset(currency)\\n if quote_asset is None:\\n raise DeserializationError('Got a trade entry with an empty quote asset')\\n base_amount_bought = deserialize_asset_amount(to_amount)\\n quote_amount_sold = deserialize_asset_amount(amount)\\n else:\\n base_asset = Asset(currency)\\n quote_asset = Asset(native_currency)\\n base_amount_bought = deserialize_asset_amount(amount)\\n quote_amount_sold = deserialize_asset_amount(native_amount)\\n\\n rate = Price(abs(quote_amount_sold / base_amount_bought))\\n pair = TradePair(f'{base_asset.identifier}_{quote_asset.identifier}')\\n trade = Trade(\\n timestamp=timestamp,\\n location=Location.CRYPTOCOM,\\n pair=pair,\\n trade_type=trade_type,\\n amount=base_amount_bought,\\n rate=rate,\\n fee=fee,\\n fee_currency=fee_currency,\\n link='',\\n notes=notes,\\n )\\n self.db.add_trades([trade])\\n\\n elif row_type == 'crypto_withdrawal' or row_type == 'crypto_deposit':\\n if row_type == 'crypto_withdrawal':\\n category = AssetMovementCategory.WITHDRAWAL\\n amount = deserialize_asset_amount_force_positive(csv_row['Amount'])\\n else:\\n category = AssetMovementCategory.DEPOSIT\\n amount = deserialize_asset_amount(csv_row['Amount'])\\n\\n asset = Asset(csv_row['Currency'])\\n asset_movement = AssetMovement(\\n location=Location.CRYPTOCOM,\\n category=category,\\n address=None,\\n transaction_id=None,\\n timestamp=timestamp,\\n asset=asset,\\n amount=amount,\\n fee=fee,\\n fee_asset=asset,\\n link='',\\n )\\n self.db.add_asset_movements([asset_movement])\\n\\n elif row_type in (\\n 'crypto_earn_program_created',\\n 'lockup_lock',\\n 'lockup_unlock',\\n 'dynamic_coin_swap_bonus_exchange_deposit',\\n 'crypto_wallet_swap_debited',\\n 'crypto_wallet_swap_credited',\\n 'lockup_swap_debited',\\n 'lockup_swap_credited',\\n 'lockup_swap_rebate',\\n 'dynamic_coin_swap_bonus_exchange_deposit',\\n # we don't handle cryto.com exchange yet\\n 'crypto_to_exchange_transfer',\\n 'exchange_to_crypto_transfer',\\n # supercharger actions\\n 'supercharger_deposit',\\n 'supercharger_withdrawal',\\n # already handled using _import_cryptocom_double_entries\\n 'dynamic_coin_swap_debited',\\n 'dynamic_coin_swap_credited',\\n 'dust_conversion_debited',\\n 'dust_conversion_credited',\\n ):\\n # those types are ignored because it doesn't affect the wallet balance\\n # or are not handled here\\n return\\n else:\\n raise UnsupportedCryptocomEntry(\\n f'Unknown entrype type \\\"{row_type}\\\" encountered during '\\n f'cryptocom data import. Ignoring entry',\\n )\",\n \"def txs_from_json(path):\\n with open(path, 'r') as f:\\n for tvec in json.load(f):\\n if len(tvec) == 1:\\n continue\\n assert len(tvec) == 3\\n prevouts = tvec[0]\\n for prevout in prevouts:\\n assert len(prevout) == 3\\n\\n tx_hex = tvec[1]\\n\\n flags = set()\\n for flag in tvec[2].split(','):\\n assert flag in FLAGS\\n flags.add(flag)\\n\\n try:\\n tx = Tx.from_hex(tx_hex)\\n except:\\n print(\\\"Cannot parse tx_hex: %s\\\" % tx_hex)\\n raise\\n\\n spendable_db = {}\\n blank_spendable = Spendable(0, b'', b'\\\\0' * 32, 0)\\n for prevout in prevouts:\\n spendable = Spendable(coin_value=1000000,\\n script=compile_script(prevout[2]),\\n tx_hash=h2b_rev(prevout[0]), tx_out_index=prevout[1])\\n spendable_db[(spendable.tx_hash, spendable.tx_out_index)] = spendable\\n unspents = [spendable_db.get((tx_in.previous_hash, tx_in.previous_index), blank_spendable) for tx_in in tx.txs_in]\\n tx.set_unspents(unspents)\\n\\n yield (tx, flags)\",\n \"def test_execute_dump_all_transaction(self):\\n\\n instruction = Instruction(\\\"dump()\\\")\\n\\n with std_out() as (out, err):\\n self.transaction_manager.execute(instruction)\\n\\n output = out.getvalue().strip()\\n\\n self.assertEqual(output, \\\"{1: {'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}, 2: {'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x11': { x11: 110 }, 'x12': { x12: 120 }, 'x1': { x1: 10 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}, 3: {'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}, 4: {'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x3': { x3: 30 }, 'x12': { x12: 120 }, 'x13': { x13: 130 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}, 5: {'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}, 6: {'x14': { x14: 140 }, 'x20': { x20: 200 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x15': { x15: 150 }, 'x4': { x4: 40 }, 'x5': { x5: 50 }}, 7: {'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}, 8: {'x14': { x14: 140 }, 'x20': { x20: 200 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x7': { x7: 70 }, 'x4': { x4: 40 }, 'x17': { x17: 170 }}, 9: {'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}, 10: {'x19': { x19: 190 }, 'x14': { x14: 140 }, 'x18': { x18: 180 }, 'x10': { x10: 100 }, 'x8': { x8: 80 }, 'x9': { x9: 90 }, 'x16': { x16: 160 }, 'x2': { x2: 20 }, 'x12': { x12: 120 }, 'x6': { x6: 60 }, 'x20': { x20: 200 }, 'x4': { x4: 40 }}}\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62972873","0.6246917","0.608508","0.5919277","0.58387107","0.5822863","0.5689972","0.5678795","0.5596907","0.5539039","0.5362343","0.535953","0.5318176","0.53046554","0.52756685","0.52726775","0.525928","0.5177265","0.5176545","0.51757026","0.51573217","0.51498437","0.5077048","0.50280756","0.50260115","0.5011225","0.5010137","0.50072503","0.5006537","0.5006247","0.5006247","0.49990916","0.49990916","0.49933434","0.49896547","0.498724","0.49583527","0.494413","0.49393064","0.49311435","0.49299607","0.4889967","0.48891473","0.48794308","0.48770523","0.4875841","0.4875318","0.48688352","0.48687235","0.48670688","0.48604366","0.48557612","0.48532915","0.48467115","0.48389843","0.4833645","0.48316073","0.48307183","0.4827922","0.48273033","0.4826018","0.48231697","0.48218033","0.48095176","0.4798145","0.47952","0.47860497","0.47844806","0.478124","0.47804272","0.47796357","0.47743228","0.47722626","0.4760734","0.4758628","0.47187862","0.4718129","0.4715836","0.4714951","0.47146666","0.47125956","0.4709356","0.47074968","0.46903902","0.46900317","0.46896324","0.46813813","0.46791956","0.46759084","0.4673917","0.46732906","0.4659116","0.46566272","0.46538308","0.46466646","0.46460813","0.4640064","0.46373665","0.46321106","0.46279654"],"string":"[\n \"0.62972873\",\n \"0.6246917\",\n \"0.608508\",\n \"0.5919277\",\n \"0.58387107\",\n \"0.5822863\",\n \"0.5689972\",\n \"0.5678795\",\n \"0.5596907\",\n \"0.5539039\",\n \"0.5362343\",\n \"0.535953\",\n \"0.5318176\",\n \"0.53046554\",\n \"0.52756685\",\n \"0.52726775\",\n \"0.525928\",\n \"0.5177265\",\n \"0.5176545\",\n \"0.51757026\",\n \"0.51573217\",\n \"0.51498437\",\n \"0.5077048\",\n \"0.50280756\",\n \"0.50260115\",\n \"0.5011225\",\n \"0.5010137\",\n \"0.50072503\",\n \"0.5006537\",\n \"0.5006247\",\n \"0.5006247\",\n \"0.49990916\",\n \"0.49990916\",\n \"0.49933434\",\n \"0.49896547\",\n \"0.498724\",\n \"0.49583527\",\n \"0.494413\",\n \"0.49393064\",\n \"0.49311435\",\n \"0.49299607\",\n \"0.4889967\",\n \"0.48891473\",\n \"0.48794308\",\n \"0.48770523\",\n \"0.4875841\",\n \"0.4875318\",\n \"0.48688352\",\n \"0.48687235\",\n \"0.48670688\",\n \"0.48604366\",\n \"0.48557612\",\n \"0.48532915\",\n \"0.48467115\",\n \"0.48389843\",\n \"0.4833645\",\n \"0.48316073\",\n \"0.48307183\",\n \"0.4827922\",\n \"0.48273033\",\n \"0.4826018\",\n \"0.48231697\",\n \"0.48218033\",\n \"0.48095176\",\n \"0.4798145\",\n \"0.47952\",\n \"0.47860497\",\n \"0.47844806\",\n \"0.478124\",\n \"0.47804272\",\n \"0.47796357\",\n \"0.47743228\",\n \"0.47722626\",\n \"0.4760734\",\n \"0.4758628\",\n \"0.47187862\",\n \"0.4718129\",\n \"0.4715836\",\n \"0.4714951\",\n \"0.47146666\",\n \"0.47125956\",\n \"0.4709356\",\n \"0.47074968\",\n \"0.46903902\",\n \"0.46900317\",\n \"0.46896324\",\n \"0.46813813\",\n \"0.46791956\",\n \"0.46759084\",\n \"0.4673917\",\n \"0.46732906\",\n \"0.4659116\",\n \"0.46566272\",\n \"0.46538308\",\n \"0.46466646\",\n \"0.46460813\",\n \"0.4640064\",\n \"0.46373665\",\n \"0.46321106\",\n \"0.46279654\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5942677"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":84585,"cells":{"query":{"kind":"string","value":"convert a DuReaderYesNo example into necessary features"},"document":{"kind":"string","value":"def convert_example(example,\n tokenizer,\n label_list,\n max_seq_length=512,\n is_test=False):\n\n def _truncate_seqs(seqs, max_seq_length):\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n tokens_a, tokens_b = seqs\n max_seq_length -= 3\n while True: # truncate with longest_first strategy\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_seq_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()\n return seqs\n\n def _concat_seqs(seqs, separators, seq_mask=0, separator_mask=1):\n concat = sum((seq + sep for sep, seq in zip(separators, seqs)), [])\n segment_ids = sum(\n ([i] * (len(seq) + len(sep))\n for i, (sep, seq) in enumerate(zip(separators, seqs))), [])\n if isinstance(seq_mask, int):\n seq_mask = [[seq_mask] * len(seq) for seq in seqs]\n if isinstance(separator_mask, int):\n separator_mask = [[separator_mask] * len(sep) for sep in separators]\n p_mask = sum((s_mask + mask\n for sep, seq, s_mask, mask in zip(\n separators, seqs, seq_mask, separator_mask)), [])\n return concat, segment_ids, p_mask\n\n if not is_test:\n # `label_list == None` is for regression task\n label_dtype = \"int64\" if label_list else \"float32\"\n # get the label\n label = example[-2]\n example = example[:-2]\n #create label maps if classification task\n if label_list:\n label_map = {}\n for (i, l) in enumerate(label_list):\n label_map[l] = i\n label = label_map[label]\n label = np.array([label], dtype=label_dtype)\n else:\n qas_id = example[-1]\n example = example[:-2]\n # tokenize raw text\n tokens_raw = [tokenizer(l) for l in example]\n # truncate to the truncate_length,\n tokens_trun = _truncate_seqs(tokens_raw, max_seq_length)\n # concate the sequences with special tokens\n tokens_trun[0] = [tokenizer.cls_token] + tokens_trun[0]\n tokens, segment_ids, _ = _concat_seqs(tokens_trun, [[tokenizer.sep_token]] *\n len(tokens_trun))\n # convert the token to ids\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n valid_length = len(input_ids)\n\n if not is_test:\n return input_ids, segment_ids, valid_length, label\n else:\n return input_ids, segment_ids, valid_length, qas_id"},"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 convert_example(example, tokenizer):\n\n feature = tokenizer(\n text=example['question'],\n text_pair=example['answer'],\n max_seq_len=args.max_seq_length)\n feature['labels'] = example['labels']\n feature['id'] = example['id']\n\n return feature","def ParseYesNo(src):\n return src.strip().lower() == u'yes'","def convert_examples_to_features(examples, tokenizer, max_seq_length):\n \n features = []\n num_tokens_article = []\n count = 0\n masking_token_id = tokenizer.convert_tokens_to_ids(['[MASK]'])[0]\n # padding_token_id = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)\n for example_index, example in enumerate(examples):\n article_tokens = tokenizer.tokenize(example['article'])\n ques_tokens = tokenizer.tokenize(example['question'].replace(\"@placeholder\", \"_\"))\n masked_index = ques_tokens.index('_')\n ques_tokens[masked_index] = '[MASK]'\n \n# options = example['options']\n options = tokenizer.convert_tokens_to_ids(example['options'])\n# print(options, '\\n')\n\n choices_features = []\n _truncate_seq_pair(article_tokens, ques_tokens, max_seq_length - 3)\n\n# tokens = [\"[CLS]\"] + ques_tokens + [\"[SEP]\"] + article_tokens + [\"[SEP]\"]\n tokens = ques_tokens + [\"[SEP]\"] + article_tokens + [\"[SEP]\"]\n\n# segment_ids = [0] * (len(ques_tokens) + 2) + [1] * (len(article_tokens) + 1)\n segment_ids = [0] * (len(ques_tokens) + 1) + [1] * (len(article_tokens) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\t\n candidates = example['options']\n candidates_ids = tokenizer.convert_tokens_to_ids(candidates)\n# print(tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0])\n\n lm_labels = [-1 if t_id != masking_token_id else tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0] for t_id in input_ids]\n# lm_labels = [t_id if t_id != 0 else -1 for t_id in input_ids]\n# for i, t_id in enumerate(lm_labels) :\n# if(t_id == masking_token_id):\n# lm_labels[i] = tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0]\n\n# print(lm_labels, '\\n')\n # tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0]\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n assert len(lm_labels) == max_seq_length\n\n choices_features.append((tokens, input_ids, input_mask, segment_ids))\n\n features.append(\n InputFeatures(\n choices_features = choices_features,\n lm_labels = lm_labels,\n options = options,\n label = example['label']\n )\n )\n \n return features","def test__extract_features(self):\n text_sample = \"I really really love this movie\"\n feature_sample = ['really','love','good']\n feature_score_type = \"presence\"\n model_sample = Model(feature_sample,feature_score_type)\n result_features = model_sample.extract_features(text_sample)\n assert_equal(result_features,{'really':1,'love':1,'good':0})\n feature_score_type = \"term_frequency\"\n model_sample = Model(feature_sample,feature_score_type)\n result_features = model_sample.extract_features(text_sample)\n assert_equal(result_features,{'really':2,'love':1,'good':0})","def convert_examples_to_features(examples, tokenizer, is_training, args):\n all_features = []\n positive_features = 0\n negative_features = 0\n logger.info(\"Converting a list of NqExamples into InputFeatures ...\")\n for index, example in enumerate(tqdm(examples)):\n example_index = example['example_id']\n paragraph_id = example['paragraph_id']\n if args.do_ls:\n features = convert_single_ls_example(example, tokenizer, is_training, args)\n else:\n features = convert_single_example(example, tokenizer, is_training, args)\n\n for feature in features:\n feature.example_index = example_index\n feature.unique_id = paragraph_id + '_' + str(feature.doc_span_index)\n all_features.append(feature)\n if is_training:\n if feature.answer_type == AnswerType['UNKNOWN']:\n negative_features += 1\n else:\n positive_features += 1\n\n if is_training and index % 5000 == 0:\n print('Positive features:', positive_features, 'Negative features:', negative_features)\n\n print('Positive features:', positive_features, 'Negative features:', negative_features)\n\n return all_features","def convert_xnli_examples_to_features(self):\n features = self.features\n lang_filtered_features = []\n for ex_index, example in enumerate(self.examples):\n language = example.guid.split('-')[1]\n if language in self.lang_list:\n lang_filtered_features.append(features[ex_index] + [language])\n return lang_filtered_features","def import_examples(file):\n examples_set = list()\n\n with open(file, 'r') as f:\n for line in f:\n terms = line.strip().split(',')\n # Convert label 0 into no and 1 into yes\n if terms[14] == \"0\":\n terms[14] = \"no\"\n else:\n terms[14] = \"yes\"\n examples_set.append(terms)\n return examples_set","def make_returnn_audio_features_func():\n return _extract","def get_features(self, para, label_list, tokenizer, max_seq_length):\n\t\tlabel_map = {label : i for i, label in enumerate(label_list)}\n# self.reverse_label_map = {v: k for k, v in label_map.items()}\n\t\tguid = \"%s-%s\" % (\"test\", 1)\n\t\ttext_a = para[\"model_answer\"]\n\t\ttext_b = para[\"candidate_answer\"]\n\t\tlabel = label_list[0]\n\t\texample = InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label)\n\t\t\n\t\ttokens_a = tokenizer.tokenize(example.text_a)\n\n\t\ttokens_b = tokenizer.tokenize(example.text_b)\n\t\tif example.text_b:\n\t\t\ttokens_b = tokenizer.tokenize(example.text_b)\n\t\t\t# Modifies `tokens_a` and `tokens_b` in place so that the total\n\t\t\t# length is less than the specified length.\n\t\t\t# Account for [CLS], [SEP], [SEP] with \"- 3\"\n\t\t\tself._truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n\t\telse:\n\t\t\t# Account for [CLS] and [SEP] with \"- 2\"\n\t\t\tif len(tokens_a) > max_seq_length - 2:\n\t\t\t\ttokens_a = tokens_a[:(max_seq_length - 2)]\n\n\t\t# The convention in BERT is:\n\t\t# (a) For sequence pairs:\n\t\t# tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n\t\t# type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n\t\t# (b) For single sequences:\n\t\t# tokens: [CLS] the dog is hairy . [SEP]\n\t\t# type_ids: 0 0 0 0 0 0 0\n\t\t#\n\t\t# Where \"type_ids\" are used to indicate whether this is the first\n\t\t# sequence or the second sequence. The embedding vectors for `type=0` and\n\t\t# `type=1` were learned during pre-training and are added to the wordpiece\n\t\t# embedding vector (and position vector). This is not *strictly* necessary\n\t\t# since the [SEP] token unambigiously separates the sequences, but it makes\n\t\t# it easier for the model to learn the concept of sequences.\n\t\t#\n\t\t# For classification tasks, the first vector (corresponding to [CLS]) is\n\t\t# used as as the \"sentence vector\". Note that this only makes sense because\n\t\t# the entire model is fine-tuned.\n\t\ttokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n\t\tsegment_ids = [0] * len(tokens)\n\n\t\tif tokens_b:\n\t\t\ttokens += tokens_b + [\"[SEP]\"]\n\t\t\tsegment_ids += [1] * (len(tokens_b) + 1)\n\n\t\tinput_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n\t\t# The mask has 1 for real tokens and 0 for padding tokens. Only real\n\t\t# tokens are attended to.\n\t\tinput_mask = [1] * len(input_ids)\n\n\t\t# Zero-pad up to the sequence length.\n\t\tpadding = [0] * (max_seq_length - len(input_ids))\n\t\tinput_ids += padding\n\t\tinput_mask += padding\n\t\tsegment_ids += padding\n\n\t\tassert len(input_ids) == max_seq_length\n\t\tassert len(input_mask) == max_seq_length\n\t\tassert len(segment_ids) == max_seq_length\n\t\tlabel_id = label_map[example.label]\n# print(\"*** Example ***\")\n# print(\"guid: %s\" % (example.guid))\n# print(\"tokens: %s\" % \" \".join(\n# [str(x) for x in tokens]))\n# print(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n# print(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n# print(\"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n\n\t\t\n\t\treturn InputFeatures(input_ids=input_ids,\n\t\t\t\t\t\t\t input_mask=input_mask,\n\t\t\t\t\t\t\t segment_ids=segment_ids,\n\t\t\t\t\t\t\t label_id=label_id)","def read_examples(input_file, output_mode = 'classification'):\n examples = []\n labels = []\n toxicity = []\n weights = []\n unique_id = 0\n\n # Comments with the following indentities will have a higher wright in the loss\n identity_columns = [\n 'male', 'female', 'homosexual_gay_or_lesbian', 'christian', 'jewish',\n 'muslim', 'black', 'white', 'psychiatric_or_mental_illness']\n with open(input_file, \"r\", encoding='utf-8') as reader:\n csv_reader = csv.reader(reader, delimiter=',')\n for _i, line in enumerate(csv_reader):\n\n if _i == 0:\n # Get headers and look for identity columnns\n headers = list(line)\n # Stores its positions for futher use\n interesting_positions = [headers.index(interest_identity) for interest_identity in identity_columns]\n\n else:\n # Get toxicity ground truth\n target = float(line[1])\n if target >= 0.5:\n \tlabel = \"Toxic\"\n else:\n \tlabel = \"OK\"\n text = line[2]\n text_a = None\n text_b = None\n m = re.match(r\"^(.*) \\|\\|\\| (.*)$\", text)\n if m is None:\n text_a = text\n else:\n print(text_a, text_b)\n text_a = m.group(1)\n text_b = m.group(2)\n # store class or float toxicity depending on mode\n if output_mode != 'classification':\n label = target\n\n # Calculate weight\n weight = 0.25\n # Subgroup:\n\n weight+= 0.25*(sum([float(line[interest])>=0.5 for interest in interesting_positions if line[interest] !=''])>=1)\n # Background Positive, Subgroup Negative\n weight+=0.25*((target>=0.5)*sum([float(line[interest])<0.5 for interest in interesting_positions if line[interest] !=''])>=1)\n # Background Negative, Subgroup Positive\n weight+= 0.25*((target<0.5)*sum([float(line[interest])>=0.5 for interest in interesting_positions if line[interest] !=''])>=1)\n # Original implementation\n '''\n # Overall\n weights = np.ones((len(x_train),)) / 4\n # Subgroup\n weights += (train[identity_columns].fillna(0).values>=0.5).sum(axis=1).astype(bool).astype(np.int) / 4\n # Background Positive, Subgroup Negative\n weights += (( (train['target'].values>=0.5).astype(bool).astype(np.int) +\n (train[identity_columns].fillna(0).values<0.5).sum(axis=1).astype(bool).astype(np.int) ) > 1 ).astype(bool).astype(np.int) / 4\n # Background Negative, Subgroup Positive\n weights += (( (train['target'].values<0.5).astype(bool).astype(np.int) +\n (train[identity_columns].fillna(0).values>=0.5).sum(axis=1).astype(bool).astype(np.int) ) > 1 ).astype(bool).astype(np.int) / 4\n \n '''\n examples.append(\n InputExample(guid=unique_id, text_a=text_a, text_b=text_b, label = label, weight = weight))\n labels.append(label)\n toxicity.append(target)\n unique_id += 1\n\n\n\n return examples, labels, toxicity","def feature():\n pass","def load_demo():\n\tprint(\"\"\"\n\tBreast Cancer Wisconsin dataset. It contains a total of 569 samples of tumor and malignant cells. \n\tData labeled 1 corresponds to malignant cells, while data labeled 0 corresponds to benign cells. \n\tThe 30 characteristics contain real values obtained from images of cell nuclei. For more information:\n\n\t\t\thttp://archive.ics.uci.edu/ml/datasets/breast+cancer+wisconsin+(diagnostic)\n\n\n\tThe returned value is a dictionary where 'x_data' are the predictor variables, 'y_data' the class \n\tlabels and 'features' the name of the characteristics.\n\t\"\"\")\n\tpath = '/'.join(os.path.abspath(pywinEA.__file__).split('/')[:-1])\n\t\n\tdata = pd.read_csv(path+'/dataset/data/BreastCancerWisconsin.csv', index_col=0)\n\tx_data = data.iloc[:, 1:].values\n\ty_data = data.iloc[:, 0].values\n\tfeatures = data.columns[1:].values\n\n\t# Transform labels\n\ty_data[np.where(y_data == 'M')] = 1\n\ty_data[np.where(y_data == 'B')] = 0\n\ty_data = y_data.astype(int)\n\n\treturn {'x_data': x_data, 'y_data': y_data, 'features': features}","def feat():\n pass","def __add_answered_on_feature(samples: List[TrainSample], all_features: np.array) -> np.array:\n new_features = []\n for sample, features in zip(samples, all_features):\n if isinstance(sample.selected_player, bool):\n answered_on = 1.0 if sample.selected_player else 0.0\n else:\n answered_on = 1.0 if sample.selected_player in sample.answer else 0.0\n features = np.append(features, answered_on * features)\n features = np.append(features, [answered_on])\n new_features.append(features)\n return np.array(new_features)","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer, mode): #check later if we can merge this function with the SQuAD preprocessing \n label_map = {}\n for (i, label) in enumerate(label_list):\n label_map[label] = i\n\n features = []\n for (ex_index, example) in enumerate(examples):\n if mode!=\"ae\":\n tokens_a = tokenizer.tokenize(example.text_a)\n else: #only do subword tokenization.\n tokens_a, labels_a, example.idx_map= tokenizer.subword_tokenize([token.lower() for token in example.text_a], example.label )\n tokens_b = None\n if example.text_b:\n tokens_b = tokenizer.tokenize(example.text_b)\n\n if tokens_b:\n # Modifies `tokens_a` and `tokens_b` in place so that the total\n # length is less than the specified length.\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n # Account for [CLS] and [SEP] with \"- 2\"\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[0:(max_seq_length - 2)]\n\n tokens = []\n segment_ids = []\n tokens.append(\"[CLS]\")\n segment_ids.append(0)\n for token in tokens_a:\n tokens.append(token)\n segment_ids.append(0)\n tokens.append(\"[SEP]\")\n segment_ids.append(0)\n\n if tokens_b:\n for token in tokens_b:\n tokens.append(token)\n segment_ids.append(1)\n tokens.append(\"[SEP]\")\n segment_ids.append(1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n while len(input_ids) < max_seq_length:\n input_ids.append(0)\n input_mask.append(0)\n segment_ids.append(0)\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n\n if mode!=\"ae\":\n label_id = label_map[example.label]\n else:\n label_id = [-1] * len(input_ids) #-1 is the index to ignore\n #truncate the label length if it exceeds the limit.\n lb=[label_map[label] for label in labels_a]\n if len(lb) > max_seq_length - 2:\n lb = lb[0:(max_seq_length - 2)]\n label_id[1:len(lb)+1] = lb\n \n features.append(\n InputFeatures(\n input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_id=label_id))\n return features","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer, mode): #check later if we can merge this function with the SQuAD preprocessing\n label_map = {}\n for (i, label) in enumerate(label_list):\n label_map[label] = i\n\n features = []\n for (ex_index, example) in enumerate(examples):\n if mode!=\"ae\":\n tokens_a = tokenizer.tokenize(example.text_a)\n else: #only do subword tokenization.\n tokens_a, labels_a, example.idx_map= tokenizer.subword_tokenize([token.lower() for token in example.text_a], example.label )\n\n tokens_b = None\n if example.text_b:\n tokens_b = tokenizer.tokenize(example.text_b)\n\n if tokens_b:\n # Modifies `tokens_a` and `tokens_b` in place so that the total\n # length is less than the specified length.\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n # Account for [CLS] and [SEP] with \"- 2\"\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[0:(max_seq_length - 2)]\n\n tokens = []\n segment_ids = []\n tokens.append(\"[CLS]\")\n segment_ids.append(0)\n for token in tokens_a:\n tokens.append(token)\n segment_ids.append(0)\n tokens.append(\"[SEP]\")\n segment_ids.append(0)\n\n if tokens_b:\n for token in tokens_b:\n tokens.append(token)\n segment_ids.append(1)\n tokens.append(\"[SEP]\")\n segment_ids.append(1)\n\n target_indices = find_target_indices(tokens_a, tokens)\n if target_indices is None:\n target_indices = (1, 1 + len(tokens_a))\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n while len(input_ids) < max_seq_length:\n input_ids.append(0)\n input_mask.append(0)\n segment_ids.append(0)\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n\n if mode!=\"ae\":\n label_id = label_map[example.label]\n else:\n label_id = [-1] * len(input_ids) #-1 is the index to ignore\n #truncate the label length if it exceeds the limit.\n lb=[label_map[label] for label in labels_a]\n if len(lb) > max_seq_length - 2:\n lb = lb[0:(max_seq_length - 2)]\n label_id[1:len(lb)+1] = lb\n\n features.append(\n InputFeatures(\n input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_id=label_id,\n target_indices=target_indices))\n return features","def yesno(*args):","def other_features_(tweet, cleaned_tweet):\n #print(\"WARNING>>>>>>>>>>>>>>>>> VADERSENTIMENT DISABLED\")\n sentiment = nlp.sentiment_analyzer.polarity_scores(tweet)\n\n words = cleaned_tweet #Get text only\n\n syllables = textstat.syllable_count(words) #count syllables in words\n num_chars = sum(len(w) for w in words) #num chars in words\n num_chars_total = len(tweet)\n num_terms = len(tweet.split())\n num_words = len(words.split())\n avg_syl = round(float((syllables+0.001))/float(num_words+0.001),4)\n num_unique_terms = len(set(words.split()))\n ###Modified FK grade, where avg words per sentence is just num words/1\n FKRA = round(float(0.39 * float(num_words)/1.0) + float(11.8 * avg_syl) - 15.59,1)\n ##Modified FRE score, where sentence fixed to 1\n FRE = round(206.835 - 1.015*(float(num_words)/1.0) - (84.6*float(avg_syl)),2)\n\n\n twitter_objs = count_twitter_objs(tweet) #Count #, @, and http://\n features = [FKRA, FRE, syllables, num_chars, num_chars_total, num_terms, num_words,\n num_unique_terms, sentiment['compound'],\n twitter_objs[2], twitter_objs[1],]\n #features = pandas.DataFrame(features)\n return features","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n\n label_map = {} # label\n for (i, label) in enumerate(label_list): # ['0', '1']\n label_map[label] = i\n\n features = [] # feature\n for (ex_index, example) in enumerate(examples):\n text_a_id = int(example.text_a_id)\n text_b_id = int(example.text_b_id)\n\n text_a_fields = example.text_a.split(\" _eop_ \")\n \n tokens_a = []\n text_a_subtype = []\n for text_a_field_idx, text_a_field in enumerate(text_a_fields):\n text_a_field_token = tokenizer.tokenize(text_a_field)\n tokens_a.extend(text_a_field_token)\n text_a_subtype.extend([text_a_field_idx]*len(text_a_field_token))\n assert len(tokens_a) == len(text_a_subtype)\n\n tokens_b = None\n if example.text_b:\n tokens_b = tokenizer.tokenize(example.text_b) # text_b tokenize\n\n if tokens_b: # if has b\n # Modifies `tokens_a` and `tokens_b` in place so that the total\n # length is less than the specified length.\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3) # truncate\n else:\n # Account for [CLS] and [SEP] with \"- 2\"\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[0:(max_seq_length - 2)]\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambiguously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as as the \"sentence vector\". Note that this only makes sense because # (?)\n # the entire model is fine-tuned.\n tokens = []\n segment_ids = []\n subtype_ids = []\n tokens.append(\"[CLS]\")\n segment_ids.append(0)\n subtype_ids.append(0)\n for token_idx, token in enumerate(tokens_a):\n tokens.append(token)\n segment_ids.append(0)\n subtype_ids.append(text_a_subtype[token_idx])\n tokens.append(\"[SEP]\")\n segment_ids.append(0)\n subtype_ids.append(1)\n\n if tokens_b:\n for token_idx, token in enumerate(tokens_b):\n tokens.append(token)\n segment_ids.append(1)\n subtype_ids.append(2)\n tokens.append(\"[SEP]\")\n segment_ids.append(1)\n subtype_ids.append(2)\n\n input_sents = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_sents) # mask\n\n # Zero-pad up to the sequence length.\n while len(input_sents) < max_seq_length:\n input_sents.append(0)\n input_mask.append(0)\n segment_ids.append(0)\n subtype_ids.append(0)\n\n assert len(input_sents) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n assert len(subtype_ids) == max_seq_length\n\n label_id = label_map[example.label]\n\n if ex_index%2000 == 0:\n print('convert_{}_examples_to_features'.format(ex_index))\n\n features.append(\n InputFeatures( # object\n text_a_id=text_a_id,\n text_b_id=text_b_id,\n input_sents=input_sents,\n input_mask=input_mask,\n segment_ids=segment_ids,\n subtype_ids=subtype_ids,\n label_id=label_id))\n\n return features","def load_simple_features(self, simple_features):\n self.simple_features = pd.DataFrame(simple_features).T\n self.simple_features.fillna(False, inplace=True)\n self.simple_features = self.simple_features.astype(bool)\n\n # Aggregate features descriptions\n self.simple_features_description = {}\n for binary in simple_features:\n for token in simple_features[binary]:\n if token not in self.simple_features_description:\n self.simple_features_description[token] = \\\n simple_features[binary][token]","def get_yesno(yesno):\n return 'yes' if yesno == 1 else 'no'","def yn(self, mask, target, args):\n self.msg(mask, target, \"[1dyes] ==> \" + random.choice(['Yes', 'No']))","def convert_examples_to_features(examples, max_seq_length, tokenizer):\n\n features = []\n for (ex_index, example) in enumerate(examples):\n print(example.text_a)\n tokens_a = tokenizer.tokenize(example.text_a)\n\n tokens_b = None\n if example.text_b:\n tokens_b = tokenizer.tokenize(example.text_b)\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[:(max_seq_length - 2)]\n\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n segment_ids = [0] * len(tokens)\n\n if tokens_b:\n tokens += tokens_b + [\"[SEP]\"]\n segment_ids += [1] * (len(tokens_b) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n input_mask = [1] * len(input_ids)\n\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n \n labels_ids = []\n for label in example.labels:\n labels_ids.append(int(label))\n \n if ex_index < 0:\n logger.info(\"*** Example ***\")\n logger.info(\"guid: %s\" % (example.guid))\n logger.info(\"tokens: %s\" % \" \".join(\n [str(x) for x in tokens]))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n logger.info(\n \"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n logger.info(\"label: %s (id = %s)\" % (example.labels, labels_ids))\n\n features.append(\n InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_ids=labels_ids))\n return features","def convert_examples_to_features(self):\n features = []\n max_label_len = 0\n # find ou the max label length\n labels_list = []\n for ex_index, example in enumerate(self.examples):\n processor = example.processor\n label_ids = self.tokenizer.text_to_ids(processor.label2string(example.label)) + [self.tokenizer.eos_id]\n max_label_len = max(len(label_ids), max_label_len)\n labels_list.append(label_ids)\n if self.max_seq_length_decoder is None:\n self.max_seq_length_decoder = max_label_len\n else:\n self.max_seq_length_decoder = max(\n self.max_seq_length_decoder, max_label_len\n ) # take the max of the two to be conservative\n for ex_index, example in enumerate(self.examples):\n taskname = example.taskname\n taskname_ids = self.tokenizer.text_to_ids(taskname)\n processor = example.processor\n if ex_index % 10000 == 0:\n logging.info(f\"Writing example {ex_index} of {len(self.examples)}\")\n label_ids = labels_list[ex_index]\n enc_query = processor.get_ptune_query(\n example.content,\n self.pseudo_token_id,\n self.max_seq_length - self.max_seq_length_decoder + 1,\n self.templates,\n self.tokenizer,\n )\n input_ids = enc_query + label_ids[:-1]\n labels = [SMALL_NUM for i in range(len(enc_query) - 1)] + label_ids\n features.append([input_ids, labels, enc_query, taskname_ids])\n return features","def _parse_single_example(example, options):\n # Initialize `keys_to_features`.\n keys_to_features = {\n TFExampleFields.img_id: tf.io.FixedLenFeature([], tf.string),\n TFExampleFields.annot_id: tf.io.FixedLenFeature([], tf.string),\n TFExampleFields.answer_label: tf.io.FixedLenFeature([], tf.int64),\n TFExampleFields.img_bbox_label: tf.io.VarLenFeature(tf.string),\n TFExampleFields.img_bbox_score: tf.io.VarLenFeature(tf.float32),\n TFExampleFields.img_bbox_feature: tf.io.VarLenFeature(tf.float32),\n TFExampleFields.question: tf.io.VarLenFeature(tf.string),\n TFExampleFields.question_tag: tf.io.VarLenFeature(tf.int64),\n }\n for bbox_key in TFExampleFields.img_bbox_field_keys:\n bbox_field = os.path.join(TFExampleFields.img_bbox_scope, bbox_key)\n keys_to_features[bbox_field] = tf.io.VarLenFeature(tf.float32)\n for i in range(1, 1 + NUM_CHOICES):\n keys_to_features.update({\n TFExampleFields.cls_bert + '_%i' % i:\n tf.io.VarLenFeature(tf.float32),\n TFExampleFields.question_bert + '_%i' % i:\n tf.io.VarLenFeature(tf.float32),\n TFExampleFields.answer_choice + '_%i' % i:\n tf.io.VarLenFeature(tf.string),\n TFExampleFields.answer_choice_tag + '_%i' % i:\n tf.io.VarLenFeature(tf.int64),\n TFExampleFields.answer_choice_bert + '_%i' % i:\n tf.io.VarLenFeature(tf.float32)\n })\n\n # Initialize `items_to_handlers`.\n items_to_handlers = {\n InputFields.img_id:\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.img_id,\n default_value=''),\n InputFields.annot_id:\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.annot_id,\n default_value=''),\n InputFields.answer_label:\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.answer_label,\n default_value=-1),\n InputFields.object_bboxes:\n tfexample_decoder.BoundingBox(\n keys=TFExampleFields.img_bbox_field_keys,\n prefix=TFExampleFields.img_bbox_scope),\n InputFields.object_labels:\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.img_bbox_label,\n default_value=''),\n InputFields.object_scores:\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.img_bbox_score,\n default_value=0),\n InputFields.question:\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.question,\n default_value=PAD),\n InputFields.question_tag:\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.question_tag,\n default_value=-1),\n TFExampleFields.img_bbox_feature:\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.img_bbox_feature,\n default_value=0),\n }\n\n for i in range(1, 1 + NUM_CHOICES):\n tensor_key = TFExampleFields.cls_bert + '_%i' % i\n items_to_handlers[tensor_key] = tfexample_decoder.Tensor(\n tensor_key=tensor_key, default_value=0)\n tensor_key = TFExampleFields.question_bert + '_%i' % i\n items_to_handlers[tensor_key] = tfexample_decoder.Tensor(\n tensor_key=tensor_key, default_value=0)\n tensor_key = TFExampleFields.answer_choice + '_%i' % i\n items_to_handlers[tensor_key] = tfexample_decoder.Tensor(\n tensor_key=tensor_key, default_value=PAD)\n tensor_key = TFExampleFields.answer_choice_tag + '_%i' % i\n items_to_handlers[tensor_key] = tfexample_decoder.Tensor(\n tensor_key=tensor_key, default_value=-1)\n tensor_key = TFExampleFields.answer_choice_bert + '_%i' % i\n items_to_handlers[tensor_key] = tfexample_decoder.Tensor(\n tensor_key=tensor_key, default_value=0)\n if options.decode_jpeg:\n keys_to_features.update({\n TFExampleFields.img_encoded: tf.io.FixedLenFeature([], tf.string),\n TFExampleFields.img_format: tf.io.FixedLenFeature([], tf.string),\n })\n items_to_handlers.update({\n InputFields.img_data:\n tfexample_decoder.Image(image_key=TFExampleFields.img_encoded,\n format_key=TFExampleFields.img_format,\n shape=None)\n })\n\n # Decode example.\n example_decoder = tfexample_decoder.TFExampleDecoder(keys_to_features,\n items_to_handlers)\n\n output_keys = example_decoder.list_items()\n output_tensors = example_decoder.decode(example)\n output_tensors = [\n x if x.dtype != tf.int64 else tf.cast(x, tf.int32) for x in output_tensors\n ]\n decoded_example = dict(zip(output_keys, output_tensors))\n return _update_decoded_example(decoded_example, options)","def convert_example_to_features_for_test(example, max_seq_length, tokenizer):\r\n features = []\r\n tokens = []\r\n labels_temp = []\r\n for i, word in enumerate(example.text_a.split(' ')):\r\n token_wordpiece = tokenizer.tokenize(word) #04/26/1882 ['04', '/', '26', '/', '1882']\r\n tokens.extend(token_wordpiece)\r\n for m in range(len(token_wordpiece)):\r\n if m == 0:\r\n labels_temp.append(0)\r\n else:\r\n labels_temp.append('X')\r\n # max_seq_length-1\r\n if len(tokens) >= max_seq_length - 1:\r\n tokens = tokens[0:(max_seq_length - 2)]\r\n labels_temp = labels_temp[0:(max_seq_length - 2)]\r\n\r\n ntokens = []\r\n new_labels_temp = []\r\n segment_ids = []\r\n\r\n ntokens.append('[CLS]')\r\n new_labels_temp.append('[CLS]')\r\n segment_ids.append(0)\r\n for i, token in enumerate(tokens):\r\n ntokens.append(token)\r\n new_labels_temp.append(labels_temp[i])\r\n segment_ids.append(0)\r\n ntokens.append('[SEP]')\r\n new_labels_temp.append('[SEP]')\r\n segment_ids.append(0)\r\n input_ids = tokenizer.convert_tokens_to_ids(ntokens)\r\n input_mask = [1] * len(input_ids)\r\n\r\n #if the length is short, tianbu 0\r\n while len(input_ids) < max_seq_length:\r\n input_ids.append(0)\r\n input_mask.append(0)\r\n segment_ids.append(0)\r\n #we do not concerned about it\r\n ntokens.append('NULL')\r\n\r\n assert len(input_ids) == max_seq_length\r\n assert len(input_mask) == max_seq_length\r\n assert len(segment_ids) == max_seq_length\r\n\r\n features.append(InputFeatures(input_ids=input_ids, input_mask=input_mask, segment_ids=segment_ids, label_ids=None))\r\n return features, new_labels_temp","def convert_example(example,\n tokenizer,\n label_list,\n max_seq_length=512,\n is_test=False):\n if not is_test:\n # `label_list == None` is for regression task\n label_dtype = \"int64\" if label_list else \"float32\"\n # Get the label\n label = example['labels']\n label = np.array([label], dtype=label_dtype)\n # Convert raw text to feature\n if (int(is_test) + len(example)) == 2:\n example = tokenizer(example['sentence'], max_seq_len=max_seq_length)\n else:\n example = tokenizer(\n example['sentence1'],\n text_pair=example['sentence2'],\n max_seq_len=max_seq_length)\n\n if not is_test:\n return example['input_ids'], example['token_type_ids'], label\n else:\n return example['input_ids'], example['token_type_ids']","def read_oqmrc_examples(input_file, is_test):\n\n examples = []\n drop1 = 0\n drop2 = 0\n drop3 = 0\n drop4 = 0\n with tf.gfile.Open(input_file, \"r\") as reader:\n for line in reader:\n sample = json.loads(line)\n answer = None\n if not is_test:\n answer = sample[\"answer\"]\n answer = answer.strip()\n if answer == \"\":\n drop1 += 1\n continue\n alternatives = sample['alternatives'].split(\"|\")\n for i, alter in enumerate(alternatives):\n alternatives[i] = alter.strip()\n while \"\" in alternatives:\n alternatives.remove(\"\") # 删除空白的无效候选项\n if len(alternatives) != 3:\n drop2 += 1\n continue\n random.shuffle(alternatives)\n label = None\n ansnum = 0\n for i, alter in enumerate(alternatives):\n if alternatives[i] == answer:\n label = i\n ansnum += 1\n if ansnum > 1:\n drop3 += 1\n continue\n if not is_test and label is None:\n drop4 += 1\n continue\n paragraph_text = sample[\"passage\"]\n qas_id = sample[\"query_id\"]\n question_text = sample[\"query\"]\n example = OqmrcExample(\n q_id=qas_id,\n question=question_text,\n paragraph=paragraph_text,\n alters=alternatives,\n answer=answer,\n label=label)\n examples.append(example)\n tf.logging.info(\"%d个样本答案为空白，%d个样本候选项不足，%d个样本多个候选项和答案相同，%d个样本找不到答案\" %\n (drop1, drop2, drop3, drop4))\n return examples","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n\n label_map = {label: i for i, label in enumerate(label_list, 1)}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n textlist = example.text_a.split(' ')\n labellist = example.label\n tokens = []\n labels = []\n valid = []\n label_mask = []\n for i, word in enumerate(textlist):\n token = tokenizer.tokenize(word)\n tokens.extend(token)\n label_1 = labellist[i]\n for m in range(len(token)):\n if m == 0:\n labels.append(label_1)\n valid.append(1)\n label_mask.append(True)\n else:\n valid.append(0)\n if len(tokens) >= max_seq_length - 1:\n tokens = tokens[0:(max_seq_length - 2)]\n labels = labels[0:(max_seq_length - 2)]\n valid = valid[0:(max_seq_length - 2)]\n label_mask = label_mask[0:(max_seq_length - 2)]\n ntokens = []\n segment_ids = []\n label_ids = []\n ntokens.append(\"[CLS]\")\n segment_ids.append(0)\n valid.insert(0, 1)\n label_mask.insert(0, True)\n label_ids.append(label_map[\"[CLS]\"])\n for i, token in enumerate(tokens):\n ntokens.append(token)\n segment_ids.append(0)\n if len(labels) > i:\n label_ids.append(label_map[labels[i]])\n ntokens.append(\"[SEP]\")\n segment_ids.append(0)\n valid.append(1)\n label_mask.append(True)\n label_ids.append(label_map[\"[SEP]\"])\n input_ids = tokenizer.convert_tokens_to_ids(ntokens)\n input_mask = [1] * len(input_ids)\n label_mask = [True] * len(label_ids)\n while len(input_ids) < max_seq_length:\n input_ids.append(0)\n input_mask.append(0)\n segment_ids.append(0)\n label_ids.append(0)\n valid.append(1)\n label_mask.append(False)\n while len(label_ids) < max_seq_length:\n label_ids.append(0)\n label_mask.append(False)\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n assert len(label_ids) == max_seq_length\n assert len(valid) == max_seq_length\n assert len(label_mask) == max_seq_length\n\n features.append(\n InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_id=label_ids,\n valid_ids=valid,\n label_mask=label_mask))\n return features","def convert_examples_to_features(\n examples: List[InputExample],\n label_list: List[str],\n max_length: int,\n tokenizer: PreTrainedTokenizer,\n pad_token_segment_id=0,\n pad_on_left=False,\n pad_token=0,\n mask_padding_with_zero=True,\n) -> List[InputFeatures]:\n\n label_map = {label: i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in tqdm.tqdm(enumerate(examples), desc=\"convert examples to features\"):\n if ex_index % 10000 == 0:\n logger.info(\"Writing example %d of %d\" % (ex_index, len(examples)))\n choices_features = []\n for ending_idx, (context, ending) in enumerate(zip(example.contexts, example.endings)):\n text_a = context\n if example.question.find(\"_\") != -1:\n # this is for cloze question\n text_b = example.question.replace(\"_\", ending)\n else:\n text_b = example.question + \" \" + ending\n if len(text_a) == 0:\n logger.info(\"context of example %d have length 0\" % (ex_index))\n text_a = \" \"\n\n inputs = tokenizer.encode_plus(text_a, text_b, add_special_tokens=True, max_length=max_length,)\n if \"num_truncated_tokens\" in inputs and inputs[\"num_truncated_tokens\"] > 0:\n logger.info(\n \"Attention! you are cropping tokens (swag task is ok). \"\n \"If you are training ARC and RACE and you are poping question + options,\"\n \"you need to try to use a bigger max seq length!\"\n )\n\n input_ids, token_type_ids = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding_length = max_length - len(input_ids)\n if pad_on_left:\n input_ids = ([pad_token] * padding_length) + input_ids\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\n else:\n input_ids = input_ids + ([pad_token] * padding_length)\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\n\n assert len(input_ids) == max_length\n assert len(attention_mask) == max_length\n assert len(token_type_ids) == max_length\n choices_features.append((input_ids, attention_mask, token_type_ids))\n\n label = label_map[example.label]\n\n if ex_index < 2:\n logger.info(\"*** Example ***\")\n logger.info(\"race_id: {}\".format(example.example_id))\n for choice_idx, (input_ids, attention_mask, token_type_ids) in enumerate(choices_features):\n logger.info(\"choice: {}\".format(choice_idx))\n logger.info(\"input_ids: {}\".format(\" \".join(map(str, input_ids))))\n logger.info(\"attention_mask: {}\".format(\" \".join(map(str, attention_mask))))\n logger.info(\"token_type_ids: {}\".format(\" \".join(map(str, token_type_ids))))\n logger.info(\"label: {}\".format(label))\n\n features.append(InputFeatures(example_id=example.example_id, choices_features=choices_features, label=label,))\n\n return features","def _create_yes_no(self):\n text_maker = TextMaker(join(\"fonts\", \"party_txt_font.png\"), max=15)\n self.yes_no_surf = text_maker.get_surface(\"YES NO\")","def create_example(line, tfidf_dict, is_training, args):\n sample = json.loads(line, object_pairs_hook=collections.OrderedDict)\n example_id = sample['example_id']\n question_text = sample['question_text']\n ori_doc_tokens = sample['document_text'].split()\n\n # 抽取特定段落list[list]\n tfidf_cands_ids = tfidf_dict[str(example_id)]\n # tfidf并不保证所有段落必定出现在所选段落内\n if is_training:\n long_answer_cand = sample['annotations'][0]['long_answer']['candidate_index']\n\n if long_answer_cand != -1:\n # answer_cand保证top_level是true\n if sample['long_answer_candidates'][long_answer_cand]['top_level'] is False:\n gt_start_token = sample['long_answer_candidates'][long_answer_cand]['start_token']\n gt_end_token = sample['long_answer_candidates'][long_answer_cand]['end_token']\n for il, cand in enumerate(sample['long_answer_candidates']):\n if cand['start_token'] <= gt_start_token and cand['end_token'] >= gt_end_token \\\n and cand['top_level'] is True:\n long_answer_cand = il\n break\n # training的时候当tfidf中没有包含正确答案，且long_answer是存在的时候，tfidf的结果则只选目标段落\n hit_answer = False\n for pids in tfidf_cands_ids:\n if long_answer_cand in pids:\n hit_answer = True\n break\n if hit_answer is False:\n tfidf_cands_ids = [[]]\n token_count = 0\n for ic, cand in enumerate(sample['long_answer_candidates']):\n if cand['top_level'] is True:\n tfidf_cands_ids[-1].append(ic)\n token_count += (cand['end_token'] - cand['start_token'])\n if token_count > 600:\n tfidf_cands_ids.append([])\n token_count = 0\n while len(tfidf_cands_ids[-1]) == 0:\n tfidf_cands_ids.pop(-1)\n # 防止负样本爆炸，只选目标段落\n tfidf_cands_ids = [cands for cands in tfidf_cands_ids if long_answer_cand in cands]\n\n # 由于接下来要对special_tokens排序，所以这里tfidf选择的段落要按照首段排序\n tfidf_cands_ids = sorted(tfidf_cands_ids, key=lambda x: x[0])\n\n if args.do_combine: # 如果do_combine，我们把所有抽取的candidates合并到一起\n tfidf_cands_ids_ = []\n for c in tfidf_cands_ids:\n tfidf_cands_ids_.extend(c)\n tfidf_cands_ids = [tfidf_cands_ids_]\n\n # 获取candidate的type信息，去除HTML符号\n # 保留特殊token到段首\n # 注意table paragraph list最小起步是1\n special_tokens_count = {'ContextId': -1, 'Table': 0, 'Paragraph': 0, 'List': 0}\n\n # 为了保证一致性，TABLE, Paragraph等结构信息还是尽可能保留...\n selected_ps = []\n for i, cand_ids in enumerate(tfidf_cands_ids):\n position_map = [] # 新paragraph到老paragraph的token位置映射\n map_to_origin = {} # 为了保证能够对答案位置进行正确的偏移，这里需要重新搞一波map映射\n p_tokens = []\n for cand_id in cand_ids:\n st = sample['long_answer_candidates'][cand_id]['start_token']\n ed = sample['long_answer_candidates'][cand_id]['end_token']\n ind = st # 追踪pos_map\n ori_cand_tokens = ori_doc_tokens[st:ed]\n # 先加ContextId特殊token\n special_tokens_count['ContextId'] += 1\n special_tokens_count['ContextId'] = min(special_tokens_count['ContextId'], args.max_position)\n p_tokens.append('[ContextId={}]'.format(special_tokens_count['ContextId']))\n position_map.append(ind)\n cand_type = get_candidate_type(ori_cand_tokens)\n if cand_type in special_tokens_count:\n special_tokens_count[cand_type] += 1\n special_tokens_count[cand_type] = min(special_tokens_count[cand_type], args.max_position)\n p_tokens.append('[' + cand_type + '=' + str(special_tokens_count[cand_type]) + ']')\n position_map.append(ind)\n for token in ori_cand_tokens:\n if '<' not in token: # 去除HTML符号\n p_tokens.append(token)\n position_map.append(ind)\n map_to_origin[ind] = len(position_map) - 1\n ind += 1\n assert len(position_map) == len(p_tokens)\n\n selected_ps.append({'paragraph_tokens': p_tokens,\n 'question_text': question_text,\n 'position_map': position_map,\n 'map_to_origin': map_to_origin,\n 'example_id': example_id,\n 'paragraph_id': str(example_id) + '_' + str(i),\n 'answer_type': AnswerType['UNKNOWN'],\n 'long_start': -1,\n 'long_end': -1,\n 'short_start': -1,\n 'short_end': -1,\n 'short_answer_text': None})\n\n answer = None\n answer_text = None\n if is_training and 'annotations' in sample:\n # 答案只取第一个标注\n annotation = sample['annotations'][0]\n if annotation is not None:\n long_answer = annotation['long_answer']\n if long_answer['candidate_index'] != -1:\n answer_type = AnswerType['LONG']\n ori_long_start = long_answer['start_token']\n ori_long_end = long_answer['end_token']\n else:\n answer_type = AnswerType['UNKNOWN']\n ori_long_start = -1\n ori_long_end = -1\n\n assert annotation[\"yes_no_answer\"] in (\"YES\", \"NO\", \"NONE\")\n if annotation[\"yes_no_answer\"] == 'YES':\n answer_text = 'YES'\n answer_type = AnswerType['YES']\n elif annotation[\"yes_no_answer\"] == 'NO':\n answer_text = 'NO'\n answer_type = AnswerType['NO']\n\n short_answers = annotation['short_answers']\n # 这里short answer必须排序\n short_answers = sorted(short_answers, key=lambda x: x['start_token'])\n if len(short_answers) > 0:\n # TODO:可能存在多个short，multi-tag\n answer_type = AnswerType['SHORT']\n short_ans = random.choice(short_answers)\n ori_short_start = short_ans['start_token']\n ori_short_end = short_ans['end_token']\n answer_text = ori_doc_tokens[ori_short_start:ori_short_end]\n answer_text = \" \".join([at for at in answer_text if '<' not in at])\n else:\n ori_short_start = -1\n ori_short_end = -1\n else:\n answer_type = AnswerType['UNKNOWN']\n ori_long_start = -1\n ori_long_end = -1\n ori_short_start = -1\n ori_short_end = -1\n\n answer = {'answer_type': answer_type,\n 'ori_long_start': ori_long_start,\n 'ori_long_end': ori_long_end,\n 'ori_short_start': ori_short_start,\n 'ori_short_end': ori_short_end}\n\n if answer['answer_type'] == AnswerType['SHORT'] and answer_text == \"\":\n print('WRONG SHORT', answer, answer_text)\n answer['answer_type'] = AnswerType['LONG']\n answer['ori_short_start'] = -1\n answer['ori_short_end'] = -1\n\n examples = []\n for p_sample in selected_ps:\n if answer and answer['answer_type'] != AnswerType['UNKNOWN']:\n # 如果长答案在候选里，那么首位必然都在这个候选里，!!!注意这里的ori_long_end必须-1，否则可能会漏!!!\n if answer['ori_long_start'] in p_sample['map_to_origin'] \\\n and answer['ori_long_end'] - 1 in p_sample['map_to_origin']:\n final_long_start = p_sample['map_to_origin'][answer['ori_long_start']]\n final_long_end = p_sample['map_to_origin'][answer['ori_long_end'] - 1] + 1\n long_answer_text = \" \".join(p_sample['paragraph_tokens'][final_long_start:final_long_end])\n\n p_sample['answer_type'] = answer['answer_type']\n p_sample['long_start'] = final_long_start\n p_sample['long_end'] = final_long_end\n\n # 短答案必然在长答案所在段落里面\n if answer['answer_type'] == AnswerType['SHORT']:\n final_short_start = p_sample['map_to_origin'][answer['ori_short_start']]\n final_short_end = p_sample['map_to_origin'][answer['ori_short_end'] - 1] + 1\n p_sample['short_start'] = final_short_start\n p_sample['short_end'] = final_short_end\n\n new_answer_text = \" \".join(p_sample['paragraph_tokens'][final_short_start:final_short_end])\n assert new_answer_text == answer_text, (new_answer_text, answer_text, long_answer_text)\n p_sample['short_answer_text'] = new_answer_text\n\n # 由于negative的段落太多了，所以这里先过滤掉一部分\n elif is_training and random.random() > args.example_neg_filter:\n continue\n\n # 由于negative的段落太多了，所以这里先过滤掉一部分\n elif is_training and random.random() > args.example_neg_filter:\n continue\n\n p_sample.pop('map_to_origin')\n examples.append(p_sample)\n\n return examples","def gen_yes_no_markup() -> ReplyKeyboardMarkup:\n\n return yes_no_markup","def demonstration_examples(kind):\n\n DIR = './data/demos/'\n RNN_DEMO = \"-demo_rnn_examples\"\n EXT = '.pkl'\n\n if kind == 'rnn':\n return pd.read_pickle(DIR+RNN_DEMO+EXT)","def label_notes(all_notes_lines):\n# nf = nemo.core.NeuralModuleFactory(backend=nemo.core.Backend.PyTorch, log_dir=None)\n #note_line_queries = notes.split('\\n')\n #note_line_queries = ['pt arrived obtunded not answering questions responding to voice and sternal rub speaking in garbled voice pupils unequal left 3mm and right 2mm brisk bilaterally trauma sicu MD aware currently recieving keppra IV finished dilantin gtt due for level at 08a EEG today LSCTA on 3LNC sats 100 % SBP 90 s to 100 s HR NSR no ectopy 60 s NS @ 75cc continuous +BS no stools rec d lactulose at OSH to recieve PR q4h abd soft non-tender non-distended foley in place draining adequate amt clear yellow urine skin intact left 20G x2 WNL wife Name NI']\n\n# labels_dict = get_vocab(LABELS_DICT)\n# pretrained_bert_model = nemo_nlp.nm.trainables.get_huggingface_model(\n# bert_config=BERT_CONFIG, pretrained_model_name=PRETRAINED_MODEL_NAME\n# )\n\n# tokenizer = nemo.collections.nlp.data.tokenizers.get_tokenizer(\n# tokenizer_name=TOKENIZER,\n# pretrained_model_name=PRETRAINED_MODEL_NAME,\n# tokenizer_model=TOKENIZER_MODEL,\n# )\n# hidden_size = pretrained_bert_model.hidden_size\n\n load_datalayer_begin_time = time.time()\n data_layer = nemo_nlp.nm.data_layers.BertTokenClassificationInferDataLayer(\n queries=all_notes_lines, tokenizer=tokenizer, max_seq_length=MAX_SEQ_LENGTH, batch_size=2000\n )\n load_datalayer_end_time = time.time()\n\n classifier = TokenClassifier(hidden_size=hidden_size, num_classes=len(labels_dict))\n\n input_ids, input_type_ids, input_mask, _, subtokens_mask = data_layer()\n \n load_hidden_states_begin_time = time.time()\n hidden_states = pretrained_bert_model(input_ids=input_ids, token_type_ids=input_type_ids, attention_mask=input_mask)\n load_hidden_states_end_time = time.time()\n load_logits_begin_time = time.time()\n logits = classifier(hidden_states=hidden_states)\n load_logits_end_time = time.time()\n\n ###########################################################################\n\n # Instantiate an optimizer to perform `infer` action\n infer_begin_time = time.time()\n evaluated_tensors = nf.infer(tensors=[logits, subtokens_mask], checkpoint_dir=CHECKPOINT_DIR)\n infer_end_time = time.time()\n\n logits, subtokens_mask = [concatenate(tensors) for tensors in evaluated_tensors]\n\n preds = np.argmax(logits, axis=2) \n all_notes_labeled_lines = []\n\n for i, query in enumerate(all_notes_lines):\n logging.info(f'Query: {query}')\n\n pred = preds[i][subtokens_mask[i] > 0.5]\n words = query.strip().split()\n\n #replaced with logic below instead of raising an error:\n '''\n if len(pred) != len(words):\n logging.info('Preds length: ' + str(len(preds[i])))\n logging.info('subtokens_mask length: ' + str(len(subtokens_mask[i])))\n logging.info('Pred length: ' + str(len(pred)))\n logging.info('words length: ' + str(len(words)))\n logging.info('Preds: ' + str(preds.tolist()))\n logging.info('subtokens_mask: ' + str(subtokens_mask[i]))\n logging.info('Pred:' + str(pred.tolist()))\n logging.info('words:' + str(words))\n\n labeled_note = '__Prediction/Word Mismatch__ pred length: ' + str(len(pred)) + ', words length: ' + str(len(words))\n break\n #raise ValueError('Pred and words must be of the same length')\n \n output = ''\n for j, w in enumerate(words):\n output += w\n label = labels_dict[pred[j]]\n if label != NONE_LABEL:\n label = add_brackets(label)\n output += label\n output += ' '\n labeled_note += '\\n' + output.strip()\n logging.info(f'Combined: {output.strip()}')\n\n '''\n\n if len(pred) == len(words):\n output = ''\n for j, w in enumerate(words):\n output += w\n label = labels_dict[pred[j]]\n if label != NONE_LABEL:\n label = add_brackets(label)\n output += label\n output += ' '\n all_notes_labeled_lines.append(output.strip())\n logging.info(f'Combined: {output.strip()}')\n else:\n all_notes_labeled_lines.append(query)\n pred_length = str(len(pred))\n word_length = str(len(words))\n logging.info(f'__Prediction/Word Length Mismatch__ pred length: {pred_length}, words length: {word_length}')\n logging.info(f'{query}')\n \n\n print(str(load_datalayer_end_time-load_datalayer_begin_time)+' seconds to load the datalayer')\n print(str(load_hidden_states_end_time-load_hidden_states_begin_time)+' seconds to load hidden states')\n print(str(load_logits_end_time-load_logits_begin_time)+' seconds to load logits')\n print(str(infer_end_time-infer_begin_time)+' seconds to run inference')\n\n return all_notes_labeled_lines","def verify_startwith_rule2(self, type_tagged, type = None):\n featuresets = []\n for t, question_tag in type_tagged:\n if t in type:\n featuresets.append([self.startwith_feture2(question_tag),t])\n else:\n featuresets.append([self.startwith_feture2(question_tag),'other'])\n print(featuresets)\n perc = 0.5\n train_set, test_set = featuresets[:int(len(featuresets)*perc)], featuresets[int(len(featuresets)*perc):]\n classifier = nltk.NaiveBayesClassifier.train(train_set)\n print(\"Accurancy \")\n print(nltk.classify.accuracy(classifier, test_set))\n classifier.show_most_informative_features(10)","async def test_input_boolean(client, input_boolean_entities) -> None:\n body = await generate_latest_metrics(client)\n\n assert (\n 'input_boolean_state{domain=\"input_boolean\",'\n 'entity=\"input_boolean.test\",'\n 'friendly_name=\"Test\"} 1.0' in body\n )\n\n assert (\n 'input_boolean_state{domain=\"input_boolean\",'\n 'entity=\"input_boolean.helper\",'\n 'friendly_name=\"Helper\"} 0.0' in body\n )","def _process_examples(self):\n logger = getLogger(\"problog_lfi\")\n # value can be True / False / None\n # ( atom ), ( ( value, ... ), ... )\n\n # Simple implementation: don't add neutral evidence.\n\n # ad_groups is a list of lists where each list contains an AD\n ad_groups = list()\n for ad in self._adatoms:\n # if it's an AD group\n if len(ad[1]) > 1:\n ad_list = []\n for var in ad[1]:\n ad_list.append(Term(self.names[var].functor, *self.names[var].args))\n ad_groups.append(tuple(ad_list))\n logger.debug(\"AD Groups\\t\\t:\" + str(ad_groups))\n\n def all_false(d):\n \"\"\"\n This function recognizes inconsistent evidence s.t. all values are False in AD.\n :param d: dictionary of ADs in form {term: value}\n value can be True, False, None, \"Template\"\n :return: whether all values are False\n \"\"\"\n # false_count should be the same as the length of d\n false_count = sum(v is False for v in d.values())\n return false_count == len(d)\n\n def all_false_except_one(d):\n \"\"\"\n This function recognizes incomplete evidence s.t.\n the non-False value in AD needs to be set to True.\n :param d: dictionary of ADs in form {term: value}\n value can be True, False, None, \"Template\"\n :return: whether all values except one are False\n \"\"\"\n false_count = sum(v is False for v in d.values())\n the_left_is_none = bool(sum(v is None for v in d.values()))\n return (false_count == len(d) - 1) and the_left_is_none\n\n def getADtemplate(d, atom=None):\n \"\"\"\n This function gets atom's complement AD template.\n This should only be used when the AD contains non-ground terms.\n :param d: dictionary of ADs in form {term: value}\n value can be True, False, None, \"Template\"\n :param atom: an evidence\n :return: atom's complement AD template\n \"\"\"\n if atom is not None:\n temp_dict = {\n k: v\n for k, v in d.items()\n if v == \"Template\" and atom.signature != k.signature\n }\n return temp_dict\n else:\n temp_dict = {k: v for k, v in d.items() if v == \"Template\"}\n return temp_dict\n\n def add_to_ad_evidence(pair, l, ADtemplate):\n \"\"\"\n :param pair: a new pair of (atom, value)\n :param l: a list of dictionaries, all dictionaries need to have the same format\n :return:\n \"\"\"\n (k, v) = pair\n # if entry k exists, update the value with k\n for d in l:\n if k in d:\n d[k] = v\n return\n # if entry k does not exist, create a new dictionary from template\n # and instantiate it with k\n new_d = dict()\n for temp_k in ADtemplate.keys():\n new_key = Term(temp_k.functor, *k.args)\n new_d[new_key] = None\n # put v in there\n new_d[k] = v\n l.append(new_d)\n\n if self.infer_AD_values:\n result = ExampleSet()\n inconsistent = False\n # iterate over all examples given in .ev\n for index, example in enumerate(self.examples):\n ad_evidences = []\n non_ad_evidence = {}\n for ad_group in ad_groups:\n # create a dictionary to memorize what evidence is given in AD\n d = dict()\n # TODO: what if the AD contains both ground and non-ground????\n # e.g. t(_)::a; t(_)::b(X)\n for var in ad_group:\n if var.is_ground():\n d[var] = None # for ground unknown evidence\n else:\n d[var] = \"Template\" # for unground unknown evidence\n ad_evidences.append(d)\n\n # add all evidence in the example to ad_evidences\n for atom, value in example:\n # if atom has a tunable probability to learn\n if any([atom.signature == name.signature for name in self.names]):\n if len(atom.args) == 0: # Propositional evidence\n # insert evidence\n is_ad = False\n for d in ad_evidences:\n if atom in d:\n d[atom] = value\n is_ad = True\n if not is_ad:\n non_ad_evidence[\n atom\n ] = value\n else: # First Order evidence\n # find the right AD dictionary : AD_dict\n AD_dict = None\n for d in ad_evidences:\n if any([atom.signature == k.signature for k in d]):\n AD_dict = d\n # if the instantiation is new, add it as a key to the dictionary\n if AD_dict and AD_dict.get(atom) is None:\n AD_dict[atom] = value\n # also add other AD parts in the dictionary with value==None\n other_ADs = getADtemplate(AD_dict, atom)\n for otherAD in other_ADs.keys():\n new_key = Term(otherAD.functor, *atom.args)\n AD_dict[new_key] = AD_dict.get(new_key, None)\n else:\n non_ad_evidence[atom] = value\n else:\n non_ad_evidence[atom] = value\n\n # grounded_ad_evidences contains all usable evidence (gound, not template)\n grounded_ad_evidences = []\n for d in ad_evidences:\n # for first order evidence dictionaries\n if \"Template\" in d.values():\n # new_ad_evidence is a list of dictionaries\n # each dictionary is a group of the AD template instantiation\n new_ad_evidence = list()\n # get template AD evidence\n ADtemplate = getADtemplate(d)\n # group all pairs according to ADtemplate\n for k, v in d.items():\n if v != \"Template\":\n add_to_ad_evidence((k, v), new_ad_evidence, ADtemplate)\n grounded_ad_evidences += new_ad_evidence\n else:\n # simply us them\n grounded_ad_evidences.append(d)\n\n inconsistent_example = False\n for i, d in enumerate(grounded_ad_evidences):\n # inconsistent1 = multiple_true(d)\n inconsistent2 = all_false(d)\n add_compliment = all_false_except_one(d)\n\n if inconsistent2:\n inconsistent_example = True\n continue\n elif add_compliment:\n for key, value in d.items():\n if value is None:\n grounded_ad_evidences[i][key] = True\n\n if not inconsistent_example and len(grounded_ad_evidences) > 0:\n # There are (fully tunable) ADs in the program\n evidence_list = []\n for d in grounded_ad_evidences:\n for key, value in d.items():\n if value is not None:\n if (key, value) not in evidence_list:\n # TODO: Switch to orderedSet so we don't have to check whether it's in already\n evidence_list.append((key, value))\n\n for key, value in non_ad_evidence.items():\n evidence_list.append((key, value))\n\n atoms, values = zip(*evidence_list)\n result.add(index, atoms, values)\n\n else:\n # (No AD case) or (Inconsistent Evidence Case)\n atoms, values = zip(*example)\n result.add(index, atoms, values)\n return result\n else:\n # smarter: compile-once all examples with same atoms\n result = ExampleSet()\n for index, example in enumerate(self.examples):\n atoms, values = zip(*example)\n result.add(index, atoms, values)\n return result","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n\n label_map = {label: i for i, label in enumerate(label_list)}\n tokens_a_longer_max_seq_length = 0\n features = []\n for (ex_index, example) in enumerate(examples):\n tokens_a = tokenizer.tokenize(example.text_a)\n tokens_b = None\n\n len_tokens_a = len(tokens_a)\n len_tokens_b = 0\n\n\n\n if example.text_b:\n tokens_b = tokenizer.tokenize(example.text_b)\n len_tokens_b = len(tokens_b)\n # Modifies `tokens_a` and `tokens_b` in place so that the total\n # length is less than the specified length.\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n # Account for [CLS] and [SEP] with \"- 2\"\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[:(max_seq_length - 2)]\n\n if (len_tokens_a + len_tokens_b) > (max_seq_length - 2):\n tokens_a_longer_max_seq_length += 1\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambigiously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as as the \"sentence vector\". Note that this only makes sense because\n # the entire model is fine-tuned.\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n segment_ids = [0] * len(tokens)\n\n if tokens_b:\n tokens += tokens_b + [\"[SEP]\"]\n segment_ids += [1] * (len(tokens_b) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\n assert len(input_ids)==max_seq_length\n assert len(input_mask)==max_seq_length\n assert len(segment_ids)==max_seq_length\n\n label_id = label_map[example.label]\n if ex_index < 1 and example.guid is not None and example.guid.startswith('train'):\n logger.info(\"\\n\\n*** Example ***\")\n logger.info(\"guid: %s\" % (example.guid))\n logger.info(\"tokens: %s\" % \" \".join(\n [str(x) for x in tokens]))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n logger.info(\n \"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n logger.info(\"label: %s (id = %d)\" % (example.label, label_id))\n logger.info(\"\\n\\n\")\n\n features.append(\n InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_id=label_id))\n\n logger.info(\":: Sentences longer than max_sequence_length: %d\" % (tokens_a_longer_max_seq_length))\n logger.info(\":: Num sentences: %d\" % (len(examples)))\n return features","def bool_fix(name_dates, candidate_json, yes_no_key):\n for candidate in name_dates:\n for key in yes_no_key:\n test = str(candidate_json[candidate][key].strip())\n if test == 'Yes' or test == 'yes' or test == 'Y' or test == 'y':\n candidate_json[candidate][key] = True\n elif test == 'No' or test == 'no' or test == 'N' or test == 'n':\n candidate_json[candidate][key] = False\n else:\n # returns incorrect data for error exploration\n print(test)\n return candidate_json","def np_example_to_features(np_example: FeatureDict,\n config: ml_collections.ConfigDict,\n random_seed: int = 0) -> FeatureDict:\n np_example = dict(np_example)\n num_res = int(np_example['seq_length'][0])\n cfg, feature_names = make_data_config(config, num_res=num_res)\n\n if 'deletion_matrix_int' in np_example:\n np_example['deletion_matrix'] = (\n np_example.pop('deletion_matrix_int').astype(np.float32))\n\n if USE_TF:\n tf_graph = tf.Graph()\n with tf_graph.as_default(), tf.device('/device:CPU:0'):\n tf.compat.v1.set_random_seed(random_seed)\n tensor_dict = proteins_dataset.np_to_tensor_dict(\n np_example=np_example, features=feature_names)\n\n processed_batch = input_pipeline.process_tensors_from_config(\n tensor_dict, cfg)\n\n tf_graph.finalize()\n\n with tf.Session(graph=tf_graph) as sess:\n features = sess.run(processed_batch)\n\n else:\n array_dict = input_pipeline.np_to_array_dict(\n np_example=np_example,\n features=feature_names,\n use_templates=cfg.common.use_templates)\n features = input_pipeline.process_arrays_from_config(array_dict, cfg)\n features = {k: v for k, v in features.items() if v.dtype != 'O'}\n\n extra_msa_length = cfg.common.max_extra_msa\n for k in ['extra_msa', 'extra_has_deletion', 'extra_deletion_value',\n 'extra_msa_mask']:\n features[k] = features[k][:, :extra_msa_length]\n\n for k in features.keys():\n if features[k].dtype == np.int64:\n features[k] = features[k].astype(np.int32)\n elif features[k].dtype == np.float64:\n features[k] = features[k].astype(np.float32)\n\n return features","def test_ann_features():\n CQT(file_struct, FeatureTypes.ann_beatsync, sr=11025).features","def read_marco_examples(input_file, is_training):\n with open(input_file, \"r\") as reader:\n source = json.load(reader)\n\n def is_whitespace(c):\n if c == \" \" or c == \"\\t\" or c == \"\\r\" or c == \"\\n\" or ord(c) == 0x202F:\n return True\n return False\n\n \n def is_alphabet(char):\n if (char >= '\\u0041' and char <= '\\u005a') or (char >= '\\u0061' and char <= '\\u007a'):\n return True\n return False\n def is_number(char):\n if char >= '\\u0030' and char <= '\\u0039':\n return True\n return False\n def is_other(uchar):\n if not (is_number(uchar) or is_alphabet(uchar)):\n return True\n return False\n\n \n def z_tokenize(text):\n doc_tokens = []\n char_to_word_offset = []\n\n # pas2tokens\n prev_is_whitespace = True\n for c in text:\n if is_whitespace(c):\n prev_is_whitespace = True\n else:\n if prev_is_whitespace or (doc_tokens[-1][-1] == '.' and not is_number(c)):\n doc_tokens.append(c)\n else:\n doc_tokens[-1] += c\n prev_is_whitespace = False\n char_to_word_offset.append(len(doc_tokens) - 1)\n char_to_word_offset.append(len(doc_tokens))\n\n return doc_tokens, char_to_word_offset\n\n query_ids = source['query_id']\n queries = source['query']\n passages = source['passages']\n answers = source.get('answers', {})\n\n examples = []\n for qid in query_ids:\n passage = passages[qid]\n query = queries[qid]\n answer = answers.get(qid)\n\n if is_training:\n if answer is None or answer[0] == 'No Answer Present.':\n continue\n\n for ans in answer[0:1]:\n if len(ans) == 0:\n continue\n\n \n is_match = False\n for ind, pas in enumerate(passage[:10]):\n paragraph_text = pas['passage_text']\n pos = paragraph_text.find(ans)\n if pos >= 0:\n is_match = True\n if not is_match:\n continue\n \n for ind, pas in enumerate(passage[:10]):\n paragraph_text = pas['passage_text']\n doc_tokens, char_to_word_offset = z_tokenize(paragraph_text)\n if pas.get('is_selected', False):\n is_select = 1.0\n else:\n is_select = 0.0\n pos = paragraph_text.find(ans)\n if pos >= 0:\n start = char_to_word_offset[pos]\n end = char_to_word_offset[pos+len(ans)]\n ans_text = ans\n has_answer = 1.0\n else:\n start = 0\n end = 0\n ans_text = ans\n has_answer = 0.0\n\n example = MarcoExample(\n qas_id=qid,\n question_text=query,\n doc_tokens=doc_tokens,\n orig_answer_text=ans_text,\n start_position=start,\n end_position=end,\n is_select=is_select,\n has_answer = has_answer)\n examples.append(example)\n if ind < 9:\n for idx in range(ind+1, 10):\n examples.append(example)\n else:\n if answer[0] == 'No Answer Present.':\n continue\n \n for ans in answer[0:1]:\n is_match = False\n for ind, pas in enumerate(passage[:10]):\n paragraph_text = pas['passage_text']\n pos = paragraph_text.find(ans)\n if pos >= 0:\n is_match = True\n \n start = None\n end = None\n ans_text = None\n if not is_match:\n ans_text = ''\n\n for ind, pas in enumerate(passage[:10]):\n paragraph_text = pas['passage_text']\n doc_tokens, char_to_word_offset = z_tokenize(paragraph_text)\n if pas.get('is_selected', False):\n is_select = 1.0\n else:\n is_select = 0.0\n pos = paragraph_text.find(ans)\n if pos >= 0:\n has_answer = 1.0\n else:\n has_answer = 0.0\n\n example = MarcoExample(\n qas_id=qid,\n question_text=query,\n doc_tokens=doc_tokens,\n orig_answer_text=ans_text,\n start_position=start,\n end_position=end,\n is_select=is_select,\n has_answer = has_answer)\n examples.append(example)\n if ind < 9:\n for idx in range(ind+1, 10):\n examples.append(example)\n\n return examples","def yes(func):\n return MultipleChoice(_text_from_func(func), Answer('yes'), Answer('no'), is_code=True)","def convert_example_to_features_test(example, cur_time, max_seq_length, tokenizer):\n tokens_a = example\n # Modifies `tokens_a` and `tokens_b` in place so that the total\n # length is less than the specified length.\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n\n\n\n\n tokens_a = truncate_seq_pair_test(tokens_a, max_seq_length - 3)\n\n\n\n\n savedtoken = []\n for l in range(5):\n if tokens_a[-1] in {\".\", \",\", \"'\", \"`\" , \"'\", \"?\"}:\n savedtoken.insert(0, tokens_a[-1])\n tokens_a.pop()\n\n else:\n break\n\n\n lmlabel = tokens_a[-1]\n lmlabel = tokenizer.vocab[lmlabel]\n tokens_a.pop()\n\n\n # concatenate lm labels and account for CLS, SEP, SEP\n if not savedtoken:\n extra_lm_labels = 1\n else:\n extra_lm_labels = len(savedtoken)\n\n lm_label_ids = ([-1] + len(tokens_a)*[-1] + [lmlabel] + extra_lm_labels * [-1] + [-1])\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambigiously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as as the \"sentence vector\". Note that this only makes sense because\n # the entire model is fine-tuned.\n tokens = []\n segment_ids = []\n tokens.append(\"[CLS]\")\n segment_ids.append(0)\n\n\n\n\n for token in tokens_a:\n tokens.append(token)\n segment_ids.append(0)\n\n tokens.append(\"[MASK]\")\n if not savedtoken:\n tokens.append(\".\")\n segment_ids.append(0)\n else:\n tokens.extend(savedtoken)\n for _ in range(len(savedtoken)):\n segment_ids.append(0)\n tokens.append(\"[SEP]\")\n\n \n segment_ids.append(0)\n segment_ids.append(0)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n while len(input_ids) < max_seq_length:\n input_ids.append(0)\n input_mask.append(0)\n segment_ids.append(0)\n lm_label_ids.append(-1)\n\n # print(\"input, segment, lmlabel\")\n # print(len(input_ids))\n # print(len(segment_ids))\n # print(len(lm_label_ids))\n if len(input_ids) != max_seq_length:\n import pdb; pdb.set_trace()\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n assert len(lm_label_ids) == max_seq_length\n\n if cur_time < 5:\n logger.info(\"*** Example ***\")\n logger.info(\"cur_time: %s\" % (cur_time))\n logger.info(\"tokens: %s\" % \" \".join(\n [str(x) for x in tokens]))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n logger.info(\n \"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n logger.info(\"LM label: %s \" % (lm_label_ids))\n\n features = InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n lm_label_ids=lm_label_ids,\n )\n return features","def bool_to_word(boolean):\n return 'Yes' if boolean else 'No'","def convert_single_ls_example(example, tokenizer, is_training, args):\n tok_to_orig_index = []\n orig_to_tok_index = []\n all_doc_tokens = [] # all subtokens of original doc after tokenizing\n features = []\n for (i, token) in enumerate(example['paragraph_tokens']):\n orig_to_tok_index.append(len(all_doc_tokens))\n sub_tokens = albert_tokenize(tokenizer, token)\n tok_to_orig_index.extend([i] * len(sub_tokens))\n all_doc_tokens.extend(sub_tokens)\n\n # 特别注意！由于在paragraph_tokens中我们的token已经映射过一次了\n # 这里wordpiece等于又映射了一遍，所以这里的操作是二次映射\n if example['position_map']:\n tok_to_orig_index = [example['position_map'][index] for index in tok_to_orig_index]\n\n # QUERY\n query_tokens = []\n query_tokens.append(\"[Q]\")\n query_tokens.extend(albert_tokenize(tokenizer, example['question_text']))\n if len(query_tokens) > args.max_query_length:\n query_tokens = query_tokens[-args.max_query_length:]\n\n # ANSWER 预处理的时候先长短分开\n tok_long_start_position = -1\n tok_long_end_position = -1\n tok_short_start_position = -1\n tok_short_end_position = -1\n # 这里终点是必然在para_tokens内的\n if is_training:\n if example['answer_type'] != AnswerType['UNKNOWN']:\n tok_long_start_position = orig_to_tok_index[example['long_start']]\n if example['long_end'] == len(orig_to_tok_index):\n tok_long_end_position = orig_to_tok_index[-1]\n else:\n tok_long_end_position = orig_to_tok_index[example['long_end']] - 1\n if example['answer_type'] == AnswerType['SHORT']:\n tok_short_start_position = orig_to_tok_index[example['short_start']]\n if example['short_end'] == len(orig_to_tok_index):\n tok_short_end_position = orig_to_tok_index[-1]\n else:\n tok_short_end_position = orig_to_tok_index[example['short_end']] - 1\n\n # Get max tokens number for original doc,\n # should minus query tokens number and 3 special tokens\n # The -3 accounts for [CLS], [SEP] and [SEP]\n max_tokens_for_doc = args.max_seq_length - len(query_tokens) - 3\n\n # We can have documents that are longer than the maximum sequence length.\n # To deal with this we do a sliding window approach, where we take chunks\n # of up to our max length with a stride of `doc_stride`.\n _DocSpan = collections.namedtuple(\"DocSpan\", [\"start\", \"length\"])\n doc_spans = []\n start_offset = 0\n while start_offset < len(all_doc_tokens):\n length = len(all_doc_tokens) - start_offset # compute number of tokens remaining unsliding\n length = min(length, max_tokens_for_doc) # determine current sliding window size\n doc_spans.append(_DocSpan(start=start_offset, length=length))\n\n # Consider case for reaching end of original doc\n if start_offset + length == len(all_doc_tokens):\n break\n start_offset += min(length, args.doc_stride)\n\n # Convert window + query + special tokens to feature\n for (doc_span_index, doc_span) in enumerate(doc_spans):\n tokens = []\n token_to_orig_map = {}\n token_is_max_context = {}\n segment_ids = []\n tokens.append(\"[CLS]\")\n segment_ids.append(0)\n tokens.extend(query_tokens)\n segment_ids.extend([0] * len(query_tokens))\n tokens.append(\"[SEP]\")\n segment_ids.append(0)\n\n for i in range(doc_span.length):\n split_token_index = doc_span.start + i\n token_to_orig_map[len(tokens)] = tok_to_orig_index[split_token_index]\n\n is_max_context = check_is_max_context(doc_spans, doc_span_index, split_token_index)\n token_is_max_context[len(tokens)] = is_max_context\n tokens.append(all_doc_tokens[split_token_index])\n segment_ids.append(1)\n tokens.append(\"[SEP]\")\n segment_ids.append(1)\n assert len(tokens) == len(segment_ids)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (args.max_seq_length - len(input_ids))\n input_ids.extend(padding)\n input_mask.extend(padding)\n segment_ids.extend(padding)\n\n assert len(input_ids) == args.max_seq_length\n assert len(input_mask) == args.max_seq_length\n assert len(segment_ids) == args.max_seq_length\n\n long_start_position = None\n long_end_position = None\n short_start_position = None\n short_end_position = None\n answer_type = None\n answer_text = \"\"\n if is_training:\n doc_start = doc_span.start\n doc_end = doc_span.start + doc_span.length - 1\n # For training, if our document chunk does not contain an annotation\n # we throw it out, since there is nothing to predict.\n contains_an_annotation = (tok_long_start_position >= doc_start and tok_long_end_position <= doc_end)\n # 负样本需要经过采样，且目标为[CLS]\n if (not contains_an_annotation) or example['answer_type'] == AnswerType['UNKNOWN']:\n if args.include_unknowns < 0 or random.random() > args.include_unknowns:\n continue\n long_start_position = 0\n long_end_position = 0\n short_start_position = 0\n short_end_position = 0\n answer_type = AnswerType['UNKNOWN']\n else:\n doc_offset = len(query_tokens) + 2\n long_start_position = tok_long_start_position - doc_start + doc_offset\n long_end_position = tok_long_end_position - doc_start + doc_offset\n if example['answer_type'] == AnswerType['SHORT']:\n short_start_position = tok_short_start_position - doc_start + doc_offset\n short_end_position = tok_short_end_position - doc_start + doc_offset\n else:\n short_start_position = 0\n short_end_position = 0\n answer_type = example['answer_type']\n\n # 如果是短答案，对一下答案是否正确\n if example['answer_type'] == AnswerType['SHORT']:\n answer_text = \" \".join(tokens[short_start_position:(short_end_position + 1)])\n answer_text = answer_text.replace(' ', '').replace(u\"▁\", ' ').strip()\n gt_answer = example['short_answer_text'].lower()\n answer_text_chars = [c for c in answer_text if c not in \" \\t\\r\\n\" and ord(c) != 0x202F]\n gt_answer_chars = [c for c in gt_answer if c not in \" \\t\\r\\n\" and ord(c) != 0x202F]\n if \"\".join(answer_text_chars) != \"\".join(gt_answer_chars) \\\n and len(\"\".join(answer_text_chars)) != len(\"\".join(gt_answer_chars)):\n print(answer_text, 'V.S.', gt_answer)\n\n feature = InputLSFeatures(\n unique_id=None,\n example_index=None,\n doc_span_index=doc_span_index,\n tokens=tokens,\n token_to_orig_map=token_to_orig_map,\n token_is_max_context=token_is_max_context,\n input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n long_start_position=long_start_position,\n long_end_position=long_end_position,\n short_start_position=short_start_position,\n short_end_position=short_end_position,\n answer_text=answer_text,\n answer_type=answer_type)\n\n features.append(feature)\n\n return features","def yes():\r\n global CurrentState\r\n global CurrentInput\r\n global RESPONSEOPTIONS\r\n state = RESPONSEOPTIONS[0]\r\n # print(\"state under update:\",state)\r\n state.updateStateIncoming(CurrentState.id)\r\n state.updateStateWords(CurrentInput)\r\n # print(\"writing state:\",state)\r\n writeState(state)\r\n CurrentState = getState(state.id)","def convert_examples_to_features(self):\n features = []\n for ex_index, example in enumerate(self.examples):\n if ex_index % 10000 == 0:\n logging.info(f\"Writing example {ex_index} of {len(self.examples)}\")\n\n text_to_text_query = self.processor.get_t5_prompted_query(example.text_a, example.text_b)\n enc_query = self.tokenizer.text_to_ids(text_to_text_query)\n if len(enc_query) > self.max_seq_length:\n enc_query = enc_query[: self.max_seq_length]\n dec_query = (\n [self.tokenizer.bos_id]\n + self.tokenizer.text_to_ids(self.processor.label2string(example.label))\n + [self.tokenizer.eos_id]\n )\n\n dec_input = dec_query[:-1]\n labels = dec_query[1:]\n\n features.append([enc_query, dec_input, labels])\n\n return features","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n\n label_map = {label : i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n tokens = example.text\n\n# # Account for [CLS] and [SEP] with \"- 2\"\n# if len(tokens) > max_seq_length - 2:\n# tokens = tokens[:(max_seq_length - 2)]\n\n bert_tokens = []\n orig_to_tok_map = []\n\n bert_tokens.append(\"[CLS]\")\n for token in tokens:\n new_tokens = tokenizer.tokenize(token)\n if len(bert_tokens) + len(new_tokens) > max_seq_length - 1:\n # print(\"You shouldn't see this since the test set is already pre-separated.\")\n break\n else:\n orig_to_tok_map.append(len(bert_tokens))\n bert_tokens.extend(new_tokens)\n bert_tokens.append(\"[SEP]\")\n\n if len(bert_tokens) == 2: # edge case\n continue\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambigiously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as as the \"sentence vector\". Note that this only makes sense because\n # the entire model is fine-tuned.\n\n input_ids = tokenizer.convert_tokens_to_ids(bert_tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n\n segment_ids = [0] * max_seq_length # no use for our problem\n\n labels = example.label\n label_ids = [0] * max_seq_length\n label_mask = [0] * max_seq_length\n\n for label, target_index in zip(labels, orig_to_tok_map):\n label_ids[target_index] = label_map[label]\n label_mask[target_index] = 1\n\n assert len(segment_ids) == max_seq_length\n assert len(label_ids) == max_seq_length\n assert len(label_mask) == max_seq_length\n\n features.append(\n InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_ids=label_ids,\n label_mask=label_mask))\n return features","def to_features(self):\n to_return = dict()\n\n to_return['bias'] = 1.0\n to_return['user:' + self.user] = 1.0\n to_return['format:' + self.format] = 1.0\n to_return['token:' + self.token.lower()] = 1.0\n\n to_return['part_of_speech:' + self.part_of_speech] = 1.0\n for morphological_feature in self.morphological_features:\n to_return['morphological_feature:' + morphological_feature] = 1.0\n to_return['dependency_label:' + self.dependency_label] = 1.0\n\n return to_return","def put_yes_no(root, var, labels, flag):\n yesfield = Tk.Radiobutton(root, text=labels[0], variable=var, value=1)\n yesfield.grid(row=0, column=0, sticky=Tk.W)\n yesfield.config(bg=BGCOL)\n nofield = Tk.Radiobutton(root, text=labels[1], variable=var, value=0)\n nofield.grid(row=0, column=1, sticky=Tk.W)\n nofield.config(bg=BGCOL)\n if flag:\n yesfield.select()\n else:\n nofield.select()","def boolean_func(experiment):","def parse_features(self, skip=...):\n ...","def parse_features(self, skip=...):\n ...","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n\n # label_map = {label : i for i, label in enumerate(label_list)}\n\n features = []\n exindex = {}\n passagelens = []\n\n sum_of_labels = 0\n\n for (ex_index, example) in tqdm(enumerate(examples), desc=\"Tokenizing:\"):\n if example.text_a not in tokenmap.keys():\n tokens_a = tokenizer.tokenize(example.text_a)\n tokenmap[example.text_a] = tokens_a\n else:\n tokens_a = tokenmap[example.text_a]\n\n tokens_b = None\n if example.text_b:\n if example.text_b not in tokenmap.keys():\n tokens_b = tokenizer.tokenize(example.text_b)\n tokenmap[example.text_b] = tokens_b\n else:\n tokens_b = tokenmap[example.text_b]\n # Modifies `tokens_a` and `tokens_b` in place so that the total\n # length is less than the specified length.\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n\n passagelens.append(len(tokens_a) + len(tokens_b) + 3)\n\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n # Account for [CLS] and [SEP] with \"- 2\"\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[:(max_seq_length - 2)]\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambigiously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as as the \"sentence vector\". Note that this only makes sense because\n # the entire model is fine-tuned.\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n segment_ids = [0] * len(tokens)\n\n if tokens_b:\n tokens += tokens_b + [\"[SEP]\"]\n segment_ids += [1] * (len(tokens_b) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n\n # label_id = label_map[example.label]\n label_id = example.label\n\n sum_of_labels += label_id\n\n if ex_index < 5:\n logger.info(\"*** Example ***\")\n logger.info(\"guid: %s\" % (example.guid))\n logger.info(\"tokens: %s\" % \" \".join(\n [str(x) for x in tokens]))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n logger.info(\n \"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n logger.info(\"label: %s (id = %d)\" % (str(example.label), 0))\n\n exindex[ex_index] = example.guid\n features.append(\n InputFeatures(uuid=ex_index,\n input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_id=label_id))\n\n print(\"Passage Token Lengths Distribution\", passagelens[-1], np.percentile(passagelens, 50),\n np.percentile(passagelens, 90), np.percentile(passagelens, 95), np.percentile(passagelens, 99))\n return features, exindex","def convert_examples_to_features(self, examples, max_seq_length, tokenizer):\n\n features = []\n\n for (ex_index, example) in enumerate(tqdm(examples)):\n\n tokens = tokenizer.tokenize(example.text_a)\n\n gather_ids = list()\n for (idx, token) in enumerate(tokens):\n if (not token.startswith(\"##\") and idx < max_seq_length - 2):\n gather_ids.append(idx + 1)\n\n # Account for [CLS] and [SEP] with \"- 2\"\n if len(tokens) > max_seq_length - 2:\n tokens = tokens[:max_seq_length - 2]\n\n tokens = [\"[CLS]\"] + tokens + [\"[SEP]\"]\n segment_ids = [0] * len(tokens)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\n gather_padding = [0] * (max_seq_length - len(gather_ids))\n gather_masks = [1] * len(gather_ids) + gather_padding\n gather_ids += gather_padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n assert len(gather_ids) == max_seq_length\n assert len(gather_masks) == max_seq_length\n\n partial_masks = self.generate_partial_masks(example.text_a.split(' '), max_seq_length, example.label,\n self.labels)\n\n if ex_index < 2:\n self.logger.info(\"*** Example ***\")\n self.logger.info(\"guid: %s\" % (example.guid))\n self.logger.info(\"tokens: %s\" % \" \".join(\n [str(x) for x in tokens]))\n self.logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n self.logger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n self.logger.info(\n \"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n self.logger.info(\n \"gather_ids: %s\" % \" \".join([str(x) for x in gather_ids]))\n self.logger.info(\n \"gather_masks: %s\" % \" \".join([str(x) for x in gather_masks]))\n # self.logger.info(\"label: %s (id = %s)\" % (example.label, \" \".join([str(x) for x in label_ids])))\n\n features.append(\n InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n partial_masks=partial_masks,\n gather_ids=gather_ids,\n gather_masks=gather_masks))\n\n return features","def test_human_readable_boolean_false():\n # TODO: add a test case that follows the provided example","def convert_single_example(example, tokenizer, is_training, args):\n tok_to_orig_index = []\n orig_to_tok_index = []\n all_doc_tokens = [] # all subtokens of original doc after tokenizing\n features = []\n for (i, token) in enumerate(example['paragraph_tokens']):\n orig_to_tok_index.append(len(all_doc_tokens))\n sub_tokens = albert_tokenize(tokenizer, token)\n tok_to_orig_index.extend([i] * len(sub_tokens))\n all_doc_tokens.extend(sub_tokens)\n\n # 特别注意！由于在paragraph_tokens中我们的token已经映射过一次了\n # 这里wordpiece等于又映射了一遍，所以这里的操作是二次映射\n if example['position_map']:\n tok_to_orig_index = [example['position_map'][index] for index in tok_to_orig_index]\n\n # QUERY\n query_tokens = []\n query_tokens.append(\"[Q]\")\n query_tokens.extend(albert_tokenize(tokenizer, example['question_text']))\n if len(query_tokens) > args.max_query_length:\n query_tokens = query_tokens[-args.max_query_length:]\n\n # ANSWER 预处理的时候先长短分开\n tok_start_position = -1\n tok_end_position = -1\n # 这里终点是必然在para_tokens内的\n if is_training:\n # 现阶段，有短答案预测短答案，否则预测长答案\n if example['answer_type'] != AnswerType['UNKNOWN']:\n tok_long_start_position = orig_to_tok_index[example['long_start']]\n if example['long_end'] == len(orig_to_tok_index):\n tok_long_end_position = orig_to_tok_index[-1]\n else:\n tok_long_end_position = orig_to_tok_index[example['long_end']] - 1\n tok_start_position = tok_long_start_position\n tok_end_position = tok_long_end_position\n if example['answer_type'] == AnswerType['SHORT']:\n tok_short_start_position = orig_to_tok_index[example['short_start']]\n if example['short_end'] == len(orig_to_tok_index):\n tok_short_end_position = orig_to_tok_index[-1]\n else:\n tok_short_end_position = orig_to_tok_index[example['short_end']] - 1\n tok_start_position = tok_short_start_position\n tok_end_position = tok_short_end_position\n\n # Get max tokens number for original doc,\n # should minus query tokens number and 3 special tokens\n # The -3 accounts for [CLS], [SEP] and [SEP]\n max_tokens_for_doc = args.max_seq_length - len(query_tokens) - 3\n\n # We can have documents that are longer than the maximum sequence length.\n # To deal with this we do a sliding window approach, where we take chunks\n # of up to our max length with a stride of `doc_stride`.\n _DocSpan = collections.namedtuple(\"DocSpan\", [\"start\", \"length\"])\n doc_spans = []\n start_offset = 0\n while start_offset < len(all_doc_tokens):\n length = len(all_doc_tokens) - start_offset # compute number of tokens remaining unsliding\n length = min(length, max_tokens_for_doc) # determine current sliding window size\n doc_spans.append(_DocSpan(start=start_offset, length=length))\n\n # Consider case for reaching end of original doc\n if start_offset + length == len(all_doc_tokens):\n break\n start_offset += min(length, args.doc_stride)\n\n # Convert window + query + special tokens to feature\n for (doc_span_index, doc_span) in enumerate(doc_spans):\n tokens = []\n token_to_orig_map = {}\n token_is_max_context = {}\n segment_ids = []\n tokens.append(\"[CLS]\")\n segment_ids.append(0)\n tokens.extend(query_tokens)\n segment_ids.extend([0] * len(query_tokens))\n tokens.append(\"[SEP]\")\n segment_ids.append(0)\n\n for i in range(doc_span.length):\n split_token_index = doc_span.start + i\n token_to_orig_map[len(tokens)] = tok_to_orig_index[split_token_index]\n\n is_max_context = check_is_max_context(doc_spans, doc_span_index, split_token_index)\n token_is_max_context[len(tokens)] = is_max_context\n tokens.append(all_doc_tokens[split_token_index])\n segment_ids.append(1)\n tokens.append(\"[SEP]\")\n segment_ids.append(1)\n assert len(tokens) == len(segment_ids)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (args.max_seq_length - len(input_ids))\n input_ids.extend(padding)\n input_mask.extend(padding)\n segment_ids.extend(padding)\n\n assert len(input_ids) == args.max_seq_length\n assert len(input_mask) == args.max_seq_length\n assert len(segment_ids) == args.max_seq_length\n\n start_position = None\n end_position = None\n answer_type = None\n answer_text = \"\"\n if is_training:\n doc_start = doc_span.start\n doc_end = doc_span.start + doc_span.length - 1\n # For training, if our document chunk does not contain an annotation\n # we throw it out, since there is nothing to predict.\n contains_an_annotation = (tok_start_position >= doc_start and tok_end_position <= doc_end)\n # 负样本需要经过采样，且目标为[CLS]\n if (not contains_an_annotation) or example['answer_type'] == AnswerType['UNKNOWN']:\n if args.include_unknowns < 0 or random.random() > args.include_unknowns:\n continue\n start_position = 0\n end_position = 0\n answer_type = AnswerType['UNKNOWN']\n else:\n doc_offset = len(query_tokens) + 2\n start_position = tok_start_position - doc_start + doc_offset\n end_position = tok_end_position - doc_start + doc_offset\n answer_type = example['answer_type']\n\n # 如果是短答案，对一下答案是否正确\n if example['answer_type'] == AnswerType['SHORT']:\n answer_text = \" \".join(tokens[start_position:(end_position + 1)])\n answer_text = answer_text.replace(' ', '').replace(u\"▁\", ' ').strip()\n gt_answer = example['short_answer_text'].lower()\n answer_text_chars = [c for c in answer_text if c not in \" \\t\\r\\n\" and ord(c) != 0x202F]\n gt_answer_chars = [c for c in gt_answer if c not in \" \\t\\r\\n\" and ord(c) != 0x202F]\n if \"\".join(answer_text_chars) != \"\".join(gt_answer_chars):\n print(answer_text, 'V.S.', gt_answer)\n\n feature = InputFeatures(\n unique_id=None,\n example_index=None,\n doc_span_index=doc_span_index,\n tokens=tokens,\n token_to_orig_map=token_to_orig_map,\n token_is_max_context=token_is_max_context,\n input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n start_position=start_position,\n end_position=end_position,\n answer_text=answer_text,\n answer_type=answer_type)\n\n features.append(feature)\n\n return features","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n\n\tlabel_map = {label : i for i, label in enumerate(label_list)}\n\n\tfeatures = []\n\tfor (ex_index, example) in enumerate(examples):\n\t\ttokens_a = tokenizer.tokenize(example.text_a)\n\n\t\ttokens_b = None\n\t\tif example.text_b:\n\t\t\ttokens_b = tokenizer.tokenize(example.text_b)\n\t\t\t# Modifies `tokens_a` and `tokens_b` in place so that the total\n\t\t\t# length is less than the specified length.\n\t\t\t# Account for [CLS], [SEP], [SEP] with \"- 3\"\n\t\t\t_truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n\t\telse:\n\t\t\t# Account for [CLS] and [SEP] with \"- 2\"\n\t\t\tif len(tokens_a) > max_seq_length - 2:\n\t\t\t\ttokens_a = tokens_a[:(max_seq_length - 2)]\n\n\t\t# The convention in BERT is:\n\t\t# (a) For sequence pairs:\n\t\t# tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n\t\t# type_ids: 0 0 0\t0\t0\t 0\t 0 0\t1 1 1 1 1 1\n\t\t# (b) For single sequences:\n\t\t# tokens: [CLS] the dog is hairy . [SEP]\n\t\t# type_ids: 0 0 0 0 0\t 0 0\n\t\t#\n\t\t# Where \"type_ids\" are used to indicate whether this is the first\n\t\t# sequence or the second sequence. The embedding vectors for `type=0` and\n\t\t# `type=1` were learned during pre-training and are added to the wordpiece\n\t\t# embedding vector (and position vector). This is not *strictly* necessary\n\t\t# since the [SEP] token unambigiously separates the sequences, but it makes\n\t\t# it easier for the model to learn the concept of sequences.\n\t\t#\n\t\t# For classification tasks, the first vector (corresponding to [CLS]) is\n\t\t# used as as the \"sentence vector\". Note that this only makes sense because\n\t\t# the entire model is fine-tuned.\n\t\ttokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n\t\tsegment_ids = [0] * len(tokens)\n\n\t\tif tokens_b:\n\t\t\ttokens += tokens_b + [\"[SEP]\"]\n\t\t\tsegment_ids += [1] * (len(tokens_b) + 1)\n\n\t\tinput_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n\t\t# The mask has 1 for real tokens and 0 for padding tokens. Only real\n\t\t# tokens are attended to.\n\t\tinput_mask = [1] * len(input_ids)\n\n\t\t# Zero-pad up to the sequence length.\n\t\tpadding = [0] * (max_seq_length - len(input_ids))\n\t\tinput_ids += padding\n\t\tinput_mask += padding\n\t\tsegment_ids += padding\n\n\t\tassert len(input_ids) == max_seq_length\n\t\tassert len(input_mask) == max_seq_length\n\t\tassert len(segment_ids) == max_seq_length\n\n\t\t\n\t\tlabels_ids = [label_map[example.label]]\n\n#\t\t label_id = label_map[example.label]\n\t\tif ex_index < 0:\n\t\t\tlogger.info(\"*** Example ***\")\n\t\t\tlogger.info(\"guid: %s\" % (example.guid))\n\t\t\tlogger.info(\"tokens: %s\" % \" \".join(\n\t\t\t\t\t[str(x) for x in tokens]))\n\t\t\tlogger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n\t\t\tlogger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n\t\t\tlogger.info(\n\t\t\t\t\t\"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n\t\t\tlogger.info(\"label: %s (id = %s)\" % (example.labels, labels_ids))\n\n\t\tfeatures.append(\n\t\t\t\tInputFeatures(input_ids=input_ids,\n\t\t\t\t\t\t\t input_mask=input_mask,\n\t\t\t\t\t\t\t segment_ids=segment_ids,\n\t\t\t\t\t\t\t label_ids=labels_ids))\n\treturn features","def convert_single_example(ex_index, example, label_list, max_seq_length,\n tokenizer):\n label_map = {}\n for (i, label) in enumerate(label_list):\n label_map[label] = i\n\n input_ids, segment_ids, input_mask = \\\n tokenizer.encode_text(text_a=example.text_a,\n text_b=example.text_b,\n max_seq_length=max_seq_length)\n\n label_id = label_map[example.label]\n\n # here we disable the verbose printing of the data\n if ex_index < 0:\n logging.info(\"*** Example ***\")\n logging.info(\"guid: %s\", example.guid)\n logging.info(\"input_ids: %s\", \" \".join([str(x) for x in input_ids]))\n logging.info(\"input_ids length: %d\", len(input_ids))\n logging.info(\"input_mask: %s\", \" \".join([str(x) for x in input_mask]))\n logging.info(\"segment_ids: %s\", \" \".join([str(x) for x in segment_ids]))\n logging.info(\"label: %s (id = %d)\", example.label, label_id)\n\n feature = InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_id=label_id)\n return feature","def load_boolq_file(filename, num_par=2):\n tokenizer = tokenization.NltkTokenizer()\n examples = []\n with tf.gfile.Open(filename) as f:\n for line in f:\n obj = json.loads(line)\n context = tokenizer.tokenize(obj[\"passage\"])\n if FLAGS.max_passage_len:\n context = context[:FLAGS.max_passage_len]\n question = tokenizer.tokenize(obj[\"question\"])\n examples.append((question, context, obj[\"answer\"]))\n\n def get_data():\n out = list(examples)\n np.random.shuffle(out)\n return out\n\n ds = tf.data.Dataset.from_generator(get_data, (tf.string, tf.string, tf.bool),\n ([None], [None], []))\n\n def to_dict(p, h, label):\n return {\"hypothesis\": p, \"premise\": h, \"label\": label}\n\n return ds.map(to_dict, num_parallel_calls=num_par)","def _transformEx(self,example):\n x = []\n x.extend(example) \n x.append(1)\n return x,example.label","def nonlearning():\n\taT.featureAndTrain(['../../AudioData/chunked_data_sorted/pos', '../../AudioData/chunked_data_sorted/neg'], \n\t\t\t\t\t\t1.0, 1.0, aT.shortTermWindow, aT.shortTermStep, \n \"svm\", \"emotion_classifier\", True)","def test_get_input_labeled(self):\n result = pre.get_input(self.testfilename, labeled=True)\n truth = (\n [[Reference(0, 'm jones', \n 'symbol intersect detect method improv spatial intersect join', \n ['e rundensteiner', 'y huang'], 'geoinformatica', '81'),\n Reference(1, 'matthew c jones', \n 'improv spatial intersect join symbol intersect detect', \n ['e rundensteiner', 'h kuno', 'p marron', 'v taube', 'y ra'], \n 'sigmodels.intern manag data', '81'),\n Reference(2, 'matthew c jones',\n 'view materi techniqu complex hirarch object', ['e rundensteiner',\n 'y huang'], 'ssd symposium larg spatial databas', '81')],\n [Reference(3, 'mike w miller', 'domin draw bipartit graph', \n ['l berg'], 'sigucc special interest group univers comput servic',\n '185'),\n Reference(4, 'mike w miller', 'rel compromis statist databas', \n [], 'sigucc special interest group univers comput servic', '185')],\n [Reference(5, 'c chen', 'formal approach scenario analysi',\n ['d kung', 'j samuel', 'j gao', 'p hsia', 'y toyoshima'],\n 'ieee softwar', '94')],\n [Reference(6, 'jane j robinson', 'discours code clue context', [], \n 'acl meet the associ comput linguist', '69'),\n Reference(7, 'jane j robinson', 'diagram grammar dialogu', [],\n 'cooper interfac inform system', '69')],\n [Reference(8, 'a gupta', 'iri h java distanc educ', ['a gonzalez', \n 'a hamid', 'c overstreet', 'h wahab', 'j wild', 'k maly', 's ghanem',\n 'x zhu'], 'acm journal educ resourc comput', '0')],\n [Reference(9, 'mary d brown',\n 'intern redund represent limit bypass support pipelin adder regist '\n 'file', ['y patt'], 'proceed the th ieee intern symposium high '\n 'perform comput architectur hpca intern symposium high perform comput'\n ' architectur talk slide', '43')]],\n\n ['m jones', 'e rundensteiner', 'y huang', 'matthew c jones', \n 'e rundensteiner', 'h kuno', 'p marron', 'v taube', 'y ra', \n 'matthew c jones', 'e rundensteiner', 'y huang', 'mike w miller',\n 'l berg', 'mike w miller', 'c chen', 'd kung', 'j samuel', 'j gao',\n 'p hsia', 'y toyoshima', 'jane j robinson', 'jane j robinson',\n 'a gupta', 'a gonzalez', 'a hamid', 'c overstreet', 'h wahab', 'j wild',\n 'k maly', 's ghanem', 'x zhu', 'mary d brown', 'y patt'])\n self.assertEquals(result, truth)","def get_yes_no(question):\n complete_question = question + \" ([Y]es/[N]o): \"\n\n answer = get_verified_input(prompt=complete_question, verify_by_func=is_yes_or_no)\n\n # returns True is yes, False if no\n return is_yes_or_no(answer, check_no=False)","def extract_features(tlc):\n text = clean_text(tlc['body'])\n fields = dict()\n # add features here #\n fields['Top_comment_word_count'] = len(text.split(' '))\n fields['Top_comment_text'] = text\n\n # Extract time-based features\n def get_day_of_week(text):\n return datetime.datetime.strptime(text, '%Y-%m-%d %H:%M:%S').weekday() + 1\n\n def get_day_of_month(text):\n return datetime.datetime.strptime(text, '%Y-%m-%d %H:%M:%S').day\n\n def get_time_of_day(text):\n return datetime.datetime.strptime(text, '%Y-%m-%d %H:%M:%S').hour\n time_local = time.localtime(tlc['created_utc'])\n time_local = time.strftime(\"%Y-%m-%d %H:%M:%S\", time_local)\n fields['Top_comment_day'] = get_day_of_month(time_local)\n fields['Top_comment_day_of_week'] = get_day_of_week(time_local)\n fields['Top_comment_hour'] = get_time_of_day(time_local)\n\n # Extract gender value\n gp = GenderPerformr()\n probs, _ = gp.predict(tlc['author'])\n # Rescale it from [0,1] to [-1,1]\n fields['Top_comment_author_gender_value'] = 2 * probs - 1\n\n # Extract percentage of mispellings\n check = SpellChecker(\"en_US\")\n tokenizer = get_tokenizer(\"en_US\")\n # Prevent the denominator from 0\n def weird_division(n, d):\n return n / d if d else 0\n\n def get_mispellings_percentage(text):\n mispelling_count = 0\n total_count = 0\n if text == 'nan':\n return total_count\n else:\n check.set_text(text)\n for err in check:\n mispelling_count = mispelling_count + 1\n for w in tokenizer(text):\n total_count = total_count + 1\n value = weird_division(mispelling_count, total_count)\n return value\n fields['Top_comment_mispellings'] = get_mispellings_percentage(text)\n\n # Get politeness, agreement, support scores, and rescale them from [1,5] to [-1,1]\n ar = Agreementr()\n pr = Politenessr()\n sr = Supportr()\n fields['Top_comment_agreement_value'] = 0.5*float(ar.predict([text]))-1.5\n fields['Top_comment_politeness_value'] = 0.5*float(pr.predict([text]))-1.5\n fields['Top_comment_support_value'] = 0.5*float(sr.predict([text]))-1.5\n\n # Get toxicity scores\n KEY = \"yourkey.txt\" # os.getenv(\"GOOGLE_API_KEY\")\n service = discovery.build('commentanalyzer', 'v1alpha1', developerKey=KEY)\n\n def get_results(request_id, response, exception):\n toxicity_scores.append((request_id, response))\n\n toxicity_scores = []\n count = 0\n batch = service.new_batch_http_request(callback=get_results)\n analyze_request = {\n 'comment': {'text': text},\n \"requestedAttributes\": {\n \"TOXICITY\": {},\n \"SEVERE_TOXICITY\": {},\n \"ATTACK_ON_COMMENTER\": {}\n }\n }\n batch.add(service.comments().analyze(body=analyze_request), request_id=str(count))\n batch.execute()\n toxic_score = toxicity_scores[0][1]['attributeScores']['TOXICITY']['summaryScore']['value']\n attack_score = toxicity_scores[0][1]['attributeScores']['ATTACK_ON_COMMENTER']['summaryScore']['value']\n if toxic_score > 0.5:\n fields['Top_comment_untuned_toxicity'] = 1\n else:\n fields['Top_comment_untuned_toxicity'] = 0\n if toxic_score > 0.8 and attack_score > 0.5:\n fields['Top_comment_tuned_toxicity'] = 1\n else:\n fields['Top_comment_tuned_toxicity'] = 0\n # end of feature extractions #\n return fields","def convert_examples_to_features(examples, tokenizer, cls_token_segment_id=0, pad_token_id=0, pad_token_segment_id=0,\r\n pad_token_label_id=-100, sequence_a_segment_id=0, mask_padding_with_zero=True):\r\n cls_token = '[CLS]'\r\n sep_token = '[SEP]'\r\n\r\n features = []\r\n for (ex_index, example) in enumerate(examples):\r\n tokens = []\r\n label_ids = []\r\n for word, label in zip(example['words'], example['nes']):\r\n word_tokens = tokenizer.tokenize(word)\r\n tokens.extend(word_tokens)\r\n # Use the real label id for the first token of the word, and padding ids for the remaining tokens\r\n label_ids.extend([ner_to_id[label]] + [pad_token_label_id] * (len(word_tokens) - 1))\r\n\r\n # Account for [CLS] and [SEP] with \"- 2\"\r\n special_tokens_count = 2\r\n if len(tokens) > MAX_SEN_LEN - special_tokens_count:\r\n tokens = tokens[:(MAX_SEN_LEN - special_tokens_count)]\r\n label_ids = label_ids[:(MAX_SEN_LEN - special_tokens_count)]\r\n\r\n tokens += [sep_token]\r\n label_ids += [pad_token_label_id]\r\n\r\n segment_ids = [sequence_a_segment_id] * len(tokens)\r\n\r\n tokens = [cls_token] + tokens\r\n label_ids = [pad_token_label_id] + label_ids\r\n segment_ids = [cls_token_segment_id] + segment_ids\r\n\r\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\r\n\r\n # The mask has 1 for real tokens and 0 for padding tokens. Only real tokens are attended to.\r\n input_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\r\n\r\n # Zero-pad up to the sequence length.\r\n padding_length = MAX_SEN_LEN - len(input_ids)\r\n\r\n input_ids += ([pad_token_id] * padding_length)\r\n input_mask += ([0 if mask_padding_with_zero else 1] * padding_length)\r\n segment_ids += ([pad_token_segment_id] * padding_length)\r\n label_ids += ([pad_token_label_id] * padding_length)\r\n\r\n assert len(input_ids) == MAX_SEN_LEN\r\n assert len(input_mask) == MAX_SEN_LEN\r\n assert len(segment_ids) == MAX_SEN_LEN\r\n assert len(label_ids) == MAX_SEN_LEN\r\n\r\n features.append(\r\n {'input_ids': input_ids, 'input_mask': input_mask, 'segment_ids': segment_ids, 'label_ids': label_ids})\r\n\r\n return features","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n\n\tlabel_map = {label : i for i, label in enumerate(label_list,1)}\n\t\n\tfeatures = []\n\tfor (ex_index,example) in enumerate(examples):\n\n\t\ttext_a, entity_a, entity_b = example.text_a.split('[RE]')\n\n\t\ttokens_a = tokenizer.tokenize(text_a)\n\t\ttokens_b = None\n\t\ttokens_ea = tokenizer.tokenize(entity_a)\n\t\ttokens_eb = tokenizer.tokenize(entity_b)\n\n\t\t# Account for [CLS] and [SEP] with \"- 2\"\n\t\tif (len(tokens_a) + len(tokens_ea) + len(tokens_eb)) > (max_seq_length - 4) :\n\t\t\ttokens_a = tokens_a[0:(max_seq_length - 4 - len(tokens_ea) - len(tokens_eb))]\n\n\t\ttokens = []\n\t\tsegment_ids = []\n\t\ttokens.append(\"[CLS]\")\n\t\tsegment_ids.append(0)\n\t\tfor token in tokens_a:\n\t\t\ttokens.append(token)\n\t\t\tsegment_ids.append(0)\n\t\ttokens.append(\"[SEP]\")\n\t\tsegment_ids.append(0)\n\t\tfor token in tokens_ea:\n\t\t\ttokens.append(token)\n\t\t\tsegment_ids.append(0)\n\n\t\ttokens.append(\"[SEP]\")\n\t\tsegment_ids.append(0)\n\n\t\tfor token in tokens_eb:\n\t\t\ttokens.append(token)\n\t\t\tsegment_ids.append(0)\n\n\t\ttokens.append(\"[SEP]\")\n\t\tsegment_ids.append(0)\n\n\t\tinput_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n\t\t# The mask has 1 for real tokens and 0 for padding tokens. Only real\n\t\t# tokens are attended to.\n\t\tinput_mask = [1] * len(input_ids)\n\n\t\t# Zero-pad up to the sequence length.\n\t\twhile len(input_ids) < max_seq_length:\n\t\t\tinput_ids.append(0)\n\t\t\tinput_mask.append(0)\n\t\t\tsegment_ids.append(0)\n\n\t\tassert len(input_ids) == max_seq_length\n\t\tassert len(input_mask) == max_seq_length\n\t\tassert len(segment_ids) == max_seq_length\n\n\t\tlabel_id = label_map[example.label]\n\t\tif ex_index < 2:\n\t\t\tlogger.info(\"*** Example ***\")\n\t\t\tlogger.info(\"guid: %s\" % (example.guid))\n\t\t\tlogger.info(\"tokens: %s\" % \" \".join(\n\t\t\t\t\t[str(x) for x in tokens]))\n\t\t\tlogger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n\t\t\tlogger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n\t\t\tlogger.info(\n\t\t\t\t\t\"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n\t\t\tlogger.info(\"label: %s (id = %d)\" % (example.label, label_id))\n\n\t\tfeatures.append(InputFeatures(\n\t\t\tinput_ids=input_ids,\n\t\t\tinput_mask=input_mask,\n\t\t\tsegment_ids=segment_ids,\n\t\t\tlabel_id=label_id))\n\treturn features","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer, output_mode, is_master=True):\n\n label_map = {label: i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n if ex_index % 10000 == 0 and is_master:\n print(\"Writing example %d of %d\" % (ex_index, len(examples)))\n\n tokens_a = tokenizer.tokenize(example.text_a)\n\n tokens_b = None\n if example.text_b:\n tokens_b = tokenizer.tokenize(example.text_b)\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[:(max_seq_length - 2)]\n\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n segment_ids = [0] * len(tokens)\n\n if tokens_b:\n tokens += tokens_b + [\"[SEP]\"]\n segment_ids += [1] * (len(tokens_b) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n input_mask = [1] * len(input_ids)\n seq_length = len(input_ids)\n\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n\n if output_mode == \"classification\":\n label_id = label_map[example.label]\n elif output_mode == \"regression\":\n label_id = float(example.label)\n else:\n raise KeyError(output_mode)\n\n if ex_index == 0 and is_master:\n print(\"*** Example ***\")\n print(\"guid: %s\" % (example.guid))\n print(\"tokens: %s\" % \" \".join([str(x) for x in tokens]))\n print(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n print(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n print(\"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n print(\"label: {}\".format(example.label))\n print(\"label_id: {}\".format(label_id))\n\n features.append(\n InputFeatures(\n input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_id=label_id,\n seq_length=seq_length,\n guid=example.guid))\n return features","def parse_question(question):\n\tcontext = question['support']\n\tanswer = question['correct_answer']\n\ttarget = question['question']\n\n\tcontext_words = context.split(\" \")[0: 510]\n\ttarget_words = target.split(\" \")\n\n\tpunc_filter = str.maketrans('', '', string.punctuation)\n\n\tcontext_words = [word.translate(punc_filter) for word in context_words]\n\ttarget_words = [word.translate(punc_filter) for word in target_words]\n\tanswer_words = [word.translate(punc_filter) for word in answer.split(\" \")]\n\n\tbio_embeddings = [EMBEDER['O']]\n\tinside_answer = False\n\tanswer_index = 0\n\tcan_be_inside_answer = True\n\n\t# The following loop and above code does:\n\t# -Find where the answer is and place a B tag\n\t# -While still in the answer (the answer is more than one word) put an I tag\n\t# -Outside of the answer place a O tag\n\t# -Start and end with an O tag for BERT's automatic\n\t# -start token and end token representing the start and end of a sentence.\n\tfor word in context_words:\n\t\tif word.lower() == answer_words[0].lower() and can_be_inside_answer:\n\t\t\tbio_embeddings.append(EMBEDER[\"B\"])\n\t\t\tanswer_index += 1\n\t\t\tinside_answer = True\n\t\t\tcan_be_inside_answer = False\n\t\telif inside_answer:\n\t\t\tif len(answer_words) > 1:\n\t\t\t\tif word.lower() != answer_words[answer_index]:\n\t\t\t\t\tinside_answer = False\n\t\t\t\t\tbio_embeddings.append(EMBEDER[\"O\"])\n\t\t\t\telse:\n\t\t\t\t\tbio_embeddings.append(EMBEDER[\"I\"])\n\t\t\telse:\n\t\t\t\tinside_answer = False\n\t\t\t\tbio_embeddings.append(EMBEDER[\"O\"])\n\t\telse:\n\t\t\tbio_embeddings.append(EMBEDER[\"O\"])\n\tbio_embeddings.append(EMBEDER[\"O\"])\n\n\tground_truth = torch.tensor([BERT_TOKENIZER.encode(target_words)])\n\tcontext_words = torch.tensor([BERT_TOKENIZER.encode(context_words)])\n\n\tassert len(bio_embeddings) == len(context_words[0]), f'The BIO tags are not equal in length to the embeddings! ' \\\n\t f'{None} & {len(bio_embeddings)} & {len(context_words[0])}'\n\treturn context_words, bio_embeddings, ground_truth","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\r\n\r\n label_map = {label : i for i, label in enumerate(label_list)}\r\n\r\n features = []\r\n for (ex_index, example) in enumerate(examples):\r\n tokens_a = tokenizer.tokenize(example.text_a)\r\n\r\n tokens_b = None\r\n if example.text_b:\r\n tokens_b = tokenizer.tokenize(example.text_b)\r\n # Modifies `tokens_a` and `tokens_b` in place so that the total\r\n # length is less than the specified length.\r\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\r\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\r\n else:\r\n # Account for [CLS] and [SEP] with \"- 2\"\r\n if len(tokens_a) > max_seq_length - 2:\r\n tokens_a = tokens_a[:(max_seq_length - 2)]\r\n\r\n # The convention in BERT is:\r\n # (a) For sequence pairs:\r\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\r\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\r\n # (b) For single sequences:\r\n # tokens: [CLS] the dog is hairy . [SEP]\r\n # type_ids: 0 0 0 0 0 0 0\r\n #\r\n # Where \"type_ids\" are used to indicate whether this is the first\r\n # sequence or the second sequence. The embedding vectors for `type=0` and\r\n # `type=1` were learned during pre-training and are added to the wordpiece\r\n # embedding vector (and position vector). This is not *strictly* necessary\r\n # since the [SEP] token unambigiously separates the sequences, but it makes\r\n # it easier for the model to learn the concept of sequences.\r\n #\r\n # For classification tasks, the first vector (corresponding to [CLS]) is\r\n # used as as the \"sentence vector\". Note that this only makes sense because\r\n # the entire model is fine-tuned.\r\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\r\n segment_ids = [0] * len(tokens)\r\n\r\n if tokens_b:\r\n tokens += tokens_b + [\"[SEP]\"]\r\n segment_ids += [1] * (len(tokens_b) + 1)\r\n\r\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\r\n\r\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\r\n # tokens are attended to.\r\n input_mask = [1] * len(input_ids)\r\n\r\n # Zero-pad up to the sequence length.\r\n padding = [0] * (max_seq_length - len(input_ids))\r\n input_ids += padding\r\n input_mask += padding\r\n segment_ids += padding\r\n\r\n assert len(input_ids) == max_seq_length\r\n assert len(input_mask) == max_seq_length\r\n assert len(segment_ids) == max_seq_length\r\n\r\n label_id = example.label\r\n if ex_index < 5:\r\n logger.info(\"*** Example ***\")\r\n logger.info(\"guid: %s\" % (example.guid))\r\n logger.info(\"tokens: %s\" % \" \".join(\r\n [str(x) for x in tokens]))\r\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\r\n logger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\r\n logger.info(\r\n \"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\r\n # logger.info(\"label: %s (id = %d)\" % (example.label, label_id))\r\n\r\n features.append(\r\n InputFeatures(input_ids=input_ids,\r\n input_mask=input_mask,\r\n segment_ids=segment_ids,\r\n label_id=label_id))\r\n return features","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\r\n\r\n label_map = {label : i for i, label in enumerate(label_list)}\r\n\r\n features = []\r\n for (ex_index, example) in enumerate(examples):\r\n tokens_a = tokenizer.tokenize(example.text_a)\r\n\r\n tokens_b = None\r\n if example.text_b:\r\n tokens_b = tokenizer.tokenize(example.text_b)\r\n # Modifies `tokens_a` and `tokens_b` in place so that the total\r\n # length is less than the specified length.\r\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\r\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\r\n else:\r\n # Account for [CLS] and [SEP] with \"- 2\"\r\n if len(tokens_a) > max_seq_length - 2:\r\n tokens_a = tokens_a[:(max_seq_length - 2)]\r\n\r\n # The convention in BERT is:\r\n # (a) For sequence pairs:\r\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\r\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\r\n # (b) For single sequences:\r\n # tokens: [CLS] the dog is hairy . [SEP]\r\n # type_ids: 0 0 0 0 0 0 0\r\n #\r\n # Where \"type_ids\" are used to indicate whether this is the first\r\n # sequence or the second sequence. The embedding vectors for `type=0` and\r\n # `type=1` were learned during pre-training and are added to the wordpiece\r\n # embedding vector (and position vector). This is not *strictly* necessary\r\n # since the [SEP] token unambigiously separates the sequences, but it makes\r\n # it easier for the model to learn the concept of sequences.\r\n #\r\n # For classification tasks, the first vector (corresponding to [CLS]) is\r\n # used as as the \"sentence vector\". Note that this only makes sense because\r\n # the entire model is fine-tuned.\r\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\r\n segment_ids = [0] * len(tokens)\r\n\r\n if tokens_b:\r\n tokens += tokens_b + [\"[SEP]\"]\r\n segment_ids += [1] * (len(tokens_b) + 1)\r\n\r\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\r\n\r\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\r\n # tokens are attended to.\r\n input_mask = [1] * len(input_ids)\r\n\r\n # Zero-pad up to the sequence length.\r\n padding = [0] * (max_seq_length - len(input_ids))\r\n input_ids += padding\r\n input_mask += padding\r\n segment_ids += padding\r\n\r\n assert len(input_ids) == max_seq_length\r\n assert len(input_mask) == max_seq_length\r\n assert len(segment_ids) == max_seq_length\r\n\r\n # label_id = label_map[example.label]\r\n label_id = example.label\r\n label_id = float(label_id)\r\n if ex_index < 5:\r\n logger.info(\"*** Example ***\")\r\n logger.info(\"guid: %s\" % (example.guid))\r\n logger.info(\"tokens: %s\" % \" \".join(\r\n [str(x) for x in tokens]))\r\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\r\n logger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\r\n logger.info(\r\n \"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\r\n logger.info(\"label: %s (id = %s)\" % (example.label, label_id))\r\n\r\n features.append(\r\n InputFeatures(input_ids=input_ids,\r\n input_mask=input_mask,\r\n segment_ids=segment_ids,\r\n label_id=label_id))\r\n return features","def convert_examples_to_features(examples,label_list, max_seq_length,tokenizer):\r\n label_map = {}\r\n for (i, label) in enumerate(label_list):\r\n label_map[label] = i\r\n\r\n input_data=[]\r\n for (ex_index, example) in enumerate(examples):\r\n tokens_a = tokenizer.tokenize(example.text_a)\r\n tokens_b = None\r\n if example.text_b:\r\n tokens_b = tokenizer.tokenize(example.text_b)\r\n if tokens_b:\r\n # Modifies `tokens_a` and `tokens_b` in place so that the total\r\n # length is less than the specified length.\r\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\r\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\r\n else:\r\n # Account for [CLS] and [SEP] with \"- 2\"\r\n if len(tokens_a) > max_seq_length - 2:\r\n tokens_a = tokens_a[0:(max_seq_length - 2)]\r\n\r\n if ex_index % 10000 == 0:\r\n tf.logging.info(\"Writing example %d of %d\" % (ex_index, len(examples)))\r\n\r\n # The convention in BERT is:\r\n # (a) For sequence pairs:\r\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\r\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\r\n # (b) For single sequences:\r\n # tokens: [CLS] the dog is hairy . [SEP]\r\n # type_ids: 0 0 0 0 0 0 0\r\n #\r\n # Where \"type_ids\" are used to indicate whether this is the first\r\n # sequence or the second sequence. The embedding vectors for `type=0` and\r\n # `type=1` were learned during pre-training and are added to the wordpiece\r\n # embedding vector (and position vector). This is not *strictly* necessary\r\n # since the [SEP] token unambigiously separates the sequences, but it makes\r\n # it easier for the model to learn the concept of sequences.\r\n #\r\n # For classification tasks, the first vector (corresponding to [CLS]) is\r\n # used as as the \"sentence vector\". Note that this only makes sense because\r\n # the entire model is fine-tuned.\r\n tokens = []\r\n segment_ids = []\r\n tokens.append(\"[CLS]\")\r\n segment_ids.append(0)\r\n for token in tokens_a:\r\n tokens.append(token)\r\n segment_ids.append(0)\r\n tokens.append(\"[SEP]\")\r\n segment_ids.append(0)\r\n\r\n if tokens_b:\r\n for token in tokens_b:\r\n tokens.append(token)\r\n segment_ids.append(1)\r\n tokens.append(\"[SEP]\")\r\n segment_ids.append(1)\r\n\r\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\r\n\r\n input_mask = [1] * len(input_ids)\r\n\r\n while len(input_ids) < max_seq_length:\r\n input_ids.append(0)\r\n input_mask.append(0)\r\n segment_ids.append(0)\r\n assert len(input_ids) == max_seq_length\r\n assert len(input_mask) == max_seq_length\r\n assert len(segment_ids) == max_seq_length\r\n\r\n label_id = label_map[example.label]\r\n if ex_index < 3:\r\n tf.logging.info(\"*** Example ***\")\r\n tf.logging.info(\"guid: %s\" % (example.guid))\r\n tf.logging.info(\"tokens: %s\" % \" \".join([tokenization.printable_text(x) for x in tokens]))\r\n tf.logging.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\r\n tf.logging.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\r\n tf.logging.info(\"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\r\n tf.logging.info(\"label: %s (id = %d)\" % (example.label, label_id))\r\n\r\n features = collections.OrderedDict()\r\n features[\"input_ids\"] = input_ids\r\n features[\"input_mask\"] = input_mask\r\n features[\"segment_ids\"] = segment_ids\r\n features[\"label_ids\"] =label_id\r\n input_data.append(features)\r\n\r\n return input_data","def BoolVariable(key, help, default):\n return (key, '%s (yes|no)' % help, default,\n _validator, _text2bool)","def extract_feature(self, article) :\n pass","def convert_examples_to_features(examples, label_list, max_seq_length,\n tokenizer, output_mode):\n\n label_map = {label : i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n if ex_index % 10000 == 0:\n logger.info(\"Writing example %d of %d\" % (ex_index, len(examples)))\n\n tokens_a = tokenizer.tokenize(example.text_a)\n\n tokens_b = None\n if example.text_b:\n tokens_b = tokenizer.tokenize(example.text_b)\n # Modifies `tokens_a` and `tokens_b` in place so that the total\n # length is less than the specified length.\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n # Account for [CLS] and [SEP] with \"- 2\"\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[:(max_seq_length - 2)]\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambiguously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as as the \"sentence vector\". Note that this only makes sense because\n # the entire model is fine-tuned.\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n segment_ids = [0] * len(tokens)\n\n if tokens_b:\n tokens += tokens_b + [\"[SEP]\"]\n segment_ids += [1] * (len(tokens_b) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n\n if output_mode == \"classification\":\n label_id = label_map[example.label]\n elif output_mode == \"regression\":\n label_id = float(example.label)\n else:\n raise KeyError(output_mode)\n\n if ex_index < 5:\n logger.info(\"*** Example ***\")\n logger.info(\"guid: %s\" % (example.guid))\n logger.info(\"tokens: %s\" % \" \".join(\n [str(x) for x in tokens]))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n logger.info(\n \"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n logger.info(\"label: %s (id = %d)\" % (example.label, label_id))\n\n features.append(\n InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_id=label_id,\n weight = example.weight))\n return features","def positive_responses():\n return ['yes', 'y', 'Yes', 'Y']","def _toBoolean (iraf_flag):\n\n return (iraf_flag == iraf.yes)","def substantiate():","def unpack_true(data):\n return True, 0","def yes_no(x):\n \n x = x.lower()\n if x[0] == 'n':\n return 0\n if x[0] == 'y':\n return 1\n return None","def _create_examples(self,lines, set_type):\n examples = []\n if len(lines[1]) == 2 and len(lines[1][0]) == 1: # label text_a\n for (i, line) in enumerate(lines):\n guid = f\"{set_type}-{i}\"\n text_a = tx.utils.compat_as_text(line[1])\n label = tx.utils.compat_as_text(line[0])\n examples.append(InputExample(guid=guid, text_a=text_a,\n text_b=\"\", label=label))\n\n elif len(lines[1]) == 2 and len(lines[1][0]) > 1: # text_a text_b (when test file has no label)\n for (i, line) in enumerate(lines):\n guid = f\"{set_type}-{i}\"\n text_a = tx.utils.compat_as_text(line[0])\n text_b = tx.utils.compat_as_text(line[1])\n if set_type == \"test\":\n label = \"0\"\n else:\n print(\"the file is not for testing, yet contains no labels\")\n exit()\n examples.append(InputExample(guid=guid, text_a=text_a,\n text_b=text_b, label=label))\n elif len(lines[1]) == 1: # text_a (when test file has no label)\n for (i, line) in enumerate(lines):\n guid = f\"{set_type}-{i}\"\n text_a = tx.utils.compat_as_text(line[0])\n if set_type == \"test\":\n label = \"0\"\n else:\n print(\"the file is not for testing, yet contains no labels\")\n exit()\n examples.append(InputExample(guid=guid, text_a=text_a,\n text_b=\"\", label=label))\n elif len(lines[1]) == 3: # label text_a text_b\n for (i, line) in enumerate(lines):\n guid = f\"{set_type}-{i}\"\n text_a = tx.utils.compat_as_text(line[1])\n text_b = tx.utils.compat_as_text(line[2])\n\n label = tx.utils.compat_as_text(line[0])\n examples.append(InputExample(guid=guid, text_a=text_a,\n text_b=text_b, label=label))\n return examples","def convert_single_example(ex_index, example, label_list, output_mode, max_seq_length, max_predictions_per_seq,\n tokenizer):\n\n if isinstance(example, PaddingInputExample):\n return InputFeatures(\n input_ids=[0] * max_seq_length,\n input_mask=[0] * max_seq_length,\n segment_ids=[0] * max_seq_length,\n label_id=0,\n is_real_example=False)\n\n label_map = {}\n for (i, label) in enumerate(label_list):\n label_map[label] = i\n #BERT will add # at head of the number\n #tokens_a = tokenizer.tokenize(example.text_a) \n tokens_a = [a for a in example.text_a]\n tokens_b = None\n if example.text_b:\n tokens_b = tokenizer.tokenize(example.text_b)\n\n if tokens_b:\n # Modifies `tokens_a` and `tokens_b` in place so that the total\n # length is less than the specified length.\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n # Account for [CLS] and [SEP] with \"- 2\"\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[0:(max_seq_length - 2)]\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambiguously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as the \"sentence vector\". Note that this only makes sense because\n # the entire model is fine-tuned.\n tokens = []\n segment_ids = []\n tokens.append(\"[CLS]\")\n segment_ids.append(0)\n for token in tokens_a:\n tokens.append(token)\n segment_ids.append(0)\n tokens.append(\"[SEP]\")\n segment_ids.append(0)\n\n if tokens_b:\n for token in tokens_b:\n tokens.append(token)\n segment_ids.append(1)\n tokens.append(\"[SEP]\")\n segment_ids.append(1)\n \n \n for j, tok in enumerate(tokens):\n if tok not in tokenizer.vocab:\n tokens[j] = \"[UNK]\"\n \n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n # Zero-pad up to the sequence length.\n while len(input_ids) < max_seq_length:\n input_ids.append(0)\n input_mask.append(0)\n segment_ids.append(0)\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n \n #masked_lm_ids = tokenizer.tokenize(\"\".join(example.masked_lm_ids).decode(\"utf8\"))\n masked_lm_ids = []\n masked_lm_ids.append(\"[CLS]\")\n for tok in example.masked_lm_ids:\n masked_lm_ids.append(tok if tok in tokenizer.vocab else \"[UNK]\")\n masked_lm_ids.append(\"[SEP]\")\n masked_lm_ids = tokenizer.convert_tokens_to_ids(masked_lm_ids) \n \n\n masked_lm_weights = [1.0] * len(masked_lm_ids)\n masked_lm_weights[0] = 0.0\n masked_lm_weights[len(masked_lm_ids)-1] = 0.0\n masked_lm_positions = [i for i in range(len(masked_lm_ids))]\n\n while len(masked_lm_positions) < max_predictions_per_seq:\n masked_lm_positions.append(0)\n masked_lm_ids.append(0)\n masked_lm_weights.append(0.0)\n\n assert len(masked_lm_ids) == max_predictions_per_seq\n assert len(masked_lm_positions) == max_predictions_per_seq\n assert len(masked_lm_weights) == max_predictions_per_seq\n\n if output_mode == 'classification':\n label_id = label_map[example.label]\n elif output_mode == 'regression':\n label_id = float(example.label)\n\n else:\n raise KeyError(mode)\n if ex_index < 20:\n tf.logging.info(\"*** Example ***\")\n tf.logging.info(\"guid: %s\" % (example.guid))\n tf.logging.info(\"tokens: %s\" % \" \".join(\n [tokenization.printable_text(x) for x in tokens]))\n tf.logging.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n tf.logging.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n tf.logging.info(\"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n tf.logging.info(\"masked_lm_positions: %s\" % \" \".join([str(x) for x in masked_lm_positions]))\n tf.logging.info(\"masked_lm_ids: %s\" % \" \".join([str(x) for x in masked_lm_ids]))\n tf.logging.info(\"masked_lm_tokens: %s\" % \" \".join(\n\t[str(x) for x in tokenizer.convert_ids_to_tokens(masked_lm_ids)]))\n tf.logging.info(\"masked_lm_weights: %s\" % \" \".join([str(x) for x in masked_lm_weights]))\n tf.logging.info(\"label: %s (id = %d)\" % (example.label, label_id))\n\n feature = InputFeatures(\n input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n masked_lm_positions=masked_lm_positions,\n masked_lm_ids=masked_lm_ids,\n masked_lm_weights=masked_lm_weights,\n label_id=label_id,\n is_real_example=True)\n return feature","def yes_no(value):\n return 'Yes' if value else 'No'","def test_regex_featurizer():\n from rasa.nlu.featurizers.sparse_featurizer.regex_featurizer import RegexFeaturizer\n sentence, expected, labeled_tokens = (\n \"hey how are you today\",\n [\n [0.0, 1.0, 0.0],\n [0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0],\n [0.0, 1.0, 0.0],\n ],\n [0],\n )\n patterns = [\n {\"pattern\": \"[0-9]+\", \"name\": \"number\", \"usage\": \"intent\"},\n {\"pattern\": \"\\\\bhey*\", \"name\": \"hello\", \"usage\": \"intent\"},\n {\"pattern\": \"[0-1]+\", \"name\": \"binary\", \"usage\": \"intent\"},\n ]\n ftr = RegexFeaturizer({}, known_patterns=patterns)\n\n # adds tokens to the message\n tokenizer = SpacyTokenizer({})\n message = Message(sentence, data={RESPONSE: sentence})\n assert show_message(message, False) == {\n \"response\": \"hey how are you today\",\n \"text\": \"hey how are you today\"\n }\n message.set(SPACY_DOCS[TEXT], spacy_nlp(sentence))\n tokenizer.process(message)\n # assert show_message(message) == {'response': 'hey how are you today', 'text_spacy_doc': spacy_nlp(\"hey how are you today\"),\n # 'tokens': ['hey', 'how', 'are', 'you', 'today', '__CLS__'],\n # 'text': 'hey how are you today'}\n # result = ftr._features_for_patterns(message, TEXT)\n ftr.process(message) # [TEXT, RESPONSE]\n show_message(message)\n assert len(message.get(TOKENS_NAMES[TEXT], [])) > 0","def test_get_input_unlabeled(self):\n result = pre.get_input(self.testfilename)\n truth = (\n [[Reference(0, 'm jones', \n 'symbol intersect detect method improv spatial intersect join', \n ['e rundensteiner', 'y huang'], 'geoinformatica', None),\n Reference(1, 'matthew c jones', \n 'improv spatial intersect join symbol intersect detect', \n ['e rundensteiner', 'h kuno', 'p marron', 'v taube', 'y ra'], \n 'sigmodels.intern manag data', None),\n Reference(2, 'matthew c jones',\n 'view materi techniqu complex hirarch object', ['e rundensteiner',\n 'y huang'], 'ssd symposium larg spatial databas', None)],\n [Reference(3, 'mike w miller', 'domin draw bipartit graph', \n ['l berg'], 'sigucc special interest group univers comput servic',\n None),\n Reference(4, 'mike w miller', 'rel compromis statist databas', \n [], 'sigucc special interest group univers comput servic', None)],\n [Reference(5, 'c chen', 'formal approach scenario analysi',\n ['d kung', 'j samuel', 'j gao', 'p hsia', 'y toyoshima'],\n 'ieee softwar', None)],\n [Reference(6, 'jane j robinson', 'discours code clue context', [], \n 'acl meet the associ comput linguist', None),\n Reference(7, 'jane j robinson', 'diagram grammar dialogu', [],\n 'cooper interfac inform system', None)],\n [Reference(8, 'a gupta', 'iri h java distanc educ', ['a gonzalez', \n 'a hamid', 'c overstreet', 'h wahab', 'j wild', 'k maly', 's ghanem',\n 'x zhu'], 'acm journal educ resourc comput', None)],\n [Reference(9, 'mary d brown',\n 'intern redund represent limit bypass support pipelin adder regist'\n 'file', ['y patt'], 'proceed the th ieee intern symposium high '\n 'perform comput architectur hpca intern symposium high perform '\n 'comput architectur talk slide', None)]],\n\n ['m jones', 'e rundensteiner', 'y huang', 'matthew c jones', \n 'e rundensteiner', 'h kuno', 'p marron', 'v taube', 'y ra', \n 'matthew c jones', 'e rundensteiner', 'y huang', 'mike w miller',\n 'l berg', 'mike w miller', 'c chen', 'd kung', 'j samuel', 'j gao',\n 'p hsia', 'y toyoshima', 'jane j robinson', 'jane j robinson',\n 'a gupta', 'a gonzalez', 'a hamid', 'c overstreet', 'h wahab', 'j wild',\n 'k maly', 's ghanem', 'x zhu', 'mary d brown', 'y patt'])\n self.assertEquals(result, truth)","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n if label_list:\n label_map = {label: i for i, label in enumerate(label_list)}\n else:\n label_map = None\n\n features = []\n tokenslist = []\n for (ex_index, example) in enumerate(examples):\n tokens_a = tokenizer.tokenize(example.text_a)\n\n tokens_b = None\n if example.text_b:\n tokens_b = tokenizer.tokenize(example.text_b)\n # Modifies `tokens_a` and `tokens_b` in place so that the total\n # length is less than the specified length.\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n # Account for [CLS] and [SEP] with \"- 2\"\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[:(max_seq_length - 2)]\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambigiously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as as the \"sentence vector\". Note that this only makes sense because\n # the entire model is fine-tuned.\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n base_tokens = [\"[UNK]\"] + [\"[UNK]\"]*len(tokens_a) + [\"[UNK]\"]\n segment_ids = [0] * len(tokens)\n\n if tokens_b:\n tokens += tokens_b + [\"[SEP]\"]\n base_tokens += [\"[UNK]\"]*len(tokens_b) + [\"[UNK]\"]\n segment_ids += [1] * (len(tokens_b) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n baseline_ids = tokenizer.convert_tokens_to_ids(base_tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n baseline_ids += padding\n input_mask += padding\n segment_ids += padding\n\n assert len(baseline_ids) == max_seq_length\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n\n if label_map:\n label_id = label_map[example.label]\n else:\n label_id = float(example.label)\n if ex_index < 2:\n logger.debug(\"*** Example ***\")\n logger.debug(\"guid: %s\" % (example.guid))\n logger.debug(\"tokens: %s\" % \" \".join(\n [str(x) for x in tokens]))\n logger.debug(\"input_ids: %s\" %\n \" \".join([str(x) for x in input_ids]))\n logger.debug(\"input_mask: %s\" %\n \" \".join([str(x) for x in input_mask]))\n logger.debug(\n \"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n logger.debug(\"label: %s (id = %d)\" % (example.label, label_id))\n\n features.append(\n InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_id=label_id,\n baseline_ids=baseline_ids))\n tokenslist.append({\"token\":tokens, \"golden_label\":example.label, \"pred_label\":None})\n return features, tokenslist","def create_feature(example):\n input_ids, label_ids = encode_fn(\n example['tokens'], example['labels'])\n\n features = {\n 'input_ids': int64_feature(input_ids),\n 'label_ids': int64_feature(label_ids)\n }\n\n return features","def findHighOddsFeatures(self, label1, label2):\n featuresOdds = []\n\n \"*** YOUR CODE HERE ***\"\n\n return featuresOdds","def test_get_analyzed_recipe_instructions(self):\n pass","def test__validate_features__0():\n for input_value, expected_output in (\n (None, None),\n ([], None),\n ([GuildFeature.animated_banner], (GuildFeature.animated_banner, )),\n ([GuildFeature.animated_banner.value], (GuildFeature.animated_banner, )),\n (\n [GuildFeature.animated_banner, GuildFeature.animated_icon],\n (GuildFeature.animated_banner, GuildFeature.animated_icon,),\n ),\n ):\n output = validate_features(input_value)\n vampytest.assert_eq(output, expected_output)","def yesno2bool(value):\n if not isinstance(value, str):\n raise InstrumentParameterException(\"value not a string\")\n\n if(value.lower() == 'no'):\n return False\n elif(value.lower() == 'yes'):\n return True\n else:\n raise InstrumentParameterException(\"Could not convert '%s' to bool\" % value)","def convert_to_dialogData(\n premise_raw, hypo_raw, answer_raw, dialog_format=False, binary_classes=False\n):\n premise_raw = premise_raw.strip('\\n').strip('\\t')\n hypo_raw = hypo_raw.strip('\\n').strip('\\t')\n clas = MULTINLI_LABELS\n\n if binary_classes:\n answer_raw = BICLASS_DICT[answer_raw]\n clas = BICLASS_LABELS\n if not dialog_format:\n premise_raw = MULTINLI_PREMISE_PREFIX + premise_raw\n hypo_raw = MULTINLI_HYPO_PREFIX + hypo_raw\n\n question = premise_raw + '\\n' + hypo_raw\n answers = [answer_raw]\n\n return question, answers, clas","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n\n label_map = {label: i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n tokens_a = tokenizer.tokenize(example.text_a)\n\n tokens_b = None\n if example.text_b:\n tokens_b = tokenizer.tokenize(example.text_b)\n # Modifies `tokens_a` and `tokens_b` in place so that the total\n # length is less than the specified length.\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n # Account for [CLS] and [SEP] with \"- 2\"\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[:(max_seq_length - 2)]\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambigiously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as as the \"sentence vector\". Note that this only makes sense because\n # the entire model is fine-tuned.\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n segment_ids = [0] * len(tokens)\n\n if tokens_b:\n tokens += tokens_b + [\"[SEP]\"]\n segment_ids += [1] * (len(tokens_b) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n\n label_id = label_map[example.label]\n features.append(\n InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_id=label_id))\n return features","def addmanualflags(recipe, reason, antenna=\"\", spw=\"\", scan=\"\", uvrange=\"\", field=\"\"):\n recipe.add(\"cab/casa_flagdata\", \"handflags\", {\n \"vis\": ZEROGEN_DATA,\n \"mode\": \"manual\",\n \"antenna\": antenna,\n \"spw\": spw,\n \"scan\": scan,\n \"uvrange\": uvrange,\n \"field\": field\n },\n input=INPUT, output=OUTPUT, label=reason)\n MANUAL_FLAG_LIST.append(reason)\n return [reason]","def get_feature_set_PC(tweet, sentimentvalues):\n features= {\n 'text_length': np.log(len(tweet.text))\n } #ADD ADDITIONAL FEATURES\n if tweet.nrof_sademoticons>0:\n features['sademoticons'] = tweet.nrof_sademoticons\n if tweet.nrof_happyemoticons>0:\n features['happyemoticons'] = tweet.nrof_happyemoticons\n \n for phrase in tweet.tagged_words:\n for word in phrase:\n try:\n tag = word['pos']\n features[tag] = features.get(tag, 0) + 1\n if tag in ADJECTIVES:\n features['adjectives'] = features.get(tag, 0) + 1\n elif tag in ADVERBS: \n features['adverbs'] = features.get(tag, 0) + 1\n elif tag in PRONOUNS:\n features['pronoun'] = 1\n except KeyError:\n continue\n for key in features.keys():\n features[key] = features[key]*1.0\n \n #Add lexical features\n # total polarity score, number of positive words, number of negative words\n pos_score = 0\n neg_score = 0\n nrof_pos_words = 0\n nrof_neg_words = 0\n for word in sentimentvalues.keys():\n if sentimentvalues[word][0]>0:\n nrof_pos_words = nrof_pos_words + 1\n pos_score = pos_score + sentimentvalues[word][0]\n if sentimentvalues[word][1]>0:\n nrof_neg_words = nrof_neg_words + 1\n neg_score = neg_score + sentimentvalues[word][1]\n\n if neg_score>0:\n features['neg_score'] = neg_score+1.0\n if pos_score>0:\n features['pos_score'] = pos_score+1.0\n if nrof_pos_words>0:\n features['positive_words'] = nrof_pos_words*1.0\n if nrof_neg_words>0:\n features['negative_words'] = nrof_neg_words*1.0\n \n return features","def _generate_examples(self, data_dir=None, archive=None, label_path=None, process=None):\n if process == 'train':\n abnormal_train = pd.read_csv(os.path.join(data_dir, \"train-abnormal.csv\"), names=[\"Patient_Number\", \"abnormal\"])\n ACL_train = pd.read_csv(os.path.join(data_dir, \"train-acl.csv\"), names=[\"Patient_Number\", \"ACL\"])\n meniscus_train = pd.read_csv(os.path.join(data_dir, \"train-meniscus.csv\"), names=[\"Patient_Number\", \"meniscus\"])\n abnormal_acl_train = abnormal_train.merge(ACL_train, on=\"Patient_Number\")\n ab_acl_meni_train = abnormal_acl_train.merge(meniscus_train, on=\"Patient_Number\")\n else:\n abnormal_test = pd.read_csv(os.path.join(data_dir, \"valid-abnormal.csv\"), names=[\"Patient_Number\", \"abnormal\"])\n ACL_test = pd.read_csv(os.path.join(data_dir, \"valid-acl.csv\"), names=[\"Patient_Number\", \"ACL\"])\n meniscus_test = pd.read_csv(os.path.join(data_dir, \"valid-meniscus.csv\"), names=[\"Patient_Number\", \"meniscus\"])\n abnormal_acl_test = abnormal_test.merge(ACL_test, on=\"Patient_Number\")\n ab_acl_meni_test = abnormal_acl_test.merge(meniscus_test, on=\"Patient_Number\")\n\n def sumup(row):\n if (row['abnormal'] == 1) & (row[\"ACL\"] == 1) & (row[\"meniscus\"] == 1):\n val = \"Both_ACL_Meniscus\"\n elif (row['abnormal'] == 1) & (row[\"ACL\"] == 1) & (row[\"meniscus\"] == 0):\n val = \"ACL\"\n elif (row['abnormal'] == 1) & (row[\"ACL\"] == 0) & (row[\"meniscus\"] == 1):\n val = \"Meniscus\"\n elif (row['abnormal'] == 1) & (row[\"ACL\"] == 0) & (row[\"meniscus\"] == 0):\n val = \"abnormal\"\n elif row['abnormal'] == 0:\n val = \"normal\"\n return val\n if process == 'train':\n ab_acl_meni_train['sumup'] = ab_acl_meni_train.apply(sumup, axis=1)\n ab_acl_meni_train[['Patient_Number', \"sumup\"]].to_csv(os.path.join(data_dir, \"train_labels.csv\"), header=False)\n else:\n ab_acl_meni_test['sumup'] = ab_acl_meni_test.apply(sumup, axis=1)\n ab_acl_meni_test[['Patient_Number', \"sumup\"]].to_csv(os.path.join(data_dir, \"valid_labels.csv\"), header=False)\n\n all_labels = pd.read_csv(label_path, names=[\"Patient_Number\", \"label\"])\n\n count = 0\n archive_list = [os.path.join(archive, \"axial\"), os.path.join(archive, \"coronal\"), os.path.join(archive, \"sagittal\")]\n for direction in archive_list:\n files = []\n for r, d, f in tf.io.gfile.walk(direction):\n for file in f:\n if '.npy' in file:\n files.append(os.path.join(r, file))\n sorted_files = sorted(files)\n\n for path_cube in sorted_files:\n cube = np.load(tf.io.gfile.GFile(path_cube, mode='rb'))\n for picture in cube:\n example_image = picture[..., np.newaxis]\n example_label = (all_labels.loc[all_labels['Patient_Number'] ==\n int(os.path.splitext(os.path.basename(path_cube))[0][:4]),\n 'label'].iloc[0])\n count += 1\n yield count, {\n 'image': example_image,\n 'label': example_label,\n }","def convert_single_example(ex_index, example, label_list, max_seq_length,tokenizer):\n label_map = {}\n for (i, label) in enumerate(label_list):\n label_map[label] = i\n text_a=example.text_a\n labels_a=[]\n text_a=re.split(\"(<[a-zA-Z]+>[^<>]+</[a-zA-Z]+>)\",text_a)\n tokens_a=[]\n for sub_text in text_a:\n if len(sub_text.strip())<1:\n continue\n elif re.search('<([a-zA-Z]+)>([^<>]+)<[/a-zA-Z]+>',sub_text):\n re_res=re.search('<([a-zA-Z]+)>([^<>]+)<[/a-zA-Z]+>',sub_text)\n slot_name=re_res.group(1)\n slot_value=re_res.group(2)\n slot_value=tokenizer.tokenize(slot_value)\n slot_labels=[]\n for i,s in enumerate(slot_value):\n if i==0:\n slot_labels.append(\"B_\"+slot_name)\n elif re.search(\"^##\",s):\n slot_labels.append(\"x\")\n else:\n slot_labels.append(\"M_\"+slot_name)\n tokens_a.extend(slot_value)\n labels_a.extend(slot_labels)\n else:\n sub_text=tokenizer.tokenize(sub_text)\n sub_labels=['x' if re.search(\"^##\",i) else 'o' for i in sub_text]\n tokens_a.extend(sub_text)\n labels_a.extend(sub_labels)\n tokens = []\n segment_ids = []\n tokens.append(\"[CLS]\")\n segment_ids.append(0)\n for token in tokens_a:\n tokens.append(token)\n segment_ids.append(0)\n tokens.append(\"[SEP]\")\n segment_ids.append(0)\n labels=[example.label]\n for label in labels_a:\n labels.append(label)\n labels.append('o')\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n input_mask = [1] * len(input_ids)\n output_mask=[1 if i!='x' else 0 for i in labels]\n label_ids=[label_map[i] for i in labels]\n while len(input_ids) < max_seq_length:\n input_ids.append(0)\n segment_ids.append(0)\n input_mask.append(0)\n output_mask.append(0)\n label_ids.append(label_map['<PAD>'])\n assert len(input_ids)==max_seq_length\n assert len(segment_ids)==max_seq_length\n assert len(label_ids)==max_seq_length\n assert len(input_mask)==max_seq_length\n assert len(output_mask)==max_seq_length\n if ex_index < 5:\n tf.logging.info(\"*** Example ***\")\n tf.logging.info(\"guid: %s\" % (example.guid))\n tf.logging.info(\"tokens: %s\" % \" \".join(tokens))\n tf.logging.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n tf.logging.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n tf.logging.info(\"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n tf.logging.info(\"labels: %s\" % \" \".join([str(x) for x in labels]))\n tf.logging.info(\"label_ids: %s\" % \" \".join([str(x) for x in label_ids]))\n tf.logging.info(\"output_mask: %s\" % \" \".join([str(x) for x in output_mask]))\n feature = InputFeatures(\n input_ids=input_ids,\n segment_ids=segment_ids,\n label_ids=label_ids,\n input_mask=input_mask,\n output_mask=output_mask)\n return feature","def test_model_mc_question(mc_question_one_true):\n assert mc_question_one_true.answer1 == \"a1\"\n assert mc_question_one_true.answer1_correct == True\n assert mc_question_one_true.answer2 == \"a2\"\n assert mc_question_one_true.answer2_correct == False\n assert mc_question_one_true.answer3 == \"a3\"\n assert mc_question_one_true.answer3_correct == False","def test_features_property():\n atom = ATOMClassifier(X_bin, y_bin, random_state=1)\n atom.run(\"LR\")\n assert [i == j for i, j in zip(atom.lr.features, atom.features)]"],"string":"[\n \"def convert_example(example, tokenizer):\\n\\n feature = tokenizer(\\n text=example['question'],\\n text_pair=example['answer'],\\n max_seq_len=args.max_seq_length)\\n feature['labels'] = example['labels']\\n feature['id'] = example['id']\\n\\n return feature\",\n \"def ParseYesNo(src):\\n return src.strip().lower() == u'yes'\",\n \"def convert_examples_to_features(examples, tokenizer, max_seq_length):\\n \\n features = []\\n num_tokens_article = []\\n count = 0\\n masking_token_id = tokenizer.convert_tokens_to_ids(['[MASK]'])[0]\\n # padding_token_id = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)\\n for example_index, example in enumerate(examples):\\n article_tokens = tokenizer.tokenize(example['article'])\\n ques_tokens = tokenizer.tokenize(example['question'].replace(\\\"@placeholder\\\", \\\"_\\\"))\\n masked_index = ques_tokens.index('_')\\n ques_tokens[masked_index] = '[MASK]'\\n \\n# options = example['options']\\n options = tokenizer.convert_tokens_to_ids(example['options'])\\n# print(options, '\\\\n')\\n\\n choices_features = []\\n _truncate_seq_pair(article_tokens, ques_tokens, max_seq_length - 3)\\n\\n# tokens = [\\\"[CLS]\\\"] + ques_tokens + [\\\"[SEP]\\\"] + article_tokens + [\\\"[SEP]\\\"]\\n tokens = ques_tokens + [\\\"[SEP]\\\"] + article_tokens + [\\\"[SEP]\\\"]\\n\\n# segment_ids = [0] * (len(ques_tokens) + 2) + [1] * (len(article_tokens) + 1)\\n segment_ids = [0] * (len(ques_tokens) + 1) + [1] * (len(article_tokens) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\t\\n candidates = example['options']\\n candidates_ids = tokenizer.convert_tokens_to_ids(candidates)\\n# print(tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0])\\n\\n lm_labels = [-1 if t_id != masking_token_id else tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0] for t_id in input_ids]\\n# lm_labels = [t_id if t_id != 0 else -1 for t_id in input_ids]\\n# for i, t_id in enumerate(lm_labels) :\\n# if(t_id == masking_token_id):\\n# lm_labels[i] = tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0]\\n\\n# print(lm_labels, '\\\\n')\\n # tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0]\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n assert len(lm_labels) == max_seq_length\\n\\n choices_features.append((tokens, input_ids, input_mask, segment_ids))\\n\\n features.append(\\n InputFeatures(\\n choices_features = choices_features,\\n lm_labels = lm_labels,\\n options = options,\\n label = example['label']\\n )\\n )\\n \\n return features\",\n \"def test__extract_features(self):\\n text_sample = \\\"I really really love this movie\\\"\\n feature_sample = ['really','love','good']\\n feature_score_type = \\\"presence\\\"\\n model_sample = Model(feature_sample,feature_score_type)\\n result_features = model_sample.extract_features(text_sample)\\n assert_equal(result_features,{'really':1,'love':1,'good':0})\\n feature_score_type = \\\"term_frequency\\\"\\n model_sample = Model(feature_sample,feature_score_type)\\n result_features = model_sample.extract_features(text_sample)\\n assert_equal(result_features,{'really':2,'love':1,'good':0})\",\n \"def convert_examples_to_features(examples, tokenizer, is_training, args):\\n all_features = []\\n positive_features = 0\\n negative_features = 0\\n logger.info(\\\"Converting a list of NqExamples into InputFeatures ...\\\")\\n for index, example in enumerate(tqdm(examples)):\\n example_index = example['example_id']\\n paragraph_id = example['paragraph_id']\\n if args.do_ls:\\n features = convert_single_ls_example(example, tokenizer, is_training, args)\\n else:\\n features = convert_single_example(example, tokenizer, is_training, args)\\n\\n for feature in features:\\n feature.example_index = example_index\\n feature.unique_id = paragraph_id + '_' + str(feature.doc_span_index)\\n all_features.append(feature)\\n if is_training:\\n if feature.answer_type == AnswerType['UNKNOWN']:\\n negative_features += 1\\n else:\\n positive_features += 1\\n\\n if is_training and index % 5000 == 0:\\n print('Positive features:', positive_features, 'Negative features:', negative_features)\\n\\n print('Positive features:', positive_features, 'Negative features:', negative_features)\\n\\n return all_features\",\n \"def convert_xnli_examples_to_features(self):\\n features = self.features\\n lang_filtered_features = []\\n for ex_index, example in enumerate(self.examples):\\n language = example.guid.split('-')[1]\\n if language in self.lang_list:\\n lang_filtered_features.append(features[ex_index] + [language])\\n return lang_filtered_features\",\n \"def import_examples(file):\\n examples_set = list()\\n\\n with open(file, 'r') as f:\\n for line in f:\\n terms = line.strip().split(',')\\n # Convert label 0 into no and 1 into yes\\n if terms[14] == \\\"0\\\":\\n terms[14] = \\\"no\\\"\\n else:\\n terms[14] = \\\"yes\\\"\\n examples_set.append(terms)\\n return examples_set\",\n \"def make_returnn_audio_features_func():\\n return _extract\",\n \"def get_features(self, para, label_list, tokenizer, max_seq_length):\\n\\t\\tlabel_map = {label : i for i, label in enumerate(label_list)}\\n# self.reverse_label_map = {v: k for k, v in label_map.items()}\\n\\t\\tguid = \\\"%s-%s\\\" % (\\\"test\\\", 1)\\n\\t\\ttext_a = para[\\\"model_answer\\\"]\\n\\t\\ttext_b = para[\\\"candidate_answer\\\"]\\n\\t\\tlabel = label_list[0]\\n\\t\\texample = InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label)\\n\\t\\t\\n\\t\\ttokens_a = tokenizer.tokenize(example.text_a)\\n\\n\\t\\ttokens_b = tokenizer.tokenize(example.text_b)\\n\\t\\tif example.text_b:\\n\\t\\t\\ttokens_b = tokenizer.tokenize(example.text_b)\\n\\t\\t\\t# Modifies `tokens_a` and `tokens_b` in place so that the total\\n\\t\\t\\t# length is less than the specified length.\\n\\t\\t\\t# Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n\\t\\t\\tself._truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n\\t\\telse:\\n\\t\\t\\t# Account for [CLS] and [SEP] with \\\"- 2\\\"\\n\\t\\t\\tif len(tokens_a) > max_seq_length - 2:\\n\\t\\t\\t\\ttokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n\\t\\t# The convention in BERT is:\\n\\t\\t# (a) For sequence pairs:\\n\\t\\t# tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n\\t\\t# type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n\\t\\t# (b) For single sequences:\\n\\t\\t# tokens: [CLS] the dog is hairy . [SEP]\\n\\t\\t# type_ids: 0 0 0 0 0 0 0\\n\\t\\t#\\n\\t\\t# Where \\\"type_ids\\\" are used to indicate whether this is the first\\n\\t\\t# sequence or the second sequence. The embedding vectors for `type=0` and\\n\\t\\t# `type=1` were learned during pre-training and are added to the wordpiece\\n\\t\\t# embedding vector (and position vector). This is not *strictly* necessary\\n\\t\\t# since the [SEP] token unambigiously separates the sequences, but it makes\\n\\t\\t# it easier for the model to learn the concept of sequences.\\n\\t\\t#\\n\\t\\t# For classification tasks, the first vector (corresponding to [CLS]) is\\n\\t\\t# used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n\\t\\t# the entire model is fine-tuned.\\n\\t\\ttokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n\\t\\tsegment_ids = [0] * len(tokens)\\n\\n\\t\\tif tokens_b:\\n\\t\\t\\ttokens += tokens_b + [\\\"[SEP]\\\"]\\n\\t\\t\\tsegment_ids += [1] * (len(tokens_b) + 1)\\n\\n\\t\\tinput_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n\\t\\t# The mask has 1 for real tokens and 0 for padding tokens. Only real\\n\\t\\t# tokens are attended to.\\n\\t\\tinput_mask = [1] * len(input_ids)\\n\\n\\t\\t# Zero-pad up to the sequence length.\\n\\t\\tpadding = [0] * (max_seq_length - len(input_ids))\\n\\t\\tinput_ids += padding\\n\\t\\tinput_mask += padding\\n\\t\\tsegment_ids += padding\\n\\n\\t\\tassert len(input_ids) == max_seq_length\\n\\t\\tassert len(input_mask) == max_seq_length\\n\\t\\tassert len(segment_ids) == max_seq_length\\n\\t\\tlabel_id = label_map[example.label]\\n# print(\\\"*** Example ***\\\")\\n# print(\\\"guid: %s\\\" % (example.guid))\\n# print(\\\"tokens: %s\\\" % \\\" \\\".join(\\n# [str(x) for x in tokens]))\\n# print(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n# print(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n# print(\\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n\\n\\t\\t\\n\\t\\treturn InputFeatures(input_ids=input_ids,\\n\\t\\t\\t\\t\\t\\t\\t input_mask=input_mask,\\n\\t\\t\\t\\t\\t\\t\\t segment_ids=segment_ids,\\n\\t\\t\\t\\t\\t\\t\\t label_id=label_id)\",\n \"def read_examples(input_file, output_mode = 'classification'):\\n examples = []\\n labels = []\\n toxicity = []\\n weights = []\\n unique_id = 0\\n\\n # Comments with the following indentities will have a higher wright in the loss\\n identity_columns = [\\n 'male', 'female', 'homosexual_gay_or_lesbian', 'christian', 'jewish',\\n 'muslim', 'black', 'white', 'psychiatric_or_mental_illness']\\n with open(input_file, \\\"r\\\", encoding='utf-8') as reader:\\n csv_reader = csv.reader(reader, delimiter=',')\\n for _i, line in enumerate(csv_reader):\\n\\n if _i == 0:\\n # Get headers and look for identity columnns\\n headers = list(line)\\n # Stores its positions for futher use\\n interesting_positions = [headers.index(interest_identity) for interest_identity in identity_columns]\\n\\n else:\\n # Get toxicity ground truth\\n target = float(line[1])\\n if target >= 0.5:\\n \\tlabel = \\\"Toxic\\\"\\n else:\\n \\tlabel = \\\"OK\\\"\\n text = line[2]\\n text_a = None\\n text_b = None\\n m = re.match(r\\\"^(.*) \\\\|\\\\|\\\\| (.*)$\\\", text)\\n if m is None:\\n text_a = text\\n else:\\n print(text_a, text_b)\\n text_a = m.group(1)\\n text_b = m.group(2)\\n # store class or float toxicity depending on mode\\n if output_mode != 'classification':\\n label = target\\n\\n # Calculate weight\\n weight = 0.25\\n # Subgroup:\\n\\n weight+= 0.25*(sum([float(line[interest])>=0.5 for interest in interesting_positions if line[interest] !=''])>=1)\\n # Background Positive, Subgroup Negative\\n weight+=0.25*((target>=0.5)*sum([float(line[interest])<0.5 for interest in interesting_positions if line[interest] !=''])>=1)\\n # Background Negative, Subgroup Positive\\n weight+= 0.25*((target<0.5)*sum([float(line[interest])>=0.5 for interest in interesting_positions if line[interest] !=''])>=1)\\n # Original implementation\\n '''\\n # Overall\\n weights = np.ones((len(x_train),)) / 4\\n # Subgroup\\n weights += (train[identity_columns].fillna(0).values>=0.5).sum(axis=1).astype(bool).astype(np.int) / 4\\n # Background Positive, Subgroup Negative\\n weights += (( (train['target'].values>=0.5).astype(bool).astype(np.int) +\\n (train[identity_columns].fillna(0).values<0.5).sum(axis=1).astype(bool).astype(np.int) ) > 1 ).astype(bool).astype(np.int) / 4\\n # Background Negative, Subgroup Positive\\n weights += (( (train['target'].values<0.5).astype(bool).astype(np.int) +\\n (train[identity_columns].fillna(0).values>=0.5).sum(axis=1).astype(bool).astype(np.int) ) > 1 ).astype(bool).astype(np.int) / 4\\n \\n '''\\n examples.append(\\n InputExample(guid=unique_id, text_a=text_a, text_b=text_b, label = label, weight = weight))\\n labels.append(label)\\n toxicity.append(target)\\n unique_id += 1\\n\\n\\n\\n return examples, labels, toxicity\",\n \"def feature():\\n pass\",\n \"def load_demo():\\n\\tprint(\\\"\\\"\\\"\\n\\tBreast Cancer Wisconsin dataset. It contains a total of 569 samples of tumor and malignant cells. \\n\\tData labeled 1 corresponds to malignant cells, while data labeled 0 corresponds to benign cells. \\n\\tThe 30 characteristics contain real values obtained from images of cell nuclei. For more information:\\n\\n\\t\\t\\thttp://archive.ics.uci.edu/ml/datasets/breast+cancer+wisconsin+(diagnostic)\\n\\n\\n\\tThe returned value is a dictionary where 'x_data' are the predictor variables, 'y_data' the class \\n\\tlabels and 'features' the name of the characteristics.\\n\\t\\\"\\\"\\\")\\n\\tpath = '/'.join(os.path.abspath(pywinEA.__file__).split('/')[:-1])\\n\\t\\n\\tdata = pd.read_csv(path+'/dataset/data/BreastCancerWisconsin.csv', index_col=0)\\n\\tx_data = data.iloc[:, 1:].values\\n\\ty_data = data.iloc[:, 0].values\\n\\tfeatures = data.columns[1:].values\\n\\n\\t# Transform labels\\n\\ty_data[np.where(y_data == 'M')] = 1\\n\\ty_data[np.where(y_data == 'B')] = 0\\n\\ty_data = y_data.astype(int)\\n\\n\\treturn {'x_data': x_data, 'y_data': y_data, 'features': features}\",\n \"def feat():\\n pass\",\n \"def __add_answered_on_feature(samples: List[TrainSample], all_features: np.array) -> np.array:\\n new_features = []\\n for sample, features in zip(samples, all_features):\\n if isinstance(sample.selected_player, bool):\\n answered_on = 1.0 if sample.selected_player else 0.0\\n else:\\n answered_on = 1.0 if sample.selected_player in sample.answer else 0.0\\n features = np.append(features, answered_on * features)\\n features = np.append(features, [answered_on])\\n new_features.append(features)\\n return np.array(new_features)\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer, mode): #check later if we can merge this function with the SQuAD preprocessing \\n label_map = {}\\n for (i, label) in enumerate(label_list):\\n label_map[label] = i\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n if mode!=\\\"ae\\\":\\n tokens_a = tokenizer.tokenize(example.text_a)\\n else: #only do subword tokenization.\\n tokens_a, labels_a, example.idx_map= tokenizer.subword_tokenize([token.lower() for token in example.text_a], example.label )\\n tokens_b = None\\n if example.text_b:\\n tokens_b = tokenizer.tokenize(example.text_b)\\n\\n if tokens_b:\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\n # length is less than the specified length.\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[0:(max_seq_length - 2)]\\n\\n tokens = []\\n segment_ids = []\\n tokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n for token in tokens_a:\\n tokens.append(token)\\n segment_ids.append(0)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(0)\\n\\n if tokens_b:\\n for token in tokens_b:\\n tokens.append(token)\\n segment_ids.append(1)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n while len(input_ids) < max_seq_length:\\n input_ids.append(0)\\n input_mask.append(0)\\n segment_ids.append(0)\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n\\n if mode!=\\\"ae\\\":\\n label_id = label_map[example.label]\\n else:\\n label_id = [-1] * len(input_ids) #-1 is the index to ignore\\n #truncate the label length if it exceeds the limit.\\n lb=[label_map[label] for label in labels_a]\\n if len(lb) > max_seq_length - 2:\\n lb = lb[0:(max_seq_length - 2)]\\n label_id[1:len(lb)+1] = lb\\n \\n features.append(\\n InputFeatures(\\n input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_id=label_id))\\n return features\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer, mode): #check later if we can merge this function with the SQuAD preprocessing\\n label_map = {}\\n for (i, label) in enumerate(label_list):\\n label_map[label] = i\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n if mode!=\\\"ae\\\":\\n tokens_a = tokenizer.tokenize(example.text_a)\\n else: #only do subword tokenization.\\n tokens_a, labels_a, example.idx_map= tokenizer.subword_tokenize([token.lower() for token in example.text_a], example.label )\\n\\n tokens_b = None\\n if example.text_b:\\n tokens_b = tokenizer.tokenize(example.text_b)\\n\\n if tokens_b:\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\n # length is less than the specified length.\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[0:(max_seq_length - 2)]\\n\\n tokens = []\\n segment_ids = []\\n tokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n for token in tokens_a:\\n tokens.append(token)\\n segment_ids.append(0)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(0)\\n\\n if tokens_b:\\n for token in tokens_b:\\n tokens.append(token)\\n segment_ids.append(1)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(1)\\n\\n target_indices = find_target_indices(tokens_a, tokens)\\n if target_indices is None:\\n target_indices = (1, 1 + len(tokens_a))\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n while len(input_ids) < max_seq_length:\\n input_ids.append(0)\\n input_mask.append(0)\\n segment_ids.append(0)\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n\\n if mode!=\\\"ae\\\":\\n label_id = label_map[example.label]\\n else:\\n label_id = [-1] * len(input_ids) #-1 is the index to ignore\\n #truncate the label length if it exceeds the limit.\\n lb=[label_map[label] for label in labels_a]\\n if len(lb) > max_seq_length - 2:\\n lb = lb[0:(max_seq_length - 2)]\\n label_id[1:len(lb)+1] = lb\\n\\n features.append(\\n InputFeatures(\\n input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_id=label_id,\\n target_indices=target_indices))\\n return features\",\n \"def yesno(*args):\",\n \"def other_features_(tweet, cleaned_tweet):\\n #print(\\\"WARNING>>>>>>>>>>>>>>>>> VADERSENTIMENT DISABLED\\\")\\n sentiment = nlp.sentiment_analyzer.polarity_scores(tweet)\\n\\n words = cleaned_tweet #Get text only\\n\\n syllables = textstat.syllable_count(words) #count syllables in words\\n num_chars = sum(len(w) for w in words) #num chars in words\\n num_chars_total = len(tweet)\\n num_terms = len(tweet.split())\\n num_words = len(words.split())\\n avg_syl = round(float((syllables+0.001))/float(num_words+0.001),4)\\n num_unique_terms = len(set(words.split()))\\n ###Modified FK grade, where avg words per sentence is just num words/1\\n FKRA = round(float(0.39 * float(num_words)/1.0) + float(11.8 * avg_syl) - 15.59,1)\\n ##Modified FRE score, where sentence fixed to 1\\n FRE = round(206.835 - 1.015*(float(num_words)/1.0) - (84.6*float(avg_syl)),2)\\n\\n\\n twitter_objs = count_twitter_objs(tweet) #Count #, @, and http://\\n features = [FKRA, FRE, syllables, num_chars, num_chars_total, num_terms, num_words,\\n num_unique_terms, sentiment['compound'],\\n twitter_objs[2], twitter_objs[1],]\\n #features = pandas.DataFrame(features)\\n return features\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n\\n label_map = {} # label\\n for (i, label) in enumerate(label_list): # ['0', '1']\\n label_map[label] = i\\n\\n features = [] # feature\\n for (ex_index, example) in enumerate(examples):\\n text_a_id = int(example.text_a_id)\\n text_b_id = int(example.text_b_id)\\n\\n text_a_fields = example.text_a.split(\\\" _eop_ \\\")\\n \\n tokens_a = []\\n text_a_subtype = []\\n for text_a_field_idx, text_a_field in enumerate(text_a_fields):\\n text_a_field_token = tokenizer.tokenize(text_a_field)\\n tokens_a.extend(text_a_field_token)\\n text_a_subtype.extend([text_a_field_idx]*len(text_a_field_token))\\n assert len(tokens_a) == len(text_a_subtype)\\n\\n tokens_b = None\\n if example.text_b:\\n tokens_b = tokenizer.tokenize(example.text_b) # text_b tokenize\\n\\n if tokens_b: # if has b\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\n # length is less than the specified length.\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3) # truncate\\n else:\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[0:(max_seq_length - 2)]\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambiguously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because # (?)\\n # the entire model is fine-tuned.\\n tokens = []\\n segment_ids = []\\n subtype_ids = []\\n tokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n subtype_ids.append(0)\\n for token_idx, token in enumerate(tokens_a):\\n tokens.append(token)\\n segment_ids.append(0)\\n subtype_ids.append(text_a_subtype[token_idx])\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(0)\\n subtype_ids.append(1)\\n\\n if tokens_b:\\n for token_idx, token in enumerate(tokens_b):\\n tokens.append(token)\\n segment_ids.append(1)\\n subtype_ids.append(2)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(1)\\n subtype_ids.append(2)\\n\\n input_sents = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_sents) # mask\\n\\n # Zero-pad up to the sequence length.\\n while len(input_sents) < max_seq_length:\\n input_sents.append(0)\\n input_mask.append(0)\\n segment_ids.append(0)\\n subtype_ids.append(0)\\n\\n assert len(input_sents) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n assert len(subtype_ids) == max_seq_length\\n\\n label_id = label_map[example.label]\\n\\n if ex_index%2000 == 0:\\n print('convert_{}_examples_to_features'.format(ex_index))\\n\\n features.append(\\n InputFeatures( # object\\n text_a_id=text_a_id,\\n text_b_id=text_b_id,\\n input_sents=input_sents,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n subtype_ids=subtype_ids,\\n label_id=label_id))\\n\\n return features\",\n \"def load_simple_features(self, simple_features):\\n self.simple_features = pd.DataFrame(simple_features).T\\n self.simple_features.fillna(False, inplace=True)\\n self.simple_features = self.simple_features.astype(bool)\\n\\n # Aggregate features descriptions\\n self.simple_features_description = {}\\n for binary in simple_features:\\n for token in simple_features[binary]:\\n if token not in self.simple_features_description:\\n self.simple_features_description[token] = \\\\\\n simple_features[binary][token]\",\n \"def get_yesno(yesno):\\n return 'yes' if yesno == 1 else 'no'\",\n \"def yn(self, mask, target, args):\\n self.msg(mask, target, \\\"[1dyes] ==> \\\" + random.choice(['Yes', 'No']))\",\n \"def convert_examples_to_features(examples, max_seq_length, tokenizer):\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n print(example.text_a)\\n tokens_a = tokenizer.tokenize(example.text_a)\\n\\n tokens_b = None\\n if example.text_b:\\n tokens_b = tokenizer.tokenize(example.text_b)\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n segment_ids = [0] * len(tokens)\\n\\n if tokens_b:\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\n segment_ids += [1] * (len(tokens_b) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n input_mask = [1] * len(input_ids)\\n\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n \\n labels_ids = []\\n for label in example.labels:\\n labels_ids.append(int(label))\\n \\n if ex_index < 0:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [str(x) for x in tokens]))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n logger.info(\\n \\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n logger.info(\\\"label: %s (id = %s)\\\" % (example.labels, labels_ids))\\n\\n features.append(\\n InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_ids=labels_ids))\\n return features\",\n \"def convert_examples_to_features(self):\\n features = []\\n max_label_len = 0\\n # find ou the max label length\\n labels_list = []\\n for ex_index, example in enumerate(self.examples):\\n processor = example.processor\\n label_ids = self.tokenizer.text_to_ids(processor.label2string(example.label)) + [self.tokenizer.eos_id]\\n max_label_len = max(len(label_ids), max_label_len)\\n labels_list.append(label_ids)\\n if self.max_seq_length_decoder is None:\\n self.max_seq_length_decoder = max_label_len\\n else:\\n self.max_seq_length_decoder = max(\\n self.max_seq_length_decoder, max_label_len\\n ) # take the max of the two to be conservative\\n for ex_index, example in enumerate(self.examples):\\n taskname = example.taskname\\n taskname_ids = self.tokenizer.text_to_ids(taskname)\\n processor = example.processor\\n if ex_index % 10000 == 0:\\n logging.info(f\\\"Writing example {ex_index} of {len(self.examples)}\\\")\\n label_ids = labels_list[ex_index]\\n enc_query = processor.get_ptune_query(\\n example.content,\\n self.pseudo_token_id,\\n self.max_seq_length - self.max_seq_length_decoder + 1,\\n self.templates,\\n self.tokenizer,\\n )\\n input_ids = enc_query + label_ids[:-1]\\n labels = [SMALL_NUM for i in range(len(enc_query) - 1)] + label_ids\\n features.append([input_ids, labels, enc_query, taskname_ids])\\n return features\",\n \"def _parse_single_example(example, options):\\n # Initialize `keys_to_features`.\\n keys_to_features = {\\n TFExampleFields.img_id: tf.io.FixedLenFeature([], tf.string),\\n TFExampleFields.annot_id: tf.io.FixedLenFeature([], tf.string),\\n TFExampleFields.answer_label: tf.io.FixedLenFeature([], tf.int64),\\n TFExampleFields.img_bbox_label: tf.io.VarLenFeature(tf.string),\\n TFExampleFields.img_bbox_score: tf.io.VarLenFeature(tf.float32),\\n TFExampleFields.img_bbox_feature: tf.io.VarLenFeature(tf.float32),\\n TFExampleFields.question: tf.io.VarLenFeature(tf.string),\\n TFExampleFields.question_tag: tf.io.VarLenFeature(tf.int64),\\n }\\n for bbox_key in TFExampleFields.img_bbox_field_keys:\\n bbox_field = os.path.join(TFExampleFields.img_bbox_scope, bbox_key)\\n keys_to_features[bbox_field] = tf.io.VarLenFeature(tf.float32)\\n for i in range(1, 1 + NUM_CHOICES):\\n keys_to_features.update({\\n TFExampleFields.cls_bert + '_%i' % i:\\n tf.io.VarLenFeature(tf.float32),\\n TFExampleFields.question_bert + '_%i' % i:\\n tf.io.VarLenFeature(tf.float32),\\n TFExampleFields.answer_choice + '_%i' % i:\\n tf.io.VarLenFeature(tf.string),\\n TFExampleFields.answer_choice_tag + '_%i' % i:\\n tf.io.VarLenFeature(tf.int64),\\n TFExampleFields.answer_choice_bert + '_%i' % i:\\n tf.io.VarLenFeature(tf.float32)\\n })\\n\\n # Initialize `items_to_handlers`.\\n items_to_handlers = {\\n InputFields.img_id:\\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.img_id,\\n default_value=''),\\n InputFields.annot_id:\\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.annot_id,\\n default_value=''),\\n InputFields.answer_label:\\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.answer_label,\\n default_value=-1),\\n InputFields.object_bboxes:\\n tfexample_decoder.BoundingBox(\\n keys=TFExampleFields.img_bbox_field_keys,\\n prefix=TFExampleFields.img_bbox_scope),\\n InputFields.object_labels:\\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.img_bbox_label,\\n default_value=''),\\n InputFields.object_scores:\\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.img_bbox_score,\\n default_value=0),\\n InputFields.question:\\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.question,\\n default_value=PAD),\\n InputFields.question_tag:\\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.question_tag,\\n default_value=-1),\\n TFExampleFields.img_bbox_feature:\\n tfexample_decoder.Tensor(tensor_key=TFExampleFields.img_bbox_feature,\\n default_value=0),\\n }\\n\\n for i in range(1, 1 + NUM_CHOICES):\\n tensor_key = TFExampleFields.cls_bert + '_%i' % i\\n items_to_handlers[tensor_key] = tfexample_decoder.Tensor(\\n tensor_key=tensor_key, default_value=0)\\n tensor_key = TFExampleFields.question_bert + '_%i' % i\\n items_to_handlers[tensor_key] = tfexample_decoder.Tensor(\\n tensor_key=tensor_key, default_value=0)\\n tensor_key = TFExampleFields.answer_choice + '_%i' % i\\n items_to_handlers[tensor_key] = tfexample_decoder.Tensor(\\n tensor_key=tensor_key, default_value=PAD)\\n tensor_key = TFExampleFields.answer_choice_tag + '_%i' % i\\n items_to_handlers[tensor_key] = tfexample_decoder.Tensor(\\n tensor_key=tensor_key, default_value=-1)\\n tensor_key = TFExampleFields.answer_choice_bert + '_%i' % i\\n items_to_handlers[tensor_key] = tfexample_decoder.Tensor(\\n tensor_key=tensor_key, default_value=0)\\n if options.decode_jpeg:\\n keys_to_features.update({\\n TFExampleFields.img_encoded: tf.io.FixedLenFeature([], tf.string),\\n TFExampleFields.img_format: tf.io.FixedLenFeature([], tf.string),\\n })\\n items_to_handlers.update({\\n InputFields.img_data:\\n tfexample_decoder.Image(image_key=TFExampleFields.img_encoded,\\n format_key=TFExampleFields.img_format,\\n shape=None)\\n })\\n\\n # Decode example.\\n example_decoder = tfexample_decoder.TFExampleDecoder(keys_to_features,\\n items_to_handlers)\\n\\n output_keys = example_decoder.list_items()\\n output_tensors = example_decoder.decode(example)\\n output_tensors = [\\n x if x.dtype != tf.int64 else tf.cast(x, tf.int32) for x in output_tensors\\n ]\\n decoded_example = dict(zip(output_keys, output_tensors))\\n return _update_decoded_example(decoded_example, options)\",\n \"def convert_example_to_features_for_test(example, max_seq_length, tokenizer):\\r\\n features = []\\r\\n tokens = []\\r\\n labels_temp = []\\r\\n for i, word in enumerate(example.text_a.split(' ')):\\r\\n token_wordpiece = tokenizer.tokenize(word) #04/26/1882 ['04', '/', '26', '/', '1882']\\r\\n tokens.extend(token_wordpiece)\\r\\n for m in range(len(token_wordpiece)):\\r\\n if m == 0:\\r\\n labels_temp.append(0)\\r\\n else:\\r\\n labels_temp.append('X')\\r\\n # max_seq_length-1\\r\\n if len(tokens) >= max_seq_length - 1:\\r\\n tokens = tokens[0:(max_seq_length - 2)]\\r\\n labels_temp = labels_temp[0:(max_seq_length - 2)]\\r\\n\\r\\n ntokens = []\\r\\n new_labels_temp = []\\r\\n segment_ids = []\\r\\n\\r\\n ntokens.append('[CLS]')\\r\\n new_labels_temp.append('[CLS]')\\r\\n segment_ids.append(0)\\r\\n for i, token in enumerate(tokens):\\r\\n ntokens.append(token)\\r\\n new_labels_temp.append(labels_temp[i])\\r\\n segment_ids.append(0)\\r\\n ntokens.append('[SEP]')\\r\\n new_labels_temp.append('[SEP]')\\r\\n segment_ids.append(0)\\r\\n input_ids = tokenizer.convert_tokens_to_ids(ntokens)\\r\\n input_mask = [1] * len(input_ids)\\r\\n\\r\\n #if the length is short, tianbu 0\\r\\n while len(input_ids) < max_seq_length:\\r\\n input_ids.append(0)\\r\\n input_mask.append(0)\\r\\n segment_ids.append(0)\\r\\n #we do not concerned about it\\r\\n ntokens.append('NULL')\\r\\n\\r\\n assert len(input_ids) == max_seq_length\\r\\n assert len(input_mask) == max_seq_length\\r\\n assert len(segment_ids) == max_seq_length\\r\\n\\r\\n features.append(InputFeatures(input_ids=input_ids, input_mask=input_mask, segment_ids=segment_ids, label_ids=None))\\r\\n return features, new_labels_temp\",\n \"def convert_example(example,\\n tokenizer,\\n label_list,\\n max_seq_length=512,\\n is_test=False):\\n if not is_test:\\n # `label_list == None` is for regression task\\n label_dtype = \\\"int64\\\" if label_list else \\\"float32\\\"\\n # Get the label\\n label = example['labels']\\n label = np.array([label], dtype=label_dtype)\\n # Convert raw text to feature\\n if (int(is_test) + len(example)) == 2:\\n example = tokenizer(example['sentence'], max_seq_len=max_seq_length)\\n else:\\n example = tokenizer(\\n example['sentence1'],\\n text_pair=example['sentence2'],\\n max_seq_len=max_seq_length)\\n\\n if not is_test:\\n return example['input_ids'], example['token_type_ids'], label\\n else:\\n return example['input_ids'], example['token_type_ids']\",\n \"def read_oqmrc_examples(input_file, is_test):\\n\\n examples = []\\n drop1 = 0\\n drop2 = 0\\n drop3 = 0\\n drop4 = 0\\n with tf.gfile.Open(input_file, \\\"r\\\") as reader:\\n for line in reader:\\n sample = json.loads(line)\\n answer = None\\n if not is_test:\\n answer = sample[\\\"answer\\\"]\\n answer = answer.strip()\\n if answer == \\\"\\\":\\n drop1 += 1\\n continue\\n alternatives = sample['alternatives'].split(\\\"|\\\")\\n for i, alter in enumerate(alternatives):\\n alternatives[i] = alter.strip()\\n while \\\"\\\" in alternatives:\\n alternatives.remove(\\\"\\\") # 删除空白的无效候选项\\n if len(alternatives) != 3:\\n drop2 += 1\\n continue\\n random.shuffle(alternatives)\\n label = None\\n ansnum = 0\\n for i, alter in enumerate(alternatives):\\n if alternatives[i] == answer:\\n label = i\\n ansnum += 1\\n if ansnum > 1:\\n drop3 += 1\\n continue\\n if not is_test and label is None:\\n drop4 += 1\\n continue\\n paragraph_text = sample[\\\"passage\\\"]\\n qas_id = sample[\\\"query_id\\\"]\\n question_text = sample[\\\"query\\\"]\\n example = OqmrcExample(\\n q_id=qas_id,\\n question=question_text,\\n paragraph=paragraph_text,\\n alters=alternatives,\\n answer=answer,\\n label=label)\\n examples.append(example)\\n tf.logging.info(\\\"%d个样本答案为空白，%d个样本候选项不足，%d个样本多个候选项和答案相同，%d个样本找不到答案\\\" %\\n (drop1, drop2, drop3, drop4))\\n return examples\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n\\n label_map = {label: i for i, label in enumerate(label_list, 1)}\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n textlist = example.text_a.split(' ')\\n labellist = example.label\\n tokens = []\\n labels = []\\n valid = []\\n label_mask = []\\n for i, word in enumerate(textlist):\\n token = tokenizer.tokenize(word)\\n tokens.extend(token)\\n label_1 = labellist[i]\\n for m in range(len(token)):\\n if m == 0:\\n labels.append(label_1)\\n valid.append(1)\\n label_mask.append(True)\\n else:\\n valid.append(0)\\n if len(tokens) >= max_seq_length - 1:\\n tokens = tokens[0:(max_seq_length - 2)]\\n labels = labels[0:(max_seq_length - 2)]\\n valid = valid[0:(max_seq_length - 2)]\\n label_mask = label_mask[0:(max_seq_length - 2)]\\n ntokens = []\\n segment_ids = []\\n label_ids = []\\n ntokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n valid.insert(0, 1)\\n label_mask.insert(0, True)\\n label_ids.append(label_map[\\\"[CLS]\\\"])\\n for i, token in enumerate(tokens):\\n ntokens.append(token)\\n segment_ids.append(0)\\n if len(labels) > i:\\n label_ids.append(label_map[labels[i]])\\n ntokens.append(\\\"[SEP]\\\")\\n segment_ids.append(0)\\n valid.append(1)\\n label_mask.append(True)\\n label_ids.append(label_map[\\\"[SEP]\\\"])\\n input_ids = tokenizer.convert_tokens_to_ids(ntokens)\\n input_mask = [1] * len(input_ids)\\n label_mask = [True] * len(label_ids)\\n while len(input_ids) < max_seq_length:\\n input_ids.append(0)\\n input_mask.append(0)\\n segment_ids.append(0)\\n label_ids.append(0)\\n valid.append(1)\\n label_mask.append(False)\\n while len(label_ids) < max_seq_length:\\n label_ids.append(0)\\n label_mask.append(False)\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n assert len(label_ids) == max_seq_length\\n assert len(valid) == max_seq_length\\n assert len(label_mask) == max_seq_length\\n\\n features.append(\\n InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_id=label_ids,\\n valid_ids=valid,\\n label_mask=label_mask))\\n return features\",\n \"def convert_examples_to_features(\\n examples: List[InputExample],\\n label_list: List[str],\\n max_length: int,\\n tokenizer: PreTrainedTokenizer,\\n pad_token_segment_id=0,\\n pad_on_left=False,\\n pad_token=0,\\n mask_padding_with_zero=True,\\n) -> List[InputFeatures]:\\n\\n label_map = {label: i for i, label in enumerate(label_list)}\\n\\n features = []\\n for (ex_index, example) in tqdm.tqdm(enumerate(examples), desc=\\\"convert examples to features\\\"):\\n if ex_index % 10000 == 0:\\n logger.info(\\\"Writing example %d of %d\\\" % (ex_index, len(examples)))\\n choices_features = []\\n for ending_idx, (context, ending) in enumerate(zip(example.contexts, example.endings)):\\n text_a = context\\n if example.question.find(\\\"_\\\") != -1:\\n # this is for cloze question\\n text_b = example.question.replace(\\\"_\\\", ending)\\n else:\\n text_b = example.question + \\\" \\\" + ending\\n if len(text_a) == 0:\\n logger.info(\\\"context of example %d have length 0\\\" % (ex_index))\\n text_a = \\\" \\\"\\n\\n inputs = tokenizer.encode_plus(text_a, text_b, add_special_tokens=True, max_length=max_length,)\\n if \\\"num_truncated_tokens\\\" in inputs and inputs[\\\"num_truncated_tokens\\\"] > 0:\\n logger.info(\\n \\\"Attention! you are cropping tokens (swag task is ok). \\\"\\n \\\"If you are training ARC and RACE and you are poping question + options,\\\"\\n \\\"you need to try to use a bigger max seq length!\\\"\\n )\\n\\n input_ids, token_type_ids = inputs[\\\"input_ids\\\"], inputs[\\\"token_type_ids\\\"]\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding_length = max_length - len(input_ids)\\n if pad_on_left:\\n input_ids = ([pad_token] * padding_length) + input_ids\\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\\n else:\\n input_ids = input_ids + ([pad_token] * padding_length)\\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\\n\\n assert len(input_ids) == max_length\\n assert len(attention_mask) == max_length\\n assert len(token_type_ids) == max_length\\n choices_features.append((input_ids, attention_mask, token_type_ids))\\n\\n label = label_map[example.label]\\n\\n if ex_index < 2:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"race_id: {}\\\".format(example.example_id))\\n for choice_idx, (input_ids, attention_mask, token_type_ids) in enumerate(choices_features):\\n logger.info(\\\"choice: {}\\\".format(choice_idx))\\n logger.info(\\\"input_ids: {}\\\".format(\\\" \\\".join(map(str, input_ids))))\\n logger.info(\\\"attention_mask: {}\\\".format(\\\" \\\".join(map(str, attention_mask))))\\n logger.info(\\\"token_type_ids: {}\\\".format(\\\" \\\".join(map(str, token_type_ids))))\\n logger.info(\\\"label: {}\\\".format(label))\\n\\n features.append(InputFeatures(example_id=example.example_id, choices_features=choices_features, label=label,))\\n\\n return features\",\n \"def _create_yes_no(self):\\n text_maker = TextMaker(join(\\\"fonts\\\", \\\"party_txt_font.png\\\"), max=15)\\n self.yes_no_surf = text_maker.get_surface(\\\"YES NO\\\")\",\n \"def create_example(line, tfidf_dict, is_training, args):\\n sample = json.loads(line, object_pairs_hook=collections.OrderedDict)\\n example_id = sample['example_id']\\n question_text = sample['question_text']\\n ori_doc_tokens = sample['document_text'].split()\\n\\n # 抽取特定段落list[list]\\n tfidf_cands_ids = tfidf_dict[str(example_id)]\\n # tfidf并不保证所有段落必定出现在所选段落内\\n if is_training:\\n long_answer_cand = sample['annotations'][0]['long_answer']['candidate_index']\\n\\n if long_answer_cand != -1:\\n # answer_cand保证top_level是true\\n if sample['long_answer_candidates'][long_answer_cand]['top_level'] is False:\\n gt_start_token = sample['long_answer_candidates'][long_answer_cand]['start_token']\\n gt_end_token = sample['long_answer_candidates'][long_answer_cand]['end_token']\\n for il, cand in enumerate(sample['long_answer_candidates']):\\n if cand['start_token'] <= gt_start_token and cand['end_token'] >= gt_end_token \\\\\\n and cand['top_level'] is True:\\n long_answer_cand = il\\n break\\n # training的时候当tfidf中没有包含正确答案，且long_answer是存在的时候，tfidf的结果则只选目标段落\\n hit_answer = False\\n for pids in tfidf_cands_ids:\\n if long_answer_cand in pids:\\n hit_answer = True\\n break\\n if hit_answer is False:\\n tfidf_cands_ids = [[]]\\n token_count = 0\\n for ic, cand in enumerate(sample['long_answer_candidates']):\\n if cand['top_level'] is True:\\n tfidf_cands_ids[-1].append(ic)\\n token_count += (cand['end_token'] - cand['start_token'])\\n if token_count > 600:\\n tfidf_cands_ids.append([])\\n token_count = 0\\n while len(tfidf_cands_ids[-1]) == 0:\\n tfidf_cands_ids.pop(-1)\\n # 防止负样本爆炸，只选目标段落\\n tfidf_cands_ids = [cands for cands in tfidf_cands_ids if long_answer_cand in cands]\\n\\n # 由于接下来要对special_tokens排序，所以这里tfidf选择的段落要按照首段排序\\n tfidf_cands_ids = sorted(tfidf_cands_ids, key=lambda x: x[0])\\n\\n if args.do_combine: # 如果do_combine，我们把所有抽取的candidates合并到一起\\n tfidf_cands_ids_ = []\\n for c in tfidf_cands_ids:\\n tfidf_cands_ids_.extend(c)\\n tfidf_cands_ids = [tfidf_cands_ids_]\\n\\n # 获取candidate的type信息，去除HTML符号\\n # 保留特殊token到段首\\n # 注意table paragraph list最小起步是1\\n special_tokens_count = {'ContextId': -1, 'Table': 0, 'Paragraph': 0, 'List': 0}\\n\\n # 为了保证一致性，TABLE, Paragraph等结构信息还是尽可能保留...\\n selected_ps = []\\n for i, cand_ids in enumerate(tfidf_cands_ids):\\n position_map = [] # 新paragraph到老paragraph的token位置映射\\n map_to_origin = {} # 为了保证能够对答案位置进行正确的偏移，这里需要重新搞一波map映射\\n p_tokens = []\\n for cand_id in cand_ids:\\n st = sample['long_answer_candidates'][cand_id]['start_token']\\n ed = sample['long_answer_candidates'][cand_id]['end_token']\\n ind = st # 追踪pos_map\\n ori_cand_tokens = ori_doc_tokens[st:ed]\\n # 先加ContextId特殊token\\n special_tokens_count['ContextId'] += 1\\n special_tokens_count['ContextId'] = min(special_tokens_count['ContextId'], args.max_position)\\n p_tokens.append('[ContextId={}]'.format(special_tokens_count['ContextId']))\\n position_map.append(ind)\\n cand_type = get_candidate_type(ori_cand_tokens)\\n if cand_type in special_tokens_count:\\n special_tokens_count[cand_type] += 1\\n special_tokens_count[cand_type] = min(special_tokens_count[cand_type], args.max_position)\\n p_tokens.append('[' + cand_type + '=' + str(special_tokens_count[cand_type]) + ']')\\n position_map.append(ind)\\n for token in ori_cand_tokens:\\n if '<' not in token: # 去除HTML符号\\n p_tokens.append(token)\\n position_map.append(ind)\\n map_to_origin[ind] = len(position_map) - 1\\n ind += 1\\n assert len(position_map) == len(p_tokens)\\n\\n selected_ps.append({'paragraph_tokens': p_tokens,\\n 'question_text': question_text,\\n 'position_map': position_map,\\n 'map_to_origin': map_to_origin,\\n 'example_id': example_id,\\n 'paragraph_id': str(example_id) + '_' + str(i),\\n 'answer_type': AnswerType['UNKNOWN'],\\n 'long_start': -1,\\n 'long_end': -1,\\n 'short_start': -1,\\n 'short_end': -1,\\n 'short_answer_text': None})\\n\\n answer = None\\n answer_text = None\\n if is_training and 'annotations' in sample:\\n # 答案只取第一个标注\\n annotation = sample['annotations'][0]\\n if annotation is not None:\\n long_answer = annotation['long_answer']\\n if long_answer['candidate_index'] != -1:\\n answer_type = AnswerType['LONG']\\n ori_long_start = long_answer['start_token']\\n ori_long_end = long_answer['end_token']\\n else:\\n answer_type = AnswerType['UNKNOWN']\\n ori_long_start = -1\\n ori_long_end = -1\\n\\n assert annotation[\\\"yes_no_answer\\\"] in (\\\"YES\\\", \\\"NO\\\", \\\"NONE\\\")\\n if annotation[\\\"yes_no_answer\\\"] == 'YES':\\n answer_text = 'YES'\\n answer_type = AnswerType['YES']\\n elif annotation[\\\"yes_no_answer\\\"] == 'NO':\\n answer_text = 'NO'\\n answer_type = AnswerType['NO']\\n\\n short_answers = annotation['short_answers']\\n # 这里short answer必须排序\\n short_answers = sorted(short_answers, key=lambda x: x['start_token'])\\n if len(short_answers) > 0:\\n # TODO:可能存在多个short，multi-tag\\n answer_type = AnswerType['SHORT']\\n short_ans = random.choice(short_answers)\\n ori_short_start = short_ans['start_token']\\n ori_short_end = short_ans['end_token']\\n answer_text = ori_doc_tokens[ori_short_start:ori_short_end]\\n answer_text = \\\" \\\".join([at for at in answer_text if '<' not in at])\\n else:\\n ori_short_start = -1\\n ori_short_end = -1\\n else:\\n answer_type = AnswerType['UNKNOWN']\\n ori_long_start = -1\\n ori_long_end = -1\\n ori_short_start = -1\\n ori_short_end = -1\\n\\n answer = {'answer_type': answer_type,\\n 'ori_long_start': ori_long_start,\\n 'ori_long_end': ori_long_end,\\n 'ori_short_start': ori_short_start,\\n 'ori_short_end': ori_short_end}\\n\\n if answer['answer_type'] == AnswerType['SHORT'] and answer_text == \\\"\\\":\\n print('WRONG SHORT', answer, answer_text)\\n answer['answer_type'] = AnswerType['LONG']\\n answer['ori_short_start'] = -1\\n answer['ori_short_end'] = -1\\n\\n examples = []\\n for p_sample in selected_ps:\\n if answer and answer['answer_type'] != AnswerType['UNKNOWN']:\\n # 如果长答案在候选里，那么首位必然都在这个候选里，!!!注意这里的ori_long_end必须-1，否则可能会漏!!!\\n if answer['ori_long_start'] in p_sample['map_to_origin'] \\\\\\n and answer['ori_long_end'] - 1 in p_sample['map_to_origin']:\\n final_long_start = p_sample['map_to_origin'][answer['ori_long_start']]\\n final_long_end = p_sample['map_to_origin'][answer['ori_long_end'] - 1] + 1\\n long_answer_text = \\\" \\\".join(p_sample['paragraph_tokens'][final_long_start:final_long_end])\\n\\n p_sample['answer_type'] = answer['answer_type']\\n p_sample['long_start'] = final_long_start\\n p_sample['long_end'] = final_long_end\\n\\n # 短答案必然在长答案所在段落里面\\n if answer['answer_type'] == AnswerType['SHORT']:\\n final_short_start = p_sample['map_to_origin'][answer['ori_short_start']]\\n final_short_end = p_sample['map_to_origin'][answer['ori_short_end'] - 1] + 1\\n p_sample['short_start'] = final_short_start\\n p_sample['short_end'] = final_short_end\\n\\n new_answer_text = \\\" \\\".join(p_sample['paragraph_tokens'][final_short_start:final_short_end])\\n assert new_answer_text == answer_text, (new_answer_text, answer_text, long_answer_text)\\n p_sample['short_answer_text'] = new_answer_text\\n\\n # 由于negative的段落太多了，所以这里先过滤掉一部分\\n elif is_training and random.random() > args.example_neg_filter:\\n continue\\n\\n # 由于negative的段落太多了，所以这里先过滤掉一部分\\n elif is_training and random.random() > args.example_neg_filter:\\n continue\\n\\n p_sample.pop('map_to_origin')\\n examples.append(p_sample)\\n\\n return examples\",\n \"def gen_yes_no_markup() -> ReplyKeyboardMarkup:\\n\\n return yes_no_markup\",\n \"def demonstration_examples(kind):\\n\\n DIR = './data/demos/'\\n RNN_DEMO = \\\"-demo_rnn_examples\\\"\\n EXT = '.pkl'\\n\\n if kind == 'rnn':\\n return pd.read_pickle(DIR+RNN_DEMO+EXT)\",\n \"def label_notes(all_notes_lines):\\n# nf = nemo.core.NeuralModuleFactory(backend=nemo.core.Backend.PyTorch, log_dir=None)\\n #note_line_queries = notes.split('\\\\n')\\n #note_line_queries = ['pt arrived obtunded not answering questions responding to voice and sternal rub speaking in garbled voice pupils unequal left 3mm and right 2mm brisk bilaterally trauma sicu MD aware currently recieving keppra IV finished dilantin gtt due for level at 08a EEG today LSCTA on 3LNC sats 100 % SBP 90 s to 100 s HR NSR no ectopy 60 s NS @ 75cc continuous +BS no stools rec d lactulose at OSH to recieve PR q4h abd soft non-tender non-distended foley in place draining adequate amt clear yellow urine skin intact left 20G x2 WNL wife Name NI']\\n\\n# labels_dict = get_vocab(LABELS_DICT)\\n# pretrained_bert_model = nemo_nlp.nm.trainables.get_huggingface_model(\\n# bert_config=BERT_CONFIG, pretrained_model_name=PRETRAINED_MODEL_NAME\\n# )\\n\\n# tokenizer = nemo.collections.nlp.data.tokenizers.get_tokenizer(\\n# tokenizer_name=TOKENIZER,\\n# pretrained_model_name=PRETRAINED_MODEL_NAME,\\n# tokenizer_model=TOKENIZER_MODEL,\\n# )\\n# hidden_size = pretrained_bert_model.hidden_size\\n\\n load_datalayer_begin_time = time.time()\\n data_layer = nemo_nlp.nm.data_layers.BertTokenClassificationInferDataLayer(\\n queries=all_notes_lines, tokenizer=tokenizer, max_seq_length=MAX_SEQ_LENGTH, batch_size=2000\\n )\\n load_datalayer_end_time = time.time()\\n\\n classifier = TokenClassifier(hidden_size=hidden_size, num_classes=len(labels_dict))\\n\\n input_ids, input_type_ids, input_mask, _, subtokens_mask = data_layer()\\n \\n load_hidden_states_begin_time = time.time()\\n hidden_states = pretrained_bert_model(input_ids=input_ids, token_type_ids=input_type_ids, attention_mask=input_mask)\\n load_hidden_states_end_time = time.time()\\n load_logits_begin_time = time.time()\\n logits = classifier(hidden_states=hidden_states)\\n load_logits_end_time = time.time()\\n\\n ###########################################################################\\n\\n # Instantiate an optimizer to perform `infer` action\\n infer_begin_time = time.time()\\n evaluated_tensors = nf.infer(tensors=[logits, subtokens_mask], checkpoint_dir=CHECKPOINT_DIR)\\n infer_end_time = time.time()\\n\\n logits, subtokens_mask = [concatenate(tensors) for tensors in evaluated_tensors]\\n\\n preds = np.argmax(logits, axis=2) \\n all_notes_labeled_lines = []\\n\\n for i, query in enumerate(all_notes_lines):\\n logging.info(f'Query: {query}')\\n\\n pred = preds[i][subtokens_mask[i] > 0.5]\\n words = query.strip().split()\\n\\n #replaced with logic below instead of raising an error:\\n '''\\n if len(pred) != len(words):\\n logging.info('Preds length: ' + str(len(preds[i])))\\n logging.info('subtokens_mask length: ' + str(len(subtokens_mask[i])))\\n logging.info('Pred length: ' + str(len(pred)))\\n logging.info('words length: ' + str(len(words)))\\n logging.info('Preds: ' + str(preds.tolist()))\\n logging.info('subtokens_mask: ' + str(subtokens_mask[i]))\\n logging.info('Pred:' + str(pred.tolist()))\\n logging.info('words:' + str(words))\\n\\n labeled_note = '__Prediction/Word Mismatch__ pred length: ' + str(len(pred)) + ', words length: ' + str(len(words))\\n break\\n #raise ValueError('Pred and words must be of the same length')\\n \\n output = ''\\n for j, w in enumerate(words):\\n output += w\\n label = labels_dict[pred[j]]\\n if label != NONE_LABEL:\\n label = add_brackets(label)\\n output += label\\n output += ' '\\n labeled_note += '\\\\n' + output.strip()\\n logging.info(f'Combined: {output.strip()}')\\n\\n '''\\n\\n if len(pred) == len(words):\\n output = ''\\n for j, w in enumerate(words):\\n output += w\\n label = labels_dict[pred[j]]\\n if label != NONE_LABEL:\\n label = add_brackets(label)\\n output += label\\n output += ' '\\n all_notes_labeled_lines.append(output.strip())\\n logging.info(f'Combined: {output.strip()}')\\n else:\\n all_notes_labeled_lines.append(query)\\n pred_length = str(len(pred))\\n word_length = str(len(words))\\n logging.info(f'__Prediction/Word Length Mismatch__ pred length: {pred_length}, words length: {word_length}')\\n logging.info(f'{query}')\\n \\n\\n print(str(load_datalayer_end_time-load_datalayer_begin_time)+' seconds to load the datalayer')\\n print(str(load_hidden_states_end_time-load_hidden_states_begin_time)+' seconds to load hidden states')\\n print(str(load_logits_end_time-load_logits_begin_time)+' seconds to load logits')\\n print(str(infer_end_time-infer_begin_time)+' seconds to run inference')\\n\\n return all_notes_labeled_lines\",\n \"def verify_startwith_rule2(self, type_tagged, type = None):\\n featuresets = []\\n for t, question_tag in type_tagged:\\n if t in type:\\n featuresets.append([self.startwith_feture2(question_tag),t])\\n else:\\n featuresets.append([self.startwith_feture2(question_tag),'other'])\\n print(featuresets)\\n perc = 0.5\\n train_set, test_set = featuresets[:int(len(featuresets)*perc)], featuresets[int(len(featuresets)*perc):]\\n classifier = nltk.NaiveBayesClassifier.train(train_set)\\n print(\\\"Accurancy \\\")\\n print(nltk.classify.accuracy(classifier, test_set))\\n classifier.show_most_informative_features(10)\",\n \"async def test_input_boolean(client, input_boolean_entities) -> None:\\n body = await generate_latest_metrics(client)\\n\\n assert (\\n 'input_boolean_state{domain=\\\"input_boolean\\\",'\\n 'entity=\\\"input_boolean.test\\\",'\\n 'friendly_name=\\\"Test\\\"} 1.0' in body\\n )\\n\\n assert (\\n 'input_boolean_state{domain=\\\"input_boolean\\\",'\\n 'entity=\\\"input_boolean.helper\\\",'\\n 'friendly_name=\\\"Helper\\\"} 0.0' in body\\n )\",\n \"def _process_examples(self):\\n logger = getLogger(\\\"problog_lfi\\\")\\n # value can be True / False / None\\n # ( atom ), ( ( value, ... ), ... )\\n\\n # Simple implementation: don't add neutral evidence.\\n\\n # ad_groups is a list of lists where each list contains an AD\\n ad_groups = list()\\n for ad in self._adatoms:\\n # if it's an AD group\\n if len(ad[1]) > 1:\\n ad_list = []\\n for var in ad[1]:\\n ad_list.append(Term(self.names[var].functor, *self.names[var].args))\\n ad_groups.append(tuple(ad_list))\\n logger.debug(\\\"AD Groups\\\\t\\\\t:\\\" + str(ad_groups))\\n\\n def all_false(d):\\n \\\"\\\"\\\"\\n This function recognizes inconsistent evidence s.t. all values are False in AD.\\n :param d: dictionary of ADs in form {term: value}\\n value can be True, False, None, \\\"Template\\\"\\n :return: whether all values are False\\n \\\"\\\"\\\"\\n # false_count should be the same as the length of d\\n false_count = sum(v is False for v in d.values())\\n return false_count == len(d)\\n\\n def all_false_except_one(d):\\n \\\"\\\"\\\"\\n This function recognizes incomplete evidence s.t.\\n the non-False value in AD needs to be set to True.\\n :param d: dictionary of ADs in form {term: value}\\n value can be True, False, None, \\\"Template\\\"\\n :return: whether all values except one are False\\n \\\"\\\"\\\"\\n false_count = sum(v is False for v in d.values())\\n the_left_is_none = bool(sum(v is None for v in d.values()))\\n return (false_count == len(d) - 1) and the_left_is_none\\n\\n def getADtemplate(d, atom=None):\\n \\\"\\\"\\\"\\n This function gets atom's complement AD template.\\n This should only be used when the AD contains non-ground terms.\\n :param d: dictionary of ADs in form {term: value}\\n value can be True, False, None, \\\"Template\\\"\\n :param atom: an evidence\\n :return: atom's complement AD template\\n \\\"\\\"\\\"\\n if atom is not None:\\n temp_dict = {\\n k: v\\n for k, v in d.items()\\n if v == \\\"Template\\\" and atom.signature != k.signature\\n }\\n return temp_dict\\n else:\\n temp_dict = {k: v for k, v in d.items() if v == \\\"Template\\\"}\\n return temp_dict\\n\\n def add_to_ad_evidence(pair, l, ADtemplate):\\n \\\"\\\"\\\"\\n :param pair: a new pair of (atom, value)\\n :param l: a list of dictionaries, all dictionaries need to have the same format\\n :return:\\n \\\"\\\"\\\"\\n (k, v) = pair\\n # if entry k exists, update the value with k\\n for d in l:\\n if k in d:\\n d[k] = v\\n return\\n # if entry k does not exist, create a new dictionary from template\\n # and instantiate it with k\\n new_d = dict()\\n for temp_k in ADtemplate.keys():\\n new_key = Term(temp_k.functor, *k.args)\\n new_d[new_key] = None\\n # put v in there\\n new_d[k] = v\\n l.append(new_d)\\n\\n if self.infer_AD_values:\\n result = ExampleSet()\\n inconsistent = False\\n # iterate over all examples given in .ev\\n for index, example in enumerate(self.examples):\\n ad_evidences = []\\n non_ad_evidence = {}\\n for ad_group in ad_groups:\\n # create a dictionary to memorize what evidence is given in AD\\n d = dict()\\n # TODO: what if the AD contains both ground and non-ground????\\n # e.g. t(_)::a; t(_)::b(X)\\n for var in ad_group:\\n if var.is_ground():\\n d[var] = None # for ground unknown evidence\\n else:\\n d[var] = \\\"Template\\\" # for unground unknown evidence\\n ad_evidences.append(d)\\n\\n # add all evidence in the example to ad_evidences\\n for atom, value in example:\\n # if atom has a tunable probability to learn\\n if any([atom.signature == name.signature for name in self.names]):\\n if len(atom.args) == 0: # Propositional evidence\\n # insert evidence\\n is_ad = False\\n for d in ad_evidences:\\n if atom in d:\\n d[atom] = value\\n is_ad = True\\n if not is_ad:\\n non_ad_evidence[\\n atom\\n ] = value\\n else: # First Order evidence\\n # find the right AD dictionary : AD_dict\\n AD_dict = None\\n for d in ad_evidences:\\n if any([atom.signature == k.signature for k in d]):\\n AD_dict = d\\n # if the instantiation is new, add it as a key to the dictionary\\n if AD_dict and AD_dict.get(atom) is None:\\n AD_dict[atom] = value\\n # also add other AD parts in the dictionary with value==None\\n other_ADs = getADtemplate(AD_dict, atom)\\n for otherAD in other_ADs.keys():\\n new_key = Term(otherAD.functor, *atom.args)\\n AD_dict[new_key] = AD_dict.get(new_key, None)\\n else:\\n non_ad_evidence[atom] = value\\n else:\\n non_ad_evidence[atom] = value\\n\\n # grounded_ad_evidences contains all usable evidence (gound, not template)\\n grounded_ad_evidences = []\\n for d in ad_evidences:\\n # for first order evidence dictionaries\\n if \\\"Template\\\" in d.values():\\n # new_ad_evidence is a list of dictionaries\\n # each dictionary is a group of the AD template instantiation\\n new_ad_evidence = list()\\n # get template AD evidence\\n ADtemplate = getADtemplate(d)\\n # group all pairs according to ADtemplate\\n for k, v in d.items():\\n if v != \\\"Template\\\":\\n add_to_ad_evidence((k, v), new_ad_evidence, ADtemplate)\\n grounded_ad_evidences += new_ad_evidence\\n else:\\n # simply us them\\n grounded_ad_evidences.append(d)\\n\\n inconsistent_example = False\\n for i, d in enumerate(grounded_ad_evidences):\\n # inconsistent1 = multiple_true(d)\\n inconsistent2 = all_false(d)\\n add_compliment = all_false_except_one(d)\\n\\n if inconsistent2:\\n inconsistent_example = True\\n continue\\n elif add_compliment:\\n for key, value in d.items():\\n if value is None:\\n grounded_ad_evidences[i][key] = True\\n\\n if not inconsistent_example and len(grounded_ad_evidences) > 0:\\n # There are (fully tunable) ADs in the program\\n evidence_list = []\\n for d in grounded_ad_evidences:\\n for key, value in d.items():\\n if value is not None:\\n if (key, value) not in evidence_list:\\n # TODO: Switch to orderedSet so we don't have to check whether it's in already\\n evidence_list.append((key, value))\\n\\n for key, value in non_ad_evidence.items():\\n evidence_list.append((key, value))\\n\\n atoms, values = zip(*evidence_list)\\n result.add(index, atoms, values)\\n\\n else:\\n # (No AD case) or (Inconsistent Evidence Case)\\n atoms, values = zip(*example)\\n result.add(index, atoms, values)\\n return result\\n else:\\n # smarter: compile-once all examples with same atoms\\n result = ExampleSet()\\n for index, example in enumerate(self.examples):\\n atoms, values = zip(*example)\\n result.add(index, atoms, values)\\n return result\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n\\n label_map = {label: i for i, label in enumerate(label_list)}\\n tokens_a_longer_max_seq_length = 0\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n tokens_a = tokenizer.tokenize(example.text_a)\\n tokens_b = None\\n\\n len_tokens_a = len(tokens_a)\\n len_tokens_b = 0\\n\\n\\n\\n if example.text_b:\\n tokens_b = tokenizer.tokenize(example.text_b)\\n len_tokens_b = len(tokens_b)\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\n # length is less than the specified length.\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n if (len_tokens_a + len_tokens_b) > (max_seq_length - 2):\\n tokens_a_longer_max_seq_length += 1\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n # the entire model is fine-tuned.\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n segment_ids = [0] * len(tokens)\\n\\n if tokens_b:\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\n segment_ids += [1] * (len(tokens_b) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\n assert len(input_ids)==max_seq_length\\n assert len(input_mask)==max_seq_length\\n assert len(segment_ids)==max_seq_length\\n\\n label_id = label_map[example.label]\\n if ex_index < 1 and example.guid is not None and example.guid.startswith('train'):\\n logger.info(\\\"\\\\n\\\\n*** Example ***\\\")\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [str(x) for x in tokens]))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n logger.info(\\n \\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n logger.info(\\\"label: %s (id = %d)\\\" % (example.label, label_id))\\n logger.info(\\\"\\\\n\\\\n\\\")\\n\\n features.append(\\n InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_id=label_id))\\n\\n logger.info(\\\":: Sentences longer than max_sequence_length: %d\\\" % (tokens_a_longer_max_seq_length))\\n logger.info(\\\":: Num sentences: %d\\\" % (len(examples)))\\n return features\",\n \"def bool_fix(name_dates, candidate_json, yes_no_key):\\n for candidate in name_dates:\\n for key in yes_no_key:\\n test = str(candidate_json[candidate][key].strip())\\n if test == 'Yes' or test == 'yes' or test == 'Y' or test == 'y':\\n candidate_json[candidate][key] = True\\n elif test == 'No' or test == 'no' or test == 'N' or test == 'n':\\n candidate_json[candidate][key] = False\\n else:\\n # returns incorrect data for error exploration\\n print(test)\\n return candidate_json\",\n \"def np_example_to_features(np_example: FeatureDict,\\n config: ml_collections.ConfigDict,\\n random_seed: int = 0) -> FeatureDict:\\n np_example = dict(np_example)\\n num_res = int(np_example['seq_length'][0])\\n cfg, feature_names = make_data_config(config, num_res=num_res)\\n\\n if 'deletion_matrix_int' in np_example:\\n np_example['deletion_matrix'] = (\\n np_example.pop('deletion_matrix_int').astype(np.float32))\\n\\n if USE_TF:\\n tf_graph = tf.Graph()\\n with tf_graph.as_default(), tf.device('/device:CPU:0'):\\n tf.compat.v1.set_random_seed(random_seed)\\n tensor_dict = proteins_dataset.np_to_tensor_dict(\\n np_example=np_example, features=feature_names)\\n\\n processed_batch = input_pipeline.process_tensors_from_config(\\n tensor_dict, cfg)\\n\\n tf_graph.finalize()\\n\\n with tf.Session(graph=tf_graph) as sess:\\n features = sess.run(processed_batch)\\n\\n else:\\n array_dict = input_pipeline.np_to_array_dict(\\n np_example=np_example,\\n features=feature_names,\\n use_templates=cfg.common.use_templates)\\n features = input_pipeline.process_arrays_from_config(array_dict, cfg)\\n features = {k: v for k, v in features.items() if v.dtype != 'O'}\\n\\n extra_msa_length = cfg.common.max_extra_msa\\n for k in ['extra_msa', 'extra_has_deletion', 'extra_deletion_value',\\n 'extra_msa_mask']:\\n features[k] = features[k][:, :extra_msa_length]\\n\\n for k in features.keys():\\n if features[k].dtype == np.int64:\\n features[k] = features[k].astype(np.int32)\\n elif features[k].dtype == np.float64:\\n features[k] = features[k].astype(np.float32)\\n\\n return features\",\n \"def test_ann_features():\\n CQT(file_struct, FeatureTypes.ann_beatsync, sr=11025).features\",\n \"def read_marco_examples(input_file, is_training):\\n with open(input_file, \\\"r\\\") as reader:\\n source = json.load(reader)\\n\\n def is_whitespace(c):\\n if c == \\\" \\\" or c == \\\"\\\\t\\\" or c == \\\"\\\\r\\\" or c == \\\"\\\\n\\\" or ord(c) == 0x202F:\\n return True\\n return False\\n\\n \\n def is_alphabet(char):\\n if (char >= '\\\\u0041' and char <= '\\\\u005a') or (char >= '\\\\u0061' and char <= '\\\\u007a'):\\n return True\\n return False\\n def is_number(char):\\n if char >= '\\\\u0030' and char <= '\\\\u0039':\\n return True\\n return False\\n def is_other(uchar):\\n if not (is_number(uchar) or is_alphabet(uchar)):\\n return True\\n return False\\n\\n \\n def z_tokenize(text):\\n doc_tokens = []\\n char_to_word_offset = []\\n\\n # pas2tokens\\n prev_is_whitespace = True\\n for c in text:\\n if is_whitespace(c):\\n prev_is_whitespace = True\\n else:\\n if prev_is_whitespace or (doc_tokens[-1][-1] == '.' and not is_number(c)):\\n doc_tokens.append(c)\\n else:\\n doc_tokens[-1] += c\\n prev_is_whitespace = False\\n char_to_word_offset.append(len(doc_tokens) - 1)\\n char_to_word_offset.append(len(doc_tokens))\\n\\n return doc_tokens, char_to_word_offset\\n\\n query_ids = source['query_id']\\n queries = source['query']\\n passages = source['passages']\\n answers = source.get('answers', {})\\n\\n examples = []\\n for qid in query_ids:\\n passage = passages[qid]\\n query = queries[qid]\\n answer = answers.get(qid)\\n\\n if is_training:\\n if answer is None or answer[0] == 'No Answer Present.':\\n continue\\n\\n for ans in answer[0:1]:\\n if len(ans) == 0:\\n continue\\n\\n \\n is_match = False\\n for ind, pas in enumerate(passage[:10]):\\n paragraph_text = pas['passage_text']\\n pos = paragraph_text.find(ans)\\n if pos >= 0:\\n is_match = True\\n if not is_match:\\n continue\\n \\n for ind, pas in enumerate(passage[:10]):\\n paragraph_text = pas['passage_text']\\n doc_tokens, char_to_word_offset = z_tokenize(paragraph_text)\\n if pas.get('is_selected', False):\\n is_select = 1.0\\n else:\\n is_select = 0.0\\n pos = paragraph_text.find(ans)\\n if pos >= 0:\\n start = char_to_word_offset[pos]\\n end = char_to_word_offset[pos+len(ans)]\\n ans_text = ans\\n has_answer = 1.0\\n else:\\n start = 0\\n end = 0\\n ans_text = ans\\n has_answer = 0.0\\n\\n example = MarcoExample(\\n qas_id=qid,\\n question_text=query,\\n doc_tokens=doc_tokens,\\n orig_answer_text=ans_text,\\n start_position=start,\\n end_position=end,\\n is_select=is_select,\\n has_answer = has_answer)\\n examples.append(example)\\n if ind < 9:\\n for idx in range(ind+1, 10):\\n examples.append(example)\\n else:\\n if answer[0] == 'No Answer Present.':\\n continue\\n \\n for ans in answer[0:1]:\\n is_match = False\\n for ind, pas in enumerate(passage[:10]):\\n paragraph_text = pas['passage_text']\\n pos = paragraph_text.find(ans)\\n if pos >= 0:\\n is_match = True\\n \\n start = None\\n end = None\\n ans_text = None\\n if not is_match:\\n ans_text = ''\\n\\n for ind, pas in enumerate(passage[:10]):\\n paragraph_text = pas['passage_text']\\n doc_tokens, char_to_word_offset = z_tokenize(paragraph_text)\\n if pas.get('is_selected', False):\\n is_select = 1.0\\n else:\\n is_select = 0.0\\n pos = paragraph_text.find(ans)\\n if pos >= 0:\\n has_answer = 1.0\\n else:\\n has_answer = 0.0\\n\\n example = MarcoExample(\\n qas_id=qid,\\n question_text=query,\\n doc_tokens=doc_tokens,\\n orig_answer_text=ans_text,\\n start_position=start,\\n end_position=end,\\n is_select=is_select,\\n has_answer = has_answer)\\n examples.append(example)\\n if ind < 9:\\n for idx in range(ind+1, 10):\\n examples.append(example)\\n\\n return examples\",\n \"def yes(func):\\n return MultipleChoice(_text_from_func(func), Answer('yes'), Answer('no'), is_code=True)\",\n \"def convert_example_to_features_test(example, cur_time, max_seq_length, tokenizer):\\n tokens_a = example\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\n # length is less than the specified length.\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n\\n\\n\\n\\n tokens_a = truncate_seq_pair_test(tokens_a, max_seq_length - 3)\\n\\n\\n\\n\\n savedtoken = []\\n for l in range(5):\\n if tokens_a[-1] in {\\\".\\\", \\\",\\\", \\\"'\\\", \\\"`\\\" , \\\"'\\\", \\\"?\\\"}:\\n savedtoken.insert(0, tokens_a[-1])\\n tokens_a.pop()\\n\\n else:\\n break\\n\\n\\n lmlabel = tokens_a[-1]\\n lmlabel = tokenizer.vocab[lmlabel]\\n tokens_a.pop()\\n\\n\\n # concatenate lm labels and account for CLS, SEP, SEP\\n if not savedtoken:\\n extra_lm_labels = 1\\n else:\\n extra_lm_labels = len(savedtoken)\\n\\n lm_label_ids = ([-1] + len(tokens_a)*[-1] + [lmlabel] + extra_lm_labels * [-1] + [-1])\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n # the entire model is fine-tuned.\\n tokens = []\\n segment_ids = []\\n tokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n\\n\\n\\n\\n for token in tokens_a:\\n tokens.append(token)\\n segment_ids.append(0)\\n\\n tokens.append(\\\"[MASK]\\\")\\n if not savedtoken:\\n tokens.append(\\\".\\\")\\n segment_ids.append(0)\\n else:\\n tokens.extend(savedtoken)\\n for _ in range(len(savedtoken)):\\n segment_ids.append(0)\\n tokens.append(\\\"[SEP]\\\")\\n\\n \\n segment_ids.append(0)\\n segment_ids.append(0)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n while len(input_ids) < max_seq_length:\\n input_ids.append(0)\\n input_mask.append(0)\\n segment_ids.append(0)\\n lm_label_ids.append(-1)\\n\\n # print(\\\"input, segment, lmlabel\\\")\\n # print(len(input_ids))\\n # print(len(segment_ids))\\n # print(len(lm_label_ids))\\n if len(input_ids) != max_seq_length:\\n import pdb; pdb.set_trace()\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n assert len(lm_label_ids) == max_seq_length\\n\\n if cur_time < 5:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"cur_time: %s\\\" % (cur_time))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [str(x) for x in tokens]))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n logger.info(\\n \\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n logger.info(\\\"LM label: %s \\\" % (lm_label_ids))\\n\\n features = InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n lm_label_ids=lm_label_ids,\\n )\\n return features\",\n \"def bool_to_word(boolean):\\n return 'Yes' if boolean else 'No'\",\n \"def convert_single_ls_example(example, tokenizer, is_training, args):\\n tok_to_orig_index = []\\n orig_to_tok_index = []\\n all_doc_tokens = [] # all subtokens of original doc after tokenizing\\n features = []\\n for (i, token) in enumerate(example['paragraph_tokens']):\\n orig_to_tok_index.append(len(all_doc_tokens))\\n sub_tokens = albert_tokenize(tokenizer, token)\\n tok_to_orig_index.extend([i] * len(sub_tokens))\\n all_doc_tokens.extend(sub_tokens)\\n\\n # 特别注意！由于在paragraph_tokens中我们的token已经映射过一次了\\n # 这里wordpiece等于又映射了一遍，所以这里的操作是二次映射\\n if example['position_map']:\\n tok_to_orig_index = [example['position_map'][index] for index in tok_to_orig_index]\\n\\n # QUERY\\n query_tokens = []\\n query_tokens.append(\\\"[Q]\\\")\\n query_tokens.extend(albert_tokenize(tokenizer, example['question_text']))\\n if len(query_tokens) > args.max_query_length:\\n query_tokens = query_tokens[-args.max_query_length:]\\n\\n # ANSWER 预处理的时候先长短分开\\n tok_long_start_position = -1\\n tok_long_end_position = -1\\n tok_short_start_position = -1\\n tok_short_end_position = -1\\n # 这里终点是必然在para_tokens内的\\n if is_training:\\n if example['answer_type'] != AnswerType['UNKNOWN']:\\n tok_long_start_position = orig_to_tok_index[example['long_start']]\\n if example['long_end'] == len(orig_to_tok_index):\\n tok_long_end_position = orig_to_tok_index[-1]\\n else:\\n tok_long_end_position = orig_to_tok_index[example['long_end']] - 1\\n if example['answer_type'] == AnswerType['SHORT']:\\n tok_short_start_position = orig_to_tok_index[example['short_start']]\\n if example['short_end'] == len(orig_to_tok_index):\\n tok_short_end_position = orig_to_tok_index[-1]\\n else:\\n tok_short_end_position = orig_to_tok_index[example['short_end']] - 1\\n\\n # Get max tokens number for original doc,\\n # should minus query tokens number and 3 special tokens\\n # The -3 accounts for [CLS], [SEP] and [SEP]\\n max_tokens_for_doc = args.max_seq_length - len(query_tokens) - 3\\n\\n # We can have documents that are longer than the maximum sequence length.\\n # To deal with this we do a sliding window approach, where we take chunks\\n # of up to our max length with a stride of `doc_stride`.\\n _DocSpan = collections.namedtuple(\\\"DocSpan\\\", [\\\"start\\\", \\\"length\\\"])\\n doc_spans = []\\n start_offset = 0\\n while start_offset < len(all_doc_tokens):\\n length = len(all_doc_tokens) - start_offset # compute number of tokens remaining unsliding\\n length = min(length, max_tokens_for_doc) # determine current sliding window size\\n doc_spans.append(_DocSpan(start=start_offset, length=length))\\n\\n # Consider case for reaching end of original doc\\n if start_offset + length == len(all_doc_tokens):\\n break\\n start_offset += min(length, args.doc_stride)\\n\\n # Convert window + query + special tokens to feature\\n for (doc_span_index, doc_span) in enumerate(doc_spans):\\n tokens = []\\n token_to_orig_map = {}\\n token_is_max_context = {}\\n segment_ids = []\\n tokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n tokens.extend(query_tokens)\\n segment_ids.extend([0] * len(query_tokens))\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(0)\\n\\n for i in range(doc_span.length):\\n split_token_index = doc_span.start + i\\n token_to_orig_map[len(tokens)] = tok_to_orig_index[split_token_index]\\n\\n is_max_context = check_is_max_context(doc_spans, doc_span_index, split_token_index)\\n token_is_max_context[len(tokens)] = is_max_context\\n tokens.append(all_doc_tokens[split_token_index])\\n segment_ids.append(1)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(1)\\n assert len(tokens) == len(segment_ids)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (args.max_seq_length - len(input_ids))\\n input_ids.extend(padding)\\n input_mask.extend(padding)\\n segment_ids.extend(padding)\\n\\n assert len(input_ids) == args.max_seq_length\\n assert len(input_mask) == args.max_seq_length\\n assert len(segment_ids) == args.max_seq_length\\n\\n long_start_position = None\\n long_end_position = None\\n short_start_position = None\\n short_end_position = None\\n answer_type = None\\n answer_text = \\\"\\\"\\n if is_training:\\n doc_start = doc_span.start\\n doc_end = doc_span.start + doc_span.length - 1\\n # For training, if our document chunk does not contain an annotation\\n # we throw it out, since there is nothing to predict.\\n contains_an_annotation = (tok_long_start_position >= doc_start and tok_long_end_position <= doc_end)\\n # 负样本需要经过采样，且目标为[CLS]\\n if (not contains_an_annotation) or example['answer_type'] == AnswerType['UNKNOWN']:\\n if args.include_unknowns < 0 or random.random() > args.include_unknowns:\\n continue\\n long_start_position = 0\\n long_end_position = 0\\n short_start_position = 0\\n short_end_position = 0\\n answer_type = AnswerType['UNKNOWN']\\n else:\\n doc_offset = len(query_tokens) + 2\\n long_start_position = tok_long_start_position - doc_start + doc_offset\\n long_end_position = tok_long_end_position - doc_start + doc_offset\\n if example['answer_type'] == AnswerType['SHORT']:\\n short_start_position = tok_short_start_position - doc_start + doc_offset\\n short_end_position = tok_short_end_position - doc_start + doc_offset\\n else:\\n short_start_position = 0\\n short_end_position = 0\\n answer_type = example['answer_type']\\n\\n # 如果是短答案，对一下答案是否正确\\n if example['answer_type'] == AnswerType['SHORT']:\\n answer_text = \\\" \\\".join(tokens[short_start_position:(short_end_position + 1)])\\n answer_text = answer_text.replace(' ', '').replace(u\\\"▁\\\", ' ').strip()\\n gt_answer = example['short_answer_text'].lower()\\n answer_text_chars = [c for c in answer_text if c not in \\\" \\\\t\\\\r\\\\n\\\" and ord(c) != 0x202F]\\n gt_answer_chars = [c for c in gt_answer if c not in \\\" \\\\t\\\\r\\\\n\\\" and ord(c) != 0x202F]\\n if \\\"\\\".join(answer_text_chars) != \\\"\\\".join(gt_answer_chars) \\\\\\n and len(\\\"\\\".join(answer_text_chars)) != len(\\\"\\\".join(gt_answer_chars)):\\n print(answer_text, 'V.S.', gt_answer)\\n\\n feature = InputLSFeatures(\\n unique_id=None,\\n example_index=None,\\n doc_span_index=doc_span_index,\\n tokens=tokens,\\n token_to_orig_map=token_to_orig_map,\\n token_is_max_context=token_is_max_context,\\n input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n long_start_position=long_start_position,\\n long_end_position=long_end_position,\\n short_start_position=short_start_position,\\n short_end_position=short_end_position,\\n answer_text=answer_text,\\n answer_type=answer_type)\\n\\n features.append(feature)\\n\\n return features\",\n \"def yes():\\r\\n global CurrentState\\r\\n global CurrentInput\\r\\n global RESPONSEOPTIONS\\r\\n state = RESPONSEOPTIONS[0]\\r\\n # print(\\\"state under update:\\\",state)\\r\\n state.updateStateIncoming(CurrentState.id)\\r\\n state.updateStateWords(CurrentInput)\\r\\n # print(\\\"writing state:\\\",state)\\r\\n writeState(state)\\r\\n CurrentState = getState(state.id)\",\n \"def convert_examples_to_features(self):\\n features = []\\n for ex_index, example in enumerate(self.examples):\\n if ex_index % 10000 == 0:\\n logging.info(f\\\"Writing example {ex_index} of {len(self.examples)}\\\")\\n\\n text_to_text_query = self.processor.get_t5_prompted_query(example.text_a, example.text_b)\\n enc_query = self.tokenizer.text_to_ids(text_to_text_query)\\n if len(enc_query) > self.max_seq_length:\\n enc_query = enc_query[: self.max_seq_length]\\n dec_query = (\\n [self.tokenizer.bos_id]\\n + self.tokenizer.text_to_ids(self.processor.label2string(example.label))\\n + [self.tokenizer.eos_id]\\n )\\n\\n dec_input = dec_query[:-1]\\n labels = dec_query[1:]\\n\\n features.append([enc_query, dec_input, labels])\\n\\n return features\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n\\n label_map = {label : i for i, label in enumerate(label_list)}\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n tokens = example.text\\n\\n# # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n# if len(tokens) > max_seq_length - 2:\\n# tokens = tokens[:(max_seq_length - 2)]\\n\\n bert_tokens = []\\n orig_to_tok_map = []\\n\\n bert_tokens.append(\\\"[CLS]\\\")\\n for token in tokens:\\n new_tokens = tokenizer.tokenize(token)\\n if len(bert_tokens) + len(new_tokens) > max_seq_length - 1:\\n # print(\\\"You shouldn't see this since the test set is already pre-separated.\\\")\\n break\\n else:\\n orig_to_tok_map.append(len(bert_tokens))\\n bert_tokens.extend(new_tokens)\\n bert_tokens.append(\\\"[SEP]\\\")\\n\\n if len(bert_tokens) == 2: # edge case\\n continue\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n # the entire model is fine-tuned.\\n\\n input_ids = tokenizer.convert_tokens_to_ids(bert_tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n\\n segment_ids = [0] * max_seq_length # no use for our problem\\n\\n labels = example.label\\n label_ids = [0] * max_seq_length\\n label_mask = [0] * max_seq_length\\n\\n for label, target_index in zip(labels, orig_to_tok_map):\\n label_ids[target_index] = label_map[label]\\n label_mask[target_index] = 1\\n\\n assert len(segment_ids) == max_seq_length\\n assert len(label_ids) == max_seq_length\\n assert len(label_mask) == max_seq_length\\n\\n features.append(\\n InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_ids=label_ids,\\n label_mask=label_mask))\\n return features\",\n \"def to_features(self):\\n to_return = dict()\\n\\n to_return['bias'] = 1.0\\n to_return['user:' + self.user] = 1.0\\n to_return['format:' + self.format] = 1.0\\n to_return['token:' + self.token.lower()] = 1.0\\n\\n to_return['part_of_speech:' + self.part_of_speech] = 1.0\\n for morphological_feature in self.morphological_features:\\n to_return['morphological_feature:' + morphological_feature] = 1.0\\n to_return['dependency_label:' + self.dependency_label] = 1.0\\n\\n return to_return\",\n \"def put_yes_no(root, var, labels, flag):\\n yesfield = Tk.Radiobutton(root, text=labels[0], variable=var, value=1)\\n yesfield.grid(row=0, column=0, sticky=Tk.W)\\n yesfield.config(bg=BGCOL)\\n nofield = Tk.Radiobutton(root, text=labels[1], variable=var, value=0)\\n nofield.grid(row=0, column=1, sticky=Tk.W)\\n nofield.config(bg=BGCOL)\\n if flag:\\n yesfield.select()\\n else:\\n nofield.select()\",\n \"def boolean_func(experiment):\",\n \"def parse_features(self, skip=...):\\n ...\",\n \"def parse_features(self, skip=...):\\n ...\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n\\n # label_map = {label : i for i, label in enumerate(label_list)}\\n\\n features = []\\n exindex = {}\\n passagelens = []\\n\\n sum_of_labels = 0\\n\\n for (ex_index, example) in tqdm(enumerate(examples), desc=\\\"Tokenizing:\\\"):\\n if example.text_a not in tokenmap.keys():\\n tokens_a = tokenizer.tokenize(example.text_a)\\n tokenmap[example.text_a] = tokens_a\\n else:\\n tokens_a = tokenmap[example.text_a]\\n\\n tokens_b = None\\n if example.text_b:\\n if example.text_b not in tokenmap.keys():\\n tokens_b = tokenizer.tokenize(example.text_b)\\n tokenmap[example.text_b] = tokens_b\\n else:\\n tokens_b = tokenmap[example.text_b]\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\n # length is less than the specified length.\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n\\n passagelens.append(len(tokens_a) + len(tokens_b) + 3)\\n\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n # the entire model is fine-tuned.\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n segment_ids = [0] * len(tokens)\\n\\n if tokens_b:\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\n segment_ids += [1] * (len(tokens_b) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n\\n # label_id = label_map[example.label]\\n label_id = example.label\\n\\n sum_of_labels += label_id\\n\\n if ex_index < 5:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [str(x) for x in tokens]))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n logger.info(\\n \\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n logger.info(\\\"label: %s (id = %d)\\\" % (str(example.label), 0))\\n\\n exindex[ex_index] = example.guid\\n features.append(\\n InputFeatures(uuid=ex_index,\\n input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_id=label_id))\\n\\n print(\\\"Passage Token Lengths Distribution\\\", passagelens[-1], np.percentile(passagelens, 50),\\n np.percentile(passagelens, 90), np.percentile(passagelens, 95), np.percentile(passagelens, 99))\\n return features, exindex\",\n \"def convert_examples_to_features(self, examples, max_seq_length, tokenizer):\\n\\n features = []\\n\\n for (ex_index, example) in enumerate(tqdm(examples)):\\n\\n tokens = tokenizer.tokenize(example.text_a)\\n\\n gather_ids = list()\\n for (idx, token) in enumerate(tokens):\\n if (not token.startswith(\\\"##\\\") and idx < max_seq_length - 2):\\n gather_ids.append(idx + 1)\\n\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n if len(tokens) > max_seq_length - 2:\\n tokens = tokens[:max_seq_length - 2]\\n\\n tokens = [\\\"[CLS]\\\"] + tokens + [\\\"[SEP]\\\"]\\n segment_ids = [0] * len(tokens)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\n gather_padding = [0] * (max_seq_length - len(gather_ids))\\n gather_masks = [1] * len(gather_ids) + gather_padding\\n gather_ids += gather_padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n assert len(gather_ids) == max_seq_length\\n assert len(gather_masks) == max_seq_length\\n\\n partial_masks = self.generate_partial_masks(example.text_a.split(' '), max_seq_length, example.label,\\n self.labels)\\n\\n if ex_index < 2:\\n self.logger.info(\\\"*** Example ***\\\")\\n self.logger.info(\\\"guid: %s\\\" % (example.guid))\\n self.logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [str(x) for x in tokens]))\\n self.logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n self.logger.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n self.logger.info(\\n \\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n self.logger.info(\\n \\\"gather_ids: %s\\\" % \\\" \\\".join([str(x) for x in gather_ids]))\\n self.logger.info(\\n \\\"gather_masks: %s\\\" % \\\" \\\".join([str(x) for x in gather_masks]))\\n # self.logger.info(\\\"label: %s (id = %s)\\\" % (example.label, \\\" \\\".join([str(x) for x in label_ids])))\\n\\n features.append(\\n InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n partial_masks=partial_masks,\\n gather_ids=gather_ids,\\n gather_masks=gather_masks))\\n\\n return features\",\n \"def test_human_readable_boolean_false():\\n # TODO: add a test case that follows the provided example\",\n \"def convert_single_example(example, tokenizer, is_training, args):\\n tok_to_orig_index = []\\n orig_to_tok_index = []\\n all_doc_tokens = [] # all subtokens of original doc after tokenizing\\n features = []\\n for (i, token) in enumerate(example['paragraph_tokens']):\\n orig_to_tok_index.append(len(all_doc_tokens))\\n sub_tokens = albert_tokenize(tokenizer, token)\\n tok_to_orig_index.extend([i] * len(sub_tokens))\\n all_doc_tokens.extend(sub_tokens)\\n\\n # 特别注意！由于在paragraph_tokens中我们的token已经映射过一次了\\n # 这里wordpiece等于又映射了一遍，所以这里的操作是二次映射\\n if example['position_map']:\\n tok_to_orig_index = [example['position_map'][index] for index in tok_to_orig_index]\\n\\n # QUERY\\n query_tokens = []\\n query_tokens.append(\\\"[Q]\\\")\\n query_tokens.extend(albert_tokenize(tokenizer, example['question_text']))\\n if len(query_tokens) > args.max_query_length:\\n query_tokens = query_tokens[-args.max_query_length:]\\n\\n # ANSWER 预处理的时候先长短分开\\n tok_start_position = -1\\n tok_end_position = -1\\n # 这里终点是必然在para_tokens内的\\n if is_training:\\n # 现阶段，有短答案预测短答案，否则预测长答案\\n if example['answer_type'] != AnswerType['UNKNOWN']:\\n tok_long_start_position = orig_to_tok_index[example['long_start']]\\n if example['long_end'] == len(orig_to_tok_index):\\n tok_long_end_position = orig_to_tok_index[-1]\\n else:\\n tok_long_end_position = orig_to_tok_index[example['long_end']] - 1\\n tok_start_position = tok_long_start_position\\n tok_end_position = tok_long_end_position\\n if example['answer_type'] == AnswerType['SHORT']:\\n tok_short_start_position = orig_to_tok_index[example['short_start']]\\n if example['short_end'] == len(orig_to_tok_index):\\n tok_short_end_position = orig_to_tok_index[-1]\\n else:\\n tok_short_end_position = orig_to_tok_index[example['short_end']] - 1\\n tok_start_position = tok_short_start_position\\n tok_end_position = tok_short_end_position\\n\\n # Get max tokens number for original doc,\\n # should minus query tokens number and 3 special tokens\\n # The -3 accounts for [CLS], [SEP] and [SEP]\\n max_tokens_for_doc = args.max_seq_length - len(query_tokens) - 3\\n\\n # We can have documents that are longer than the maximum sequence length.\\n # To deal with this we do a sliding window approach, where we take chunks\\n # of up to our max length with a stride of `doc_stride`.\\n _DocSpan = collections.namedtuple(\\\"DocSpan\\\", [\\\"start\\\", \\\"length\\\"])\\n doc_spans = []\\n start_offset = 0\\n while start_offset < len(all_doc_tokens):\\n length = len(all_doc_tokens) - start_offset # compute number of tokens remaining unsliding\\n length = min(length, max_tokens_for_doc) # determine current sliding window size\\n doc_spans.append(_DocSpan(start=start_offset, length=length))\\n\\n # Consider case for reaching end of original doc\\n if start_offset + length == len(all_doc_tokens):\\n break\\n start_offset += min(length, args.doc_stride)\\n\\n # Convert window + query + special tokens to feature\\n for (doc_span_index, doc_span) in enumerate(doc_spans):\\n tokens = []\\n token_to_orig_map = {}\\n token_is_max_context = {}\\n segment_ids = []\\n tokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n tokens.extend(query_tokens)\\n segment_ids.extend([0] * len(query_tokens))\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(0)\\n\\n for i in range(doc_span.length):\\n split_token_index = doc_span.start + i\\n token_to_orig_map[len(tokens)] = tok_to_orig_index[split_token_index]\\n\\n is_max_context = check_is_max_context(doc_spans, doc_span_index, split_token_index)\\n token_is_max_context[len(tokens)] = is_max_context\\n tokens.append(all_doc_tokens[split_token_index])\\n segment_ids.append(1)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(1)\\n assert len(tokens) == len(segment_ids)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (args.max_seq_length - len(input_ids))\\n input_ids.extend(padding)\\n input_mask.extend(padding)\\n segment_ids.extend(padding)\\n\\n assert len(input_ids) == args.max_seq_length\\n assert len(input_mask) == args.max_seq_length\\n assert len(segment_ids) == args.max_seq_length\\n\\n start_position = None\\n end_position = None\\n answer_type = None\\n answer_text = \\\"\\\"\\n if is_training:\\n doc_start = doc_span.start\\n doc_end = doc_span.start + doc_span.length - 1\\n # For training, if our document chunk does not contain an annotation\\n # we throw it out, since there is nothing to predict.\\n contains_an_annotation = (tok_start_position >= doc_start and tok_end_position <= doc_end)\\n # 负样本需要经过采样，且目标为[CLS]\\n if (not contains_an_annotation) or example['answer_type'] == AnswerType['UNKNOWN']:\\n if args.include_unknowns < 0 or random.random() > args.include_unknowns:\\n continue\\n start_position = 0\\n end_position = 0\\n answer_type = AnswerType['UNKNOWN']\\n else:\\n doc_offset = len(query_tokens) + 2\\n start_position = tok_start_position - doc_start + doc_offset\\n end_position = tok_end_position - doc_start + doc_offset\\n answer_type = example['answer_type']\\n\\n # 如果是短答案，对一下答案是否正确\\n if example['answer_type'] == AnswerType['SHORT']:\\n answer_text = \\\" \\\".join(tokens[start_position:(end_position + 1)])\\n answer_text = answer_text.replace(' ', '').replace(u\\\"▁\\\", ' ').strip()\\n gt_answer = example['short_answer_text'].lower()\\n answer_text_chars = [c for c in answer_text if c not in \\\" \\\\t\\\\r\\\\n\\\" and ord(c) != 0x202F]\\n gt_answer_chars = [c for c in gt_answer if c not in \\\" \\\\t\\\\r\\\\n\\\" and ord(c) != 0x202F]\\n if \\\"\\\".join(answer_text_chars) != \\\"\\\".join(gt_answer_chars):\\n print(answer_text, 'V.S.', gt_answer)\\n\\n feature = InputFeatures(\\n unique_id=None,\\n example_index=None,\\n doc_span_index=doc_span_index,\\n tokens=tokens,\\n token_to_orig_map=token_to_orig_map,\\n token_is_max_context=token_is_max_context,\\n input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n start_position=start_position,\\n end_position=end_position,\\n answer_text=answer_text,\\n answer_type=answer_type)\\n\\n features.append(feature)\\n\\n return features\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n\\n\\tlabel_map = {label : i for i, label in enumerate(label_list)}\\n\\n\\tfeatures = []\\n\\tfor (ex_index, example) in enumerate(examples):\\n\\t\\ttokens_a = tokenizer.tokenize(example.text_a)\\n\\n\\t\\ttokens_b = None\\n\\t\\tif example.text_b:\\n\\t\\t\\ttokens_b = tokenizer.tokenize(example.text_b)\\n\\t\\t\\t# Modifies `tokens_a` and `tokens_b` in place so that the total\\n\\t\\t\\t# length is less than the specified length.\\n\\t\\t\\t# Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n\\t\\t\\t_truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n\\t\\telse:\\n\\t\\t\\t# Account for [CLS] and [SEP] with \\\"- 2\\\"\\n\\t\\t\\tif len(tokens_a) > max_seq_length - 2:\\n\\t\\t\\t\\ttokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n\\t\\t# The convention in BERT is:\\n\\t\\t# (a) For sequence pairs:\\n\\t\\t# tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n\\t\\t# type_ids: 0 0 0\\t0\\t0\\t 0\\t 0 0\\t1 1 1 1 1 1\\n\\t\\t# (b) For single sequences:\\n\\t\\t# tokens: [CLS] the dog is hairy . [SEP]\\n\\t\\t# type_ids: 0 0 0 0 0\\t 0 0\\n\\t\\t#\\n\\t\\t# Where \\\"type_ids\\\" are used to indicate whether this is the first\\n\\t\\t# sequence or the second sequence. The embedding vectors for `type=0` and\\n\\t\\t# `type=1` were learned during pre-training and are added to the wordpiece\\n\\t\\t# embedding vector (and position vector). This is not *strictly* necessary\\n\\t\\t# since the [SEP] token unambigiously separates the sequences, but it makes\\n\\t\\t# it easier for the model to learn the concept of sequences.\\n\\t\\t#\\n\\t\\t# For classification tasks, the first vector (corresponding to [CLS]) is\\n\\t\\t# used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n\\t\\t# the entire model is fine-tuned.\\n\\t\\ttokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n\\t\\tsegment_ids = [0] * len(tokens)\\n\\n\\t\\tif tokens_b:\\n\\t\\t\\ttokens += tokens_b + [\\\"[SEP]\\\"]\\n\\t\\t\\tsegment_ids += [1] * (len(tokens_b) + 1)\\n\\n\\t\\tinput_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n\\t\\t# The mask has 1 for real tokens and 0 for padding tokens. Only real\\n\\t\\t# tokens are attended to.\\n\\t\\tinput_mask = [1] * len(input_ids)\\n\\n\\t\\t# Zero-pad up to the sequence length.\\n\\t\\tpadding = [0] * (max_seq_length - len(input_ids))\\n\\t\\tinput_ids += padding\\n\\t\\tinput_mask += padding\\n\\t\\tsegment_ids += padding\\n\\n\\t\\tassert len(input_ids) == max_seq_length\\n\\t\\tassert len(input_mask) == max_seq_length\\n\\t\\tassert len(segment_ids) == max_seq_length\\n\\n\\t\\t\\n\\t\\tlabels_ids = [label_map[example.label]]\\n\\n#\\t\\t label_id = label_map[example.label]\\n\\t\\tif ex_index < 0:\\n\\t\\t\\tlogger.info(\\\"*** Example ***\\\")\\n\\t\\t\\tlogger.info(\\\"guid: %s\\\" % (example.guid))\\n\\t\\t\\tlogger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n\\t\\t\\t\\t\\t[str(x) for x in tokens]))\\n\\t\\t\\tlogger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n\\t\\t\\tlogger.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n\\t\\t\\tlogger.info(\\n\\t\\t\\t\\t\\t\\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n\\t\\t\\tlogger.info(\\\"label: %s (id = %s)\\\" % (example.labels, labels_ids))\\n\\n\\t\\tfeatures.append(\\n\\t\\t\\t\\tInputFeatures(input_ids=input_ids,\\n\\t\\t\\t\\t\\t\\t\\t input_mask=input_mask,\\n\\t\\t\\t\\t\\t\\t\\t segment_ids=segment_ids,\\n\\t\\t\\t\\t\\t\\t\\t label_ids=labels_ids))\\n\\treturn features\",\n \"def convert_single_example(ex_index, example, label_list, max_seq_length,\\n tokenizer):\\n label_map = {}\\n for (i, label) in enumerate(label_list):\\n label_map[label] = i\\n\\n input_ids, segment_ids, input_mask = \\\\\\n tokenizer.encode_text(text_a=example.text_a,\\n text_b=example.text_b,\\n max_seq_length=max_seq_length)\\n\\n label_id = label_map[example.label]\\n\\n # here we disable the verbose printing of the data\\n if ex_index < 0:\\n logging.info(\\\"*** Example ***\\\")\\n logging.info(\\\"guid: %s\\\", example.guid)\\n logging.info(\\\"input_ids: %s\\\", \\\" \\\".join([str(x) for x in input_ids]))\\n logging.info(\\\"input_ids length: %d\\\", len(input_ids))\\n logging.info(\\\"input_mask: %s\\\", \\\" \\\".join([str(x) for x in input_mask]))\\n logging.info(\\\"segment_ids: %s\\\", \\\" \\\".join([str(x) for x in segment_ids]))\\n logging.info(\\\"label: %s (id = %d)\\\", example.label, label_id)\\n\\n feature = InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_id=label_id)\\n return feature\",\n \"def load_boolq_file(filename, num_par=2):\\n tokenizer = tokenization.NltkTokenizer()\\n examples = []\\n with tf.gfile.Open(filename) as f:\\n for line in f:\\n obj = json.loads(line)\\n context = tokenizer.tokenize(obj[\\\"passage\\\"])\\n if FLAGS.max_passage_len:\\n context = context[:FLAGS.max_passage_len]\\n question = tokenizer.tokenize(obj[\\\"question\\\"])\\n examples.append((question, context, obj[\\\"answer\\\"]))\\n\\n def get_data():\\n out = list(examples)\\n np.random.shuffle(out)\\n return out\\n\\n ds = tf.data.Dataset.from_generator(get_data, (tf.string, tf.string, tf.bool),\\n ([None], [None], []))\\n\\n def to_dict(p, h, label):\\n return {\\\"hypothesis\\\": p, \\\"premise\\\": h, \\\"label\\\": label}\\n\\n return ds.map(to_dict, num_parallel_calls=num_par)\",\n \"def _transformEx(self,example):\\n x = []\\n x.extend(example) \\n x.append(1)\\n return x,example.label\",\n \"def nonlearning():\\n\\taT.featureAndTrain(['../../AudioData/chunked_data_sorted/pos', '../../AudioData/chunked_data_sorted/neg'], \\n\\t\\t\\t\\t\\t\\t1.0, 1.0, aT.shortTermWindow, aT.shortTermStep, \\n \\\"svm\\\", \\\"emotion_classifier\\\", True)\",\n \"def test_get_input_labeled(self):\\n result = pre.get_input(self.testfilename, labeled=True)\\n truth = (\\n [[Reference(0, 'm jones', \\n 'symbol intersect detect method improv spatial intersect join', \\n ['e rundensteiner', 'y huang'], 'geoinformatica', '81'),\\n Reference(1, 'matthew c jones', \\n 'improv spatial intersect join symbol intersect detect', \\n ['e rundensteiner', 'h kuno', 'p marron', 'v taube', 'y ra'], \\n 'sigmodels.intern manag data', '81'),\\n Reference(2, 'matthew c jones',\\n 'view materi techniqu complex hirarch object', ['e rundensteiner',\\n 'y huang'], 'ssd symposium larg spatial databas', '81')],\\n [Reference(3, 'mike w miller', 'domin draw bipartit graph', \\n ['l berg'], 'sigucc special interest group univers comput servic',\\n '185'),\\n Reference(4, 'mike w miller', 'rel compromis statist databas', \\n [], 'sigucc special interest group univers comput servic', '185')],\\n [Reference(5, 'c chen', 'formal approach scenario analysi',\\n ['d kung', 'j samuel', 'j gao', 'p hsia', 'y toyoshima'],\\n 'ieee softwar', '94')],\\n [Reference(6, 'jane j robinson', 'discours code clue context', [], \\n 'acl meet the associ comput linguist', '69'),\\n Reference(7, 'jane j robinson', 'diagram grammar dialogu', [],\\n 'cooper interfac inform system', '69')],\\n [Reference(8, 'a gupta', 'iri h java distanc educ', ['a gonzalez', \\n 'a hamid', 'c overstreet', 'h wahab', 'j wild', 'k maly', 's ghanem',\\n 'x zhu'], 'acm journal educ resourc comput', '0')],\\n [Reference(9, 'mary d brown',\\n 'intern redund represent limit bypass support pipelin adder regist '\\n 'file', ['y patt'], 'proceed the th ieee intern symposium high '\\n 'perform comput architectur hpca intern symposium high perform comput'\\n ' architectur talk slide', '43')]],\\n\\n ['m jones', 'e rundensteiner', 'y huang', 'matthew c jones', \\n 'e rundensteiner', 'h kuno', 'p marron', 'v taube', 'y ra', \\n 'matthew c jones', 'e rundensteiner', 'y huang', 'mike w miller',\\n 'l berg', 'mike w miller', 'c chen', 'd kung', 'j samuel', 'j gao',\\n 'p hsia', 'y toyoshima', 'jane j robinson', 'jane j robinson',\\n 'a gupta', 'a gonzalez', 'a hamid', 'c overstreet', 'h wahab', 'j wild',\\n 'k maly', 's ghanem', 'x zhu', 'mary d brown', 'y patt'])\\n self.assertEquals(result, truth)\",\n \"def get_yes_no(question):\\n complete_question = question + \\\" ([Y]es/[N]o): \\\"\\n\\n answer = get_verified_input(prompt=complete_question, verify_by_func=is_yes_or_no)\\n\\n # returns True is yes, False if no\\n return is_yes_or_no(answer, check_no=False)\",\n \"def extract_features(tlc):\\n text = clean_text(tlc['body'])\\n fields = dict()\\n # add features here #\\n fields['Top_comment_word_count'] = len(text.split(' '))\\n fields['Top_comment_text'] = text\\n\\n # Extract time-based features\\n def get_day_of_week(text):\\n return datetime.datetime.strptime(text, '%Y-%m-%d %H:%M:%S').weekday() + 1\\n\\n def get_day_of_month(text):\\n return datetime.datetime.strptime(text, '%Y-%m-%d %H:%M:%S').day\\n\\n def get_time_of_day(text):\\n return datetime.datetime.strptime(text, '%Y-%m-%d %H:%M:%S').hour\\n time_local = time.localtime(tlc['created_utc'])\\n time_local = time.strftime(\\\"%Y-%m-%d %H:%M:%S\\\", time_local)\\n fields['Top_comment_day'] = get_day_of_month(time_local)\\n fields['Top_comment_day_of_week'] = get_day_of_week(time_local)\\n fields['Top_comment_hour'] = get_time_of_day(time_local)\\n\\n # Extract gender value\\n gp = GenderPerformr()\\n probs, _ = gp.predict(tlc['author'])\\n # Rescale it from [0,1] to [-1,1]\\n fields['Top_comment_author_gender_value'] = 2 * probs - 1\\n\\n # Extract percentage of mispellings\\n check = SpellChecker(\\\"en_US\\\")\\n tokenizer = get_tokenizer(\\\"en_US\\\")\\n # Prevent the denominator from 0\\n def weird_division(n, d):\\n return n / d if d else 0\\n\\n def get_mispellings_percentage(text):\\n mispelling_count = 0\\n total_count = 0\\n if text == 'nan':\\n return total_count\\n else:\\n check.set_text(text)\\n for err in check:\\n mispelling_count = mispelling_count + 1\\n for w in tokenizer(text):\\n total_count = total_count + 1\\n value = weird_division(mispelling_count, total_count)\\n return value\\n fields['Top_comment_mispellings'] = get_mispellings_percentage(text)\\n\\n # Get politeness, agreement, support scores, and rescale them from [1,5] to [-1,1]\\n ar = Agreementr()\\n pr = Politenessr()\\n sr = Supportr()\\n fields['Top_comment_agreement_value'] = 0.5*float(ar.predict([text]))-1.5\\n fields['Top_comment_politeness_value'] = 0.5*float(pr.predict([text]))-1.5\\n fields['Top_comment_support_value'] = 0.5*float(sr.predict([text]))-1.5\\n\\n # Get toxicity scores\\n KEY = \\\"yourkey.txt\\\" # os.getenv(\\\"GOOGLE_API_KEY\\\")\\n service = discovery.build('commentanalyzer', 'v1alpha1', developerKey=KEY)\\n\\n def get_results(request_id, response, exception):\\n toxicity_scores.append((request_id, response))\\n\\n toxicity_scores = []\\n count = 0\\n batch = service.new_batch_http_request(callback=get_results)\\n analyze_request = {\\n 'comment': {'text': text},\\n \\\"requestedAttributes\\\": {\\n \\\"TOXICITY\\\": {},\\n \\\"SEVERE_TOXICITY\\\": {},\\n \\\"ATTACK_ON_COMMENTER\\\": {}\\n }\\n }\\n batch.add(service.comments().analyze(body=analyze_request), request_id=str(count))\\n batch.execute()\\n toxic_score = toxicity_scores[0][1]['attributeScores']['TOXICITY']['summaryScore']['value']\\n attack_score = toxicity_scores[0][1]['attributeScores']['ATTACK_ON_COMMENTER']['summaryScore']['value']\\n if toxic_score > 0.5:\\n fields['Top_comment_untuned_toxicity'] = 1\\n else:\\n fields['Top_comment_untuned_toxicity'] = 0\\n if toxic_score > 0.8 and attack_score > 0.5:\\n fields['Top_comment_tuned_toxicity'] = 1\\n else:\\n fields['Top_comment_tuned_toxicity'] = 0\\n # end of feature extractions #\\n return fields\",\n \"def convert_examples_to_features(examples, tokenizer, cls_token_segment_id=0, pad_token_id=0, pad_token_segment_id=0,\\r\\n pad_token_label_id=-100, sequence_a_segment_id=0, mask_padding_with_zero=True):\\r\\n cls_token = '[CLS]'\\r\\n sep_token = '[SEP]'\\r\\n\\r\\n features = []\\r\\n for (ex_index, example) in enumerate(examples):\\r\\n tokens = []\\r\\n label_ids = []\\r\\n for word, label in zip(example['words'], example['nes']):\\r\\n word_tokens = tokenizer.tokenize(word)\\r\\n tokens.extend(word_tokens)\\r\\n # Use the real label id for the first token of the word, and padding ids for the remaining tokens\\r\\n label_ids.extend([ner_to_id[label]] + [pad_token_label_id] * (len(word_tokens) - 1))\\r\\n\\r\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\r\\n special_tokens_count = 2\\r\\n if len(tokens) > MAX_SEN_LEN - special_tokens_count:\\r\\n tokens = tokens[:(MAX_SEN_LEN - special_tokens_count)]\\r\\n label_ids = label_ids[:(MAX_SEN_LEN - special_tokens_count)]\\r\\n\\r\\n tokens += [sep_token]\\r\\n label_ids += [pad_token_label_id]\\r\\n\\r\\n segment_ids = [sequence_a_segment_id] * len(tokens)\\r\\n\\r\\n tokens = [cls_token] + tokens\\r\\n label_ids = [pad_token_label_id] + label_ids\\r\\n segment_ids = [cls_token_segment_id] + segment_ids\\r\\n\\r\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\r\\n\\r\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real tokens are attended to.\\r\\n input_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\\r\\n\\r\\n # Zero-pad up to the sequence length.\\r\\n padding_length = MAX_SEN_LEN - len(input_ids)\\r\\n\\r\\n input_ids += ([pad_token_id] * padding_length)\\r\\n input_mask += ([0 if mask_padding_with_zero else 1] * padding_length)\\r\\n segment_ids += ([pad_token_segment_id] * padding_length)\\r\\n label_ids += ([pad_token_label_id] * padding_length)\\r\\n\\r\\n assert len(input_ids) == MAX_SEN_LEN\\r\\n assert len(input_mask) == MAX_SEN_LEN\\r\\n assert len(segment_ids) == MAX_SEN_LEN\\r\\n assert len(label_ids) == MAX_SEN_LEN\\r\\n\\r\\n features.append(\\r\\n {'input_ids': input_ids, 'input_mask': input_mask, 'segment_ids': segment_ids, 'label_ids': label_ids})\\r\\n\\r\\n return features\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n\\n\\tlabel_map = {label : i for i, label in enumerate(label_list,1)}\\n\\t\\n\\tfeatures = []\\n\\tfor (ex_index,example) in enumerate(examples):\\n\\n\\t\\ttext_a, entity_a, entity_b = example.text_a.split('[RE]')\\n\\n\\t\\ttokens_a = tokenizer.tokenize(text_a)\\n\\t\\ttokens_b = None\\n\\t\\ttokens_ea = tokenizer.tokenize(entity_a)\\n\\t\\ttokens_eb = tokenizer.tokenize(entity_b)\\n\\n\\t\\t# Account for [CLS] and [SEP] with \\\"- 2\\\"\\n\\t\\tif (len(tokens_a) + len(tokens_ea) + len(tokens_eb)) > (max_seq_length - 4) :\\n\\t\\t\\ttokens_a = tokens_a[0:(max_seq_length - 4 - len(tokens_ea) - len(tokens_eb))]\\n\\n\\t\\ttokens = []\\n\\t\\tsegment_ids = []\\n\\t\\ttokens.append(\\\"[CLS]\\\")\\n\\t\\tsegment_ids.append(0)\\n\\t\\tfor token in tokens_a:\\n\\t\\t\\ttokens.append(token)\\n\\t\\t\\tsegment_ids.append(0)\\n\\t\\ttokens.append(\\\"[SEP]\\\")\\n\\t\\tsegment_ids.append(0)\\n\\t\\tfor token in tokens_ea:\\n\\t\\t\\ttokens.append(token)\\n\\t\\t\\tsegment_ids.append(0)\\n\\n\\t\\ttokens.append(\\\"[SEP]\\\")\\n\\t\\tsegment_ids.append(0)\\n\\n\\t\\tfor token in tokens_eb:\\n\\t\\t\\ttokens.append(token)\\n\\t\\t\\tsegment_ids.append(0)\\n\\n\\t\\ttokens.append(\\\"[SEP]\\\")\\n\\t\\tsegment_ids.append(0)\\n\\n\\t\\tinput_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n\\t\\t# The mask has 1 for real tokens and 0 for padding tokens. Only real\\n\\t\\t# tokens are attended to.\\n\\t\\tinput_mask = [1] * len(input_ids)\\n\\n\\t\\t# Zero-pad up to the sequence length.\\n\\t\\twhile len(input_ids) < max_seq_length:\\n\\t\\t\\tinput_ids.append(0)\\n\\t\\t\\tinput_mask.append(0)\\n\\t\\t\\tsegment_ids.append(0)\\n\\n\\t\\tassert len(input_ids) == max_seq_length\\n\\t\\tassert len(input_mask) == max_seq_length\\n\\t\\tassert len(segment_ids) == max_seq_length\\n\\n\\t\\tlabel_id = label_map[example.label]\\n\\t\\tif ex_index < 2:\\n\\t\\t\\tlogger.info(\\\"*** Example ***\\\")\\n\\t\\t\\tlogger.info(\\\"guid: %s\\\" % (example.guid))\\n\\t\\t\\tlogger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n\\t\\t\\t\\t\\t[str(x) for x in tokens]))\\n\\t\\t\\tlogger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n\\t\\t\\tlogger.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n\\t\\t\\tlogger.info(\\n\\t\\t\\t\\t\\t\\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n\\t\\t\\tlogger.info(\\\"label: %s (id = %d)\\\" % (example.label, label_id))\\n\\n\\t\\tfeatures.append(InputFeatures(\\n\\t\\t\\tinput_ids=input_ids,\\n\\t\\t\\tinput_mask=input_mask,\\n\\t\\t\\tsegment_ids=segment_ids,\\n\\t\\t\\tlabel_id=label_id))\\n\\treturn features\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer, output_mode, is_master=True):\\n\\n label_map = {label: i for i, label in enumerate(label_list)}\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n if ex_index % 10000 == 0 and is_master:\\n print(\\\"Writing example %d of %d\\\" % (ex_index, len(examples)))\\n\\n tokens_a = tokenizer.tokenize(example.text_a)\\n\\n tokens_b = None\\n if example.text_b:\\n tokens_b = tokenizer.tokenize(example.text_b)\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n segment_ids = [0] * len(tokens)\\n\\n if tokens_b:\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\n segment_ids += [1] * (len(tokens_b) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n input_mask = [1] * len(input_ids)\\n seq_length = len(input_ids)\\n\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n\\n if output_mode == \\\"classification\\\":\\n label_id = label_map[example.label]\\n elif output_mode == \\\"regression\\\":\\n label_id = float(example.label)\\n else:\\n raise KeyError(output_mode)\\n\\n if ex_index == 0 and is_master:\\n print(\\\"*** Example ***\\\")\\n print(\\\"guid: %s\\\" % (example.guid))\\n print(\\\"tokens: %s\\\" % \\\" \\\".join([str(x) for x in tokens]))\\n print(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n print(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n print(\\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n print(\\\"label: {}\\\".format(example.label))\\n print(\\\"label_id: {}\\\".format(label_id))\\n\\n features.append(\\n InputFeatures(\\n input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_id=label_id,\\n seq_length=seq_length,\\n guid=example.guid))\\n return features\",\n \"def parse_question(question):\\n\\tcontext = question['support']\\n\\tanswer = question['correct_answer']\\n\\ttarget = question['question']\\n\\n\\tcontext_words = context.split(\\\" \\\")[0: 510]\\n\\ttarget_words = target.split(\\\" \\\")\\n\\n\\tpunc_filter = str.maketrans('', '', string.punctuation)\\n\\n\\tcontext_words = [word.translate(punc_filter) for word in context_words]\\n\\ttarget_words = [word.translate(punc_filter) for word in target_words]\\n\\tanswer_words = [word.translate(punc_filter) for word in answer.split(\\\" \\\")]\\n\\n\\tbio_embeddings = [EMBEDER['O']]\\n\\tinside_answer = False\\n\\tanswer_index = 0\\n\\tcan_be_inside_answer = True\\n\\n\\t# The following loop and above code does:\\n\\t# -Find where the answer is and place a B tag\\n\\t# -While still in the answer (the answer is more than one word) put an I tag\\n\\t# -Outside of the answer place a O tag\\n\\t# -Start and end with an O tag for BERT's automatic\\n\\t# -start token and end token representing the start and end of a sentence.\\n\\tfor word in context_words:\\n\\t\\tif word.lower() == answer_words[0].lower() and can_be_inside_answer:\\n\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"B\\\"])\\n\\t\\t\\tanswer_index += 1\\n\\t\\t\\tinside_answer = True\\n\\t\\t\\tcan_be_inside_answer = False\\n\\t\\telif inside_answer:\\n\\t\\t\\tif len(answer_words) > 1:\\n\\t\\t\\t\\tif word.lower() != answer_words[answer_index]:\\n\\t\\t\\t\\t\\tinside_answer = False\\n\\t\\t\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"O\\\"])\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"I\\\"])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tinside_answer = False\\n\\t\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"O\\\"])\\n\\t\\telse:\\n\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"O\\\"])\\n\\tbio_embeddings.append(EMBEDER[\\\"O\\\"])\\n\\n\\tground_truth = torch.tensor([BERT_TOKENIZER.encode(target_words)])\\n\\tcontext_words = torch.tensor([BERT_TOKENIZER.encode(context_words)])\\n\\n\\tassert len(bio_embeddings) == len(context_words[0]), f'The BIO tags are not equal in length to the embeddings! ' \\\\\\n\\t f'{None} & {len(bio_embeddings)} & {len(context_words[0])}'\\n\\treturn context_words, bio_embeddings, ground_truth\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\r\\n\\r\\n label_map = {label : i for i, label in enumerate(label_list)}\\r\\n\\r\\n features = []\\r\\n for (ex_index, example) in enumerate(examples):\\r\\n tokens_a = tokenizer.tokenize(example.text_a)\\r\\n\\r\\n tokens_b = None\\r\\n if example.text_b:\\r\\n tokens_b = tokenizer.tokenize(example.text_b)\\r\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\r\\n # length is less than the specified length.\\r\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\r\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\r\\n else:\\r\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\r\\n if len(tokens_a) > max_seq_length - 2:\\r\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\r\\n\\r\\n # The convention in BERT is:\\r\\n # (a) For sequence pairs:\\r\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\r\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\r\\n # (b) For single sequences:\\r\\n # tokens: [CLS] the dog is hairy . [SEP]\\r\\n # type_ids: 0 0 0 0 0 0 0\\r\\n #\\r\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\r\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\r\\n # `type=1` were learned during pre-training and are added to the wordpiece\\r\\n # embedding vector (and position vector). This is not *strictly* necessary\\r\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\r\\n # it easier for the model to learn the concept of sequences.\\r\\n #\\r\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\r\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\r\\n # the entire model is fine-tuned.\\r\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\r\\n segment_ids = [0] * len(tokens)\\r\\n\\r\\n if tokens_b:\\r\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\r\\n segment_ids += [1] * (len(tokens_b) + 1)\\r\\n\\r\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\r\\n\\r\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\r\\n # tokens are attended to.\\r\\n input_mask = [1] * len(input_ids)\\r\\n\\r\\n # Zero-pad up to the sequence length.\\r\\n padding = [0] * (max_seq_length - len(input_ids))\\r\\n input_ids += padding\\r\\n input_mask += padding\\r\\n segment_ids += padding\\r\\n\\r\\n assert len(input_ids) == max_seq_length\\r\\n assert len(input_mask) == max_seq_length\\r\\n assert len(segment_ids) == max_seq_length\\r\\n\\r\\n label_id = example.label\\r\\n if ex_index < 5:\\r\\n logger.info(\\\"*** Example ***\\\")\\r\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\r\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\r\\n [str(x) for x in tokens]))\\r\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\r\\n logger.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\r\\n logger.info(\\r\\n \\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\r\\n # logger.info(\\\"label: %s (id = %d)\\\" % (example.label, label_id))\\r\\n\\r\\n features.append(\\r\\n InputFeatures(input_ids=input_ids,\\r\\n input_mask=input_mask,\\r\\n segment_ids=segment_ids,\\r\\n label_id=label_id))\\r\\n return features\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\r\\n\\r\\n label_map = {label : i for i, label in enumerate(label_list)}\\r\\n\\r\\n features = []\\r\\n for (ex_index, example) in enumerate(examples):\\r\\n tokens_a = tokenizer.tokenize(example.text_a)\\r\\n\\r\\n tokens_b = None\\r\\n if example.text_b:\\r\\n tokens_b = tokenizer.tokenize(example.text_b)\\r\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\r\\n # length is less than the specified length.\\r\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\r\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\r\\n else:\\r\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\r\\n if len(tokens_a) > max_seq_length - 2:\\r\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\r\\n\\r\\n # The convention in BERT is:\\r\\n # (a) For sequence pairs:\\r\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\r\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\r\\n # (b) For single sequences:\\r\\n # tokens: [CLS] the dog is hairy . [SEP]\\r\\n # type_ids: 0 0 0 0 0 0 0\\r\\n #\\r\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\r\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\r\\n # `type=1` were learned during pre-training and are added to the wordpiece\\r\\n # embedding vector (and position vector). This is not *strictly* necessary\\r\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\r\\n # it easier for the model to learn the concept of sequences.\\r\\n #\\r\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\r\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\r\\n # the entire model is fine-tuned.\\r\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\r\\n segment_ids = [0] * len(tokens)\\r\\n\\r\\n if tokens_b:\\r\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\r\\n segment_ids += [1] * (len(tokens_b) + 1)\\r\\n\\r\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\r\\n\\r\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\r\\n # tokens are attended to.\\r\\n input_mask = [1] * len(input_ids)\\r\\n\\r\\n # Zero-pad up to the sequence length.\\r\\n padding = [0] * (max_seq_length - len(input_ids))\\r\\n input_ids += padding\\r\\n input_mask += padding\\r\\n segment_ids += padding\\r\\n\\r\\n assert len(input_ids) == max_seq_length\\r\\n assert len(input_mask) == max_seq_length\\r\\n assert len(segment_ids) == max_seq_length\\r\\n\\r\\n # label_id = label_map[example.label]\\r\\n label_id = example.label\\r\\n label_id = float(label_id)\\r\\n if ex_index < 5:\\r\\n logger.info(\\\"*** Example ***\\\")\\r\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\r\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\r\\n [str(x) for x in tokens]))\\r\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\r\\n logger.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\r\\n logger.info(\\r\\n \\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\r\\n logger.info(\\\"label: %s (id = %s)\\\" % (example.label, label_id))\\r\\n\\r\\n features.append(\\r\\n InputFeatures(input_ids=input_ids,\\r\\n input_mask=input_mask,\\r\\n segment_ids=segment_ids,\\r\\n label_id=label_id))\\r\\n return features\",\n \"def convert_examples_to_features(examples,label_list, max_seq_length,tokenizer):\\r\\n label_map = {}\\r\\n for (i, label) in enumerate(label_list):\\r\\n label_map[label] = i\\r\\n\\r\\n input_data=[]\\r\\n for (ex_index, example) in enumerate(examples):\\r\\n tokens_a = tokenizer.tokenize(example.text_a)\\r\\n tokens_b = None\\r\\n if example.text_b:\\r\\n tokens_b = tokenizer.tokenize(example.text_b)\\r\\n if tokens_b:\\r\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\r\\n # length is less than the specified length.\\r\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\r\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\r\\n else:\\r\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\r\\n if len(tokens_a) > max_seq_length - 2:\\r\\n tokens_a = tokens_a[0:(max_seq_length - 2)]\\r\\n\\r\\n if ex_index % 10000 == 0:\\r\\n tf.logging.info(\\\"Writing example %d of %d\\\" % (ex_index, len(examples)))\\r\\n\\r\\n # The convention in BERT is:\\r\\n # (a) For sequence pairs:\\r\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\r\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\r\\n # (b) For single sequences:\\r\\n # tokens: [CLS] the dog is hairy . [SEP]\\r\\n # type_ids: 0 0 0 0 0 0 0\\r\\n #\\r\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\r\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\r\\n # `type=1` were learned during pre-training and are added to the wordpiece\\r\\n # embedding vector (and position vector). This is not *strictly* necessary\\r\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\r\\n # it easier for the model to learn the concept of sequences.\\r\\n #\\r\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\r\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\r\\n # the entire model is fine-tuned.\\r\\n tokens = []\\r\\n segment_ids = []\\r\\n tokens.append(\\\"[CLS]\\\")\\r\\n segment_ids.append(0)\\r\\n for token in tokens_a:\\r\\n tokens.append(token)\\r\\n segment_ids.append(0)\\r\\n tokens.append(\\\"[SEP]\\\")\\r\\n segment_ids.append(0)\\r\\n\\r\\n if tokens_b:\\r\\n for token in tokens_b:\\r\\n tokens.append(token)\\r\\n segment_ids.append(1)\\r\\n tokens.append(\\\"[SEP]\\\")\\r\\n segment_ids.append(1)\\r\\n\\r\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\r\\n\\r\\n input_mask = [1] * len(input_ids)\\r\\n\\r\\n while len(input_ids) < max_seq_length:\\r\\n input_ids.append(0)\\r\\n input_mask.append(0)\\r\\n segment_ids.append(0)\\r\\n assert len(input_ids) == max_seq_length\\r\\n assert len(input_mask) == max_seq_length\\r\\n assert len(segment_ids) == max_seq_length\\r\\n\\r\\n label_id = label_map[example.label]\\r\\n if ex_index < 3:\\r\\n tf.logging.info(\\\"*** Example ***\\\")\\r\\n tf.logging.info(\\\"guid: %s\\\" % (example.guid))\\r\\n tf.logging.info(\\\"tokens: %s\\\" % \\\" \\\".join([tokenization.printable_text(x) for x in tokens]))\\r\\n tf.logging.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\r\\n tf.logging.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\r\\n tf.logging.info(\\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\r\\n tf.logging.info(\\\"label: %s (id = %d)\\\" % (example.label, label_id))\\r\\n\\r\\n features = collections.OrderedDict()\\r\\n features[\\\"input_ids\\\"] = input_ids\\r\\n features[\\\"input_mask\\\"] = input_mask\\r\\n features[\\\"segment_ids\\\"] = segment_ids\\r\\n features[\\\"label_ids\\\"] =label_id\\r\\n input_data.append(features)\\r\\n\\r\\n return input_data\",\n \"def BoolVariable(key, help, default):\\n return (key, '%s (yes|no)' % help, default,\\n _validator, _text2bool)\",\n \"def extract_feature(self, article) :\\n pass\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length,\\n tokenizer, output_mode):\\n\\n label_map = {label : i for i, label in enumerate(label_list)}\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n if ex_index % 10000 == 0:\\n logger.info(\\\"Writing example %d of %d\\\" % (ex_index, len(examples)))\\n\\n tokens_a = tokenizer.tokenize(example.text_a)\\n\\n tokens_b = None\\n if example.text_b:\\n tokens_b = tokenizer.tokenize(example.text_b)\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\n # length is less than the specified length.\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambiguously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n # the entire model is fine-tuned.\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n segment_ids = [0] * len(tokens)\\n\\n if tokens_b:\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\n segment_ids += [1] * (len(tokens_b) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n\\n if output_mode == \\\"classification\\\":\\n label_id = label_map[example.label]\\n elif output_mode == \\\"regression\\\":\\n label_id = float(example.label)\\n else:\\n raise KeyError(output_mode)\\n\\n if ex_index < 5:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [str(x) for x in tokens]))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n logger.info(\\n \\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n logger.info(\\\"label: %s (id = %d)\\\" % (example.label, label_id))\\n\\n features.append(\\n InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_id=label_id,\\n weight = example.weight))\\n return features\",\n \"def positive_responses():\\n return ['yes', 'y', 'Yes', 'Y']\",\n \"def _toBoolean (iraf_flag):\\n\\n return (iraf_flag == iraf.yes)\",\n \"def substantiate():\",\n \"def unpack_true(data):\\n return True, 0\",\n \"def yes_no(x):\\n \\n x = x.lower()\\n if x[0] == 'n':\\n return 0\\n if x[0] == 'y':\\n return 1\\n return None\",\n \"def _create_examples(self,lines, set_type):\\n examples = []\\n if len(lines[1]) == 2 and len(lines[1][0]) == 1: # label text_a\\n for (i, line) in enumerate(lines):\\n guid = f\\\"{set_type}-{i}\\\"\\n text_a = tx.utils.compat_as_text(line[1])\\n label = tx.utils.compat_as_text(line[0])\\n examples.append(InputExample(guid=guid, text_a=text_a,\\n text_b=\\\"\\\", label=label))\\n\\n elif len(lines[1]) == 2 and len(lines[1][0]) > 1: # text_a text_b (when test file has no label)\\n for (i, line) in enumerate(lines):\\n guid = f\\\"{set_type}-{i}\\\"\\n text_a = tx.utils.compat_as_text(line[0])\\n text_b = tx.utils.compat_as_text(line[1])\\n if set_type == \\\"test\\\":\\n label = \\\"0\\\"\\n else:\\n print(\\\"the file is not for testing, yet contains no labels\\\")\\n exit()\\n examples.append(InputExample(guid=guid, text_a=text_a,\\n text_b=text_b, label=label))\\n elif len(lines[1]) == 1: # text_a (when test file has no label)\\n for (i, line) in enumerate(lines):\\n guid = f\\\"{set_type}-{i}\\\"\\n text_a = tx.utils.compat_as_text(line[0])\\n if set_type == \\\"test\\\":\\n label = \\\"0\\\"\\n else:\\n print(\\\"the file is not for testing, yet contains no labels\\\")\\n exit()\\n examples.append(InputExample(guid=guid, text_a=text_a,\\n text_b=\\\"\\\", label=label))\\n elif len(lines[1]) == 3: # label text_a text_b\\n for (i, line) in enumerate(lines):\\n guid = f\\\"{set_type}-{i}\\\"\\n text_a = tx.utils.compat_as_text(line[1])\\n text_b = tx.utils.compat_as_text(line[2])\\n\\n label = tx.utils.compat_as_text(line[0])\\n examples.append(InputExample(guid=guid, text_a=text_a,\\n text_b=text_b, label=label))\\n return examples\",\n \"def convert_single_example(ex_index, example, label_list, output_mode, max_seq_length, max_predictions_per_seq,\\n tokenizer):\\n\\n if isinstance(example, PaddingInputExample):\\n return InputFeatures(\\n input_ids=[0] * max_seq_length,\\n input_mask=[0] * max_seq_length,\\n segment_ids=[0] * max_seq_length,\\n label_id=0,\\n is_real_example=False)\\n\\n label_map = {}\\n for (i, label) in enumerate(label_list):\\n label_map[label] = i\\n #BERT will add # at head of the number\\n #tokens_a = tokenizer.tokenize(example.text_a) \\n tokens_a = [a for a in example.text_a]\\n tokens_b = None\\n if example.text_b:\\n tokens_b = tokenizer.tokenize(example.text_b)\\n\\n if tokens_b:\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\n # length is less than the specified length.\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[0:(max_seq_length - 2)]\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambiguously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as the \\\"sentence vector\\\". Note that this only makes sense because\\n # the entire model is fine-tuned.\\n tokens = []\\n segment_ids = []\\n tokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n for token in tokens_a:\\n tokens.append(token)\\n segment_ids.append(0)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(0)\\n\\n if tokens_b:\\n for token in tokens_b:\\n tokens.append(token)\\n segment_ids.append(1)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(1)\\n \\n \\n for j, tok in enumerate(tokens):\\n if tok not in tokenizer.vocab:\\n tokens[j] = \\\"[UNK]\\\"\\n \\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n # Zero-pad up to the sequence length.\\n while len(input_ids) < max_seq_length:\\n input_ids.append(0)\\n input_mask.append(0)\\n segment_ids.append(0)\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n \\n #masked_lm_ids = tokenizer.tokenize(\\\"\\\".join(example.masked_lm_ids).decode(\\\"utf8\\\"))\\n masked_lm_ids = []\\n masked_lm_ids.append(\\\"[CLS]\\\")\\n for tok in example.masked_lm_ids:\\n masked_lm_ids.append(tok if tok in tokenizer.vocab else \\\"[UNK]\\\")\\n masked_lm_ids.append(\\\"[SEP]\\\")\\n masked_lm_ids = tokenizer.convert_tokens_to_ids(masked_lm_ids) \\n \\n\\n masked_lm_weights = [1.0] * len(masked_lm_ids)\\n masked_lm_weights[0] = 0.0\\n masked_lm_weights[len(masked_lm_ids)-1] = 0.0\\n masked_lm_positions = [i for i in range(len(masked_lm_ids))]\\n\\n while len(masked_lm_positions) < max_predictions_per_seq:\\n masked_lm_positions.append(0)\\n masked_lm_ids.append(0)\\n masked_lm_weights.append(0.0)\\n\\n assert len(masked_lm_ids) == max_predictions_per_seq\\n assert len(masked_lm_positions) == max_predictions_per_seq\\n assert len(masked_lm_weights) == max_predictions_per_seq\\n\\n if output_mode == 'classification':\\n label_id = label_map[example.label]\\n elif output_mode == 'regression':\\n label_id = float(example.label)\\n\\n else:\\n raise KeyError(mode)\\n if ex_index < 20:\\n tf.logging.info(\\\"*** Example ***\\\")\\n tf.logging.info(\\\"guid: %s\\\" % (example.guid))\\n tf.logging.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [tokenization.printable_text(x) for x in tokens]))\\n tf.logging.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n tf.logging.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n tf.logging.info(\\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n tf.logging.info(\\\"masked_lm_positions: %s\\\" % \\\" \\\".join([str(x) for x in masked_lm_positions]))\\n tf.logging.info(\\\"masked_lm_ids: %s\\\" % \\\" \\\".join([str(x) for x in masked_lm_ids]))\\n tf.logging.info(\\\"masked_lm_tokens: %s\\\" % \\\" \\\".join(\\n\\t[str(x) for x in tokenizer.convert_ids_to_tokens(masked_lm_ids)]))\\n tf.logging.info(\\\"masked_lm_weights: %s\\\" % \\\" \\\".join([str(x) for x in masked_lm_weights]))\\n tf.logging.info(\\\"label: %s (id = %d)\\\" % (example.label, label_id))\\n\\n feature = InputFeatures(\\n input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n masked_lm_positions=masked_lm_positions,\\n masked_lm_ids=masked_lm_ids,\\n masked_lm_weights=masked_lm_weights,\\n label_id=label_id,\\n is_real_example=True)\\n return feature\",\n \"def yes_no(value):\\n return 'Yes' if value else 'No'\",\n \"def test_regex_featurizer():\\n from rasa.nlu.featurizers.sparse_featurizer.regex_featurizer import RegexFeaturizer\\n sentence, expected, labeled_tokens = (\\n \\\"hey how are you today\\\",\\n [\\n [0.0, 1.0, 0.0],\\n [0.0, 0.0, 0.0],\\n [0.0, 0.0, 0.0],\\n [0.0, 0.0, 0.0],\\n [0.0, 0.0, 0.0],\\n [0.0, 1.0, 0.0],\\n ],\\n [0],\\n )\\n patterns = [\\n {\\\"pattern\\\": \\\"[0-9]+\\\", \\\"name\\\": \\\"number\\\", \\\"usage\\\": \\\"intent\\\"},\\n {\\\"pattern\\\": \\\"\\\\\\\\bhey*\\\", \\\"name\\\": \\\"hello\\\", \\\"usage\\\": \\\"intent\\\"},\\n {\\\"pattern\\\": \\\"[0-1]+\\\", \\\"name\\\": \\\"binary\\\", \\\"usage\\\": \\\"intent\\\"},\\n ]\\n ftr = RegexFeaturizer({}, known_patterns=patterns)\\n\\n # adds tokens to the message\\n tokenizer = SpacyTokenizer({})\\n message = Message(sentence, data={RESPONSE: sentence})\\n assert show_message(message, False) == {\\n \\\"response\\\": \\\"hey how are you today\\\",\\n \\\"text\\\": \\\"hey how are you today\\\"\\n }\\n message.set(SPACY_DOCS[TEXT], spacy_nlp(sentence))\\n tokenizer.process(message)\\n # assert show_message(message) == {'response': 'hey how are you today', 'text_spacy_doc': spacy_nlp(\\\"hey how are you today\\\"),\\n # 'tokens': ['hey', 'how', 'are', 'you', 'today', '__CLS__'],\\n # 'text': 'hey how are you today'}\\n # result = ftr._features_for_patterns(message, TEXT)\\n ftr.process(message) # [TEXT, RESPONSE]\\n show_message(message)\\n assert len(message.get(TOKENS_NAMES[TEXT], [])) > 0\",\n \"def test_get_input_unlabeled(self):\\n result = pre.get_input(self.testfilename)\\n truth = (\\n [[Reference(0, 'm jones', \\n 'symbol intersect detect method improv spatial intersect join', \\n ['e rundensteiner', 'y huang'], 'geoinformatica', None),\\n Reference(1, 'matthew c jones', \\n 'improv spatial intersect join symbol intersect detect', \\n ['e rundensteiner', 'h kuno', 'p marron', 'v taube', 'y ra'], \\n 'sigmodels.intern manag data', None),\\n Reference(2, 'matthew c jones',\\n 'view materi techniqu complex hirarch object', ['e rundensteiner',\\n 'y huang'], 'ssd symposium larg spatial databas', None)],\\n [Reference(3, 'mike w miller', 'domin draw bipartit graph', \\n ['l berg'], 'sigucc special interest group univers comput servic',\\n None),\\n Reference(4, 'mike w miller', 'rel compromis statist databas', \\n [], 'sigucc special interest group univers comput servic', None)],\\n [Reference(5, 'c chen', 'formal approach scenario analysi',\\n ['d kung', 'j samuel', 'j gao', 'p hsia', 'y toyoshima'],\\n 'ieee softwar', None)],\\n [Reference(6, 'jane j robinson', 'discours code clue context', [], \\n 'acl meet the associ comput linguist', None),\\n Reference(7, 'jane j robinson', 'diagram grammar dialogu', [],\\n 'cooper interfac inform system', None)],\\n [Reference(8, 'a gupta', 'iri h java distanc educ', ['a gonzalez', \\n 'a hamid', 'c overstreet', 'h wahab', 'j wild', 'k maly', 's ghanem',\\n 'x zhu'], 'acm journal educ resourc comput', None)],\\n [Reference(9, 'mary d brown',\\n 'intern redund represent limit bypass support pipelin adder regist'\\n 'file', ['y patt'], 'proceed the th ieee intern symposium high '\\n 'perform comput architectur hpca intern symposium high perform '\\n 'comput architectur talk slide', None)]],\\n\\n ['m jones', 'e rundensteiner', 'y huang', 'matthew c jones', \\n 'e rundensteiner', 'h kuno', 'p marron', 'v taube', 'y ra', \\n 'matthew c jones', 'e rundensteiner', 'y huang', 'mike w miller',\\n 'l berg', 'mike w miller', 'c chen', 'd kung', 'j samuel', 'j gao',\\n 'p hsia', 'y toyoshima', 'jane j robinson', 'jane j robinson',\\n 'a gupta', 'a gonzalez', 'a hamid', 'c overstreet', 'h wahab', 'j wild',\\n 'k maly', 's ghanem', 'x zhu', 'mary d brown', 'y patt'])\\n self.assertEquals(result, truth)\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n if label_list:\\n label_map = {label: i for i, label in enumerate(label_list)}\\n else:\\n label_map = None\\n\\n features = []\\n tokenslist = []\\n for (ex_index, example) in enumerate(examples):\\n tokens_a = tokenizer.tokenize(example.text_a)\\n\\n tokens_b = None\\n if example.text_b:\\n tokens_b = tokenizer.tokenize(example.text_b)\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\n # length is less than the specified length.\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n # the entire model is fine-tuned.\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n base_tokens = [\\\"[UNK]\\\"] + [\\\"[UNK]\\\"]*len(tokens_a) + [\\\"[UNK]\\\"]\\n segment_ids = [0] * len(tokens)\\n\\n if tokens_b:\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\n base_tokens += [\\\"[UNK]\\\"]*len(tokens_b) + [\\\"[UNK]\\\"]\\n segment_ids += [1] * (len(tokens_b) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n baseline_ids = tokenizer.convert_tokens_to_ids(base_tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n baseline_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\n assert len(baseline_ids) == max_seq_length\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n\\n if label_map:\\n label_id = label_map[example.label]\\n else:\\n label_id = float(example.label)\\n if ex_index < 2:\\n logger.debug(\\\"*** Example ***\\\")\\n logger.debug(\\\"guid: %s\\\" % (example.guid))\\n logger.debug(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [str(x) for x in tokens]))\\n logger.debug(\\\"input_ids: %s\\\" %\\n \\\" \\\".join([str(x) for x in input_ids]))\\n logger.debug(\\\"input_mask: %s\\\" %\\n \\\" \\\".join([str(x) for x in input_mask]))\\n logger.debug(\\n \\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n logger.debug(\\\"label: %s (id = %d)\\\" % (example.label, label_id))\\n\\n features.append(\\n InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_id=label_id,\\n baseline_ids=baseline_ids))\\n tokenslist.append({\\\"token\\\":tokens, \\\"golden_label\\\":example.label, \\\"pred_label\\\":None})\\n return features, tokenslist\",\n \"def create_feature(example):\\n input_ids, label_ids = encode_fn(\\n example['tokens'], example['labels'])\\n\\n features = {\\n 'input_ids': int64_feature(input_ids),\\n 'label_ids': int64_feature(label_ids)\\n }\\n\\n return features\",\n \"def findHighOddsFeatures(self, label1, label2):\\n featuresOdds = []\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n return featuresOdds\",\n \"def test_get_analyzed_recipe_instructions(self):\\n pass\",\n \"def test__validate_features__0():\\n for input_value, expected_output in (\\n (None, None),\\n ([], None),\\n ([GuildFeature.animated_banner], (GuildFeature.animated_banner, )),\\n ([GuildFeature.animated_banner.value], (GuildFeature.animated_banner, )),\\n (\\n [GuildFeature.animated_banner, GuildFeature.animated_icon],\\n (GuildFeature.animated_banner, GuildFeature.animated_icon,),\\n ),\\n ):\\n output = validate_features(input_value)\\n vampytest.assert_eq(output, expected_output)\",\n \"def yesno2bool(value):\\n if not isinstance(value, str):\\n raise InstrumentParameterException(\\\"value not a string\\\")\\n\\n if(value.lower() == 'no'):\\n return False\\n elif(value.lower() == 'yes'):\\n return True\\n else:\\n raise InstrumentParameterException(\\\"Could not convert '%s' to bool\\\" % value)\",\n \"def convert_to_dialogData(\\n premise_raw, hypo_raw, answer_raw, dialog_format=False, binary_classes=False\\n):\\n premise_raw = premise_raw.strip('\\\\n').strip('\\\\t')\\n hypo_raw = hypo_raw.strip('\\\\n').strip('\\\\t')\\n clas = MULTINLI_LABELS\\n\\n if binary_classes:\\n answer_raw = BICLASS_DICT[answer_raw]\\n clas = BICLASS_LABELS\\n if not dialog_format:\\n premise_raw = MULTINLI_PREMISE_PREFIX + premise_raw\\n hypo_raw = MULTINLI_HYPO_PREFIX + hypo_raw\\n\\n question = premise_raw + '\\\\n' + hypo_raw\\n answers = [answer_raw]\\n\\n return question, answers, clas\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n\\n label_map = {label: i for i, label in enumerate(label_list)}\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n tokens_a = tokenizer.tokenize(example.text_a)\\n\\n tokens_b = None\\n if example.text_b:\\n tokens_b = tokenizer.tokenize(example.text_b)\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\n # length is less than the specified length.\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n # the entire model is fine-tuned.\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n segment_ids = [0] * len(tokens)\\n\\n if tokens_b:\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\n segment_ids += [1] * (len(tokens_b) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n\\n label_id = label_map[example.label]\\n features.append(\\n InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_id=label_id))\\n return features\",\n \"def addmanualflags(recipe, reason, antenna=\\\"\\\", spw=\\\"\\\", scan=\\\"\\\", uvrange=\\\"\\\", field=\\\"\\\"):\\n recipe.add(\\\"cab/casa_flagdata\\\", \\\"handflags\\\", {\\n \\\"vis\\\": ZEROGEN_DATA,\\n \\\"mode\\\": \\\"manual\\\",\\n \\\"antenna\\\": antenna,\\n \\\"spw\\\": spw,\\n \\\"scan\\\": scan,\\n \\\"uvrange\\\": uvrange,\\n \\\"field\\\": field\\n },\\n input=INPUT, output=OUTPUT, label=reason)\\n MANUAL_FLAG_LIST.append(reason)\\n return [reason]\",\n \"def get_feature_set_PC(tweet, sentimentvalues):\\n features= {\\n 'text_length': np.log(len(tweet.text))\\n } #ADD ADDITIONAL FEATURES\\n if tweet.nrof_sademoticons>0:\\n features['sademoticons'] = tweet.nrof_sademoticons\\n if tweet.nrof_happyemoticons>0:\\n features['happyemoticons'] = tweet.nrof_happyemoticons\\n \\n for phrase in tweet.tagged_words:\\n for word in phrase:\\n try:\\n tag = word['pos']\\n features[tag] = features.get(tag, 0) + 1\\n if tag in ADJECTIVES:\\n features['adjectives'] = features.get(tag, 0) + 1\\n elif tag in ADVERBS: \\n features['adverbs'] = features.get(tag, 0) + 1\\n elif tag in PRONOUNS:\\n features['pronoun'] = 1\\n except KeyError:\\n continue\\n for key in features.keys():\\n features[key] = features[key]*1.0\\n \\n #Add lexical features\\n # total polarity score, number of positive words, number of negative words\\n pos_score = 0\\n neg_score = 0\\n nrof_pos_words = 0\\n nrof_neg_words = 0\\n for word in sentimentvalues.keys():\\n if sentimentvalues[word][0]>0:\\n nrof_pos_words = nrof_pos_words + 1\\n pos_score = pos_score + sentimentvalues[word][0]\\n if sentimentvalues[word][1]>0:\\n nrof_neg_words = nrof_neg_words + 1\\n neg_score = neg_score + sentimentvalues[word][1]\\n\\n if neg_score>0:\\n features['neg_score'] = neg_score+1.0\\n if pos_score>0:\\n features['pos_score'] = pos_score+1.0\\n if nrof_pos_words>0:\\n features['positive_words'] = nrof_pos_words*1.0\\n if nrof_neg_words>0:\\n features['negative_words'] = nrof_neg_words*1.0\\n \\n return features\",\n \"def _generate_examples(self, data_dir=None, archive=None, label_path=None, process=None):\\n if process == 'train':\\n abnormal_train = pd.read_csv(os.path.join(data_dir, \\\"train-abnormal.csv\\\"), names=[\\\"Patient_Number\\\", \\\"abnormal\\\"])\\n ACL_train = pd.read_csv(os.path.join(data_dir, \\\"train-acl.csv\\\"), names=[\\\"Patient_Number\\\", \\\"ACL\\\"])\\n meniscus_train = pd.read_csv(os.path.join(data_dir, \\\"train-meniscus.csv\\\"), names=[\\\"Patient_Number\\\", \\\"meniscus\\\"])\\n abnormal_acl_train = abnormal_train.merge(ACL_train, on=\\\"Patient_Number\\\")\\n ab_acl_meni_train = abnormal_acl_train.merge(meniscus_train, on=\\\"Patient_Number\\\")\\n else:\\n abnormal_test = pd.read_csv(os.path.join(data_dir, \\\"valid-abnormal.csv\\\"), names=[\\\"Patient_Number\\\", \\\"abnormal\\\"])\\n ACL_test = pd.read_csv(os.path.join(data_dir, \\\"valid-acl.csv\\\"), names=[\\\"Patient_Number\\\", \\\"ACL\\\"])\\n meniscus_test = pd.read_csv(os.path.join(data_dir, \\\"valid-meniscus.csv\\\"), names=[\\\"Patient_Number\\\", \\\"meniscus\\\"])\\n abnormal_acl_test = abnormal_test.merge(ACL_test, on=\\\"Patient_Number\\\")\\n ab_acl_meni_test = abnormal_acl_test.merge(meniscus_test, on=\\\"Patient_Number\\\")\\n\\n def sumup(row):\\n if (row['abnormal'] == 1) & (row[\\\"ACL\\\"] == 1) & (row[\\\"meniscus\\\"] == 1):\\n val = \\\"Both_ACL_Meniscus\\\"\\n elif (row['abnormal'] == 1) & (row[\\\"ACL\\\"] == 1) & (row[\\\"meniscus\\\"] == 0):\\n val = \\\"ACL\\\"\\n elif (row['abnormal'] == 1) & (row[\\\"ACL\\\"] == 0) & (row[\\\"meniscus\\\"] == 1):\\n val = \\\"Meniscus\\\"\\n elif (row['abnormal'] == 1) & (row[\\\"ACL\\\"] == 0) & (row[\\\"meniscus\\\"] == 0):\\n val = \\\"abnormal\\\"\\n elif row['abnormal'] == 0:\\n val = \\\"normal\\\"\\n return val\\n if process == 'train':\\n ab_acl_meni_train['sumup'] = ab_acl_meni_train.apply(sumup, axis=1)\\n ab_acl_meni_train[['Patient_Number', \\\"sumup\\\"]].to_csv(os.path.join(data_dir, \\\"train_labels.csv\\\"), header=False)\\n else:\\n ab_acl_meni_test['sumup'] = ab_acl_meni_test.apply(sumup, axis=1)\\n ab_acl_meni_test[['Patient_Number', \\\"sumup\\\"]].to_csv(os.path.join(data_dir, \\\"valid_labels.csv\\\"), header=False)\\n\\n all_labels = pd.read_csv(label_path, names=[\\\"Patient_Number\\\", \\\"label\\\"])\\n\\n count = 0\\n archive_list = [os.path.join(archive, \\\"axial\\\"), os.path.join(archive, \\\"coronal\\\"), os.path.join(archive, \\\"sagittal\\\")]\\n for direction in archive_list:\\n files = []\\n for r, d, f in tf.io.gfile.walk(direction):\\n for file in f:\\n if '.npy' in file:\\n files.append(os.path.join(r, file))\\n sorted_files = sorted(files)\\n\\n for path_cube in sorted_files:\\n cube = np.load(tf.io.gfile.GFile(path_cube, mode='rb'))\\n for picture in cube:\\n example_image = picture[..., np.newaxis]\\n example_label = (all_labels.loc[all_labels['Patient_Number'] ==\\n int(os.path.splitext(os.path.basename(path_cube))[0][:4]),\\n 'label'].iloc[0])\\n count += 1\\n yield count, {\\n 'image': example_image,\\n 'label': example_label,\\n }\",\n \"def convert_single_example(ex_index, example, label_list, max_seq_length,tokenizer):\\n label_map = {}\\n for (i, label) in enumerate(label_list):\\n label_map[label] = i\\n text_a=example.text_a\\n labels_a=[]\\n text_a=re.split(\\\"(<[a-zA-Z]+>[^<>]+</[a-zA-Z]+>)\\\",text_a)\\n tokens_a=[]\\n for sub_text in text_a:\\n if len(sub_text.strip())<1:\\n continue\\n elif re.search('<([a-zA-Z]+)>([^<>]+)<[/a-zA-Z]+>',sub_text):\\n re_res=re.search('<([a-zA-Z]+)>([^<>]+)<[/a-zA-Z]+>',sub_text)\\n slot_name=re_res.group(1)\\n slot_value=re_res.group(2)\\n slot_value=tokenizer.tokenize(slot_value)\\n slot_labels=[]\\n for i,s in enumerate(slot_value):\\n if i==0:\\n slot_labels.append(\\\"B_\\\"+slot_name)\\n elif re.search(\\\"^##\\\",s):\\n slot_labels.append(\\\"x\\\")\\n else:\\n slot_labels.append(\\\"M_\\\"+slot_name)\\n tokens_a.extend(slot_value)\\n labels_a.extend(slot_labels)\\n else:\\n sub_text=tokenizer.tokenize(sub_text)\\n sub_labels=['x' if re.search(\\\"^##\\\",i) else 'o' for i in sub_text]\\n tokens_a.extend(sub_text)\\n labels_a.extend(sub_labels)\\n tokens = []\\n segment_ids = []\\n tokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n for token in tokens_a:\\n tokens.append(token)\\n segment_ids.append(0)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(0)\\n labels=[example.label]\\n for label in labels_a:\\n labels.append(label)\\n labels.append('o')\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n input_mask = [1] * len(input_ids)\\n output_mask=[1 if i!='x' else 0 for i in labels]\\n label_ids=[label_map[i] for i in labels]\\n while len(input_ids) < max_seq_length:\\n input_ids.append(0)\\n segment_ids.append(0)\\n input_mask.append(0)\\n output_mask.append(0)\\n label_ids.append(label_map['<PAD>'])\\n assert len(input_ids)==max_seq_length\\n assert len(segment_ids)==max_seq_length\\n assert len(label_ids)==max_seq_length\\n assert len(input_mask)==max_seq_length\\n assert len(output_mask)==max_seq_length\\n if ex_index < 5:\\n tf.logging.info(\\\"*** Example ***\\\")\\n tf.logging.info(\\\"guid: %s\\\" % (example.guid))\\n tf.logging.info(\\\"tokens: %s\\\" % \\\" \\\".join(tokens))\\n tf.logging.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n tf.logging.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n tf.logging.info(\\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n tf.logging.info(\\\"labels: %s\\\" % \\\" \\\".join([str(x) for x in labels]))\\n tf.logging.info(\\\"label_ids: %s\\\" % \\\" \\\".join([str(x) for x in label_ids]))\\n tf.logging.info(\\\"output_mask: %s\\\" % \\\" \\\".join([str(x) for x in output_mask]))\\n feature = InputFeatures(\\n input_ids=input_ids,\\n segment_ids=segment_ids,\\n label_ids=label_ids,\\n input_mask=input_mask,\\n output_mask=output_mask)\\n return feature\",\n \"def test_model_mc_question(mc_question_one_true):\\n assert mc_question_one_true.answer1 == \\\"a1\\\"\\n assert mc_question_one_true.answer1_correct == True\\n assert mc_question_one_true.answer2 == \\\"a2\\\"\\n assert mc_question_one_true.answer2_correct == False\\n assert mc_question_one_true.answer3 == \\\"a3\\\"\\n assert mc_question_one_true.answer3_correct == False\",\n \"def test_features_property():\\n atom = ATOMClassifier(X_bin, y_bin, random_state=1)\\n atom.run(\\\"LR\\\")\\n assert [i == j for i, j in zip(atom.lr.features, atom.features)]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5797586","0.57104677","0.56959134","0.56715715","0.55233496","0.5512573","0.5502822","0.5428499","0.5363724","0.5356651","0.53244007","0.5321539","0.53180873","0.5256663","0.525582","0.5243374","0.52147835","0.5206472","0.5185587","0.51831275","0.5179945","0.5168982","0.5163207","0.516251","0.5154285","0.5130002","0.51278436","0.5123476","0.5113824","0.51058984","0.5099084","0.5095972","0.5095618","0.5086578","0.5082229","0.50787115","0.50687283","0.50642014","0.5058096","0.50493467","0.5047901","0.5043872","0.5038025","0.50308126","0.5029826","0.502887","0.50137085","0.50032336","0.50025547","0.49943796","0.49926227","0.4986054","0.49833074","0.49802878","0.49802878","0.49781182","0.49757183","0.49724376","0.49690327","0.49549314","0.49373433","0.4932166","0.4930819","0.49273342","0.49272704","0.49202076","0.49172312","0.49144036","0.49142453","0.49032876","0.49005583","0.48973557","0.48973557","0.48971725","0.48933524","0.48861066","0.4883722","0.48793828","0.4879081","0.4874493","0.4873858","0.48732027","0.48682237","0.48677725","0.48662132","0.48652115","0.48651412","0.4862679","0.48626643","0.48534915","0.485181","0.48512492","0.48503992","0.48491055","0.48438793","0.4838655","0.48361182","0.4824878","0.48208","0.48204267","0.48192796"],"string":"[\n \"0.5797586\",\n \"0.57104677\",\n \"0.56959134\",\n \"0.56715715\",\n \"0.55233496\",\n \"0.5512573\",\n \"0.5502822\",\n \"0.5428499\",\n \"0.5363724\",\n \"0.5356651\",\n \"0.53244007\",\n \"0.5321539\",\n \"0.53180873\",\n \"0.5256663\",\n \"0.525582\",\n \"0.5243374\",\n \"0.52147835\",\n \"0.5206472\",\n \"0.5185587\",\n \"0.51831275\",\n \"0.5179945\",\n \"0.5168982\",\n \"0.5163207\",\n \"0.516251\",\n \"0.5154285\",\n \"0.5130002\",\n \"0.51278436\",\n \"0.5123476\",\n \"0.5113824\",\n \"0.51058984\",\n \"0.5099084\",\n \"0.5095972\",\n \"0.5095618\",\n \"0.5086578\",\n \"0.5082229\",\n \"0.50787115\",\n \"0.50687283\",\n \"0.50642014\",\n \"0.5058096\",\n \"0.50493467\",\n \"0.5047901\",\n \"0.5043872\",\n \"0.5038025\",\n \"0.50308126\",\n \"0.5029826\",\n \"0.502887\",\n \"0.50137085\",\n \"0.50032336\",\n \"0.50025547\",\n \"0.49943796\",\n \"0.49926227\",\n \"0.4986054\",\n \"0.49833074\",\n \"0.49802878\",\n \"0.49802878\",\n \"0.49781182\",\n \"0.49757183\",\n \"0.49724376\",\n \"0.49690327\",\n \"0.49549314\",\n \"0.49373433\",\n \"0.4932166\",\n \"0.4930819\",\n \"0.49273342\",\n \"0.49272704\",\n \"0.49202076\",\n \"0.49172312\",\n \"0.49144036\",\n \"0.49142453\",\n \"0.49032876\",\n \"0.49005583\",\n \"0.48973557\",\n \"0.48973557\",\n \"0.48971725\",\n \"0.48933524\",\n \"0.48861066\",\n \"0.4883722\",\n \"0.48793828\",\n \"0.4879081\",\n \"0.4874493\",\n \"0.4873858\",\n \"0.48732027\",\n \"0.48682237\",\n \"0.48677725\",\n \"0.48662132\",\n \"0.48652115\",\n \"0.48651412\",\n \"0.4862679\",\n \"0.48626643\",\n \"0.48534915\",\n \"0.485181\",\n \"0.48512492\",\n \"0.48503992\",\n \"0.48491055\",\n \"0.48438793\",\n \"0.4838655\",\n \"0.48361182\",\n \"0.4824878\",\n \"0.48208\",\n \"0.48204267\",\n \"0.48192796\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84586,"cells":{"query":{"kind":"string","value":"Prepare the mnist or fashionmnist data to feed to the model."},"document":{"kind":"string","value":"def get_data(dataset):\n \n if dataset not in possible_datasets:\n datasets_output = ', '.join(possible_datasets)\n raise ValueError('dataset must be one of: {}'.format(datasets_output))\n \n if dataset == 'mnist':\n (clean_train, __), (clean_test, __) = mnist.load_data()\n elif dataset == 'fashion-mnist':\n (clean_train, __), (clean_test, __) = fashion_mnist.load_data()\n\n clean_train = clean_train.astype('float32') / 255.\n clean_train = clean_train.reshape(data_shape)\n clean_test = clean_test.astype('float32') / 255.\n clean_test = clean_test.reshape(data_shape)\n\n noisy_test = add_gaussian_noise_np(clean_test, 0.0, 0.4)\n return clean_train, clean_test, noisy_test"},"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 _prepare_data(self):\n #TODO hardcoded values need to change\n print_info(\"Preprocessing the train data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"train\"),\n self.TRAIN_OUT_PATH)\n\n print_info(\"Preprocessing the test data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"test\"),\n self.TEST_OUT_PATH)\n\n print_info(\"Preprocessing the validation data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"val\"),\n self.VAL_OUT_PATH)","def prepare_data(self):\n try:\n self.train_dataset = self.datasets['train']\n self.val_dataset = self.datasets['val']\n try:\n self.test_dataset = self.datasets['test']\n except:\n pass\n except Exception as e:\n print('Data was not succesfully prepared:', e)","def prepare_data(self, *args, **kwargs) -> None:\n if not (self.root / \"train\").exists():\n raise ValueError(\n f\"Please download and set ImageNet-1k train data under {self.root}.\"\n )\n if not (self.root / \"val\").exists():\n raise ValueError(\n f\"Please download and set ImageNet-1k val data under {self.root}.\"\n )","def preprocess_data(self):\n\n self._preprocess_train_data()\n self._preprocess_test_data()","def prepare_data():\n gennet.prepare_data('Resnet50')","def prepare_data(self, *args, **kwargs):\n # get paths to train and test splits\n _split_paths = [os.path.join(self.path_to_data, split)\n for split in os.listdir(self.path_to_data)]\n\n # for each split [train, test]\n for _path in _split_paths:\n _img_classes = os.listdir(_path) # get subfolders representing each class\n self.splits[os.path.basename(_path)] = []\n\n # get the images in pairs with its corresponding class\n for _class in _img_classes:\n _data = self.get_img_text_pair(os.path.join(_path, _class))\n\n if os.path.basename(_path) == 'train':\n self.weights[self.encode_label(_class)] = len(_data)\n self.splits[os.path.basename(_path)].extend(_data)","def buildDataSet():\n (x_train_origin, y_train_origin), (x_test_origin, y_test_origin) = mnist.load_data()\n\n assert K.image_data_format() == 'channels_last'\n x_train_origin = x_train_origin.reshape(x_train_origin.shape[0], h, w, 1)\n x_test_origin = x_test_origin.reshape(x_test_origin.shape[0], h, w, 1)\n\n dataset_train = []\n dataset_test = []\n\n #Sorting images by classes and normalize values 0=>1\n for n in range(nb_classes):\n images_class_n = np.asarray([row for idx,row in enumerate(x_train_origin) if y_train_origin[idx]==n])\n dataset_train.append(images_class_n/255)\n\n images_class_n = np.asarray([row for idx,row in enumerate(x_test_origin) if y_test_origin[idx]==n])\n dataset_test.append(images_class_n/255)\n\n return dataset_train,dataset_test,x_train_origin,y_train_origin,x_test_origin,y_test_origin","def prepare_data_for_training(args):\n # Form the train/test splits and write them to disk\n dataset = data.Dataset(args)\n # get image classes and image counts in each class\n label_map = dataset.get_class_info()\n class_count = len(list(label_map.values()))\n # split the data and store it in log dir\n df_train, df_test = dataset.split_dataset()\n\n # perform dataset augmentations\n image_data = augment.Augmentation(args)\n # get the data gens for training and test images\n train_data_gen, _ = image_data.map_fn_train(df_train)\n test_data_gen, _ = image_data.map_fn_test(df_test)\n\n return train_data_gen, test_data_gen, df_train, df_test, class_count","def prepare_data(self):\n data = self._get_dataset(self.hparams.dataset_path)\n label_encoder = data[\"label_encoder\"]\n del data[\"label_encoder\"]\n\n click.secho(\"Building inputs and labels.\", fg=\"yellow\")\n datasets = {\n \"train\": defaultdict(list),\n \"valid\": defaultdict(list),\n \"test\": defaultdict(list),\n }\n for dataset_name, dataset in data.items():\n for sample in dataset:\n instance = self.build_input(\n self.tokenizer, sample[\"text\"], label_encoder, sample[\"label\"]\n )\n for input_name, input_array in instance.items():\n datasets[dataset_name][input_name].append(input_array)\n\n click.secho(\"Padding inputs and building tensors.\", fg=\"yellow\")\n tensor_datasets = {\"train\": [], \"valid\": [], \"test\": []}\n for dataset_name, dataset in datasets.items():\n dataset = self.pad_dataset(dataset, padding=self.tokenizer.pad_index)\n for input_name in MODEL_INPUTS:\n if input_name == \"labels\":\n tensor = torch.tensor(dataset[input_name], dtype=torch.float32)\n else:\n tensor = torch.tensor(dataset[input_name])\n tensor_datasets[dataset_name].append(tensor)\n\n self.train_dataset = TensorDataset(*tensor_datasets[\"train\"])\n self.valid_dataset = TensorDataset(*tensor_datasets[\"valid\"])\n self.test_dataset = TensorDataset(*tensor_datasets[\"test\"])\n click.secho(\n \"Train dataset (Batch, Candidates, Seq length): {}\".format(\n self.train_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )\n click.secho(\n \"Valid dataset (Batch, Candidates, Seq length): {}\".format(\n self.valid_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )\n click.secho(\n \"Test dataset (Batch, Candidates, Seq length): {}\".format(\n self.test_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )","def get_mnist():\n from keras.datasets import mnist\n\n # input image dimensions\n img_rows, img_cols = 28, 28\n num_classes = 10\n # the data, shuffled and split between train and test sets\n (x_train, y_train), (x_test, y_test) = mnist.load_data()\n\n if K.image_data_format() == 'channels_first':\n print (\"Using Channels first\")\n x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)\n x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)\n input_shape = (1, img_rows, img_cols)\n else:\n print(\"Channels last\")\n x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)\n x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)\n input_shape = (img_rows, img_cols, 1)\n\n return (x_train, y_train), (x_test, y_test)","def prepare_n_mnist(filename, is_filter, num_spikes, step_factor=1):\n td = ev.read_dataset(filename)\n # td.show_td(100)\n td.data = stabilize(td)\n td.data = td.extract_roi([3, 3], [28, 28], True)\n images = make_td_images(td, num_spikes, step_factor)\n\n if is_filter:\n images = ndimage.median_filter(images, 3)\n\n # for image in images:\n # cv2.imshow('img', image)\n # cv2.waitKey(70)\n return images","def preprocess_train_data(self):\r\n print(\"* Preprocessing training data.\", flush=True)\r\n prep.create_HDF_file(self.C.training_set, is_training_set=True)\r\n\r\n self.print_time_elapsed()","def __init__(self,\n mnist_location,\n flatten=True,\n permute_labels=False,\n train_order_seed=None):\n mnist = save_restore.restore_network(mnist_location)\n\n x_train = mnist['x_train']\n x_test = mnist['x_test']\n y_train = mnist['y_train']\n y_test = mnist['y_test']\n\n if permute_labels:\n # Reassign labels according to a random permutation of the labels.\n permutation = np.random.permutation(10)\n y_train = permutation[y_train]\n y_test = permutation[y_test]\n\n # Flatten x_train and x_test.\n if flatten:\n x_train = x_train.reshape((x_train.shape[0], -1))\n x_test = x_test.reshape((x_test.shape[0], -1))\n\n # Normalize x_train and x_test.\n x_train = keras.utils.normalize(x_train).astype(np.float32)\n x_test = keras.utils.normalize(x_test).astype(np.float32)\n\n # Convert y_train and y_test to one-hot.\n y_train = keras.utils.to_categorical(y_train)\n y_test = keras.utils.to_categorical(y_test)\n\n # Prepare the dataset.\n super(DatasetMnist, self).__init__(\n (x_train, y_train),\n 64, (x_test, y_test),\n train_order_seed=train_order_seed)","def __init__(self):\n\n TEST_RATIO = 0.05\n mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=None)\n idxs = np.arange(mnist_trainset.train_data.size(0))\n np.random.shuffle(idxs)\n\n #print(torch.min(mnist_trainset.train_labels), torch.max(mnist_trainset.train_labels))\n #print(mnist_trainset.train_labels.size())\n \n # reshape input data to (1, 784) and normalize to range [0., 1.]\n self.train_data = torch.reshape(\n mnist_trainset.train_data[idxs].float(), (-1,1,28,28))/255.\n self.data_size = self.train_data.size(0)\n self.train_len = self.train_data.size(0)\n self.train_label = torch.Tensor([1]).float() # since there is only one class - 'real' image\n\n print('Train images -- {}'.format(self.train_data.size()))","def _init_dataset(self):\n champions = set()\n\n for name in os.listdir(self.data_root):\n label = name.split(\".\")[0]\n champions.add(label)\n self.image_paths += [(os.path.join(self.data_root, name), [[label]])]\n\n # self.encoder = self.encoder.fit(np.array(list(champions)).reshape(-1, 1))\n self.encoder = self.encoder.fit(list(champions))","def data(self):\n (x_train, y_train), (_, _) = datasets.fashion_mnist.load_data()\n x_train = x_train.reshape((-1, 28, 28, 1))\n x_train, y_train = x_train.astype('float16') / 255.0, \\\n tf.keras.utils.to_categorical(y_train.astype('float16'), 10)\n (x_train, x_eval) = x_train[5000:], x_train[:5000]\n (y_train, y_eval) = y_train[5000:], y_train[:5000]\n train_data, eval_data = (x_train, y_train), (x_eval, y_eval)\n return train_data, eval_data","def get_mnist_data(batch=128):\n \n def transformer(data, label):\n data = data.flatten().expand_dims(0).astype(np.float32)/255\n data = data-0.13/0.31\n label = label.astype(np.float32)\n return data, label\n\n train_dataset = gluon.data.vision.datasets.MNIST(root=M5_IMAGES, train=True, transform=transformer)\n validation_dataset = gluon.data.vision.datasets.MNIST(root=M5_IMAGES, train=False, transform=transformer)\n train_dataloader = gluon.data.DataLoader(train_dataset, batch_size=batch, last_batch='keep',shuffle=True)\n validation_dataloader = gluon.data.DataLoader(validation_dataset, batch_size=batch, last_batch='keep')\n \n return train_dataloader, validation_dataloader","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__(self, **kwargs):\n is_training = kwargs.get('is_training', True)\n rootfolder = kwargs['rootfolder']\n dtype = kwargs.get('dtype', np.float64)\n self._load_mnist(rootfolder, is_training, dtype)\n # normalize data.\n self._data /= 255.\n ndarraydata.NdarrayDataLayer.__init__(\n self, sources=[self._data, self._label], **kwargs)","def preprocess(self):\n \n file_name_list = os.listdir(self.image_dir)\n random.seed(1234)\n random.shuffle(file_name_list)\n \n for i,d in enumerate(self.domains):\n self.attr2idx[d]=i \n\n for i, file_name in enumerate(file_name_list):\n if (file_name.startswith('X_')):\n continue\n \n parts = file_name.split(\"-\")\n label = int(parts[0])\n if label not in self.domains:\n continue\n img_name = file_name\n\n count=self.get_sample_count(label)\n if count<self.valid_set_size:\n # create holdout set on the fly\n utils.copy_file(self.image_dir,self.valid_set_dir,img_name)\n else:\n self.dataset.append([img_name, self.attr2idx[label]])\n \n self.increment_sample_count(label)\n\n print(\"Sample count per domain: \"+str(self.sample_count)+\" (including holdout set, holdout size per domain is: \"+str(self.valid_set_size)+\")\")\n print('Finished preprocessing the dataset...')","def prepare_train_data(self):\r\n ## Impute rlkpis\r\n print(\"Imputing rlKPI df\")\r\n self.rlkpi.add_target_labels(1)\r\n self.rlkpi.impute_rl_kpis()\r\n\r\n print(\"Add 'met-real-station_no' & met-forecast-station_no to rl_kpis_df\")\r\n self.add_met_real_forecast_station_col_to_rlkpis()\r\n print(\"Merge 'met-real-sampled df to rl kps \")\r\n self.merge_met_real_sampled_df_to_rlkpis()\r\n\r\n ## Imputations for met-forecast\r\n print(\"Impute met-forecast\")\r\n met_forecast_obj = self.metfcast\r\n met_forecast_obj.impute_met_forecast()\r\n\r\n #Merge met forecast data to earlier merged data\r\n print(\"Merge Train data with imputed forecast df\")\r\n self.train_data = pd.merge(self.train_data,\r\n met_forecast_obj.imputed_forecast_df,\r\n on=['datetime-station_no'], indicator=True, how='inner')\r\n print(\"Check any imputation needed\", self.train_data.isna().sum().sum())\r\n self.train_data.drop(['_merge'], axis=1, inplace=True)\r\n self.perform_data_under_sampling(self.train_data)","def load_mnist(fashion, onehot_encode=True, flatten_x=False, crop_x=0, classes=None):\n\tif not fashion:\n\t\t(x_train, y_train),(x_test, y_test) = tf.keras.datasets.mnist.load_data()\n\t\tx_train, x_test = x_train / 255.0, x_test / 255.0\n\telse:\n\t\t(x_train, y_train),(x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()\n\t\tx_train, x_test = x_train / 255.0, x_test / 255.0 \n \n\tdef crop(X, crop_size):\n\t\tassert crop_x < X.shape[1]/2\n\t\tassert crop_x < X.shape[2]/2\n\t\treturn X[:,crop_size:-crop_size,crop_size:-crop_size]\n\n\tif crop_x > 0:\n\t\tx_train = crop(x_train, crop_x)\n\t\tx_test = crop(x_test, crop_x)\n\n\t# Flatten to 2d arrays (each example 1d)\n\tdef flatten_image(X):\n\t return X.reshape(X.shape[0], X.shape[1]*X.shape[1])\n\tif flatten_x:\n\t\tx_train = flatten_image(x_train)\n\t\tx_test = flatten_image(x_test)\n\n\tif onehot_encode:\n\t\ty_train = onehot_encode_labels(y_train)\n\t\ty_test = onehot_encode_labels(y_test)\n\n\tif classes is not None:\n\t\tassert len(classes) == 2\n\t\tc0, c1 = classes\n\t\ttrain_idxs_to_keep = np.logical_or(y_train==c0, y_train==c1)\n\t\tx_train, y_train = x_train[train_idxs_to_keep,:], y_train[train_idxs_to_keep]\n\t\ttest_idxs_to_keep = np.logical_or(y_test==c0, y_test==c1)\n\t\tx_test, y_test = x_test[test_idxs_to_keep,:], y_test[test_idxs_to_keep]\n\n\t\ty_train = (y_train==c1).astype(int)[:,np.newaxis]\n\t\ty_test = (y_test==c1).astype(int)[:,np.newaxis]\n\n\treturn x_train, y_train, x_test, y_test","def prepare_data(self):\n # Set up the path\n self.path_target_train = os.path.join(self.data_dir, self.train_path_file_target + \".pkl\")\n self.path_target_test = os.path.join(self.data_dir, self.test_path_file_target + \".pkl\")\n\n if not os.path.exists(self.path_target_train) or not os.path.exists(self.path_target_test):\n # Create vocabularies of the appropriate sizes.\n self.create_vocabulary(self.train_path_file)\n\n # Create token ids for the training data.\n input_train_path = self.train_path_file\n target_train_path = self.train_path_file_target\n train_input, train_input_length, train_labels = self.data_to_token_ids(input_train_path, target_train_path)\n\n # Create token ids for the validation data.\n input_test_path = self.test_path_file\n target_test_path = self.test_path_file_target\n test_input, test_input_length, _ = self.data_to_token_ids(input_test_path, target_test_path, train=False)\n\n # Collect data into a list\n training_data = [train_input, train_input_length, train_labels]\n test_data = [test_input, test_input_length]\n\n # Save all the data\n with open(self.path_target_train, 'wb') as f:\n pickle.dump(training_data,f)\n with open(self.path_target_test, 'wb') as f:\n pickle.dump(test_data, f)\n else:\n # Load data\n with open(self.path_target_train, 'rb') as f:\n training_data = pickle.load(f)\n with open(self.path_target_test, 'rb') as f:\n test_data = pickle.load(f)\n\n # Initialize vocabulary\n self.initialize_vocabulary()\n\n # Convert list into a numpy array - train data\n train_input = pd.DataFrame(training_data[0]).fillna(value=0).astype(int).values\n train_length_input = np.array(training_data[1], dtype=int)\n train_labels = np.array(training_data[2], dtype=int)\n\n # Convert list into a numpy array - test data\n test_input = pd.DataFrame(test_data[0]).fillna(value=0).astype(int).values\n test_length_input = pd.DataFrame(test_data[1]).fillna(value=0).astype(int).values\n\n # Printing maximum length\n print(\"Shape of the input training matrix {}\".format(str(train_input.shape)))\n print(\"Shape of the input test matrix {}\".format(str(test_input.shape)))\n\n # Copy the files\n self.copy_files()\n\n # Return output\n return train_input, train_length_input, train_labels, test_input, test_length_input","def generate_nmnist_dataset(initial_size, input_dir, num_spikes, step_factor):\n image_dataset = np.rec.array(None, dtype=[('height', np.uint16),\n ('width', np.uint16),\n ('image_data', 'object'),\n ('label', np.uint32)],\n shape=initial_size)\n num_images = 0\n\n # loop through each folder within the test directories\n for i in range(0, 10):\n current_dir = input_dir + os.path.sep + str(i) + os.path.sep + '*.bin'\n print('Processing {}...'.format(current_dir))\n for filename in glob.iglob(current_dir):\n images = prepare_n_mnist(filename, True, num_spikes, step_factor)\n if num_images + len(images) >= image_dataset.size:\n image_dataset = np.resize(image_dataset,\n (num_images + len(images)) * 2)\n add_images_to_dataset(image_dataset, images, num_images, i, 28, 28)\n num_images += len(images)\n\n return image_dataset[0:num_images]","def prepare_n_mnist_continuous(filename, is_filter, is_normalize=False):\n td = ev.read_dataset(filename)\n # td.show_td(100)\n td.data = stabilize(td)\n td.data = td.extract_roi([0, 0], [28, 28], True)\n # td.data = apply_tracking1(td)\n # td.data = apply_tracking2(td)\n # td.data = apply_tracking3(td)\n # td.data = td.extract_roi([3, 3], [28, 28], True)\n image = make_td_probability_image(td, 9, is_normalize)\n\n if is_filter:\n image = ndimage.median_filter(image, 3)\n\n # cv2.imshow('img', image)\n # cv2.waitKey(1)\n return image","def readMNISTData():\n mnist = input_data.read_data_sets(\"MNIST_data\",one_hot=True) \n return mnist","def prepare_feed(self, is_train=False, debug=False):\n\n feed = self.get_feed_dict(is_train)\n\n if debug:\n inds,x_batch, y_batch = self.sess.run(self.dataset.get_iterator_entry())\n feed[self.indexs] = inds\n feed[self.input_l.name] = x_batch\n feed[self.targets.name] = y_batch\n return feed\n else:\n return feed","def reset_training_data(self):\n logger.info(\"resetting training data\")\n if self.shuffle:\n random.shuffle(self.tweets)\n self.batch_generator = self.get_batch()","def build_data_set(self):\n if not self.assert_data_correct():\n self.download_all_data()\n self.unpack_rename_data()\n self.split_data_characters()\n self.clean_data_fragments()\n self.create_font_data()\n if not self.assert_train_augmented():\n self.augment_train_data()\n if not self.assert_style_data_correct():\n self.download_style_data()\n self.unpack_rename_data()","def load_data():\n # Load image data from MNIST.\n (train_x, train_y),(eval_x, eval_y) = keras.datasets.mnist.load_data()\n\n # We convert the input data to (60000, 28, 28, 1), float32 and normalize our data values to the range [0, 1].\n train_x = train_x.reshape(train_x.shape[0], train_x.shape[1], train_x.shape[2], 1)\n eval_x = eval_x.reshape(eval_x.shape[0], eval_x.shape[1], eval_x.shape[2], 1)\n\n train_x = train_x.astype('float32')\n eval_x = eval_x.astype('float32')\n train_x /= 255\n eval_x /= 255\n\n # Preprocess class labels \n train_y = train_y.astype(np.int32)\n eval_y = eval_y.astype(np.int32)\n\n train_y = np_utils.to_categorical(train_y, 10)\n eval_y = np_utils.to_categorical(eval_y, 10)\n\n return train_x, train_y, eval_x, eval_y","def get_mnist_cnn():\n # Set defaults.\n nb_classes = 10 #dataset dependent \n batch_size = 128\n epochs = 4\n \n # Input image dimensions\n img_rows, img_cols = 28, 28\n\n # Get the data.\n # the data, shuffled and split between train and test sets\n (x_train, y_train), (x_test, y_test) = mnist.load_data()\n \n if K.image_data_format() == 'channels_first':\n x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)\n x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)\n input_shape = (1, img_rows, img_cols)\n else:\n x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)\n x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)\n input_shape = (img_rows, img_cols, 1)\n\n #x_train = x_train.reshape(60000, 784)\n #x_test = x_test.reshape(10000, 784)\n \n x_train = x_train.astype('float32')\n x_test = x_test.astype('float32')\n x_train /= 255\n x_test /= 255\n\n #print('x_train shape:', x_train.shape)\n #print(x_train.shape[0], 'train samples')\n #print(x_test.shape[0], 'test samples')\n\n # convert class vectors to binary class matrices\n y_train = to_categorical(y_train, nb_classes)\n y_test = to_categorical(y_test, nb_classes)\n\n # convert class vectors to binary class matrices\n #y_train = keras.utils.to_categorical(y_train, nb_classes)\n #y_test = keras.utils.to_categorical(y_test, nb_classes)\n\n return (nb_classes, batch_size, input_shape, x_train, x_test, y_train, y_test, epochs)","def preprocess_dataset(self, dataset, params=None):\n if params is None:\n assert self.params_loaded, (\n \"You must either provide parameters or load the model params before preprocessing.\")\n params = self.params\n for key in dataset.keys():\n if dataset[key] is None:\n continue\n if hasattr(params, \"whiten_data\") and params.whiten_data:\n if hasattr(params, \"whiten_method\"):\n if params.whiten_method == \"FT\": # other methods require patching first\n if hasattr(params, \"whiten_batch_size\"):\n batch_size = params.whiten_batch_size\n else:\n batch_size = None\n dataset[key].images, dataset[key].data_mean, dataset[key].w_filter = \\\n dp.whiten_data_batch(dataset[key].images, method=params.whiten_method,\n batch_size=batch_size)\n print(\"INFO:preprocessing:FT Whitened \"+key+\" data\")\n if hasattr(params, \"lpf_data\") and params.lpf_data:\n dataset[key].images, dataset[key].data_mean, dataset[key].lpf_filter = \\\n dp.lpf_data(dataset[key].images, cutoff=params.lpf_cutoff)\n print(\"INFO:preprocessing:Low pass filtered \"+key+\" data\")\n if hasattr(params, \"contrast_normalize\") and params.contrast_normalize:\n if hasattr(params, \"gauss_patch_size\"):\n dataset[key].images = dp.contrast_normalize(dataset[key].images,\n params.gauss_patch_size)\n else:\n dataset[key].images = dp.contrast_normalize(dataset[key].images)\n print(\"INFO:preprocessing:Contrast normalized \"+key+\" data\")\n if hasattr(params, \"standardize_data\") and params.standardize_data:\n if params.data_type == \"mnist\":\n eps = 1e-5\n else:\n eps = None\n dataset[key].images, dataset[key].data_mean, dataset[key].data_std = \\\n dp.standardize_data(dataset[key].images, eps)\n self.data_mean = dataset[key].data_mean\n self.data_std = dataset[key].data_std\n print(\"INFO:preprocessing:Standardized \"+key+\" data\")\n if hasattr(params, \"extract_patches\") and params.extract_patches:\n assert all(key in params.__dict__.keys()\n for key in [\"num_patches\", \"patch_edge_size\", \"overlapping_patches\",\n \"randomize_patches\"]), (\"Insufficient params for patches.\")\n out_shape = (int(params.num_patches), int(params.patch_edge_size),\n int(params.patch_edge_size), dataset[key].num_channels)\n dataset[key].num_examples = out_shape[0]\n dataset[key].reset_counters()\n if hasattr(params, \"patch_variance_threshold\"):\n dataset[key].images = dp.extract_patches(dataset[key].images, out_shape,\n params.overlapping_patches, params.randomize_patches,\n params.patch_variance_threshold, dataset[key].rand_state)\n else:\n dataset[key].images = dp.extract_patches(dataset[key].images, out_shape,\n params.overlapping_patches, params.randomize_patches,\n var_thresh=0, rand_state=dataset[key].rand_state)\n dataset[key].shape = dataset[key].images.shape\n dataset[key].num_rows = dataset[key].shape[1]\n dataset[key].num_cols = dataset[key].shape[2]\n dataset[key].num_channels = dataset[key].shape[3]\n dataset[key].num_pixels = np.prod(dataset[key].shape[1:])\n print(\"INFO:preprocessing:Extracted patches from \"+key+\" data\")\n if hasattr(params, \"whiten_data\") and params.whiten_data:\n if hasattr(params, \"whiten_method\") and params.whiten_method != \"FT\":\n dataset[key].images, dataset[key].data_mean, dataset[key].w_filter = \\\n dp.whiten_data(dataset[key].images, method=params.whiten_method)\n print(\"INFO:preprocessing:Whitened \"+key+\" data\")\n if hasattr(params, \"norm_data\") and params.norm_data:\n dataset[key].images, dataset[key].data_max = dp.normalize_data_with_max(dataset[key].images)\n self.data_max = dataset[key].data_max\n print(\"INFO:preprocessing:Normalized \"+key+\" data with maximum\")\n if hasattr(params, \"rescale_data\") and params.rescale_data:\n dataset[key].images, dataset[key].data_min, dataset[key].data_max = dp.rescale_data_to_one(dataset[key].images)\n self.data_max = dataset[key].data_max\n self.data_min = dataset[key].data_min\n print(\"INFO:preprocessing:Rescaled each \"+key+\" datapoint to one\")\n if hasattr(params, \"center_data\") and params.center_data:\n dataset[key].images, dataset[key].data_mean = dp.center_data(dataset[key].images,\n use_dataset_mean=True)\n self.data_mean = dataset[key].data_mean\n print(\"INFO:preprocessing:Centered \"+key+\" data\")\n return dataset","def load_mnist_dataset(shape=(-1,784)):\n # We first define a download function, supporting both Python 2 and 3.\n if sys.version_info[0] == 2:\n from urllib import urlretrieve\n else:\n from urllib.request import urlretrieve\n\n def download(filename, source='http://yann.lecun.com/exdb/mnist/'):\n print(\"Downloading %s\" % filename)\n urlretrieve(source + filename, filename)\n\n # We then define functions for loading MNIST images and labels.\n # For convenience, they also download the requested files if needed.\n import gzip\n\n def load_mnist_images(filename):\n if not os.path.exists(filename):\n download(filename)\n # Read the inputs in Yann LeCun's binary format.\n with gzip.open(filename, 'rb') as f:\n data = np.frombuffer(f.read(), np.uint8, offset=16)\n # The inputs are vectors now, we reshape them to monochrome 2D images,\n # following the shape convention: (examples, channels, rows, columns)\n data = data.reshape(shape)\n # data = data.reshape(-1, 1, 28, 28) # for lasagne\n # data = data.reshape(-1, 28, 28, 1) # for tensorflow\n # data = data.reshape(-1, 784) # for tensorflow\n # The inputs come as bytes, we convert them to float32 in range [0,1].\n # (Actually to range [0, 255/256], for compatibility to the version\n # provided at http://deeplearning.net/data/mnist/mnist.pkl.gz.)\n return data / np.float32(256)\n\n def load_mnist_labels(filename):\n if not os.path.exists(filename):\n download(filename)\n # Read the labels in Yann LeCun's binary format.\n with gzip.open(filename, 'rb') as f:\n data = np.frombuffer(f.read(), np.uint8, offset=8)\n # The labels are vectors of integers now, that's exactly what we want.\n return data\n\n # We can now download and read the training and test set images and labels.\n ## you may want to change the path\n data_dir = '' #os.getcwd() + '/lasagne_tutorial/'\n # print('data_dir > %s' % data_dir)\n\n X_train = load_mnist_images(data_dir+'train-images-idx3-ubyte.gz')\n y_train = load_mnist_labels(data_dir+'train-labels-idx1-ubyte.gz')\n X_test = load_mnist_images(data_dir+'t10k-images-idx3-ubyte.gz')\n y_test = load_mnist_labels(data_dir+'t10k-labels-idx1-ubyte.gz')\n\n # We reserve the last 10000 training examples for validation.\n X_train, X_val = X_train[:-10000], X_train[-10000:]\n y_train, y_val = y_train[:-10000], y_train[-10000:]\n\n ## you may want to plot one example\n # print('X_train[0][0] >', X_train[0][0].shape, type(X_train[0][0])) # for lasagne\n # print('X_train[0] >', X_train[0].shape, type(X_train[0])) # for tensorflow\n # # exit()\n # # [[..],[..]] (28, 28) numpy.ndarray\n # # plt.imshow 只支持 (28, 28)格式，不支持 (1, 28, 28),所以用 [0][0]\n # fig = plt.figure()\n # #plotwindow = fig.add_subplot(111)\n # # plt.imshow(X_train[0][0], cmap='gray') # for lasagne (-1, 1, 28, 28)\n # plt.imshow(X_train[0].reshape(28,28), cmap='gray') # for tensorflow (-1, 28, 28, 1)\n # plt.title('A training image')\n # plt.show()\n\n # We just return all the arrays in order, as expected in main().\n # (It doesn't matter how we do this as long as we can read them again.)\n return X_train, y_train, X_val, y_val, X_test, y_test","def setUp(self):\n self.X_train, self.y_train = load_data(\"../data/traindata.mat.tar.gz\")\n self.nn = NN_hwr([len(self.X_train[0]), 50, 10])","def set_data():\r\n #if not os.path.exists(filepath):\r\n #download_data()\r\n metadata = read(filepath + flist[-1])\r\n ndata = metadata['num_cases_per_batch']\r\n ndim = metadata['num_vis']\r\n\r\n data, train, test = {}, {}, {}\r\n data['labels'] = metadata['label_names']\r\n data['ntraindata'] = metadata['num_cases_per_batch'] * (len(flist) - 2)\r\n data['ntestdata'] = metadata['num_cases_per_batch']\r\n data['ndim'] = metadata['num_vis']\r\n\r\n train['x'], train['y'] = convert_train(data['ntraindata'], data['ndim'])\r\n\r\n testdata = read(filepath + flist[-2])\r\n test['x'] = testdata['data']\r\n test['y'] = testdata['labels']\r\n\r\n data['train'], data['test'] = train, test\r\n save_pkl(data)","def create_mnist_dataset(mode='train', num_samples=2, batch_size=2):\n mnist_path = '/home/workspace/mindspore_dataset/mnist'\n num_parallel_workers = 1\n\n # define dataset\n mnist_ds = ds.MnistDataset(os.path.join(mnist_path, mode), num_samples=num_samples, shuffle=False)\n\n resize_height, resize_width = 32, 32\n\n # define map operations\n resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR) # Bilinear mode\n rescale_nml_op = CV.Rescale(1 / 0.3081, -1 * 0.1307 / 0.3081)\n rescale_op = CV.Rescale(1.0 / 255.0, shift=0.0)\n hwc2chw_op = CV.HWC2CHW()\n type_cast_op = C.TypeCast(mstype.int32)\n\n # apply map operations on images\n mnist_ds = mnist_ds.map(operations=type_cast_op, input_columns=\"label\", num_parallel_workers=num_parallel_workers)\n mnist_ds = mnist_ds.map(operations=resize_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n mnist_ds = mnist_ds.map(operations=rescale_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n mnist_ds = mnist_ds.map(operations=rescale_nml_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n mnist_ds = mnist_ds.map(operations=hwc2chw_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n\n # apply DatasetOps\n mnist_ds = mnist_ds.batch(batch_size=batch_size, drop_remainder=True)\n\n return mnist_ds","def _prepare_ml_data(X, y, to_optimize=False):\n size_test = 1\n y_test = None\n if to_optimize:\n size_test = CONFIG.OPTIMIZE_PARAMS['size'] + 1\n y_test = y.iloc[-size_test:]\n X_train = X.iloc[:-size_test]\n y_train = y.iloc[:-size_test]\n X_test = X.iloc[-size_test:]\n return X_train, y_train, X_test, y_test","def load_data_fashion_mnist(batch_size, resize=None): #@save\n mnist_train, mnist_test = tf.keras.datasets.fashion_mnist.load_data()\n # Divide all numbers by 255 so that all pixel values are between\n # 0 and 1, add a batch dimension at the last. And cast label to int32\n process = lambda X, y: (tf.expand_dims(X, axis=3) / 255,\n tf.cast(y, dtype='int32'))\n resize_fn = lambda X, y: (\n tf.image.resize_with_pad(X, resize, resize) if resize else X, y)\n return (\n tf.data.Dataset.from_tensor_slices(process(*mnist_train)).batch(\n batch_size).shuffle(len(mnist_train[0])).map(resize_fn),\n tf.data.Dataset.from_tensor_slices(process(*mnist_test)).batch(\n batch_size).map(resize_fn))","def load_data_mnist(train_size=None):\n print \"---->\\n.....Loading MNIST data from the skdata package\"\n dataset = view.OfficialImageClassification()\n if train_size:\n train_data = {}\n validation_data = {}\n order = permutation(dataset.all_images.shape[0])\n train_data['images'] = dataset.all_images[order[:train_size]] / 256.\n train_data['labels'] = dataset.all_labels[order[:train_size]]\n validation_data['images'] = (dataset.all_images[order[train_size:]]\n / 256.)\n validation_data['labels'] = dataset.all_labels[order[train_size:]]\n else:\n train_data = {}\n validation_data = {}\n train_data['images'] = dataset.all_images / 256.\n train_data['labels'] = dataset.all_labels\n for r in train_data:\n train_data[r] = train_data[r].astype(theano.config.floatX)\n for r in validation_data:\n validation_data[r] = validation_data[r].astype(theano.config.floatX)\n print \"---->\\n.....Done!\"\n\n return train_data, validation_data","def InitDataset(self):\n train_txt = 'ImageSets/Main/train.txt'\n val_txt = 'ImageSets/Main/val.txt'\n annotations = \"Annotations\"\n jpegimages = \"JPEGImages\"\n images_path = train_txt if (self.is_train) else val_txt \n images_path = readTxt(os.path.join(self.path, images_path))\n images_path.pop(-1)\n # rawdata format: [path_2_image, path_2_xml]\n rawData = list()\n for each in images_path:\n xml = os.path.join(self.path, annotations, each + '.xml')\n jpeg = os.path.join(self.path, jpegimages, each + '.jpg')\n rawData.append([jpeg, xml])\n return rawData","def preprocess_data():\n le = preprocessing.LabelEncoder()\n # Reshape and normalize pixel values to be between 0 and 1\n train_images_reshaped = train_images.reshape(len(train_images), 1024, 1024, 1)/255.\n test_images_reshaped = test_images.reshape(len(test_images), 1024, 1024, 1)/255.\n\n return train_images_reshaped, test_images_reshaped, le.fit_transform(train_labels), le.fit_transform(test_labels)","def _load_data(self):\n\n from sklearn.datasets import fetch_openml\n mnist = fetch_openml('mnist_784', cache=True)\n # data_x = np.array(final_data_df)\n feat_data = np.array(mnist.data).astype('float32')\n target_data = mnist.target.astype('int64')\n shuffling_index = np.arange(feat_data.shape[0])\n np.random.shuffle(shuffling_index)\n feat_data = feat_data[shuffling_index]\n target_data = target_data[shuffling_index]\n\n cur_data_list = []\n cur_target_list = []\n for i in range(10):\n cur_mask = target_data == i\n cur_data_list.append(feat_data[cur_mask][:500])\n cur_target_list.append(target_data[cur_mask][:500])\n feat_data = np.concatenate(cur_data_list)\n target_data = np.concatenate(cur_target_list)\n\n self.data_x = feat_data\n self.data_y = self.to_one_hot_encoding(target_data)\n self.numerical_idx = np.arange(784)\n self.non_num_idx = None\n\n # Calculate adjacency matrix\n self.meta_inf = self.data_x.astype('float32')\n\n if self.args.graph_type:\n self.adj = self.get_adjacency()","def prepare(self):\n if self.opts['verbose']:\n print(\"Preparing dataset (one-time operation)...\")\n # Create paths files and load them back in\n self._build_ID_sets()\n self._create_ID_files()\n self._load_ID_files()\n if self.opts['verbose']:\n print(\"... done with preparing the dataset.\")","def use_mnist_model(self):\n\n\t\t# load the model\n\t\tnumber_recognizer_MNIST = load_model('models/MNIST_digits_recognition.h5', compile=False)\n\n\t\t# create empty ndarray\n\t\tnumbers_mnist = np.ones(shape=(self.sudoku_size, self.sudoku_size))\n\n\t\tpics = deepcopy(self.list_of_number_pictures)\n\t\tfor i in range(self.sudoku_size):\n\t\t\tfor j in range(self.sudoku_size):\n\t\t\t\tpics[i][j] = self.preprocess_cell(pics[i][j], mnist=True, resize=True, clean_remains=True)\n\t\t\t\tif self.empty_cells[i][j] != 0:\n\t\t\t\t\tnumbers_mnist[i][j] = np.argmax(number_recognizer_MNIST.predict([[pics[i][j].reshape(28,28,1)]]))\n\n\t\treturn numbers_mnist","def get_data():\n\t(X_train, y_train), (X_val, y_val) = mnist.load_data()\n\tn_features = X_train.shape[1]*X_train.shape[1]\n\tn_train = X_train.shape[0]\n\tn_val = X_val.shape[0]\n\tX_train = X_train.reshape(n_train, n_features)\n\tX_val = X_val.reshape(n_val, n_features)\n\tX_train = X_train.astype(\"float32\") / 255\n\tX_val = X_val.astype(\"float32\") / 255\n\n\treturn (X_train, y_train), (X_val, y_val)","def preprocess():\n # Load the data\n random.seed(77)\n X,y = make_classification(n_samples=500, n_features=30, n_informative=8, n_redundant=2, \n n_repeated=0, n_classes=3, n_clusters_per_class=2, weights=None, \n flip_y=0.01, class_sep=1.0, hypercube=True, shift=0.0, scale=1.0, \n shuffle=True, random_state=None)\n\n x_train, x_val, y_train, y_val = train_test_split(X, y, random_state=0, test_size=0.25)\n\n # Standardize the data\n scaler = StandardScaler()\n X_train = scaler.fit_transform(x_train)\n X_val = scaler.transform(x_val)\n\n \n return X_train,y_train,X_val,y_val","def load_data_fashion_mnist(batch_size, resize=None): #@save\n (x_train, y_train), (x_test,y_test) = tf.keras.datasets.fashion_mnist.load_data()\n x_train,x_test = x_train/255, x_test/255\n print(y_train.shape)\n # Divide all numbers by 255 so that all pixel values are between\n # 0 and 1, add a batch dimension at the last. And cast label to int32\n train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))\n test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))\n train_dataset = train_dataset.shuffle(1000).batch(batch_size)\n test_dataset = test_dataset.batch(batch_size)\n return train_dataset,test_dataset","def _prep_data(self, x_train):\n batch_size = x_train.shape[0]\n x_neg = self.encoder.predict_on_batch(x_train)\n y_neg = np.zeros(batch_size)\n x_pos = self.std_dev * np.random.randn(batch_size,\n self.latent_dim) + self.mu\n y_pos = np.ones(batch_size)\n if self.joint_train:\n y_train = [x_train, y_pos]\n else:\n y_train = x_train\n\n return (x_neg, y_neg, x_pos, y_pos, y_train)","def generate_nmnist_continuous_dataset(initial_size, input_dir):\n image_dataset = np.rec.array(None, dtype=[('height', np.uint16),\n ('width', np.uint16),\n ('image_data', 'object'),\n ('label', np.uint32)],\n shape=initial_size)\n num_images = 0\n\n # loop through each folder within the test directories\n for i in range(0, 10):\n current_dir = input_dir + os.path.sep + str(i) + os.path.sep + '*.bin'\n print('Processing {}...'.format(current_dir))\n for filename in glob.iglob(current_dir):\n image = prepare_n_mnist_continuous(filename, False, False)\n if num_images + 1 >= image_dataset.size:\n image_dataset = np.resize(image_dataset, (num_images * 2))\n add_images_to_dataset(image_dataset, image, num_images, i, 28, 28)\n num_images += 1\n\n return image_dataset[0:num_images]","def prepare_data(self):\n if not os.path.exists(self.hparams.data_cache_dir):\n os.mkdir(self.hparams.data_cache_dir)\n for mode, filepath in zip(['train', 'val', 'test'],\n [self.hparams.train_path, self.hparams.val_path, self.hparams.test_path]):\n if mode == 'train':\n label_mode = self.hparams.label_mode\n else:\n label_mode = 'major'\n cached_features_file = self._feature_file(mode, label_mode)\n\n if not os.path.exists(cached_features_file):\n logger.info('Creating features from dataset file at %s', filepath)\n examples = read_examples_from_file(filepath, mode, label_mode)\n features = convert_examples_to_features(\n examples,\n self.labels,\n self.hparams.max_seq_length,\n self.tokenizer,\n cls_token_at_end=bool(self.hparams.model_type in ['xlnet']),\n cls_token=self.tokenizer.cls_token,\n cls_token_segment_id=2 if self.hparams.model_type in ['xlnet'] else 0,\n sep_token=self.tokenizer.sep_token,\n sep_token_extra=bool(self.hparams.model_type in ['roberta']),\n pad_on_left=bool(self.hparams.model_type in ['xlnet']),\n pad_token=self.tokenizer.convert_tokens_to_ids([self.tokenizer.pad_token])[0],\n pad_token_segment_id=4 if self.hparams.model_type in ['xlnet'] else 0,\n pad_token_label_id=self.pad_token_label_id,\n )\n logger.info('Saving features into cached file %s', cached_features_file)\n torch.save(features, cached_features_file)","def format_mnist_data(data=None):\n data_shape = data.shape\n img_size = int(sqrt(data_shape[2]))\n data = np.reshape(data, (data_shape[0], data_shape[1], img_size, img_size))\n return data","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 mnist_training():\n mndata = MNIST(MNIST_PATH)\n train_ims, train_labels = mndata.load_training()\n train_X = np.array(train_ims).T\n train_y = np.array(train_labels).T\n return train_X, train_y","def _load_training_data(self):\n self._save_training_data()","def prepare_learning(self):\n print 'Separating inputs and outputs...'\n self.inputs, self.outputs = extract_samples(self.matches,\n self.input_features,\n self.output_feature)\n\n print 'Normalizing data...'\n self.normalizer, self.inputs = normalize(self.inputs)\n\n print 'Separating train and test sets...'\n self.train_inputs, self.train_outputs, self.test_inputs, self.test_outputs = split_samples(self.inputs, self.outputs)\n\n print 'Building neural network...'\n self.network = buildNetwork(len(self.input_features),\n 2 * len(self.input_features),\n 1,\n outclass=SigmoidLayer,\n bias=True)\n\n print 'Building and filling pybrain train set object...'\n self.train_set = ClassificationDataSet(len(self.input_features))\n\n for i, input_line in enumerate(self.train_inputs):\n self.train_set.addSample(self.train_inputs[i],\n [self.train_outputs[i] - 1])\n\n self.trainer = BackpropTrainer(self.network, dataset=self.train_set,\n momentum=0.5, weightdecay=0.0)\n\n self.train_set.assignClasses()","def preprocess(self):\n print(\"processing content images...\")\n for dir_item in self.selectedContent:\n join_path = Path(self.content_image_dir,dir_item.replace('/','_'))\n if join_path.exists():\n print(\"processing %s\"%dir_item,end='\\r')\n images = join_path.glob('*.%s'%(self.subffix))\n for item in images:\n self.content_dataset.append(item)\n else:\n print(\"%s dir does not exist!\"%dir_item,end='\\r')\n label_index = 0\n print(\"processing style images...\")\n for class_item in self.selectedStyle:\n images = Path(self.style_image_dir).glob('%s/*.%s'%(class_item, self.subffix))\n for item in images:\n self.art_dataset.append([item, label_index])\n label_index += 1\n random.seed(self.random_seed)\n random.shuffle(self.content_dataset)\n random.shuffle(self.art_dataset)\n # self.dataset = images\n print('Finished preprocessing the Art Works dataset, total image number: %d...'%len(self.art_dataset))\n print('Finished preprocessing the Content dataset, total image number: %d...'%len(self.content_dataset))","def mnist_v1(batch_size=128, epochs=20, kernel_size=3):\n (X_train, Y_train), (X_test, Y_test) = mnist.load_data()\n\n # Data preparation\n X_train = prepare(X_train)\n X_test = prepare(X_test)\n Y_train = np_utils.to_categorical(Y_train, 10) # 0..9\n Y_test = np_utils.to_categorical(Y_test, 10) # 0..9\n\n # Fitting the data to the augmentation data generator\n datagen = augmentedData(X_train)\n\n # --------------------\n # NEURAL NETWORK MODEL\n # --------------------\n\n # Model architecture\n model = Sequential()\n\n model.add(Conv2D(32, (kernel_size, kernel_size), activation='relu', input_shape=(1, 28, 28)))\n model.add(Conv2D(32, (kernel_size, kernel_size), activation='relu'))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.25))\n\n model.add(Flatten())\n model.add(Dense(128, activation='relu'))\n model.add(Dropout(0.5))\n model.add(Dense(10, activation='softmax'))\n\n # Model compilation\n model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n\n #Tensor board saves\n now = datetime.datetime.now()\n tensorboard = TensorBoard(log_dir=\"logs_first/kernel_size:{}\".format(kernel_size))\n\n model.fit_generator(datagen.flow(X_train, Y_train, batch_size=batch_size), epochs=epochs, verbose=1, callbacks=[tensorboard])\n\n # Model saves\n now = datetime.datetime.now()\n model.save(\"sirr_HYPERPARAMETERS_mnist_first_\" + str(now.hour) + \"h\" + str(now.minute) + \".h5\")\n\n # Model evaluation\n return model.evaluate(X_test, Y_test, verbose=1)","def load_MNIST_data():\n mnist = input_data.read_data_sets('data', one_hot=True)\n return {'train': mnist.train.images,\n 'validation': mnist.validation.images,\n 'test': mnist.test.images}","def prepare(dataset):\n dataset = dataset.reshape(dataset.shape[0], 1, 28, 28)\n dataset = dataset.astype('float32')\n dataset /= 255\n return dataset","def __init__(self,\n method='random_int',\n flatten=True,\n train_len=60000,\n test_len=10000,\n train_order_seed=None):\n if method == 'random_int':\n x_train = np.random.randint(low=0, high=256, size=(train_len, 28, 28))\n x_test = np.random.randint(low=0, high=256, size=(test_len, 28, 28))\n y_train = np.random.randint(low=0, high=10, size=(train_len, 1))\n y_test = np.random.randint(low=0, high=10, size=(test_len, 1))\n else:\n raise NotImplementedError\n\n\n # Flatten x_train and x_test.\n if flatten:\n x_train = x_train.reshape((x_train.shape[0], -1))\n x_test = x_test.reshape((x_test.shape[0], -1))\n\n # Normalize x_train and x_test.\n x_train = keras.utils.normalize(x_train).astype(np.float32)\n x_test = keras.utils.normalize(x_test).astype(np.float32)\n\n # Convert y_train and y_test to one-hot.\n y_train = keras.utils.to_categorical(y_train)\n y_test = keras.utils.to_categorical(y_test)\n\n # Prepare the dataset.\n super(ConstructedDatasetMnist, self).__init__(\n (x_train, y_train),\n 64, (x_test, y_test),\n train_order_seed=train_order_seed)","def load_dataset():\n temp = gzip.open('mnist.pkl.gz')\n train, val , test = pickle.load(temp,encoding='latin1')\n temp.close()\n train_inp = [np.reshape(x, (784,1)) for x in train[0]]\n train_outp = [one_hot(y) for y in train[1]]\n training_data = zip(train_inp, train_outp)\n validation_inp = [np.reshape(x, (784, 1)) for x in val[0]]\n validation_data = zip(validation_inp, val[1])\n test_inp = [np.reshape(x, (784, 1)) for x in test[0]]\n test_data = zip(test_inp, test[1])\n return (training_data,validation_data,test_data)","def main():\n training_data, validation_data, test_data = mnist.load()\n\n model = nn.NeuralNetwork([784, 100, 10], learning_rate=0.01, batch_size=50)\n\n model_training = training.EarlyStoppingRegularization(model,\n training_data,\n validation_data,\n test_data,\n max_steps_without_progression=2)\n result = model_training.train()\n\n result.save('models/mnist')","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 load_data(self):\n # make sure preprocessing is same as preprocessing as the network\n # reduce mean, and divide by a value to do scaling\n self.train_datagen = ImageDataGenerator(\n rescale=1./ 255,\n shear_range=0.05,\n rotation_range=20, # randomly rotate images in the range (degrees, 0 to 180)\n zoom_range=[0.9, 1.1], # Randomly zoom image\n width_shift_range=0.1, # randomly shift images horizontally (fraction of total width)\n height_shift_range=0.1, # randomly shift images vertically (fraction of total height)\n horizontal_flip=True, # randomly flip images\n brightness_range=[0.8, 1.2],\n fill_mode='reflect',\n validation_split=0.2)\n\n self.test_datagen = ImageDataGenerator(rescale=1. / 255)\n\n self.train_generator = self.train_datagen.flow_from_directory(\n self.train_dir,\n target_size=(224, 224),\n shuffle=True,\n batch_size=self.batchsize,\n class_mode='categorical',\n subset=\"training\")\n\n self.validation_generator = self.train_datagen.flow_from_directory(\n self.train_dir,\n target_size=(224, 224),\n shuffle=True,\n batch_size=self.batchsize,\n class_mode='categorical',\n subset=\"validation\")\n\n self.test_generator = self.test_datagen.flow_from_directory(\n self.test_dir,\n target_size=(224, 224),\n shuffle=False,\n batch_size=1,\n class_mode='categorical')","def _setup_images_and_labels(self):\n if FLAGS.dataset == 'cifar10':\n self.num_classes = 10\n else:\n self.num_classes = 100\n self.images = tf.placeholder(tf.float32, [self.batch_size, 32, 32, 3])\n self.labels = tf.placeholder(tf.float32,\n [self.batch_size, self.num_classes])","def main():\n # Import or download the mnist data, from target file path.\n mnist = input_data.read_data_sets(\"Data/\", one_hot=True)\n\n # Train and test model.\n train(mnist)","def load_data_fashion_mnist(batch_size, resize=None, root=\"~/.mxnet/datasets/fashion-mnist\"):\n def transform_mnist(data, label):\n # transform a batch of examples\n if resize:\n n = data.shape[0]\n new_data = nd.zeros((n, resize, resize, data.shape[3]))\n for i in range(n):\n new_data[i] = image.imresize(data[i], resize, resize)\n data = new_data\n # change data from batch x height x weight x channel to batch x channel x height x weight\n return nd.transpose(data.astype('float32'), (0,3,1,2))/255, label.astype('float32')\n mnist_train = gluon.data.vision.FashionMNIST(root=root, train=True, transform=transform_mnist)\n mnist_test = gluon.data.vision.FashionMNIST(root=root, train=False, transform=transform_mnist)\n train_data = gluon.data.DataLoader(mnist_train, batch_size, shuffle=True)\n test_data = gluon.data.DataLoader(mnist_test, batch_size, shuffle=False)\n return (train_data, test_data)","def before_epoch(self):\n\n # Prepare prediction container in every epoch, set/reset here as new predictions are obtained after each epoch as NN learns\n self.y_pred = []","def setup(self):\n in_dataset, out_dataset = self.get_datasets()","def setup(self):\n in_dataset, out_dataset = self.get_datasets()","def init_datasets(self, display_samples = False):\n print(\"==> Loading images from \", self.img_dir)\n self.image_data_gen = ImageDataGenerator(\n rescale=1./255,\n #rotation_range=30,\n #shear_range=30,\n #width_shift_range=.15,\n #height_shift_range=.15,\n #zoom_range=0.5,\n validation_split=0.2)\n\n self.train_dataset = self.image_data_gen.flow_from_directory(\n batch_size=BATCH_SIZE,\n directory=self.img_dir,\n shuffle=True,\n target_size=self.img_size,\n class_mode='sparse',\n subset='training')\n\n self.val_dataset = self.image_data_gen.flow_from_directory(\n batch_size=BATCH_SIZE,\n directory=self.img_dir,\n shuffle=True,\n target_size=self.img_size,\n class_mode='sparse',\n subset='validation')\n\n if display_samples:\n self.display_sample_images()","def train_mnist():\r\n # type: () -> None\r\n\r\n # Build dataset and model\r\n dataset = MNIST_TRAIN(path=Config.video_folder)\r\n model = LSAMNIST(input_shape=dataset.shape, code_length=64,\r\n cpd_channels=100).to(device).train()\r\n\r\n # Set up result helper and perform test\r\n helper = OneClassResultHelper(dataset, model,\r\n checkpoints_dir=Config.model_ckpt,\r\n output_file='mnist.txt')\r\n helper.train_one_class_classification()","def pre_train(self, dataset, **kwargs):\n\n pass","def prepare_train(self) -> Tuple[ZLIMGS, ZLIMGS, ZLIMGS, ZLIMGS]:\n\n if self.setting == 'setting1':\n warnings.warn(\"Please note that Setting 1 should not use train eval dataset! \"\n \"Because its training set only contain normal samples!\")\n\n with open(self.json_path) as fp:\n ids_json = json.load(fp)\n ids_train_normal = ids_json['normal']['train']\n ids_train_defect = ids_json['defect']['train']\n\n # train\n zlimgs_train_normal = self._create_zl_imgs_given_ids(ids=ids_train_normal,\n subset=CONFIG[self.setting]['normal_train'],\n ann_type=CONFIG[self.setting]['ann_train'])\n zlimgs_train_defect = self._create_zl_imgs_given_ids(ids=ids_train_defect,\n subset=CONFIG[self.setting]['defect_train'],\n ann_type=CONFIG[self.setting]['ann_train'])\n\n # train eval\n zlimgs_train_eval_normal = self._create_zl_imgs_given_ids(ids=ids_train_normal,\n subset=CONFIG[self.setting]['normal_train'],\n ann_type=CONFIG[self.setting]['ann_eval'])\n zlimgs_train_eval_defect = self._create_zl_imgs_given_ids(ids=ids_train_defect,\n subset=CONFIG[self.setting]['defect_train'],\n ann_type=CONFIG[self.setting]['ann_eval'])\n\n return zlimgs_train_normal, zlimgs_train_defect, zlimgs_train_eval_normal, zlimgs_train_eval_defect","def _restore_data_inputs(self):\n super()._restore_data_inputs()\n self.training_data = (\n self._data.training_data.data if self._data.training_data and self._data.training_data.data else None\n )\n self.validation_data = (\n self._data.validation_data.data if self._data.validation_data and self._data.validation_data.data else None\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)","def __initDataFromImages(self):\n #Check if the local_db exist\n initial_dirs = os.listdir(os.getcwd())\n is_db_empty = False\n if len(os.listdir(self.base_dir)) == 1: #Empty here means no person data\n [images_dir] = os.listdir(self.base_dir)\n is_db_empty = images_dir == cfg.local[\"IMG_DIR\"]\n if cfg.local[\"DEFAULT_IMGS_DIR\"] in initial_dirs and is_db_empty:\n default_path = os.path.join(os.getcwd(), cfg.local[\"DEFAULT_IMGS_DIR\"])\n self.X, self.y = loadDataFromImagesPath(self.detector, default_path)\n self.le = LabelEncoder()\n #Nothing relate to mapping name to dir here, we don't care about\n #This data because of the user doesn't exist in the database\n self.__savePreProcessedData()","def read_data_sets(data_path, fake_data=False, one_hot=False,\n validation_size=5000, source_url={},\n augment=False,\n percentage_train=100.,\n unbalance=False, unbalance_dict={\"percentage\": 20, \"label1\": 0, \"label2\": 8},\n ):\n\n class DataSets(object):\n pass\n\n data_sets = DataSets()\n\n if fake_data:\n data_sets.train = DataSet([], [], fake_data=True, one_hot=True)\n data_sets.validation = DataSet([], [], fake_data=True, one_hot=True)\n data_sets.test = DataSet([], [], fake_data=True, one_hot=True)\n return data_sets\n\n if not source_url: # empty string check\n if 'fashion' in data_path:\n source_url = DEFAULT_SOURCE_URL_FASHION\n else:\n source_url = DEFAULT_SOURCE_URL_MNIST\n\n if 'fashion' in data_path or 'mnist' in data_path: # mnist or fashion\n train_images, train_labels, val_images, val_labels, test_images, test_labels = \\\n load_mnist(data_path, validation_size, source_url, one_hot)\n reshape = True\n else:\n train_images, train_labels, val_images, val_labels, test_images, test_labels = \\\n load_medical_data(data_path)\n reshape = False\n\n # add random permutation to train & validation\n np.random.seed(42)\n\n n_train = train_images.shape[0]\n perm = np.random.permutation(n_train)\n train_images = train_images[perm]\n train_labels = train_labels[perm]\n\n n_val = val_images.shape[0]\n perm = np.random.permutation(n_val)\n val_images = val_images[perm]\n val_labels = val_labels[perm]\n\n # For experiments with data-augmentation\n if augment:\n if 'fashion' in data_path: # rotations +-10 and horizontal flips\n augmented_images, augmented_labels = augment_data(train_images, train_labels, hflip=True)\n elif 'mnist' in data_path: # rotations +-10\n augmented_images, augmented_labels = augment_data(train_images, train_labels, hflip=False)\n train_images = np.concatenate([train_images, np.expand_dims(augmented_images, 3)])\n train_labels = np.concatenate([train_labels, augmented_labels])\n # for the medical datasets, you can use the \"augment\" argument while doing patch extraction\n\n # For experiments with limited amount of data\n if percentage_train != 100.:\n train_size = int(0.01*percentage_train*train_images.shape[0])\n Xtrain_images, Xval_images, ytrain, yval = train_test_split(train_images, train_labels, train_size=train_size)\n train_images = Xtrain_images\n train_labels = ytrain\n\n # For experiments with class-imbalance distribution\n if unbalance:\n n_classes = len(np.unique(np.argmax(train_labels, 1)))\n reduceto = 0.01*unbalance_dict['percentage']\n label1 = unbalance_dict['label1']\n label2 = unbalance_dict['label2']\n\n pick_ids = []\n newsize = 0\n all_classes = np.arange(0, n_classes)\n all_classes = np.delete(all_classes, np.where(all_classes == label1)[0])\n all_classes = np.delete(all_classes, np.where(all_classes == label2)[0])\n\n for lab in [label1, label2]:\n allids = np.where(np.argmax(train_labels, 1) == lab)[0]\n selectedids = np.random.choice(allids, int(reduceto * allids.shape[0]), replace=False)\n pick_ids.append(selectedids)\n newsize += len(selectedids)\n\n new_ids = convert_list_to_array(pick_ids, newsize)\n\n other_ids = []\n othersize = 0\n for lab in all_classes.tolist():\n selectedids = np.where(np.argmax(train_labels, 1) == lab)[0]\n other_ids.append(selectedids)\n othersize += len(selectedids)\n\n keep_ids = convert_list_to_array(other_ids, othersize)\n\n # new_ids: contains the indices of the reduced (imbalance) classes\n # keep_ids: contains the indices of the rest (keep the same class distribution)\n resulting_ids = np.concatenate((new_ids, keep_ids))\n np.random.shuffle(resulting_ids)\n\n train_images = train_images[resulting_ids, ...]\n train_labels = train_labels[resulting_ids, ...]\n\n data_sets.train = DataSet(train_images, train_labels, fake_data=True, one_hot=True, reshape=reshape)\n data_sets.validation = DataSet(val_images, val_labels, fake_data=True, one_hot=True, reshape=reshape)\n data_sets.test = DataSet(test_images, test_labels, fake_data=True, one_hot=True, reshape=reshape)\n\n return data_sets","def test_get_mnist_data(self):\n # TODO: Remove once get_mnist_data(...) is fixed.\n pass\n # mnist = get_mnist_data()\n # self.assertEqual(len(mnist.data), 60000)\n # self.assertEqual(len(mnist.labels), 60000)","def _prepare(self, data, train=True):\n if data is None:\n return None\n\n if hasattr(data, \"to_tfdataset\"):\n return data.to_tfdataset(train=train)\n else:\n return data","def normalize_dataset(self):","def create_mnistm(X):\r\n X_ = np.zeros([X.shape[0], 28, 28, 3], np.uint8)\r\n for i in range(X.shape[0]):\r\n bg_img = rand.choice(background_data)\r\n d = mnist_to_img(X[i])\r\n d = compose_image(d, bg_img)\r\n X_[i] = d\r\n return X_","def __download(self):\n\n if self.__check_exists():\n return\n\n print(\"Downloading AudioMNIST dataset\")\n\n # download files\n try:\n os.makedirs(self.__path)\n except OSError as e:\n if e.errno == errno.EEXIST:\n pass\n else:\n raise\n\n if not os.path.exists(os.path.join(self.__path, 'AudioMNIST-master.zip')):\n url = 'https://github.com/soerenab/AudioMNIST/archive/master.zip'\n wget_data = wget.download(url, out=self.__path)\n\n archive = zipfile.ZipFile(wget_data)\n\n for file in archive.namelist():\n if file.startswith('AudioMNIST-master/data/'):\n archive.extract(file, self.__path)\n\n print(\"Download successful\")\n\n audio_mnist_src = os.path.join(self.__path, 'AudioMNIST-master/data/')\n data = np.array(glob.glob(os.path.join(audio_mnist_src, \"**/*.wav\")))\n\n train_images = []\n train_labels = []\n test_images = []\n test_labels = []\n\n # first 5-cross-validation set from https://github.com/soerenab/AudioMNIST/blob/master/preprocess_data.py\n train_folders = [28, 56, 7, 19, 35, 1, 6, 16, 23, 34, 46, 53, 36, 57, 9, 24, 37, 2,\n 8, 17, 29, 39, 48, 54, 43, 58, 14, 25, 38, 3, 10, 20, 30, 40, 49, 55,\n 12, 47, 59, 15, 27, 41, 4, 11, 21, 31, 44, 50]\n test_folders = [26, 52, 60, 18, 32, 42, 5, 13, 22, 33, 45, 51]\n\n print(\"Converting audio to images\")\n # create train and test folders and save audios as images\n for filepath in tqdm(data):\n # the last one is just a counter for repeat of each digit, e.g. say zero once, twice, third time..\n\n dig, vp, rep = filepath.rstrip(\".wav\").split(\"/\")[-1].split(\"_\")\n\n # according to https://github.com/soerenab/AudioMNIST/blob/master/preprocess_data.py\n fs, data = wavf.read(filepath)\n\n # resample\n data = librosa.core.resample(y=data.astype(np.float32), orig_sr=fs, target_sr=8000, res_type=\"scipy\")\n # zero padding\n if len(data) > 8000:\n raise ValueError(\"data length cannot exceed padding length.\")\n elif len(data) < 8000:\n embedded_data = np.zeros(8000)\n offset = np.random.randint(low=0, high=8000 - len(data))\n embedded_data[offset:offset + len(data)] = data\n elif len(data) == 8000:\n # nothing to do here\n embedded_data = data\n pass\n\n # 1. fourier transform\n # stft, with selected parameters, spectrogram will have shape (228, 230)\n f, t, zxx = scipy.signal.stft(embedded_data, 8000, nperseg=455, noverlap=420, window='hann')\n # get amplitude\n zxx = np.abs(zxx[0:227, 2:-1])\n\n # if not 2, then convert to decibel\n zxx = librosa.amplitude_to_db(zxx, ref=np.max)\n\n # normalize from range -80,0 to 0,1\n zxx = (zxx - zxx.min()) / (zxx.max() - zxx.min())\n\n zxx = zxx[::-1] # reverse the order of frequencies to fit the images in the paper\n zxx = np.atleast_3d(zxx).transpose(2, 0, 1) # reshape to (1, img_dim_h, img_dim_w)\n\n # decide to which list to add (train or test)\n if int(vp) in train_folders:\n train_images.append(zxx)\n train_labels.append(int(dig))\n elif int(vp) in test_folders:\n test_images.append(zxx)\n test_labels.append(int(dig))\n else:\n raise Exception('Person neither in train nor in test set!')\n\n train_images = torch.Tensor(train_images).float()\n train_labels = torch.Tensor(train_labels).long()\n test_images = torch.Tensor(test_images).float()\n test_labels = torch.Tensor(test_labels).long()\n\n torch.save(train_images, os.path.join(self.__path, 'train_images_tensor.pt'))\n torch.save(train_labels, os.path.join(self.__path, 'train_labels_tensor.pt'))\n torch.save(test_images, os.path.join(self.__path, 'test_images_tensor.pt'))\n torch.save(test_labels, os.path.join(self.__path, 'test_labels_tensor.pt'))\n\n print('Done!')","def refresh_train_dataset(self):\n inputs_id, inputs_starts, inputs_paths, inputs_ends, inputs_label = self.build_data(self.reader, self.train_items, self.option.max_path_length)\n self.train_dataset = CodeDataset(inputs_id, inputs_starts, inputs_paths, inputs_ends, inputs_label)","def prepare_iris_data(data):\n\n # One-Hot Encode target variable y\n \n X = data.iloc[:, 0:4]\n y = data.iloc[:,-1]\n Y = pd.get_dummies(y)\n \n # Recombine X and Y\n \n data_w_dummies = pd.concat([X, Y], axis=1)\n data_w_dummies.head()\n \n \n # Split data into train and test sets and \n # Make data iterable by batches with DataLoader\n \n train, test = train_test_split(data_w_dummies, test_size=0.2, shuffle=True)\n \n \n trainset = torch.Tensor(train.values)\n \n testset = torch.Tensor(test.values)\n \n return trainset, testset","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 fetch_mnist():\n data_path = check_fetch_mnist()\n f = gzip.open(data_path, 'rb')\n try:\n train_set, valid_set, test_set = pickle.load(f, encoding=\"latin1\")\n except TypeError:\n train_set, valid_set, test_set = pickle.load(f)\n f.close()\n train_indices = np.arange(0, len(train_set[0]))\n valid_indices = np.arange(0, len(valid_set[0])) + train_indices[-1] + 1\n test_indices = np.arange(0, len(test_set[0])) + valid_indices[-1] + 1\n return {\"data\": np.concatenate((train_set[0], valid_set[0], test_set[0]),\n axis=0).astype(theano.config.floatX),\n \"target\": np.concatenate((train_set[1], valid_set[1], test_set[1]),\n axis=0).astype(np.int32),\n \"train_indices\": train_indices.astype(np.int32),\n \"valid_indices\": valid_indices.astype(np.int32),\n \"test_indices\": test_indices.astype(np.int32)}","def prepare_for_predict(self) -> None:\n _, self.all_labels_embed = self._create_all_labels_embed()","def preprocess_with_train_data(self,\n data_dir: Path,\n output_processed_data_dir: Path,\n ) -> NoReturn:\n pass","def prepare_cityscapes_data(seed=1, percent=30.0, version=2017):\n def _save_anno(name, images, annotations):\n \"\"\"Save annotation\n \"\"\"\n print('>> Processing data {}.json saved ({} images {} annotations)'.format(\n name, len(images), len(annotations)))\n new_anno = {}\n new_anno['images'] = images\n new_anno['annotations'] = annotations\n new_anno['categories'] = anno['categories']\n\n with open(\n '{root}/{save_name}.json'.format(\n save_name=name, root=DATA_DIR),\n 'w') as f:\n json.dump(new_anno, f)\n print('>> Data {}.json saved ({} images {} annotations)'.format(\n name, len(images), len(annotations)))\n\n np.random.seed(seed)\n \n anno = json.load(open(os.path.join(DATA_DIR, 'instancesonly_filtered_gtFine_train.json')))\n\n image_list = anno['images']\n labeled_tot = int(percent / 100. * len(image_list))\n #labeled_ind = np.random.choice(range(len(image_list)), size=labeled_tot)\n labeled_ind = np.arange(len(image_list))\n np.random.shuffle(labeled_ind)\n labeled_ind = labeled_ind[0:labeled_tot]\n\n labeled_id = []\n labeled_images = []\n unlabeled_images = []\n labeled_ind = set(labeled_ind)\n for i in range(len(image_list)):\n if i in labeled_ind:\n labeled_images.append(image_list[i])\n labeled_id.append(image_list[i]['id'])\n else:\n unlabeled_images.append(image_list[i])\n\n # get all annotations of labeled images\n labeled_id = set(labeled_id)\n labeled_annotations = []\n unlabeled_annotations = []\n for an in anno['annotations']:\n if an['image_id'] in labeled_id:\n labeled_annotations.append(an)\n else:\n unlabeled_annotations.append(an)\n\n # save labeled and unlabeled\n save_name = 'instancesonly_filtered_gtFine_train.{seed}@{tot}'.format(\n version=version, seed=seed, tot=int(percent))\n _save_anno(save_name, labeled_images, labeled_annotations)\n save_name = 'instancesonly_filtered_gtFine_train.{seed}@{tot}-unlabeled'.format(\n version=version, seed=seed, tot=int(percent))\n _save_anno(save_name, unlabeled_images, unlabeled_annotations)","def preprocess(self):\n lines = [line.rstrip() for line in open(self.attr_path, 'r')]\n all_attr_names = lines[1].split()\n for i, attr_name in enumerate(all_attr_names):\n self.attr2idx[attr_name] = i\n self.idx2attr[i] = attr_name\n\n lines = lines[2:]\n random.seed(1234)\n random.shuffle(lines)\n for i, line in enumerate(lines):\n split = line.split()\n filename = split[0]\n values = split[1:]\n\n label = []\n for attr_name in self.selected_attrs:\n idx = self.attr2idx[attr_name]\n label.append(values[idx] == '1')\n\n if (i+1) < 4:\n self.test_dataset.append([filename, label])\n else:\n self.train_dataset.append([filename, label])","def prepare_data(self):\n import subprocess\n # Download coco data set into dir specified by config then /data/coco\n subprocess.call([f\"{get_original_cwd()}/bin/fetch_dataset.sh\", f\"{self.dir}/data/coco\", f\"{get_original_cwd()}\"])\n # subprocess.call([f\"bin/fetch_dataset.sh\", f\"{self.dir}/data/coco\"])\n task = \"instances\" if self.instance else \"person_keypoints\"\n register_coco_instances(\"train\", {}, f\"{self.dir}/data/coco/{task}_train2014.json\",\n f\"{self.dir}/data/coco/train2014\")\n register_coco_instances(\"val\", {}, f\"{self.dir}/data/coco/{task}_minival2014.json\",\n f\"{self.dir}/data/coco/val2014\")\n register_coco_instances(\"test\", {}, f\"{self.dir}/data/coco/{task}_valminusminival2014.json\",\n f\"{self.dir}/data/coco/val2014\")","def load_mnist_data(amount : int = None, mnist_location : str = \"C:\\\\Users\\\\Vova\\\\PycharmProjects\\\\Neural_Network_test\\\\mnist-csv\",\n to_shuffle = True, output_process_info = True, debug=False) -> Tuple[np.array, np.array]:\n if debug:\n output_process_info = True\n buff_all_file_names = recursive_relative_lsdir(mnist_location)\n if output_process_info:\n print(\"Got mnist file names!\")\n\n if to_shuffle:\n random.shuffle(buff_all_file_names)\n if output_process_info:\n print(\"Shuffled mnist images!\")\n\n if amount is not None:\n all_file_names = buff_all_file_names[:amount]\n else:\n all_file_names = buff_all_file_names\n\n labels = np.array([int(split_path(p)[-2]) for p in all_file_names])\n if output_process_info:\n print(f\"Labeled mnist file names ({len(labels)} pcs)!\")\n\n if debug:\n s = 0\n for i in range(10):\n print(f\"Pictures for number {i}: {list(labels).count(i)}\")\n s += list(labels).count(i)\n print(\"Total:\", s)\n\n # Loading images:\n images = np.zeros((len(labels), 28, 28), dtype=np.float64)\n for i in range(len(all_file_names)):\n images[i] = convert_csv_to_array(all_file_names[i])\n percent = 100 * i / len(all_file_names)\n if random.random() < 0.001:\n print(f\"Loading is {round(percent, 3)} % ready... \", end=\"\\n\\r\")\n\n print(\"Your mnist dataset is ready :) !!!\")\n\n return labels, images","def _prepare_sets(self):\n\n ds_images, ds_labels = self._load_images_labels()\n\n ds_images_2 = ds_images.take(self.val_count)\n ds_labels_2 = ds_labels.take(self.val_count)\n ds_images_1 = ds_images.skip(self.val_count)\n ds_labels_1 = ds_labels.skip(self.val_count)\n\n ds_1 = (ds_images_1, ds_labels_1)\n ds_2 = (ds_images_2, ds_labels_2)\n\n return ds_1, ds_2","def setup(self, stage=None):\n self.data_train, self.data_val, self.data_test = [None] * 3","def preprocess_the_dataset(x_train):\n # initialize empty lists\n x_real,x_pencil=[],[]\n for image in x_train[:8000]:\n real_image = resize_128(image)\n # make it pencil drawn\n pencil_image = convert_image(real_image)\n x_real.append(real_image/127.5-1)\n x_pencil.append(pencil_image/127.5-1)\n return x_real,x_pencil","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 get_MNIST_training_normalized():\n X, Y = get_dataset(\"training\")\n X=X/255.0\n X-=0.5\n return X,Y\n\n global MNIST_training\n if MNIST_training is None:\n if os.path.exists(\"./data/MNIST_training.pkl\"):\n MNIST_training = cPickle.load(open(\"./data/MNIST_training.pkl\", \"r\"))\n else:\n MNIST_training = get_dataset(\"training\")\n MNIST_training = normalize_data(MNIST_training[0], MNIST_training[1])\n cPickle.dump(MNIST_training, open(\"./data/MNIST_training.pkl\",\"w\"))\n return MNIST_training","def __init__(self, data_dir, input_shape=[10, 64, 64, 1], target_shape=[10, 64, 64, 1],\n as_binary=False, num_digits=2, step_length=0.1):\n dataset_size = sys.maxint\n super(MovingMNISTTrainDataset, self).__init__('train', data_dir, dataset_size,\n input_shape, target_shape,\n as_binary, num_digits, step_length)","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 load_training_set():\n global training_set\n f = gzip.open('mnist.pkl.gz', 'rb')\n train, valid, test = cPickle.load(f)\n [training_set, training_labels] = train\n [validation_set, validation_labels] = valid\n [testing_set, testing_labels] = test\n training_set = np.concatenate((training_set, validation_set))\n f.close()\n np.random.shuffle(training_set)"],"string":"[\n \"def _prepare_data(self):\\n #TODO hardcoded values need to change\\n print_info(\\\"Preprocessing the train data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"train\\\"),\\n self.TRAIN_OUT_PATH)\\n\\n print_info(\\\"Preprocessing the test data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"test\\\"),\\n self.TEST_OUT_PATH)\\n\\n print_info(\\\"Preprocessing the validation data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"val\\\"),\\n self.VAL_OUT_PATH)\",\n \"def prepare_data(self):\\n try:\\n self.train_dataset = self.datasets['train']\\n self.val_dataset = self.datasets['val']\\n try:\\n self.test_dataset = self.datasets['test']\\n except:\\n pass\\n except Exception as e:\\n print('Data was not succesfully prepared:', e)\",\n \"def prepare_data(self, *args, **kwargs) -> None:\\n if not (self.root / \\\"train\\\").exists():\\n raise ValueError(\\n f\\\"Please download and set ImageNet-1k train data under {self.root}.\\\"\\n )\\n if not (self.root / \\\"val\\\").exists():\\n raise ValueError(\\n f\\\"Please download and set ImageNet-1k val data under {self.root}.\\\"\\n )\",\n \"def preprocess_data(self):\\n\\n self._preprocess_train_data()\\n self._preprocess_test_data()\",\n \"def prepare_data():\\n gennet.prepare_data('Resnet50')\",\n \"def prepare_data(self, *args, **kwargs):\\n # get paths to train and test splits\\n _split_paths = [os.path.join(self.path_to_data, split)\\n for split in os.listdir(self.path_to_data)]\\n\\n # for each split [train, test]\\n for _path in _split_paths:\\n _img_classes = os.listdir(_path) # get subfolders representing each class\\n self.splits[os.path.basename(_path)] = []\\n\\n # get the images in pairs with its corresponding class\\n for _class in _img_classes:\\n _data = self.get_img_text_pair(os.path.join(_path, _class))\\n\\n if os.path.basename(_path) == 'train':\\n self.weights[self.encode_label(_class)] = len(_data)\\n self.splits[os.path.basename(_path)].extend(_data)\",\n \"def buildDataSet():\\n (x_train_origin, y_train_origin), (x_test_origin, y_test_origin) = mnist.load_data()\\n\\n assert K.image_data_format() == 'channels_last'\\n x_train_origin = x_train_origin.reshape(x_train_origin.shape[0], h, w, 1)\\n x_test_origin = x_test_origin.reshape(x_test_origin.shape[0], h, w, 1)\\n\\n dataset_train = []\\n dataset_test = []\\n\\n #Sorting images by classes and normalize values 0=>1\\n for n in range(nb_classes):\\n images_class_n = np.asarray([row for idx,row in enumerate(x_train_origin) if y_train_origin[idx]==n])\\n dataset_train.append(images_class_n/255)\\n\\n images_class_n = np.asarray([row for idx,row in enumerate(x_test_origin) if y_test_origin[idx]==n])\\n dataset_test.append(images_class_n/255)\\n\\n return dataset_train,dataset_test,x_train_origin,y_train_origin,x_test_origin,y_test_origin\",\n \"def prepare_data_for_training(args):\\n # Form the train/test splits and write them to disk\\n dataset = data.Dataset(args)\\n # get image classes and image counts in each class\\n label_map = dataset.get_class_info()\\n class_count = len(list(label_map.values()))\\n # split the data and store it in log dir\\n df_train, df_test = dataset.split_dataset()\\n\\n # perform dataset augmentations\\n image_data = augment.Augmentation(args)\\n # get the data gens for training and test images\\n train_data_gen, _ = image_data.map_fn_train(df_train)\\n test_data_gen, _ = image_data.map_fn_test(df_test)\\n\\n return train_data_gen, test_data_gen, df_train, df_test, class_count\",\n \"def prepare_data(self):\\n data = self._get_dataset(self.hparams.dataset_path)\\n label_encoder = data[\\\"label_encoder\\\"]\\n del data[\\\"label_encoder\\\"]\\n\\n click.secho(\\\"Building inputs and labels.\\\", fg=\\\"yellow\\\")\\n datasets = {\\n \\\"train\\\": defaultdict(list),\\n \\\"valid\\\": defaultdict(list),\\n \\\"test\\\": defaultdict(list),\\n }\\n for dataset_name, dataset in data.items():\\n for sample in dataset:\\n instance = self.build_input(\\n self.tokenizer, sample[\\\"text\\\"], label_encoder, sample[\\\"label\\\"]\\n )\\n for input_name, input_array in instance.items():\\n datasets[dataset_name][input_name].append(input_array)\\n\\n click.secho(\\\"Padding inputs and building tensors.\\\", fg=\\\"yellow\\\")\\n tensor_datasets = {\\\"train\\\": [], \\\"valid\\\": [], \\\"test\\\": []}\\n for dataset_name, dataset in datasets.items():\\n dataset = self.pad_dataset(dataset, padding=self.tokenizer.pad_index)\\n for input_name in MODEL_INPUTS:\\n if input_name == \\\"labels\\\":\\n tensor = torch.tensor(dataset[input_name], dtype=torch.float32)\\n else:\\n tensor = torch.tensor(dataset[input_name])\\n tensor_datasets[dataset_name].append(tensor)\\n\\n self.train_dataset = TensorDataset(*tensor_datasets[\\\"train\\\"])\\n self.valid_dataset = TensorDataset(*tensor_datasets[\\\"valid\\\"])\\n self.test_dataset = TensorDataset(*tensor_datasets[\\\"test\\\"])\\n click.secho(\\n \\\"Train dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.train_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n \\\"Valid dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.valid_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n \\\"Test dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.test_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\",\n \"def get_mnist():\\n from keras.datasets import mnist\\n\\n # input image dimensions\\n img_rows, img_cols = 28, 28\\n num_classes = 10\\n # the data, shuffled and split between train and test sets\\n (x_train, y_train), (x_test, y_test) = mnist.load_data()\\n\\n if K.image_data_format() == 'channels_first':\\n print (\\\"Using Channels first\\\")\\n x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)\\n x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)\\n input_shape = (1, img_rows, img_cols)\\n else:\\n print(\\\"Channels last\\\")\\n x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)\\n x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)\\n input_shape = (img_rows, img_cols, 1)\\n\\n return (x_train, y_train), (x_test, y_test)\",\n \"def prepare_n_mnist(filename, is_filter, num_spikes, step_factor=1):\\n td = ev.read_dataset(filename)\\n # td.show_td(100)\\n td.data = stabilize(td)\\n td.data = td.extract_roi([3, 3], [28, 28], True)\\n images = make_td_images(td, num_spikes, step_factor)\\n\\n if is_filter:\\n images = ndimage.median_filter(images, 3)\\n\\n # for image in images:\\n # cv2.imshow('img', image)\\n # cv2.waitKey(70)\\n return images\",\n \"def preprocess_train_data(self):\\r\\n print(\\\"* Preprocessing training data.\\\", flush=True)\\r\\n prep.create_HDF_file(self.C.training_set, is_training_set=True)\\r\\n\\r\\n self.print_time_elapsed()\",\n \"def __init__(self,\\n mnist_location,\\n flatten=True,\\n permute_labels=False,\\n train_order_seed=None):\\n mnist = save_restore.restore_network(mnist_location)\\n\\n x_train = mnist['x_train']\\n x_test = mnist['x_test']\\n y_train = mnist['y_train']\\n y_test = mnist['y_test']\\n\\n if permute_labels:\\n # Reassign labels according to a random permutation of the labels.\\n permutation = np.random.permutation(10)\\n y_train = permutation[y_train]\\n y_test = permutation[y_test]\\n\\n # Flatten x_train and x_test.\\n if flatten:\\n x_train = x_train.reshape((x_train.shape[0], -1))\\n x_test = x_test.reshape((x_test.shape[0], -1))\\n\\n # Normalize x_train and x_test.\\n x_train = keras.utils.normalize(x_train).astype(np.float32)\\n x_test = keras.utils.normalize(x_test).astype(np.float32)\\n\\n # Convert y_train and y_test to one-hot.\\n y_train = keras.utils.to_categorical(y_train)\\n y_test = keras.utils.to_categorical(y_test)\\n\\n # Prepare the dataset.\\n super(DatasetMnist, self).__init__(\\n (x_train, y_train),\\n 64, (x_test, y_test),\\n train_order_seed=train_order_seed)\",\n \"def __init__(self):\\n\\n TEST_RATIO = 0.05\\n mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=None)\\n idxs = np.arange(mnist_trainset.train_data.size(0))\\n np.random.shuffle(idxs)\\n\\n #print(torch.min(mnist_trainset.train_labels), torch.max(mnist_trainset.train_labels))\\n #print(mnist_trainset.train_labels.size())\\n \\n # reshape input data to (1, 784) and normalize to range [0., 1.]\\n self.train_data = torch.reshape(\\n mnist_trainset.train_data[idxs].float(), (-1,1,28,28))/255.\\n self.data_size = self.train_data.size(0)\\n self.train_len = self.train_data.size(0)\\n self.train_label = torch.Tensor([1]).float() # since there is only one class - 'real' image\\n\\n print('Train images -- {}'.format(self.train_data.size()))\",\n \"def _init_dataset(self):\\n champions = set()\\n\\n for name in os.listdir(self.data_root):\\n label = name.split(\\\".\\\")[0]\\n champions.add(label)\\n self.image_paths += [(os.path.join(self.data_root, name), [[label]])]\\n\\n # self.encoder = self.encoder.fit(np.array(list(champions)).reshape(-1, 1))\\n self.encoder = self.encoder.fit(list(champions))\",\n \"def data(self):\\n (x_train, y_train), (_, _) = datasets.fashion_mnist.load_data()\\n x_train = x_train.reshape((-1, 28, 28, 1))\\n x_train, y_train = x_train.astype('float16') / 255.0, \\\\\\n tf.keras.utils.to_categorical(y_train.astype('float16'), 10)\\n (x_train, x_eval) = x_train[5000:], x_train[:5000]\\n (y_train, y_eval) = y_train[5000:], y_train[:5000]\\n train_data, eval_data = (x_train, y_train), (x_eval, y_eval)\\n return train_data, eval_data\",\n \"def get_mnist_data(batch=128):\\n \\n def transformer(data, label):\\n data = data.flatten().expand_dims(0).astype(np.float32)/255\\n data = data-0.13/0.31\\n label = label.astype(np.float32)\\n return data, label\\n\\n train_dataset = gluon.data.vision.datasets.MNIST(root=M5_IMAGES, train=True, transform=transformer)\\n validation_dataset = gluon.data.vision.datasets.MNIST(root=M5_IMAGES, train=False, transform=transformer)\\n train_dataloader = gluon.data.DataLoader(train_dataset, batch_size=batch, last_batch='keep',shuffle=True)\\n validation_dataloader = gluon.data.DataLoader(validation_dataset, batch_size=batch, last_batch='keep')\\n \\n return train_dataloader, validation_dataloader\",\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__(self, **kwargs):\\n is_training = kwargs.get('is_training', True)\\n rootfolder = kwargs['rootfolder']\\n dtype = kwargs.get('dtype', np.float64)\\n self._load_mnist(rootfolder, is_training, dtype)\\n # normalize data.\\n self._data /= 255.\\n ndarraydata.NdarrayDataLayer.__init__(\\n self, sources=[self._data, self._label], **kwargs)\",\n \"def preprocess(self):\\n \\n file_name_list = os.listdir(self.image_dir)\\n random.seed(1234)\\n random.shuffle(file_name_list)\\n \\n for i,d in enumerate(self.domains):\\n self.attr2idx[d]=i \\n\\n for i, file_name in enumerate(file_name_list):\\n if (file_name.startswith('X_')):\\n continue\\n \\n parts = file_name.split(\\\"-\\\")\\n label = int(parts[0])\\n if label not in self.domains:\\n continue\\n img_name = file_name\\n\\n count=self.get_sample_count(label)\\n if count<self.valid_set_size:\\n # create holdout set on the fly\\n utils.copy_file(self.image_dir,self.valid_set_dir,img_name)\\n else:\\n self.dataset.append([img_name, self.attr2idx[label]])\\n \\n self.increment_sample_count(label)\\n\\n print(\\\"Sample count per domain: \\\"+str(self.sample_count)+\\\" (including holdout set, holdout size per domain is: \\\"+str(self.valid_set_size)+\\\")\\\")\\n print('Finished preprocessing the dataset...')\",\n \"def prepare_train_data(self):\\r\\n ## Impute rlkpis\\r\\n print(\\\"Imputing rlKPI df\\\")\\r\\n self.rlkpi.add_target_labels(1)\\r\\n self.rlkpi.impute_rl_kpis()\\r\\n\\r\\n print(\\\"Add 'met-real-station_no' & met-forecast-station_no to rl_kpis_df\\\")\\r\\n self.add_met_real_forecast_station_col_to_rlkpis()\\r\\n print(\\\"Merge 'met-real-sampled df to rl kps \\\")\\r\\n self.merge_met_real_sampled_df_to_rlkpis()\\r\\n\\r\\n ## Imputations for met-forecast\\r\\n print(\\\"Impute met-forecast\\\")\\r\\n met_forecast_obj = self.metfcast\\r\\n met_forecast_obj.impute_met_forecast()\\r\\n\\r\\n #Merge met forecast data to earlier merged data\\r\\n print(\\\"Merge Train data with imputed forecast df\\\")\\r\\n self.train_data = pd.merge(self.train_data,\\r\\n met_forecast_obj.imputed_forecast_df,\\r\\n on=['datetime-station_no'], indicator=True, how='inner')\\r\\n print(\\\"Check any imputation needed\\\", self.train_data.isna().sum().sum())\\r\\n self.train_data.drop(['_merge'], axis=1, inplace=True)\\r\\n self.perform_data_under_sampling(self.train_data)\",\n \"def load_mnist(fashion, onehot_encode=True, flatten_x=False, crop_x=0, classes=None):\\n\\tif not fashion:\\n\\t\\t(x_train, y_train),(x_test, y_test) = tf.keras.datasets.mnist.load_data()\\n\\t\\tx_train, x_test = x_train / 255.0, x_test / 255.0\\n\\telse:\\n\\t\\t(x_train, y_train),(x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()\\n\\t\\tx_train, x_test = x_train / 255.0, x_test / 255.0 \\n \\n\\tdef crop(X, crop_size):\\n\\t\\tassert crop_x < X.shape[1]/2\\n\\t\\tassert crop_x < X.shape[2]/2\\n\\t\\treturn X[:,crop_size:-crop_size,crop_size:-crop_size]\\n\\n\\tif crop_x > 0:\\n\\t\\tx_train = crop(x_train, crop_x)\\n\\t\\tx_test = crop(x_test, crop_x)\\n\\n\\t# Flatten to 2d arrays (each example 1d)\\n\\tdef flatten_image(X):\\n\\t return X.reshape(X.shape[0], X.shape[1]*X.shape[1])\\n\\tif flatten_x:\\n\\t\\tx_train = flatten_image(x_train)\\n\\t\\tx_test = flatten_image(x_test)\\n\\n\\tif onehot_encode:\\n\\t\\ty_train = onehot_encode_labels(y_train)\\n\\t\\ty_test = onehot_encode_labels(y_test)\\n\\n\\tif classes is not None:\\n\\t\\tassert len(classes) == 2\\n\\t\\tc0, c1 = classes\\n\\t\\ttrain_idxs_to_keep = np.logical_or(y_train==c0, y_train==c1)\\n\\t\\tx_train, y_train = x_train[train_idxs_to_keep,:], y_train[train_idxs_to_keep]\\n\\t\\ttest_idxs_to_keep = np.logical_or(y_test==c0, y_test==c1)\\n\\t\\tx_test, y_test = x_test[test_idxs_to_keep,:], y_test[test_idxs_to_keep]\\n\\n\\t\\ty_train = (y_train==c1).astype(int)[:,np.newaxis]\\n\\t\\ty_test = (y_test==c1).astype(int)[:,np.newaxis]\\n\\n\\treturn x_train, y_train, x_test, y_test\",\n \"def prepare_data(self):\\n # Set up the path\\n self.path_target_train = os.path.join(self.data_dir, self.train_path_file_target + \\\".pkl\\\")\\n self.path_target_test = os.path.join(self.data_dir, self.test_path_file_target + \\\".pkl\\\")\\n\\n if not os.path.exists(self.path_target_train) or not os.path.exists(self.path_target_test):\\n # Create vocabularies of the appropriate sizes.\\n self.create_vocabulary(self.train_path_file)\\n\\n # Create token ids for the training data.\\n input_train_path = self.train_path_file\\n target_train_path = self.train_path_file_target\\n train_input, train_input_length, train_labels = self.data_to_token_ids(input_train_path, target_train_path)\\n\\n # Create token ids for the validation data.\\n input_test_path = self.test_path_file\\n target_test_path = self.test_path_file_target\\n test_input, test_input_length, _ = self.data_to_token_ids(input_test_path, target_test_path, train=False)\\n\\n # Collect data into a list\\n training_data = [train_input, train_input_length, train_labels]\\n test_data = [test_input, test_input_length]\\n\\n # Save all the data\\n with open(self.path_target_train, 'wb') as f:\\n pickle.dump(training_data,f)\\n with open(self.path_target_test, 'wb') as f:\\n pickle.dump(test_data, f)\\n else:\\n # Load data\\n with open(self.path_target_train, 'rb') as f:\\n training_data = pickle.load(f)\\n with open(self.path_target_test, 'rb') as f:\\n test_data = pickle.load(f)\\n\\n # Initialize vocabulary\\n self.initialize_vocabulary()\\n\\n # Convert list into a numpy array - train data\\n train_input = pd.DataFrame(training_data[0]).fillna(value=0).astype(int).values\\n train_length_input = np.array(training_data[1], dtype=int)\\n train_labels = np.array(training_data[2], dtype=int)\\n\\n # Convert list into a numpy array - test data\\n test_input = pd.DataFrame(test_data[0]).fillna(value=0).astype(int).values\\n test_length_input = pd.DataFrame(test_data[1]).fillna(value=0).astype(int).values\\n\\n # Printing maximum length\\n print(\\\"Shape of the input training matrix {}\\\".format(str(train_input.shape)))\\n print(\\\"Shape of the input test matrix {}\\\".format(str(test_input.shape)))\\n\\n # Copy the files\\n self.copy_files()\\n\\n # Return output\\n return train_input, train_length_input, train_labels, test_input, test_length_input\",\n \"def generate_nmnist_dataset(initial_size, input_dir, num_spikes, step_factor):\\n image_dataset = np.rec.array(None, dtype=[('height', np.uint16),\\n ('width', np.uint16),\\n ('image_data', 'object'),\\n ('label', np.uint32)],\\n shape=initial_size)\\n num_images = 0\\n\\n # loop through each folder within the test directories\\n for i in range(0, 10):\\n current_dir = input_dir + os.path.sep + str(i) + os.path.sep + '*.bin'\\n print('Processing {}...'.format(current_dir))\\n for filename in glob.iglob(current_dir):\\n images = prepare_n_mnist(filename, True, num_spikes, step_factor)\\n if num_images + len(images) >= image_dataset.size:\\n image_dataset = np.resize(image_dataset,\\n (num_images + len(images)) * 2)\\n add_images_to_dataset(image_dataset, images, num_images, i, 28, 28)\\n num_images += len(images)\\n\\n return image_dataset[0:num_images]\",\n \"def prepare_n_mnist_continuous(filename, is_filter, is_normalize=False):\\n td = ev.read_dataset(filename)\\n # td.show_td(100)\\n td.data = stabilize(td)\\n td.data = td.extract_roi([0, 0], [28, 28], True)\\n # td.data = apply_tracking1(td)\\n # td.data = apply_tracking2(td)\\n # td.data = apply_tracking3(td)\\n # td.data = td.extract_roi([3, 3], [28, 28], True)\\n image = make_td_probability_image(td, 9, is_normalize)\\n\\n if is_filter:\\n image = ndimage.median_filter(image, 3)\\n\\n # cv2.imshow('img', image)\\n # cv2.waitKey(1)\\n return image\",\n \"def readMNISTData():\\n mnist = input_data.read_data_sets(\\\"MNIST_data\\\",one_hot=True) \\n return mnist\",\n \"def prepare_feed(self, is_train=False, debug=False):\\n\\n feed = self.get_feed_dict(is_train)\\n\\n if debug:\\n inds,x_batch, y_batch = self.sess.run(self.dataset.get_iterator_entry())\\n feed[self.indexs] = inds\\n feed[self.input_l.name] = x_batch\\n feed[self.targets.name] = y_batch\\n return feed\\n else:\\n return feed\",\n \"def reset_training_data(self):\\n logger.info(\\\"resetting training data\\\")\\n if self.shuffle:\\n random.shuffle(self.tweets)\\n self.batch_generator = self.get_batch()\",\n \"def build_data_set(self):\\n if not self.assert_data_correct():\\n self.download_all_data()\\n self.unpack_rename_data()\\n self.split_data_characters()\\n self.clean_data_fragments()\\n self.create_font_data()\\n if not self.assert_train_augmented():\\n self.augment_train_data()\\n if not self.assert_style_data_correct():\\n self.download_style_data()\\n self.unpack_rename_data()\",\n \"def load_data():\\n # Load image data from MNIST.\\n (train_x, train_y),(eval_x, eval_y) = keras.datasets.mnist.load_data()\\n\\n # We convert the input data to (60000, 28, 28, 1), float32 and normalize our data values to the range [0, 1].\\n train_x = train_x.reshape(train_x.shape[0], train_x.shape[1], train_x.shape[2], 1)\\n eval_x = eval_x.reshape(eval_x.shape[0], eval_x.shape[1], eval_x.shape[2], 1)\\n\\n train_x = train_x.astype('float32')\\n eval_x = eval_x.astype('float32')\\n train_x /= 255\\n eval_x /= 255\\n\\n # Preprocess class labels \\n train_y = train_y.astype(np.int32)\\n eval_y = eval_y.astype(np.int32)\\n\\n train_y = np_utils.to_categorical(train_y, 10)\\n eval_y = np_utils.to_categorical(eval_y, 10)\\n\\n return train_x, train_y, eval_x, eval_y\",\n \"def get_mnist_cnn():\\n # Set defaults.\\n nb_classes = 10 #dataset dependent \\n batch_size = 128\\n epochs = 4\\n \\n # Input image dimensions\\n img_rows, img_cols = 28, 28\\n\\n # Get the data.\\n # the data, shuffled and split between train and test sets\\n (x_train, y_train), (x_test, y_test) = mnist.load_data()\\n \\n if K.image_data_format() == 'channels_first':\\n x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)\\n x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)\\n input_shape = (1, img_rows, img_cols)\\n else:\\n x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)\\n x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)\\n input_shape = (img_rows, img_cols, 1)\\n\\n #x_train = x_train.reshape(60000, 784)\\n #x_test = x_test.reshape(10000, 784)\\n \\n x_train = x_train.astype('float32')\\n x_test = x_test.astype('float32')\\n x_train /= 255\\n x_test /= 255\\n\\n #print('x_train shape:', x_train.shape)\\n #print(x_train.shape[0], 'train samples')\\n #print(x_test.shape[0], 'test samples')\\n\\n # convert class vectors to binary class matrices\\n y_train = to_categorical(y_train, nb_classes)\\n y_test = to_categorical(y_test, nb_classes)\\n\\n # convert class vectors to binary class matrices\\n #y_train = keras.utils.to_categorical(y_train, nb_classes)\\n #y_test = keras.utils.to_categorical(y_test, nb_classes)\\n\\n return (nb_classes, batch_size, input_shape, x_train, x_test, y_train, y_test, epochs)\",\n \"def preprocess_dataset(self, dataset, params=None):\\n if params is None:\\n assert self.params_loaded, (\\n \\\"You must either provide parameters or load the model params before preprocessing.\\\")\\n params = self.params\\n for key in dataset.keys():\\n if dataset[key] is None:\\n continue\\n if hasattr(params, \\\"whiten_data\\\") and params.whiten_data:\\n if hasattr(params, \\\"whiten_method\\\"):\\n if params.whiten_method == \\\"FT\\\": # other methods require patching first\\n if hasattr(params, \\\"whiten_batch_size\\\"):\\n batch_size = params.whiten_batch_size\\n else:\\n batch_size = None\\n dataset[key].images, dataset[key].data_mean, dataset[key].w_filter = \\\\\\n dp.whiten_data_batch(dataset[key].images, method=params.whiten_method,\\n batch_size=batch_size)\\n print(\\\"INFO:preprocessing:FT Whitened \\\"+key+\\\" data\\\")\\n if hasattr(params, \\\"lpf_data\\\") and params.lpf_data:\\n dataset[key].images, dataset[key].data_mean, dataset[key].lpf_filter = \\\\\\n dp.lpf_data(dataset[key].images, cutoff=params.lpf_cutoff)\\n print(\\\"INFO:preprocessing:Low pass filtered \\\"+key+\\\" data\\\")\\n if hasattr(params, \\\"contrast_normalize\\\") and params.contrast_normalize:\\n if hasattr(params, \\\"gauss_patch_size\\\"):\\n dataset[key].images = dp.contrast_normalize(dataset[key].images,\\n params.gauss_patch_size)\\n else:\\n dataset[key].images = dp.contrast_normalize(dataset[key].images)\\n print(\\\"INFO:preprocessing:Contrast normalized \\\"+key+\\\" data\\\")\\n if hasattr(params, \\\"standardize_data\\\") and params.standardize_data:\\n if params.data_type == \\\"mnist\\\":\\n eps = 1e-5\\n else:\\n eps = None\\n dataset[key].images, dataset[key].data_mean, dataset[key].data_std = \\\\\\n dp.standardize_data(dataset[key].images, eps)\\n self.data_mean = dataset[key].data_mean\\n self.data_std = dataset[key].data_std\\n print(\\\"INFO:preprocessing:Standardized \\\"+key+\\\" data\\\")\\n if hasattr(params, \\\"extract_patches\\\") and params.extract_patches:\\n assert all(key in params.__dict__.keys()\\n for key in [\\\"num_patches\\\", \\\"patch_edge_size\\\", \\\"overlapping_patches\\\",\\n \\\"randomize_patches\\\"]), (\\\"Insufficient params for patches.\\\")\\n out_shape = (int(params.num_patches), int(params.patch_edge_size),\\n int(params.patch_edge_size), dataset[key].num_channels)\\n dataset[key].num_examples = out_shape[0]\\n dataset[key].reset_counters()\\n if hasattr(params, \\\"patch_variance_threshold\\\"):\\n dataset[key].images = dp.extract_patches(dataset[key].images, out_shape,\\n params.overlapping_patches, params.randomize_patches,\\n params.patch_variance_threshold, dataset[key].rand_state)\\n else:\\n dataset[key].images = dp.extract_patches(dataset[key].images, out_shape,\\n params.overlapping_patches, params.randomize_patches,\\n var_thresh=0, rand_state=dataset[key].rand_state)\\n dataset[key].shape = dataset[key].images.shape\\n dataset[key].num_rows = dataset[key].shape[1]\\n dataset[key].num_cols = dataset[key].shape[2]\\n dataset[key].num_channels = dataset[key].shape[3]\\n dataset[key].num_pixels = np.prod(dataset[key].shape[1:])\\n print(\\\"INFO:preprocessing:Extracted patches from \\\"+key+\\\" data\\\")\\n if hasattr(params, \\\"whiten_data\\\") and params.whiten_data:\\n if hasattr(params, \\\"whiten_method\\\") and params.whiten_method != \\\"FT\\\":\\n dataset[key].images, dataset[key].data_mean, dataset[key].w_filter = \\\\\\n dp.whiten_data(dataset[key].images, method=params.whiten_method)\\n print(\\\"INFO:preprocessing:Whitened \\\"+key+\\\" data\\\")\\n if hasattr(params, \\\"norm_data\\\") and params.norm_data:\\n dataset[key].images, dataset[key].data_max = dp.normalize_data_with_max(dataset[key].images)\\n self.data_max = dataset[key].data_max\\n print(\\\"INFO:preprocessing:Normalized \\\"+key+\\\" data with maximum\\\")\\n if hasattr(params, \\\"rescale_data\\\") and params.rescale_data:\\n dataset[key].images, dataset[key].data_min, dataset[key].data_max = dp.rescale_data_to_one(dataset[key].images)\\n self.data_max = dataset[key].data_max\\n self.data_min = dataset[key].data_min\\n print(\\\"INFO:preprocessing:Rescaled each \\\"+key+\\\" datapoint to one\\\")\\n if hasattr(params, \\\"center_data\\\") and params.center_data:\\n dataset[key].images, dataset[key].data_mean = dp.center_data(dataset[key].images,\\n use_dataset_mean=True)\\n self.data_mean = dataset[key].data_mean\\n print(\\\"INFO:preprocessing:Centered \\\"+key+\\\" data\\\")\\n return dataset\",\n \"def load_mnist_dataset(shape=(-1,784)):\\n # We first define a download function, supporting both Python 2 and 3.\\n if sys.version_info[0] == 2:\\n from urllib import urlretrieve\\n else:\\n from urllib.request import urlretrieve\\n\\n def download(filename, source='http://yann.lecun.com/exdb/mnist/'):\\n print(\\\"Downloading %s\\\" % filename)\\n urlretrieve(source + filename, filename)\\n\\n # We then define functions for loading MNIST images and labels.\\n # For convenience, they also download the requested files if needed.\\n import gzip\\n\\n def load_mnist_images(filename):\\n if not os.path.exists(filename):\\n download(filename)\\n # Read the inputs in Yann LeCun's binary format.\\n with gzip.open(filename, 'rb') as f:\\n data = np.frombuffer(f.read(), np.uint8, offset=16)\\n # The inputs are vectors now, we reshape them to monochrome 2D images,\\n # following the shape convention: (examples, channels, rows, columns)\\n data = data.reshape(shape)\\n # data = data.reshape(-1, 1, 28, 28) # for lasagne\\n # data = data.reshape(-1, 28, 28, 1) # for tensorflow\\n # data = data.reshape(-1, 784) # for tensorflow\\n # The inputs come as bytes, we convert them to float32 in range [0,1].\\n # (Actually to range [0, 255/256], for compatibility to the version\\n # provided at http://deeplearning.net/data/mnist/mnist.pkl.gz.)\\n return data / np.float32(256)\\n\\n def load_mnist_labels(filename):\\n if not os.path.exists(filename):\\n download(filename)\\n # Read the labels in Yann LeCun's binary format.\\n with gzip.open(filename, 'rb') as f:\\n data = np.frombuffer(f.read(), np.uint8, offset=8)\\n # The labels are vectors of integers now, that's exactly what we want.\\n return data\\n\\n # We can now download and read the training and test set images and labels.\\n ## you may want to change the path\\n data_dir = '' #os.getcwd() + '/lasagne_tutorial/'\\n # print('data_dir > %s' % data_dir)\\n\\n X_train = load_mnist_images(data_dir+'train-images-idx3-ubyte.gz')\\n y_train = load_mnist_labels(data_dir+'train-labels-idx1-ubyte.gz')\\n X_test = load_mnist_images(data_dir+'t10k-images-idx3-ubyte.gz')\\n y_test = load_mnist_labels(data_dir+'t10k-labels-idx1-ubyte.gz')\\n\\n # We reserve the last 10000 training examples for validation.\\n X_train, X_val = X_train[:-10000], X_train[-10000:]\\n y_train, y_val = y_train[:-10000], y_train[-10000:]\\n\\n ## you may want to plot one example\\n # print('X_train[0][0] >', X_train[0][0].shape, type(X_train[0][0])) # for lasagne\\n # print('X_train[0] >', X_train[0].shape, type(X_train[0])) # for tensorflow\\n # # exit()\\n # # [[..],[..]] (28, 28) numpy.ndarray\\n # # plt.imshow 只支持 (28, 28)格式，不支持 (1, 28, 28),所以用 [0][0]\\n # fig = plt.figure()\\n # #plotwindow = fig.add_subplot(111)\\n # # plt.imshow(X_train[0][0], cmap='gray') # for lasagne (-1, 1, 28, 28)\\n # plt.imshow(X_train[0].reshape(28,28), cmap='gray') # for tensorflow (-1, 28, 28, 1)\\n # plt.title('A training image')\\n # plt.show()\\n\\n # We just return all the arrays in order, as expected in main().\\n # (It doesn't matter how we do this as long as we can read them again.)\\n return X_train, y_train, X_val, y_val, X_test, y_test\",\n \"def setUp(self):\\n self.X_train, self.y_train = load_data(\\\"../data/traindata.mat.tar.gz\\\")\\n self.nn = NN_hwr([len(self.X_train[0]), 50, 10])\",\n \"def set_data():\\r\\n #if not os.path.exists(filepath):\\r\\n #download_data()\\r\\n metadata = read(filepath + flist[-1])\\r\\n ndata = metadata['num_cases_per_batch']\\r\\n ndim = metadata['num_vis']\\r\\n\\r\\n data, train, test = {}, {}, {}\\r\\n data['labels'] = metadata['label_names']\\r\\n data['ntraindata'] = metadata['num_cases_per_batch'] * (len(flist) - 2)\\r\\n data['ntestdata'] = metadata['num_cases_per_batch']\\r\\n data['ndim'] = metadata['num_vis']\\r\\n\\r\\n train['x'], train['y'] = convert_train(data['ntraindata'], data['ndim'])\\r\\n\\r\\n testdata = read(filepath + flist[-2])\\r\\n test['x'] = testdata['data']\\r\\n test['y'] = testdata['labels']\\r\\n\\r\\n data['train'], data['test'] = train, test\\r\\n save_pkl(data)\",\n \"def create_mnist_dataset(mode='train', num_samples=2, batch_size=2):\\n mnist_path = '/home/workspace/mindspore_dataset/mnist'\\n num_parallel_workers = 1\\n\\n # define dataset\\n mnist_ds = ds.MnistDataset(os.path.join(mnist_path, mode), num_samples=num_samples, shuffle=False)\\n\\n resize_height, resize_width = 32, 32\\n\\n # define map operations\\n resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR) # Bilinear mode\\n rescale_nml_op = CV.Rescale(1 / 0.3081, -1 * 0.1307 / 0.3081)\\n rescale_op = CV.Rescale(1.0 / 255.0, shift=0.0)\\n hwc2chw_op = CV.HWC2CHW()\\n type_cast_op = C.TypeCast(mstype.int32)\\n\\n # apply map operations on images\\n mnist_ds = mnist_ds.map(operations=type_cast_op, input_columns=\\\"label\\\", num_parallel_workers=num_parallel_workers)\\n mnist_ds = mnist_ds.map(operations=resize_op, input_columns=\\\"image\\\", num_parallel_workers=num_parallel_workers)\\n mnist_ds = mnist_ds.map(operations=rescale_op, input_columns=\\\"image\\\", num_parallel_workers=num_parallel_workers)\\n mnist_ds = mnist_ds.map(operations=rescale_nml_op, input_columns=\\\"image\\\", num_parallel_workers=num_parallel_workers)\\n mnist_ds = mnist_ds.map(operations=hwc2chw_op, input_columns=\\\"image\\\", num_parallel_workers=num_parallel_workers)\\n\\n # apply DatasetOps\\n mnist_ds = mnist_ds.batch(batch_size=batch_size, drop_remainder=True)\\n\\n return mnist_ds\",\n \"def _prepare_ml_data(X, y, to_optimize=False):\\n size_test = 1\\n y_test = None\\n if to_optimize:\\n size_test = CONFIG.OPTIMIZE_PARAMS['size'] + 1\\n y_test = y.iloc[-size_test:]\\n X_train = X.iloc[:-size_test]\\n y_train = y.iloc[:-size_test]\\n X_test = X.iloc[-size_test:]\\n return X_train, y_train, X_test, y_test\",\n \"def load_data_fashion_mnist(batch_size, resize=None): #@save\\n mnist_train, mnist_test = tf.keras.datasets.fashion_mnist.load_data()\\n # Divide all numbers by 255 so that all pixel values are between\\n # 0 and 1, add a batch dimension at the last. And cast label to int32\\n process = lambda X, y: (tf.expand_dims(X, axis=3) / 255,\\n tf.cast(y, dtype='int32'))\\n resize_fn = lambda X, y: (\\n tf.image.resize_with_pad(X, resize, resize) if resize else X, y)\\n return (\\n tf.data.Dataset.from_tensor_slices(process(*mnist_train)).batch(\\n batch_size).shuffle(len(mnist_train[0])).map(resize_fn),\\n tf.data.Dataset.from_tensor_slices(process(*mnist_test)).batch(\\n batch_size).map(resize_fn))\",\n \"def load_data_mnist(train_size=None):\\n print \\\"---->\\\\n.....Loading MNIST data from the skdata package\\\"\\n dataset = view.OfficialImageClassification()\\n if train_size:\\n train_data = {}\\n validation_data = {}\\n order = permutation(dataset.all_images.shape[0])\\n train_data['images'] = dataset.all_images[order[:train_size]] / 256.\\n train_data['labels'] = dataset.all_labels[order[:train_size]]\\n validation_data['images'] = (dataset.all_images[order[train_size:]]\\n / 256.)\\n validation_data['labels'] = dataset.all_labels[order[train_size:]]\\n else:\\n train_data = {}\\n validation_data = {}\\n train_data['images'] = dataset.all_images / 256.\\n train_data['labels'] = dataset.all_labels\\n for r in train_data:\\n train_data[r] = train_data[r].astype(theano.config.floatX)\\n for r in validation_data:\\n validation_data[r] = validation_data[r].astype(theano.config.floatX)\\n print \\\"---->\\\\n.....Done!\\\"\\n\\n return train_data, validation_data\",\n \"def InitDataset(self):\\n train_txt = 'ImageSets/Main/train.txt'\\n val_txt = 'ImageSets/Main/val.txt'\\n annotations = \\\"Annotations\\\"\\n jpegimages = \\\"JPEGImages\\\"\\n images_path = train_txt if (self.is_train) else val_txt \\n images_path = readTxt(os.path.join(self.path, images_path))\\n images_path.pop(-1)\\n # rawdata format: [path_2_image, path_2_xml]\\n rawData = list()\\n for each in images_path:\\n xml = os.path.join(self.path, annotations, each + '.xml')\\n jpeg = os.path.join(self.path, jpegimages, each + '.jpg')\\n rawData.append([jpeg, xml])\\n return rawData\",\n \"def preprocess_data():\\n le = preprocessing.LabelEncoder()\\n # Reshape and normalize pixel values to be between 0 and 1\\n train_images_reshaped = train_images.reshape(len(train_images), 1024, 1024, 1)/255.\\n test_images_reshaped = test_images.reshape(len(test_images), 1024, 1024, 1)/255.\\n\\n return train_images_reshaped, test_images_reshaped, le.fit_transform(train_labels), le.fit_transform(test_labels)\",\n \"def _load_data(self):\\n\\n from sklearn.datasets import fetch_openml\\n mnist = fetch_openml('mnist_784', cache=True)\\n # data_x = np.array(final_data_df)\\n feat_data = np.array(mnist.data).astype('float32')\\n target_data = mnist.target.astype('int64')\\n shuffling_index = np.arange(feat_data.shape[0])\\n np.random.shuffle(shuffling_index)\\n feat_data = feat_data[shuffling_index]\\n target_data = target_data[shuffling_index]\\n\\n cur_data_list = []\\n cur_target_list = []\\n for i in range(10):\\n cur_mask = target_data == i\\n cur_data_list.append(feat_data[cur_mask][:500])\\n cur_target_list.append(target_data[cur_mask][:500])\\n feat_data = np.concatenate(cur_data_list)\\n target_data = np.concatenate(cur_target_list)\\n\\n self.data_x = feat_data\\n self.data_y = self.to_one_hot_encoding(target_data)\\n self.numerical_idx = np.arange(784)\\n self.non_num_idx = None\\n\\n # Calculate adjacency matrix\\n self.meta_inf = self.data_x.astype('float32')\\n\\n if self.args.graph_type:\\n self.adj = self.get_adjacency()\",\n \"def prepare(self):\\n if self.opts['verbose']:\\n print(\\\"Preparing dataset (one-time operation)...\\\")\\n # Create paths files and load them back in\\n self._build_ID_sets()\\n self._create_ID_files()\\n self._load_ID_files()\\n if self.opts['verbose']:\\n print(\\\"... done with preparing the dataset.\\\")\",\n \"def use_mnist_model(self):\\n\\n\\t\\t# load the model\\n\\t\\tnumber_recognizer_MNIST = load_model('models/MNIST_digits_recognition.h5', compile=False)\\n\\n\\t\\t# create empty ndarray\\n\\t\\tnumbers_mnist = np.ones(shape=(self.sudoku_size, self.sudoku_size))\\n\\n\\t\\tpics = deepcopy(self.list_of_number_pictures)\\n\\t\\tfor i in range(self.sudoku_size):\\n\\t\\t\\tfor j in range(self.sudoku_size):\\n\\t\\t\\t\\tpics[i][j] = self.preprocess_cell(pics[i][j], mnist=True, resize=True, clean_remains=True)\\n\\t\\t\\t\\tif self.empty_cells[i][j] != 0:\\n\\t\\t\\t\\t\\tnumbers_mnist[i][j] = np.argmax(number_recognizer_MNIST.predict([[pics[i][j].reshape(28,28,1)]]))\\n\\n\\t\\treturn numbers_mnist\",\n \"def get_data():\\n\\t(X_train, y_train), (X_val, y_val) = mnist.load_data()\\n\\tn_features = X_train.shape[1]*X_train.shape[1]\\n\\tn_train = X_train.shape[0]\\n\\tn_val = X_val.shape[0]\\n\\tX_train = X_train.reshape(n_train, n_features)\\n\\tX_val = X_val.reshape(n_val, n_features)\\n\\tX_train = X_train.astype(\\\"float32\\\") / 255\\n\\tX_val = X_val.astype(\\\"float32\\\") / 255\\n\\n\\treturn (X_train, y_train), (X_val, y_val)\",\n \"def preprocess():\\n # Load the data\\n random.seed(77)\\n X,y = make_classification(n_samples=500, n_features=30, n_informative=8, n_redundant=2, \\n n_repeated=0, n_classes=3, n_clusters_per_class=2, weights=None, \\n flip_y=0.01, class_sep=1.0, hypercube=True, shift=0.0, scale=1.0, \\n shuffle=True, random_state=None)\\n\\n x_train, x_val, y_train, y_val = train_test_split(X, y, random_state=0, test_size=0.25)\\n\\n # Standardize the data\\n scaler = StandardScaler()\\n X_train = scaler.fit_transform(x_train)\\n X_val = scaler.transform(x_val)\\n\\n \\n return X_train,y_train,X_val,y_val\",\n \"def load_data_fashion_mnist(batch_size, resize=None): #@save\\n (x_train, y_train), (x_test,y_test) = tf.keras.datasets.fashion_mnist.load_data()\\n x_train,x_test = x_train/255, x_test/255\\n print(y_train.shape)\\n # Divide all numbers by 255 so that all pixel values are between\\n # 0 and 1, add a batch dimension at the last. And cast label to int32\\n train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))\\n test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))\\n train_dataset = train_dataset.shuffle(1000).batch(batch_size)\\n test_dataset = test_dataset.batch(batch_size)\\n return train_dataset,test_dataset\",\n \"def _prep_data(self, x_train):\\n batch_size = x_train.shape[0]\\n x_neg = self.encoder.predict_on_batch(x_train)\\n y_neg = np.zeros(batch_size)\\n x_pos = self.std_dev * np.random.randn(batch_size,\\n self.latent_dim) + self.mu\\n y_pos = np.ones(batch_size)\\n if self.joint_train:\\n y_train = [x_train, y_pos]\\n else:\\n y_train = x_train\\n\\n return (x_neg, y_neg, x_pos, y_pos, y_train)\",\n \"def generate_nmnist_continuous_dataset(initial_size, input_dir):\\n image_dataset = np.rec.array(None, dtype=[('height', np.uint16),\\n ('width', np.uint16),\\n ('image_data', 'object'),\\n ('label', np.uint32)],\\n shape=initial_size)\\n num_images = 0\\n\\n # loop through each folder within the test directories\\n for i in range(0, 10):\\n current_dir = input_dir + os.path.sep + str(i) + os.path.sep + '*.bin'\\n print('Processing {}...'.format(current_dir))\\n for filename in glob.iglob(current_dir):\\n image = prepare_n_mnist_continuous(filename, False, False)\\n if num_images + 1 >= image_dataset.size:\\n image_dataset = np.resize(image_dataset, (num_images * 2))\\n add_images_to_dataset(image_dataset, image, num_images, i, 28, 28)\\n num_images += 1\\n\\n return image_dataset[0:num_images]\",\n \"def prepare_data(self):\\n if not os.path.exists(self.hparams.data_cache_dir):\\n os.mkdir(self.hparams.data_cache_dir)\\n for mode, filepath in zip(['train', 'val', 'test'],\\n [self.hparams.train_path, self.hparams.val_path, self.hparams.test_path]):\\n if mode == 'train':\\n label_mode = self.hparams.label_mode\\n else:\\n label_mode = 'major'\\n cached_features_file = self._feature_file(mode, label_mode)\\n\\n if not os.path.exists(cached_features_file):\\n logger.info('Creating features from dataset file at %s', filepath)\\n examples = read_examples_from_file(filepath, mode, label_mode)\\n features = convert_examples_to_features(\\n examples,\\n self.labels,\\n self.hparams.max_seq_length,\\n self.tokenizer,\\n cls_token_at_end=bool(self.hparams.model_type in ['xlnet']),\\n cls_token=self.tokenizer.cls_token,\\n cls_token_segment_id=2 if self.hparams.model_type in ['xlnet'] else 0,\\n sep_token=self.tokenizer.sep_token,\\n sep_token_extra=bool(self.hparams.model_type in ['roberta']),\\n pad_on_left=bool(self.hparams.model_type in ['xlnet']),\\n pad_token=self.tokenizer.convert_tokens_to_ids([self.tokenizer.pad_token])[0],\\n pad_token_segment_id=4 if self.hparams.model_type in ['xlnet'] else 0,\\n pad_token_label_id=self.pad_token_label_id,\\n )\\n logger.info('Saving features into cached file %s', cached_features_file)\\n torch.save(features, cached_features_file)\",\n \"def format_mnist_data(data=None):\\n data_shape = data.shape\\n img_size = int(sqrt(data_shape[2]))\\n data = np.reshape(data, (data_shape[0], data_shape[1], img_size, img_size))\\n return data\",\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 mnist_training():\\n mndata = MNIST(MNIST_PATH)\\n train_ims, train_labels = mndata.load_training()\\n train_X = np.array(train_ims).T\\n train_y = np.array(train_labels).T\\n return train_X, train_y\",\n \"def _load_training_data(self):\\n self._save_training_data()\",\n \"def prepare_learning(self):\\n print 'Separating inputs and outputs...'\\n self.inputs, self.outputs = extract_samples(self.matches,\\n self.input_features,\\n self.output_feature)\\n\\n print 'Normalizing data...'\\n self.normalizer, self.inputs = normalize(self.inputs)\\n\\n print 'Separating train and test sets...'\\n self.train_inputs, self.train_outputs, self.test_inputs, self.test_outputs = split_samples(self.inputs, self.outputs)\\n\\n print 'Building neural network...'\\n self.network = buildNetwork(len(self.input_features),\\n 2 * len(self.input_features),\\n 1,\\n outclass=SigmoidLayer,\\n bias=True)\\n\\n print 'Building and filling pybrain train set object...'\\n self.train_set = ClassificationDataSet(len(self.input_features))\\n\\n for i, input_line in enumerate(self.train_inputs):\\n self.train_set.addSample(self.train_inputs[i],\\n [self.train_outputs[i] - 1])\\n\\n self.trainer = BackpropTrainer(self.network, dataset=self.train_set,\\n momentum=0.5, weightdecay=0.0)\\n\\n self.train_set.assignClasses()\",\n \"def preprocess(self):\\n print(\\\"processing content images...\\\")\\n for dir_item in self.selectedContent:\\n join_path = Path(self.content_image_dir,dir_item.replace('/','_'))\\n if join_path.exists():\\n print(\\\"processing %s\\\"%dir_item,end='\\\\r')\\n images = join_path.glob('*.%s'%(self.subffix))\\n for item in images:\\n self.content_dataset.append(item)\\n else:\\n print(\\\"%s dir does not exist!\\\"%dir_item,end='\\\\r')\\n label_index = 0\\n print(\\\"processing style images...\\\")\\n for class_item in self.selectedStyle:\\n images = Path(self.style_image_dir).glob('%s/*.%s'%(class_item, self.subffix))\\n for item in images:\\n self.art_dataset.append([item, label_index])\\n label_index += 1\\n random.seed(self.random_seed)\\n random.shuffle(self.content_dataset)\\n random.shuffle(self.art_dataset)\\n # self.dataset = images\\n print('Finished preprocessing the Art Works dataset, total image number: %d...'%len(self.art_dataset))\\n print('Finished preprocessing the Content dataset, total image number: %d...'%len(self.content_dataset))\",\n \"def mnist_v1(batch_size=128, epochs=20, kernel_size=3):\\n (X_train, Y_train), (X_test, Y_test) = mnist.load_data()\\n\\n # Data preparation\\n X_train = prepare(X_train)\\n X_test = prepare(X_test)\\n Y_train = np_utils.to_categorical(Y_train, 10) # 0..9\\n Y_test = np_utils.to_categorical(Y_test, 10) # 0..9\\n\\n # Fitting the data to the augmentation data generator\\n datagen = augmentedData(X_train)\\n\\n # --------------------\\n # NEURAL NETWORK MODEL\\n # --------------------\\n\\n # Model architecture\\n model = Sequential()\\n\\n model.add(Conv2D(32, (kernel_size, kernel_size), activation='relu', input_shape=(1, 28, 28)))\\n model.add(Conv2D(32, (kernel_size, kernel_size), activation='relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n model.add(Flatten())\\n model.add(Dense(128, activation='relu'))\\n model.add(Dropout(0.5))\\n model.add(Dense(10, activation='softmax'))\\n\\n # Model compilation\\n model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\\n\\n #Tensor board saves\\n now = datetime.datetime.now()\\n tensorboard = TensorBoard(log_dir=\\\"logs_first/kernel_size:{}\\\".format(kernel_size))\\n\\n model.fit_generator(datagen.flow(X_train, Y_train, batch_size=batch_size), epochs=epochs, verbose=1, callbacks=[tensorboard])\\n\\n # Model saves\\n now = datetime.datetime.now()\\n model.save(\\\"sirr_HYPERPARAMETERS_mnist_first_\\\" + str(now.hour) + \\\"h\\\" + str(now.minute) + \\\".h5\\\")\\n\\n # Model evaluation\\n return model.evaluate(X_test, Y_test, verbose=1)\",\n \"def load_MNIST_data():\\n mnist = input_data.read_data_sets('data', one_hot=True)\\n return {'train': mnist.train.images,\\n 'validation': mnist.validation.images,\\n 'test': mnist.test.images}\",\n \"def prepare(dataset):\\n dataset = dataset.reshape(dataset.shape[0], 1, 28, 28)\\n dataset = dataset.astype('float32')\\n dataset /= 255\\n return dataset\",\n \"def __init__(self,\\n method='random_int',\\n flatten=True,\\n train_len=60000,\\n test_len=10000,\\n train_order_seed=None):\\n if method == 'random_int':\\n x_train = np.random.randint(low=0, high=256, size=(train_len, 28, 28))\\n x_test = np.random.randint(low=0, high=256, size=(test_len, 28, 28))\\n y_train = np.random.randint(low=0, high=10, size=(train_len, 1))\\n y_test = np.random.randint(low=0, high=10, size=(test_len, 1))\\n else:\\n raise NotImplementedError\\n\\n\\n # Flatten x_train and x_test.\\n if flatten:\\n x_train = x_train.reshape((x_train.shape[0], -1))\\n x_test = x_test.reshape((x_test.shape[0], -1))\\n\\n # Normalize x_train and x_test.\\n x_train = keras.utils.normalize(x_train).astype(np.float32)\\n x_test = keras.utils.normalize(x_test).astype(np.float32)\\n\\n # Convert y_train and y_test to one-hot.\\n y_train = keras.utils.to_categorical(y_train)\\n y_test = keras.utils.to_categorical(y_test)\\n\\n # Prepare the dataset.\\n super(ConstructedDatasetMnist, self).__init__(\\n (x_train, y_train),\\n 64, (x_test, y_test),\\n train_order_seed=train_order_seed)\",\n \"def load_dataset():\\n temp = gzip.open('mnist.pkl.gz')\\n train, val , test = pickle.load(temp,encoding='latin1')\\n temp.close()\\n train_inp = [np.reshape(x, (784,1)) for x in train[0]]\\n train_outp = [one_hot(y) for y in train[1]]\\n training_data = zip(train_inp, train_outp)\\n validation_inp = [np.reshape(x, (784, 1)) for x in val[0]]\\n validation_data = zip(validation_inp, val[1])\\n test_inp = [np.reshape(x, (784, 1)) for x in test[0]]\\n test_data = zip(test_inp, test[1])\\n return (training_data,validation_data,test_data)\",\n \"def main():\\n training_data, validation_data, test_data = mnist.load()\\n\\n model = nn.NeuralNetwork([784, 100, 10], learning_rate=0.01, batch_size=50)\\n\\n model_training = training.EarlyStoppingRegularization(model,\\n training_data,\\n validation_data,\\n test_data,\\n max_steps_without_progression=2)\\n result = model_training.train()\\n\\n result.save('models/mnist')\",\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 load_data(self):\\n # make sure preprocessing is same as preprocessing as the network\\n # reduce mean, and divide by a value to do scaling\\n self.train_datagen = ImageDataGenerator(\\n rescale=1./ 255,\\n shear_range=0.05,\\n rotation_range=20, # randomly rotate images in the range (degrees, 0 to 180)\\n zoom_range=[0.9, 1.1], # Randomly zoom image\\n width_shift_range=0.1, # randomly shift images horizontally (fraction of total width)\\n height_shift_range=0.1, # randomly shift images vertically (fraction of total height)\\n horizontal_flip=True, # randomly flip images\\n brightness_range=[0.8, 1.2],\\n fill_mode='reflect',\\n validation_split=0.2)\\n\\n self.test_datagen = ImageDataGenerator(rescale=1. / 255)\\n\\n self.train_generator = self.train_datagen.flow_from_directory(\\n self.train_dir,\\n target_size=(224, 224),\\n shuffle=True,\\n batch_size=self.batchsize,\\n class_mode='categorical',\\n subset=\\\"training\\\")\\n\\n self.validation_generator = self.train_datagen.flow_from_directory(\\n self.train_dir,\\n target_size=(224, 224),\\n shuffle=True,\\n batch_size=self.batchsize,\\n class_mode='categorical',\\n subset=\\\"validation\\\")\\n\\n self.test_generator = self.test_datagen.flow_from_directory(\\n self.test_dir,\\n target_size=(224, 224),\\n shuffle=False,\\n batch_size=1,\\n class_mode='categorical')\",\n \"def _setup_images_and_labels(self):\\n if FLAGS.dataset == 'cifar10':\\n self.num_classes = 10\\n else:\\n self.num_classes = 100\\n self.images = tf.placeholder(tf.float32, [self.batch_size, 32, 32, 3])\\n self.labels = tf.placeholder(tf.float32,\\n [self.batch_size, self.num_classes])\",\n \"def main():\\n # Import or download the mnist data, from target file path.\\n mnist = input_data.read_data_sets(\\\"Data/\\\", one_hot=True)\\n\\n # Train and test model.\\n train(mnist)\",\n \"def load_data_fashion_mnist(batch_size, resize=None, root=\\\"~/.mxnet/datasets/fashion-mnist\\\"):\\n def transform_mnist(data, label):\\n # transform a batch of examples\\n if resize:\\n n = data.shape[0]\\n new_data = nd.zeros((n, resize, resize, data.shape[3]))\\n for i in range(n):\\n new_data[i] = image.imresize(data[i], resize, resize)\\n data = new_data\\n # change data from batch x height x weight x channel to batch x channel x height x weight\\n return nd.transpose(data.astype('float32'), (0,3,1,2))/255, label.astype('float32')\\n mnist_train = gluon.data.vision.FashionMNIST(root=root, train=True, transform=transform_mnist)\\n mnist_test = gluon.data.vision.FashionMNIST(root=root, train=False, transform=transform_mnist)\\n train_data = gluon.data.DataLoader(mnist_train, batch_size, shuffle=True)\\n test_data = gluon.data.DataLoader(mnist_test, batch_size, shuffle=False)\\n return (train_data, test_data)\",\n \"def before_epoch(self):\\n\\n # Prepare prediction container in every epoch, set/reset here as new predictions are obtained after each epoch as NN learns\\n self.y_pred = []\",\n \"def setup(self):\\n in_dataset, out_dataset = self.get_datasets()\",\n \"def setup(self):\\n in_dataset, out_dataset = self.get_datasets()\",\n \"def init_datasets(self, display_samples = False):\\n print(\\\"==> Loading images from \\\", self.img_dir)\\n self.image_data_gen = ImageDataGenerator(\\n rescale=1./255,\\n #rotation_range=30,\\n #shear_range=30,\\n #width_shift_range=.15,\\n #height_shift_range=.15,\\n #zoom_range=0.5,\\n validation_split=0.2)\\n\\n self.train_dataset = self.image_data_gen.flow_from_directory(\\n batch_size=BATCH_SIZE,\\n directory=self.img_dir,\\n shuffle=True,\\n target_size=self.img_size,\\n class_mode='sparse',\\n subset='training')\\n\\n self.val_dataset = self.image_data_gen.flow_from_directory(\\n batch_size=BATCH_SIZE,\\n directory=self.img_dir,\\n shuffle=True,\\n target_size=self.img_size,\\n class_mode='sparse',\\n subset='validation')\\n\\n if display_samples:\\n self.display_sample_images()\",\n \"def train_mnist():\\r\\n # type: () -> None\\r\\n\\r\\n # Build dataset and model\\r\\n dataset = MNIST_TRAIN(path=Config.video_folder)\\r\\n model = LSAMNIST(input_shape=dataset.shape, code_length=64,\\r\\n cpd_channels=100).to(device).train()\\r\\n\\r\\n # Set up result helper and perform test\\r\\n helper = OneClassResultHelper(dataset, model,\\r\\n checkpoints_dir=Config.model_ckpt,\\r\\n output_file='mnist.txt')\\r\\n helper.train_one_class_classification()\",\n \"def pre_train(self, dataset, **kwargs):\\n\\n pass\",\n \"def prepare_train(self) -> Tuple[ZLIMGS, ZLIMGS, ZLIMGS, ZLIMGS]:\\n\\n if self.setting == 'setting1':\\n warnings.warn(\\\"Please note that Setting 1 should not use train eval dataset! \\\"\\n \\\"Because its training set only contain normal samples!\\\")\\n\\n with open(self.json_path) as fp:\\n ids_json = json.load(fp)\\n ids_train_normal = ids_json['normal']['train']\\n ids_train_defect = ids_json['defect']['train']\\n\\n # train\\n zlimgs_train_normal = self._create_zl_imgs_given_ids(ids=ids_train_normal,\\n subset=CONFIG[self.setting]['normal_train'],\\n ann_type=CONFIG[self.setting]['ann_train'])\\n zlimgs_train_defect = self._create_zl_imgs_given_ids(ids=ids_train_defect,\\n subset=CONFIG[self.setting]['defect_train'],\\n ann_type=CONFIG[self.setting]['ann_train'])\\n\\n # train eval\\n zlimgs_train_eval_normal = self._create_zl_imgs_given_ids(ids=ids_train_normal,\\n subset=CONFIG[self.setting]['normal_train'],\\n ann_type=CONFIG[self.setting]['ann_eval'])\\n zlimgs_train_eval_defect = self._create_zl_imgs_given_ids(ids=ids_train_defect,\\n subset=CONFIG[self.setting]['defect_train'],\\n ann_type=CONFIG[self.setting]['ann_eval'])\\n\\n return zlimgs_train_normal, zlimgs_train_defect, zlimgs_train_eval_normal, zlimgs_train_eval_defect\",\n \"def _restore_data_inputs(self):\\n super()._restore_data_inputs()\\n self.training_data = (\\n self._data.training_data.data if self._data.training_data and self._data.training_data.data else None\\n )\\n self.validation_data = (\\n self._data.validation_data.data if self._data.validation_data and self._data.validation_data.data else None\\n )\",\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 __initDataFromImages(self):\\n #Check if the local_db exist\\n initial_dirs = os.listdir(os.getcwd())\\n is_db_empty = False\\n if len(os.listdir(self.base_dir)) == 1: #Empty here means no person data\\n [images_dir] = os.listdir(self.base_dir)\\n is_db_empty = images_dir == cfg.local[\\\"IMG_DIR\\\"]\\n if cfg.local[\\\"DEFAULT_IMGS_DIR\\\"] in initial_dirs and is_db_empty:\\n default_path = os.path.join(os.getcwd(), cfg.local[\\\"DEFAULT_IMGS_DIR\\\"])\\n self.X, self.y = loadDataFromImagesPath(self.detector, default_path)\\n self.le = LabelEncoder()\\n #Nothing relate to mapping name to dir here, we don't care about\\n #This data because of the user doesn't exist in the database\\n self.__savePreProcessedData()\",\n \"def read_data_sets(data_path, fake_data=False, one_hot=False,\\n validation_size=5000, source_url={},\\n augment=False,\\n percentage_train=100.,\\n unbalance=False, unbalance_dict={\\\"percentage\\\": 20, \\\"label1\\\": 0, \\\"label2\\\": 8},\\n ):\\n\\n class DataSets(object):\\n pass\\n\\n data_sets = DataSets()\\n\\n if fake_data:\\n data_sets.train = DataSet([], [], fake_data=True, one_hot=True)\\n data_sets.validation = DataSet([], [], fake_data=True, one_hot=True)\\n data_sets.test = DataSet([], [], fake_data=True, one_hot=True)\\n return data_sets\\n\\n if not source_url: # empty string check\\n if 'fashion' in data_path:\\n source_url = DEFAULT_SOURCE_URL_FASHION\\n else:\\n source_url = DEFAULT_SOURCE_URL_MNIST\\n\\n if 'fashion' in data_path or 'mnist' in data_path: # mnist or fashion\\n train_images, train_labels, val_images, val_labels, test_images, test_labels = \\\\\\n load_mnist(data_path, validation_size, source_url, one_hot)\\n reshape = True\\n else:\\n train_images, train_labels, val_images, val_labels, test_images, test_labels = \\\\\\n load_medical_data(data_path)\\n reshape = False\\n\\n # add random permutation to train & validation\\n np.random.seed(42)\\n\\n n_train = train_images.shape[0]\\n perm = np.random.permutation(n_train)\\n train_images = train_images[perm]\\n train_labels = train_labels[perm]\\n\\n n_val = val_images.shape[0]\\n perm = np.random.permutation(n_val)\\n val_images = val_images[perm]\\n val_labels = val_labels[perm]\\n\\n # For experiments with data-augmentation\\n if augment:\\n if 'fashion' in data_path: # rotations +-10 and horizontal flips\\n augmented_images, augmented_labels = augment_data(train_images, train_labels, hflip=True)\\n elif 'mnist' in data_path: # rotations +-10\\n augmented_images, augmented_labels = augment_data(train_images, train_labels, hflip=False)\\n train_images = np.concatenate([train_images, np.expand_dims(augmented_images, 3)])\\n train_labels = np.concatenate([train_labels, augmented_labels])\\n # for the medical datasets, you can use the \\\"augment\\\" argument while doing patch extraction\\n\\n # For experiments with limited amount of data\\n if percentage_train != 100.:\\n train_size = int(0.01*percentage_train*train_images.shape[0])\\n Xtrain_images, Xval_images, ytrain, yval = train_test_split(train_images, train_labels, train_size=train_size)\\n train_images = Xtrain_images\\n train_labels = ytrain\\n\\n # For experiments with class-imbalance distribution\\n if unbalance:\\n n_classes = len(np.unique(np.argmax(train_labels, 1)))\\n reduceto = 0.01*unbalance_dict['percentage']\\n label1 = unbalance_dict['label1']\\n label2 = unbalance_dict['label2']\\n\\n pick_ids = []\\n newsize = 0\\n all_classes = np.arange(0, n_classes)\\n all_classes = np.delete(all_classes, np.where(all_classes == label1)[0])\\n all_classes = np.delete(all_classes, np.where(all_classes == label2)[0])\\n\\n for lab in [label1, label2]:\\n allids = np.where(np.argmax(train_labels, 1) == lab)[0]\\n selectedids = np.random.choice(allids, int(reduceto * allids.shape[0]), replace=False)\\n pick_ids.append(selectedids)\\n newsize += len(selectedids)\\n\\n new_ids = convert_list_to_array(pick_ids, newsize)\\n\\n other_ids = []\\n othersize = 0\\n for lab in all_classes.tolist():\\n selectedids = np.where(np.argmax(train_labels, 1) == lab)[0]\\n other_ids.append(selectedids)\\n othersize += len(selectedids)\\n\\n keep_ids = convert_list_to_array(other_ids, othersize)\\n\\n # new_ids: contains the indices of the reduced (imbalance) classes\\n # keep_ids: contains the indices of the rest (keep the same class distribution)\\n resulting_ids = np.concatenate((new_ids, keep_ids))\\n np.random.shuffle(resulting_ids)\\n\\n train_images = train_images[resulting_ids, ...]\\n train_labels = train_labels[resulting_ids, ...]\\n\\n data_sets.train = DataSet(train_images, train_labels, fake_data=True, one_hot=True, reshape=reshape)\\n data_sets.validation = DataSet(val_images, val_labels, fake_data=True, one_hot=True, reshape=reshape)\\n data_sets.test = DataSet(test_images, test_labels, fake_data=True, one_hot=True, reshape=reshape)\\n\\n return data_sets\",\n \"def test_get_mnist_data(self):\\n # TODO: Remove once get_mnist_data(...) is fixed.\\n pass\\n # mnist = get_mnist_data()\\n # self.assertEqual(len(mnist.data), 60000)\\n # self.assertEqual(len(mnist.labels), 60000)\",\n \"def _prepare(self, data, train=True):\\n if data is None:\\n return None\\n\\n if hasattr(data, \\\"to_tfdataset\\\"):\\n return data.to_tfdataset(train=train)\\n else:\\n return data\",\n \"def normalize_dataset(self):\",\n \"def create_mnistm(X):\\r\\n X_ = np.zeros([X.shape[0], 28, 28, 3], np.uint8)\\r\\n for i in range(X.shape[0]):\\r\\n bg_img = rand.choice(background_data)\\r\\n d = mnist_to_img(X[i])\\r\\n d = compose_image(d, bg_img)\\r\\n X_[i] = d\\r\\n return X_\",\n \"def __download(self):\\n\\n if self.__check_exists():\\n return\\n\\n print(\\\"Downloading AudioMNIST dataset\\\")\\n\\n # download files\\n try:\\n os.makedirs(self.__path)\\n except OSError as e:\\n if e.errno == errno.EEXIST:\\n pass\\n else:\\n raise\\n\\n if not os.path.exists(os.path.join(self.__path, 'AudioMNIST-master.zip')):\\n url = 'https://github.com/soerenab/AudioMNIST/archive/master.zip'\\n wget_data = wget.download(url, out=self.__path)\\n\\n archive = zipfile.ZipFile(wget_data)\\n\\n for file in archive.namelist():\\n if file.startswith('AudioMNIST-master/data/'):\\n archive.extract(file, self.__path)\\n\\n print(\\\"Download successful\\\")\\n\\n audio_mnist_src = os.path.join(self.__path, 'AudioMNIST-master/data/')\\n data = np.array(glob.glob(os.path.join(audio_mnist_src, \\\"**/*.wav\\\")))\\n\\n train_images = []\\n train_labels = []\\n test_images = []\\n test_labels = []\\n\\n # first 5-cross-validation set from https://github.com/soerenab/AudioMNIST/blob/master/preprocess_data.py\\n train_folders = [28, 56, 7, 19, 35, 1, 6, 16, 23, 34, 46, 53, 36, 57, 9, 24, 37, 2,\\n 8, 17, 29, 39, 48, 54, 43, 58, 14, 25, 38, 3, 10, 20, 30, 40, 49, 55,\\n 12, 47, 59, 15, 27, 41, 4, 11, 21, 31, 44, 50]\\n test_folders = [26, 52, 60, 18, 32, 42, 5, 13, 22, 33, 45, 51]\\n\\n print(\\\"Converting audio to images\\\")\\n # create train and test folders and save audios as images\\n for filepath in tqdm(data):\\n # the last one is just a counter for repeat of each digit, e.g. say zero once, twice, third time..\\n\\n dig, vp, rep = filepath.rstrip(\\\".wav\\\").split(\\\"/\\\")[-1].split(\\\"_\\\")\\n\\n # according to https://github.com/soerenab/AudioMNIST/blob/master/preprocess_data.py\\n fs, data = wavf.read(filepath)\\n\\n # resample\\n data = librosa.core.resample(y=data.astype(np.float32), orig_sr=fs, target_sr=8000, res_type=\\\"scipy\\\")\\n # zero padding\\n if len(data) > 8000:\\n raise ValueError(\\\"data length cannot exceed padding length.\\\")\\n elif len(data) < 8000:\\n embedded_data = np.zeros(8000)\\n offset = np.random.randint(low=0, high=8000 - len(data))\\n embedded_data[offset:offset + len(data)] = data\\n elif len(data) == 8000:\\n # nothing to do here\\n embedded_data = data\\n pass\\n\\n # 1. fourier transform\\n # stft, with selected parameters, spectrogram will have shape (228, 230)\\n f, t, zxx = scipy.signal.stft(embedded_data, 8000, nperseg=455, noverlap=420, window='hann')\\n # get amplitude\\n zxx = np.abs(zxx[0:227, 2:-1])\\n\\n # if not 2, then convert to decibel\\n zxx = librosa.amplitude_to_db(zxx, ref=np.max)\\n\\n # normalize from range -80,0 to 0,1\\n zxx = (zxx - zxx.min()) / (zxx.max() - zxx.min())\\n\\n zxx = zxx[::-1] # reverse the order of frequencies to fit the images in the paper\\n zxx = np.atleast_3d(zxx).transpose(2, 0, 1) # reshape to (1, img_dim_h, img_dim_w)\\n\\n # decide to which list to add (train or test)\\n if int(vp) in train_folders:\\n train_images.append(zxx)\\n train_labels.append(int(dig))\\n elif int(vp) in test_folders:\\n test_images.append(zxx)\\n test_labels.append(int(dig))\\n else:\\n raise Exception('Person neither in train nor in test set!')\\n\\n train_images = torch.Tensor(train_images).float()\\n train_labels = torch.Tensor(train_labels).long()\\n test_images = torch.Tensor(test_images).float()\\n test_labels = torch.Tensor(test_labels).long()\\n\\n torch.save(train_images, os.path.join(self.__path, 'train_images_tensor.pt'))\\n torch.save(train_labels, os.path.join(self.__path, 'train_labels_tensor.pt'))\\n torch.save(test_images, os.path.join(self.__path, 'test_images_tensor.pt'))\\n torch.save(test_labels, os.path.join(self.__path, 'test_labels_tensor.pt'))\\n\\n print('Done!')\",\n \"def refresh_train_dataset(self):\\n inputs_id, inputs_starts, inputs_paths, inputs_ends, inputs_label = self.build_data(self.reader, self.train_items, self.option.max_path_length)\\n self.train_dataset = CodeDataset(inputs_id, inputs_starts, inputs_paths, inputs_ends, inputs_label)\",\n \"def prepare_iris_data(data):\\n\\n # One-Hot Encode target variable y\\n \\n X = data.iloc[:, 0:4]\\n y = data.iloc[:,-1]\\n Y = pd.get_dummies(y)\\n \\n # Recombine X and Y\\n \\n data_w_dummies = pd.concat([X, Y], axis=1)\\n data_w_dummies.head()\\n \\n \\n # Split data into train and test sets and \\n # Make data iterable by batches with DataLoader\\n \\n train, test = train_test_split(data_w_dummies, test_size=0.2, shuffle=True)\\n \\n \\n trainset = torch.Tensor(train.values)\\n \\n testset = torch.Tensor(test.values)\\n \\n return trainset, testset\",\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 fetch_mnist():\\n data_path = check_fetch_mnist()\\n f = gzip.open(data_path, 'rb')\\n try:\\n train_set, valid_set, test_set = pickle.load(f, encoding=\\\"latin1\\\")\\n except TypeError:\\n train_set, valid_set, test_set = pickle.load(f)\\n f.close()\\n train_indices = np.arange(0, len(train_set[0]))\\n valid_indices = np.arange(0, len(valid_set[0])) + train_indices[-1] + 1\\n test_indices = np.arange(0, len(test_set[0])) + valid_indices[-1] + 1\\n return {\\\"data\\\": np.concatenate((train_set[0], valid_set[0], test_set[0]),\\n axis=0).astype(theano.config.floatX),\\n \\\"target\\\": np.concatenate((train_set[1], valid_set[1], test_set[1]),\\n axis=0).astype(np.int32),\\n \\\"train_indices\\\": train_indices.astype(np.int32),\\n \\\"valid_indices\\\": valid_indices.astype(np.int32),\\n \\\"test_indices\\\": test_indices.astype(np.int32)}\",\n \"def prepare_for_predict(self) -> None:\\n _, self.all_labels_embed = self._create_all_labels_embed()\",\n \"def preprocess_with_train_data(self,\\n data_dir: Path,\\n output_processed_data_dir: Path,\\n ) -> NoReturn:\\n pass\",\n \"def prepare_cityscapes_data(seed=1, percent=30.0, version=2017):\\n def _save_anno(name, images, annotations):\\n \\\"\\\"\\\"Save annotation\\n \\\"\\\"\\\"\\n print('>> Processing data {}.json saved ({} images {} annotations)'.format(\\n name, len(images), len(annotations)))\\n new_anno = {}\\n new_anno['images'] = images\\n new_anno['annotations'] = annotations\\n new_anno['categories'] = anno['categories']\\n\\n with open(\\n '{root}/{save_name}.json'.format(\\n save_name=name, root=DATA_DIR),\\n 'w') as f:\\n json.dump(new_anno, f)\\n print('>> Data {}.json saved ({} images {} annotations)'.format(\\n name, len(images), len(annotations)))\\n\\n np.random.seed(seed)\\n \\n anno = json.load(open(os.path.join(DATA_DIR, 'instancesonly_filtered_gtFine_train.json')))\\n\\n image_list = anno['images']\\n labeled_tot = int(percent / 100. * len(image_list))\\n #labeled_ind = np.random.choice(range(len(image_list)), size=labeled_tot)\\n labeled_ind = np.arange(len(image_list))\\n np.random.shuffle(labeled_ind)\\n labeled_ind = labeled_ind[0:labeled_tot]\\n\\n labeled_id = []\\n labeled_images = []\\n unlabeled_images = []\\n labeled_ind = set(labeled_ind)\\n for i in range(len(image_list)):\\n if i in labeled_ind:\\n labeled_images.append(image_list[i])\\n labeled_id.append(image_list[i]['id'])\\n else:\\n unlabeled_images.append(image_list[i])\\n\\n # get all annotations of labeled images\\n labeled_id = set(labeled_id)\\n labeled_annotations = []\\n unlabeled_annotations = []\\n for an in anno['annotations']:\\n if an['image_id'] in labeled_id:\\n labeled_annotations.append(an)\\n else:\\n unlabeled_annotations.append(an)\\n\\n # save labeled and unlabeled\\n save_name = 'instancesonly_filtered_gtFine_train.{seed}@{tot}'.format(\\n version=version, seed=seed, tot=int(percent))\\n _save_anno(save_name, labeled_images, labeled_annotations)\\n save_name = 'instancesonly_filtered_gtFine_train.{seed}@{tot}-unlabeled'.format(\\n version=version, seed=seed, tot=int(percent))\\n _save_anno(save_name, unlabeled_images, unlabeled_annotations)\",\n \"def preprocess(self):\\n lines = [line.rstrip() for line in open(self.attr_path, 'r')]\\n all_attr_names = lines[1].split()\\n for i, attr_name in enumerate(all_attr_names):\\n self.attr2idx[attr_name] = i\\n self.idx2attr[i] = attr_name\\n\\n lines = lines[2:]\\n random.seed(1234)\\n random.shuffle(lines)\\n for i, line in enumerate(lines):\\n split = line.split()\\n filename = split[0]\\n values = split[1:]\\n\\n label = []\\n for attr_name in self.selected_attrs:\\n idx = self.attr2idx[attr_name]\\n label.append(values[idx] == '1')\\n\\n if (i+1) < 4:\\n self.test_dataset.append([filename, label])\\n else:\\n self.train_dataset.append([filename, label])\",\n \"def prepare_data(self):\\n import subprocess\\n # Download coco data set into dir specified by config then /data/coco\\n subprocess.call([f\\\"{get_original_cwd()}/bin/fetch_dataset.sh\\\", f\\\"{self.dir}/data/coco\\\", f\\\"{get_original_cwd()}\\\"])\\n # subprocess.call([f\\\"bin/fetch_dataset.sh\\\", f\\\"{self.dir}/data/coco\\\"])\\n task = \\\"instances\\\" if self.instance else \\\"person_keypoints\\\"\\n register_coco_instances(\\\"train\\\", {}, f\\\"{self.dir}/data/coco/{task}_train2014.json\\\",\\n f\\\"{self.dir}/data/coco/train2014\\\")\\n register_coco_instances(\\\"val\\\", {}, f\\\"{self.dir}/data/coco/{task}_minival2014.json\\\",\\n f\\\"{self.dir}/data/coco/val2014\\\")\\n register_coco_instances(\\\"test\\\", {}, f\\\"{self.dir}/data/coco/{task}_valminusminival2014.json\\\",\\n f\\\"{self.dir}/data/coco/val2014\\\")\",\n \"def load_mnist_data(amount : int = None, mnist_location : str = \\\"C:\\\\\\\\Users\\\\\\\\Vova\\\\\\\\PycharmProjects\\\\\\\\Neural_Network_test\\\\\\\\mnist-csv\\\",\\n to_shuffle = True, output_process_info = True, debug=False) -> Tuple[np.array, np.array]:\\n if debug:\\n output_process_info = True\\n buff_all_file_names = recursive_relative_lsdir(mnist_location)\\n if output_process_info:\\n print(\\\"Got mnist file names!\\\")\\n\\n if to_shuffle:\\n random.shuffle(buff_all_file_names)\\n if output_process_info:\\n print(\\\"Shuffled mnist images!\\\")\\n\\n if amount is not None:\\n all_file_names = buff_all_file_names[:amount]\\n else:\\n all_file_names = buff_all_file_names\\n\\n labels = np.array([int(split_path(p)[-2]) for p in all_file_names])\\n if output_process_info:\\n print(f\\\"Labeled mnist file names ({len(labels)} pcs)!\\\")\\n\\n if debug:\\n s = 0\\n for i in range(10):\\n print(f\\\"Pictures for number {i}: {list(labels).count(i)}\\\")\\n s += list(labels).count(i)\\n print(\\\"Total:\\\", s)\\n\\n # Loading images:\\n images = np.zeros((len(labels), 28, 28), dtype=np.float64)\\n for i in range(len(all_file_names)):\\n images[i] = convert_csv_to_array(all_file_names[i])\\n percent = 100 * i / len(all_file_names)\\n if random.random() < 0.001:\\n print(f\\\"Loading is {round(percent, 3)} % ready... \\\", end=\\\"\\\\n\\\\r\\\")\\n\\n print(\\\"Your mnist dataset is ready :) !!!\\\")\\n\\n return labels, images\",\n \"def _prepare_sets(self):\\n\\n ds_images, ds_labels = self._load_images_labels()\\n\\n ds_images_2 = ds_images.take(self.val_count)\\n ds_labels_2 = ds_labels.take(self.val_count)\\n ds_images_1 = ds_images.skip(self.val_count)\\n ds_labels_1 = ds_labels.skip(self.val_count)\\n\\n ds_1 = (ds_images_1, ds_labels_1)\\n ds_2 = (ds_images_2, ds_labels_2)\\n\\n return ds_1, ds_2\",\n \"def setup(self, stage=None):\\n self.data_train, self.data_val, self.data_test = [None] * 3\",\n \"def preprocess_the_dataset(x_train):\\n # initialize empty lists\\n x_real,x_pencil=[],[]\\n for image in x_train[:8000]:\\n real_image = resize_128(image)\\n # make it pencil drawn\\n pencil_image = convert_image(real_image)\\n x_real.append(real_image/127.5-1)\\n x_pencil.append(pencil_image/127.5-1)\\n return x_real,x_pencil\",\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 get_MNIST_training_normalized():\\n X, Y = get_dataset(\\\"training\\\")\\n X=X/255.0\\n X-=0.5\\n return X,Y\\n\\n global MNIST_training\\n if MNIST_training is None:\\n if os.path.exists(\\\"./data/MNIST_training.pkl\\\"):\\n MNIST_training = cPickle.load(open(\\\"./data/MNIST_training.pkl\\\", \\\"r\\\"))\\n else:\\n MNIST_training = get_dataset(\\\"training\\\")\\n MNIST_training = normalize_data(MNIST_training[0], MNIST_training[1])\\n cPickle.dump(MNIST_training, open(\\\"./data/MNIST_training.pkl\\\",\\\"w\\\"))\\n return MNIST_training\",\n \"def __init__(self, data_dir, input_shape=[10, 64, 64, 1], target_shape=[10, 64, 64, 1],\\n as_binary=False, num_digits=2, step_length=0.1):\\n dataset_size = sys.maxint\\n super(MovingMNISTTrainDataset, self).__init__('train', data_dir, dataset_size,\\n input_shape, target_shape,\\n as_binary, num_digits, step_length)\",\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 load_training_set():\\n global training_set\\n f = gzip.open('mnist.pkl.gz', 'rb')\\n train, valid, test = cPickle.load(f)\\n [training_set, training_labels] = train\\n [validation_set, validation_labels] = valid\\n [testing_set, testing_labels] = test\\n training_set = np.concatenate((training_set, validation_set))\\n f.close()\\n np.random.shuffle(training_set)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71029925","0.7001878","0.68021387","0.66606903","0.6657912","0.6647711","0.65342814","0.6513322","0.6462048","0.6341769","0.63327867","0.6331993","0.63136804","0.6295836","0.6294832","0.6288506","0.6255097","0.6247711","0.62466383","0.62195545","0.6201863","0.62009007","0.61846566","0.6144054","0.6132228","0.6127632","0.6102626","0.60904825","0.6082999","0.607769","0.60615516","0.60390395","0.60222113","0.6001993","0.6001023","0.5991303","0.5991042","0.5977525","0.59715927","0.5960836","0.59569496","0.59464914","0.5944458","0.593815","0.5936538","0.59268075","0.59234947","0.5911719","0.5903188","0.59013206","0.58957636","0.5895163","0.58851784","0.58831686","0.58829707","0.58775836","0.58602923","0.5853406","0.5848795","0.5844963","0.58369625","0.5835497","0.58219284","0.5803397","0.58029985","0.58008903","0.5778967","0.577822","0.5774591","0.5774591","0.5771678","0.57708716","0.5765366","0.57652867","0.5761537","0.5752556","0.57521623","0.57501304","0.5749658","0.57460487","0.57432395","0.5741581","0.5739876","0.5739766","0.5736208","0.57278365","0.5725728","0.5723369","0.5721182","0.57181126","0.57104427","0.5704379","0.5700473","0.5700417","0.5696839","0.5695532","0.5692206","0.56893754","0.56808466","0.567945","0.56789905"],"string":"[\n \"0.71029925\",\n \"0.7001878\",\n \"0.68021387\",\n \"0.66606903\",\n \"0.6657912\",\n \"0.6647711\",\n \"0.65342814\",\n \"0.6513322\",\n \"0.6462048\",\n \"0.6341769\",\n \"0.63327867\",\n \"0.6331993\",\n \"0.63136804\",\n \"0.6295836\",\n \"0.6294832\",\n \"0.6288506\",\n \"0.6255097\",\n \"0.6247711\",\n \"0.62466383\",\n \"0.62195545\",\n \"0.6201863\",\n \"0.62009007\",\n \"0.61846566\",\n \"0.6144054\",\n \"0.6132228\",\n \"0.6127632\",\n \"0.6102626\",\n \"0.60904825\",\n \"0.6082999\",\n \"0.607769\",\n \"0.60615516\",\n \"0.60390395\",\n \"0.60222113\",\n \"0.6001993\",\n \"0.6001023\",\n \"0.5991303\",\n \"0.5991042\",\n \"0.5977525\",\n \"0.59715927\",\n \"0.5960836\",\n \"0.59569496\",\n \"0.59464914\",\n \"0.5944458\",\n \"0.593815\",\n \"0.5936538\",\n \"0.59268075\",\n \"0.59234947\",\n \"0.5911719\",\n \"0.5903188\",\n \"0.59013206\",\n \"0.58957636\",\n \"0.5895163\",\n \"0.58851784\",\n \"0.58831686\",\n \"0.58829707\",\n \"0.58775836\",\n \"0.58602923\",\n \"0.5853406\",\n \"0.5848795\",\n \"0.5844963\",\n \"0.58369625\",\n \"0.5835497\",\n \"0.58219284\",\n \"0.5803397\",\n \"0.58029985\",\n \"0.58008903\",\n \"0.5778967\",\n \"0.577822\",\n \"0.5774591\",\n \"0.5774591\",\n \"0.5771678\",\n \"0.57708716\",\n \"0.5765366\",\n \"0.57652867\",\n \"0.5761537\",\n \"0.5752556\",\n \"0.57521623\",\n \"0.57501304\",\n \"0.5749658\",\n \"0.57460487\",\n \"0.57432395\",\n \"0.5741581\",\n \"0.5739876\",\n \"0.5739766\",\n \"0.5736208\",\n \"0.57278365\",\n \"0.5725728\",\n \"0.5723369\",\n \"0.5721182\",\n \"0.57181126\",\n \"0.57104427\",\n \"0.5704379\",\n \"0.5700473\",\n \"0.5700417\",\n \"0.5696839\",\n \"0.5695532\",\n \"0.5692206\",\n \"0.56893754\",\n \"0.56808466\",\n \"0.567945\",\n \"0.56789905\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84587,"cells":{"query":{"kind":"string","value":"Trains a UNet to learn denoising by selfsupervision (noise2self). Uses matplotlib to display the results."},"document":{"kind":"string","value":"def train_model(clean_train, clean_test, noisy_test, num_batches=150, \n batch_size=32, show_loss_plot=False, verbose=False, seed=1337):\n \n if num_batches <= 0:\n raise ValueError('must have a positive number of batches')\n if batch_size <= 0:\n raise ValueError('must have a positive batch size')\n \n def verbose_print(s):\n if verbose:\n print(s)\n \n tf.enable_eager_execution()\n tf.set_random_seed(seed)\n np.random.seed(seed)\n \n device = '/gpu:0' if tfe.num_gpus() else '/cpu:0'\n\n with tf.device(device):\n verbose_print('building model (device={})'.format(device))\n model = BabyUnet()\n model.compile(optimizer=tf.train.AdamOptimizer(0.001),\n loss=tf.keras.losses.mean_squared_error)\n model.build((1, image_size, image_size ,1))\n \n optimizer = tf.train.AdamOptimizer()\n loss_fn = tf.losses.mean_squared_error\n loss_history = []\n \n noise_gen = noisy_clean_generator(clean_train, batch_size, 0, 0.4)\n masker = Masker(interpolate=True, spacing=4, radius=1)\n \n verbose_print('fitting model')\n start_time = time.time()\n loss_display = ''\n for (batch, (batch_noisy, batch_clean)) in enumerate(noise_gen):\n fraction_display = '{}/{}'.format(batch, num_batches).rjust(10)\n display_progress(batch, num_batches, length=30, suffix=loss_display,\n prefix=fraction_display)\n \n if batch == num_batches:\n break\n \n with tf.GradientTape() as tape:\n masked, mask = masker(batch_noisy, batch, shape=data_shape)\n batch_predictions = model(masked)\n loss_value = loss_fn(mask * batch_clean, mask * batch_predictions)\n \n loss_display = '(loss: {:0.6f})'.format(loss_value.numpy())\n loss_history.append(loss_value.numpy())\n grads = tape.gradient(loss_value, model.trainable_variables)\n optimizer.apply_gradients(\n zip(grads, model.trainable_variables),\n global_step=tf.train.get_or_create_global_step()\n )\n \n end_time = time.time()\n verbose_print('fit completed in {:0.2f}s'.format(end_time - start_time))\n \n if show_loss_plot:\n show_plot(loss_history, 'Loss', 'Epoch', 'Mean Square Error Loss')\n \n verbose_print('evaluating test set')\n masked, mask = masker(noisy_test, 0, shape=data_shape)\n test_predictions = model(masked)\n test_loss_value = loss_fn(mask * clean_test, mask * test_predictions)\n \n print(\"final test loss: {:0.6f}\".format(test_loss_value))\n \n return model"},"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 trainNet():","def demo(image, model_class, do_add_noise=True):\n Log.enable_output = True\n Log.set_log_max_depth(8)\n\n image = normalise(image)\n image = numpy.expand_dims(image, axis=0)\n image = numpy.expand_dims(image, axis=0)\n noisy = add_noise(image) if do_add_noise else image\n print(noisy.shape)\n\n # noisy = models.tensor(noisy)\n image = torch.tensor(image)\n\n model = model_class(\n nb_unet_levels=2,\n spacetime_ndim=2,\n )\n\n print(\"training starts\")\n\n start = time.time()\n n2t_train(noisy, model, nb_epochs=128)\n stop = time.time()\n print(f\"Training: elapsed time: {stop - start} \")\n\n noisy = torch.tensor(noisy)\n model.eval()\n model = model.cpu()\n print(f\"noisy tensor shape: {noisy.shape}\")\n # in case of batching we have to do this:\n start = time.time()\n denoised = model(noisy)\n stop = time.time()\n print(f\"inference: elapsed time: {stop - start} \")\n\n noisy = noisy.detach().numpy()[0, 0, :, :]\n image = image.detach().numpy()[0, 0, :, :]\n denoised = denoised.detach().numpy()[0, 0, :, :]\n\n image = numpy.clip(image, 0, 1)\n noisy = numpy.clip(noisy, 0, 1)\n denoised = numpy.clip(denoised, 0, 1)\n\n return calculate_print_psnr_ssim(image, noisy, denoised)\n\n # import napari\n #\n # viewer = napari.Viewer() # no prior setup needed\n # viewer.add_image(image, name='image')\n # viewer.add_image(noisy, name='noisy')\n # viewer.add_image(denoised, name='denoised')\n # napari.run()","def main(u_net_settings):\n model = build_u_net(*u_net_settings)\n print(model.summary())","def train(args):\n # Create the data loader\n loader = sunnerData.DataLoader(\n dataset = sunnerData.ImageDataset(\n root = [[args.train]],\n transforms = transforms.Compose([\n \n# transforms.RandomCrop(720,720)\n# transforms.RandomRotation(45)\n# transforms.RandomHorizontalFlip(), \n# transforms.ColorJitter(brightness=0.5, contrast=0.5),\n \n\n sunnerTransforms.Resize(output_size = (args.H, args.W)),\n #transforms.RandomCrop(512,512)\n sunnerTransforms.ToTensor(),\n sunnerTransforms.ToFloat(),\n # sunnerTransforms.Transpose(),\n sunnerTransforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),\n ])\n ), batch_size = args.batch_size, shuffle = True, num_workers = 2\n )\n loader = sunnerData.IterationLoader(loader, max_iter = args.n_iter)\n\n # Create the model\n model = GANomaly2D(r = args.r, device = args.device)\n model.IO(args.resume, direction = 'load')\n model.train()\n \n # Train!\n bar = tqdm(loader)\n for i, (normal_img,) in enumerate(bar):\n model.forward(normal_img)\n model.backward()\n loss_G, loss_D = model.getLoss()\n bar.set_description(\"Loss_G: \" + str(loss_G) + \" loss_D: \" + str(loss_D))\n bar.refresh()\n if i % args.record_iter == 0:\n model.eval()\n with torch.no_grad():\n z, z_ = model.forward(normal_img)\n img, img_ = model.getImg()\n visualizeEncoderDecoder(img, img_, z, z_,i)\n model.train()\n model.IO(args.det, direction = 'save')\n model.IO(args.det, direction = 'save')","def nn(data):\n training_set = SupervisedDataSet*\n\n\n input_nodes = 3\n hidden_layer_1 = 10\n hidden_layer_2 = 10\n output_layer = 5\n\n net = buildNetwork(input_nodes, hidden_layer_1, hidden_layer_2, output_layer, bias=True, hiddenclass=TanhLayer)","def train(self, nsamples = 1, verbose = False, random = True):\n imgs, skels = self.images.get_batch(nimages = nsamples, random = random);\n self.trainer.run(session = self.session, feed_dict={self.input : imgs, self.skeleton : skels})\n if verbose:\n self.plot_results(imgs);","def run_simple_CNN():\n [train_set, test_set, train_sampler, val_sampler, test_sampler] = pre_processing_and_samples()\n CNN = SimpleCNN()\n # Using GPU for training\n device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n print(device)\n if torch.cuda.is_available():\n print(\"cuda is available\")\n CNN.to(device)\n\n # Multiple GPUs\n if torch.cuda.device_count() > 1:\n CNN = nn.DataParallel(CNN)\n\n num_epochs = 100\n\n train_loss_hist, train_acc_hist, val_loss_hist, val_acc_hist = \\\n trainCNN(net=CNN, device=device, batch_size=64, n_epochs=num_epochs, learning_rate=0.001,\n train_set=train_set, test_set=test_set, train_sampler=train_sampler, val_sampler=val_sampler)\n test(net=CNN, device=device, test_set=test_set, test_sampler=test_sampler)\n\n fig, (ax1, ax2) = plt.subplots(2)\n\n ax1.set_title(\"Loss vs. Number of Training Epochs\")\n ax1.set(xlabel=\"Training Epoch\", ylabel=\"Loss\")\n ax1.plot(range(1, len(train_loss_hist) + 1), train_loss_hist, label=\"Training\")\n ax1.plot(range(1, len(val_loss_hist) + 1), val_loss_hist, label=\"Validation\")\n print(np.concatenate((train_loss_hist, val_loss_hist)))\n print(np.amax(np.concatenate((train_loss_hist, val_loss_hist))))\n ax1.set_ylim(\n (0, 1.25 * np.amax(np.concatenate((train_loss_hist, val_loss_hist), axis=0, out=None)).detach().cpu()))\n ax1.set_xticks(np.arange(1, num_epochs + 1, 1.0))\n ax1.legend()\n\n ax2.set_title(\"Accuracy vs. Number of Training Epochs\")\n ax2.set(xlabel=\"Training Epoch\", ylabel=\"Accuracy\")\n ax2.plot(range(1, num_epochs + 1), train_acc_hist, label=\"Training\")\n ax2.plot(range(1, num_epochs + 1), val_acc_hist, label=\"Validation\")\n ax2.set_ylim(0, 100) # Sets y bounds\n ax2.set_xticks(np.arange(1, num_epochs + 1, 1.0))\n ax2.legend()\n\n plt.tight_layout() # Call after plotting all subplots\n plt.savefig('basic_cifar_10.png')","def train_segmentation():\n\n start = time.time()\n\n model_base = load_pretrained(get_base(), PRETRAINED)\n cut, lr = model_meta[arch]\n m = to_gpu(Unet34(model_base))\n model = UnetModel(m)\n\n sz = 256\n bs = 64\n\n md = get_data(sz, bs)\n\n learn = ConvLearner(md, model)\n learn.opt_fn = optim.Adam()\n learn.crit = LossBinary(jaccard_weight=5)\n learn.metrics = [accuracy_thresh(0.5), dice, IoU]\n wd = 1e-7\n lr = 1e-2\n\n learn.freeze_to(1)\n learn.fit(lr, 1, wds=wd, cycle_len=1, use_clr=(5,8))\n learn.unfreeze() # unfreeze encoder\n learn.bn_freeze(True)\n\n lrs = np.array([lr/100, lr/10, lr])\n learn.fit(lrs/3, 2, wds=wd, cycle_len=2, use_clr=(20,8))\n\n learn.save('./models/weighted_unet_256_p1')\n\n sz = 384\n bs = 32\n\n md = get_data(sz, bs)\n learn.set_data(md)\n learn.unfreeze()\n learn.bn_freeze(True)\n\n learn.fit(lrs/5, 1, wds=wd, cycle_len=2, use_clr(10,8)) # first increase in image size with decreased bs\n learn.save('./models/weighted_unet_384_p1')\n\n sz = 512\n bs = 16\n\n md = get_data(sz, bs)\n learn.set_data(md)\n learn.unfreeze()\n learn.bn_freeze(True)\n\n learn.fit(lrs/10, 2, wds=wd, cycle_len=1, use_clr=(10,8), best_save_name='./models/weighted_unet_512_p1') # second increase in image size with further decreased bs\n\n sz = 768\n bs = 8\n\n md = get_data(sz, bs)\n learn.set_data(md)\n learn.unfreeze()\n learn.bn_freeze(True)\n\n learn.fit(lrs/50, 10, wds=5e-8, cycle_len=1, use_clr=(10,10), best_save_name='./models/weighted_unet_768_p1') # full image size with further decreased bs\n\n learn.crit = MixedLoss(10., 2.)\n learn.fit(lrs/50, 10, wds=5e-8, cycle_len=1, use_clr=(10,10), best_save_name='./models/weighted_unet_768_p2') # full image size with further decreased bs (final run)\n\n learn.save('./models/weighted_unet_768_final')\n\n print(f'Training finished in {time.time() - start) / 60 :.3} minutes.')","def train(net):\n\n # Set SGD hyperparameters\n n_iter = 200 # number of iterations of SGD\n learning_rate = 1e-3 # learning rate for SGD\n momentum = .99 # momentum parameter for SGD\n batch_size = 100 # number of data points in each mini-batch\n\n # Initialize binary cross-entropy loss function\n loss_fn = nn.BCELoss()\n\n # Initialize SGD optimizer with momentum\n optimizer = optim.SGD(net.parameters(), lr=learning_rate, momentum=momentum)\n\n # Placeholder to save loss at each iteration\n track_loss = []\n\n # Loop over iterations\n for i in range(n_iter):\n\n # Sample minibatch of oriented grating stimuli\n stimuli, tilt = sample_stimuli(batch_size)\n\n # Evaluate loss and update network weights\n out = net(stimuli) # predicted probability of tilt right\n loss = loss_fn(out, tilt) # evaluate loss\n optimizer.zero_grad() # clear gradients\n loss.backward() # compute gradients\n optimizer.step() # update weights\n \n # Keep track of loss at each iteration\n track_loss.append(loss.item())\n\n # Track progress\n if (i + 1) % (n_iter / 10) == 0:\n print('iteration %i | loss: %.3f | percent correct: %.2f%%' % (i + 1, loss.item(), 100 * pcorrect(out, tilt)))\n \n # Plot loss\n plt.plot(track_loss)\n plt.xlabel('iterations of SGD')\n plt.ylabel('binary cross-entropy loss')\n plt.xlim([0, None])\n plt.ylim([0, None])\n plt.show()","def visualize_manipulation_training(flow, epoch, save_dir=None):\n\n # Basic figure setup\n images_x = 3\n images_y = 3 if isinstance(flow.codec, DCN) else 2\n fig = Figure(figsize=(18, 10 / images_x * images_y))\n conf = np.array(flow.fan.performance['confusion'])\n \n # Draw the plots\n ax = fig.add_subplot(images_y, images_x, 1)\n ax.plot(flow.nip.performance['loss']['training'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['loss']['training'], 0))\n ax.set_ylabel('{} NIP loss'.format(flow.nip.class_name))\n ax.set_title('Loss')\n\n ax = fig.add_subplot(images_y, images_x, 2)\n ax.plot(flow.nip.performance['psnr']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['psnr']['validation'], 0))\n ax.set_ylabel('{} NIP psnr'.format(flow.nip.class_name))\n ax.set_title('PSNR')\n ax.set_ylim([30, 50])\n\n ax = fig.add_subplot(images_y, images_x, 3)\n ax.plot(flow.nip.performance['ssim']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['ssim']['validation'], 0))\n ax.set_ylabel('{} NIP ssim'.format(flow.nip.class_name))\n ax.set_title('SSIM')\n ax.set_ylim([0.8, 1])\n \n ax = fig.add_subplot(images_y, images_x, 4)\n ax.plot(flow.fan.performance['loss']['training'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.fan.performance['loss']['training'], 0))\n ax.set_ylabel('FAN loss')\n\n ax = fig.add_subplot(images_y, images_x, 5)\n ax.plot(flow.fan.performance['accuracy']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.fan.performance['accuracy']['validation'], 0))\n ax.set_ylabel('FAN accuracy')\n ax.set_ylim([0, 1])\n\n # The confusion matrix\n ax = fig.add_subplot(images_y, images_x, 6)\n ax.imshow(conf, vmin=0, vmax=1)\n\n ax.set_xticks(range(flow.n_classes))\n ax.set_xticklabels(flow._forensics_classes, rotation='vertical')\n ax.set_yticks(range(flow.n_classes))\n ax.set_yticklabels(flow._forensics_classes)\n\n for r in range(flow.n_classes):\n ax.text(r, r, '{:.2f}'.format(conf[r, r]), horizontalalignment='center', color='b' if conf[r, r] > 0.5 else 'w')\n\n ax.set_xlabel('PREDICTED class')\n ax.set_ylabel('TRUE class')\n ax.set_title('Accuracy: {:.2f}'.format(np.mean(np.diag(conf))))\n\n # If the compression model is a trainable DCN, include it's validation metrics\n if images_y == 3:\n ax = fig.add_subplot(images_y, images_x, 7)\n ax.plot(flow.codec.performance['loss']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['loss']['validation'], 0))\n ax.set_ylabel('DCN loss')\n\n ax = fig.add_subplot(images_y, images_x, 8)\n ax.plot(flow.codec.performance['ssim']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['ssim']['validation'], 0))\n ax.set_ylabel('DCN ssim')\n ax.set_ylim([0.8, 1])\n\n ax = fig.add_subplot(images_y, images_x, 9)\n ax.plot(flow.codec.performance['entropy']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['entropy']['validation'], 0))\n ax.set_ylabel('DCN entropy')\n\n if save_dir is not None:\n if not os.path.exists(save_dir):\n os.makedirs(save_dir)\n fig.savefig('{}/manip_validation_{:05d}.jpg'.format(save_dir, epoch), bbox_inches='tight', dpi=100)\n del fig\n\n else:\n return fig","def main(self):\r\n\r\n #Train the GEN and DISC\r\n self.modelTrain.main()\r\n self.disp.show()","def train(self, dat_in, dat_out):\n self.net.fit(dat_in, dat_out)\n # Oftentimes, the training log statements do not end with a newline.\n print()","def train_visualization(output_path): \n log_path = output_path + 'output.log'\n Train_Cost, Valid_Cost, Test_Cost, Train_Acc, Valid_Acc, Test_Acc = log_reader(log_path)\n n_epoch = len(Train_Cost)\n\n x1 = range(n_epoch)\n x2 = range(n_epoch)\n y1 = Train_Cost\n y2 = Valid_Cost\n y3 = Test_Cost\n y4 = Train_Acc\n y5 = Valid_Acc\n y6 = Test_Acc\n plt.subplot(2, 1, 1)\n plt.plot(x1, y1, label=\"Train_Cost\", linewidth=2)\n plt.plot(x1, y2, label=\"Valid_Cost\", linewidth=2)\n plt.plot(x1, y3, label=\"Test_Cost\", linewidth=2)\n\n plt.title('binary cross entropy vs. epoches')\n plt.ylabel('binary cross entropy')\n plt.legend(loc='best')\n plt.subplot(2, 1, 2)\n plt.plot(x2, y4, label=\"Train_Acc\", linewidth=2)\n plt.plot(x2, y5, label=\"Valid_Acc\", linewidth=2)\n plt.plot(x2, y6, label=\"Test_Acc\", linewidth=2)\n plt.xlabel('Accuracy@20 vs. epoches')\n plt.ylabel('Accuracy@20')\n plt.legend(loc='best')\n plt.savefig(output_path + 'loss_fig.png')\n # plt.show()","def train_one_epoch_Image_display(self):\n print('Training......')\n\n # set mode train\n self.network.train()\n\n # prepare data\n train_loss = 0\n transform = transforms.Compose([Rescale(params.rescale_size),\n RandomCrop(params.image_size),\n RandomHorizontalFlip(),\n ToTensor()\n ])\n\n\n\n dataset = Cityscapes(params.dataset_root, mode='train', transforms = transform)\n\n train_loader = DataLoader(dataset,\n batch_size=params.train_batch,\n shuffle=params.shuffle,\n num_workers=params.dataloader_workers)\n \n train_size = 1896\n if train_size % self.params.train_batch != 0:\n total_batch = train_size // self.params.train_batch + 1\n else:\n total_batch = train_size // self.params.train_batch\n recal = 0\n precision = 0\n F_one = 0\n IOU = 0\n accuracy_new = 0 \n # train through dataset\n for batch_idx, batch in enumerate(train_loader):\n self.pb.click(batch_idx, total_batch)\n image, label = batch['image'], batch['label']\n image_cuda, label_cuda = image.cuda(), label.cuda()\n\n # checkpoint split\n if self.params.should_split:\n image_cuda.requires_grad_()\n out = checkpoint_sequential(self.network, self.params.split, image_cuda)\n else:\n out = self.network(image_cuda)\n \n pred = image_cuda\n pred = pred.to(torch.device(\"cpu\"))\n pred = pred.detach()\n img_grid = pred[0]\n #img_grid = torchvision.utils.make_grid(out) \n img_grid = img_grid.numpy().transpose(1, 2, 0)*255\n cv2.imwrite(\"/content/drive/My Drive/Train_images/original%d.jpg\" % batch_idx, img_grid)\n\n \n loss = self.loss_fn(out, label_cuda)\n \n #display_image(out, label_cuda)\n TP, FP, TN, FN = confusion(out, label_cuda)\n recal = recal+TP\n precision = precision+FP\n F_one = F_one + TN\n IOU = IOU+ FN \n _,predict = torch.max(out.data,1)\n predict = predict.to(torch.device(\"cpu\"))\n predict = predict.detach()\n img = predict[0]\n img = img.numpy()*255\n #img_grid = torchvision.utils.make_grid(out) \n cv2.imwrite(\"/content/drive/My Drive/Train_images/predict_label%d.png\" % batch_idx, img)\n label = label_cuda.to(torch.device(\"cpu\"))\n label = label.detach()\n label = label[0].numpy()*255\n cv2.imwrite(\"/content/drive/My Drive/Train_images/original_label%d.png\" % batch_idx, label)\n\n \n \n\n accuracy_final = accuracy(out, label_cuda)\n accuracy_new = accuracy_new + accuracy_final\n\n \n print(\"\\t\")\n print(recal/total_batch, precision/ total_batch, F_one/ total_batch, IOU/ total_batch)\n print(accuracy_new/total_batch)","def TrainNetwork(self):\n\n self.logger.info('Train Network')\n self.netWork.TrainGenerator()\n\n # # train NetworkLSTM\n self.logger.info('Train NetworkLSTM')\n self.netWork.TrainLSTM()","def trainNetwork():\n plot_data = {}\n plot_data['train_loss'] = []\n plot_data['valid_loss'] = []\n plot_data['train_acc'] = []\n plot_data['valid_acc'] = []\n plot_data['lr'] = []\n SAVE_DIR = 'C:/Users/Dario/Desktop/Projekt/Drugi labos/lab2_torch/figures'\n device = torch.device('cuda')\n\n net = ConvolutionalModel(3, 16, 128, 10).to(device=device)\n\n lossFunc = nn.CrossEntropyLoss()\n optimizer = optim.Adam(net.parameters(), lr=0.001)\n scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.95)\n\n epoch = 10\n \n\n for e in range(epoch):\n \n accLoss = 0.0\n\n for i, data in enumerate(data_load.trainloader, 0):\n inputs, labels = data\n inputs = inputs.to(device=device)\n labels = labels.to(device=device)\n\n optimizer.zero_grad()\n\n outputs = net.forward(inputs)\n loss = lossFunc(outputs, labels)\n loss.backward()\n optimizer.step()\n\n accLoss += loss.item()\n\n if i % 100 == 0:\n print(\"Epoch: %d, Iteration: %5d, Loss: %.3f\" % ((e + 1), (i), (accLoss / (i + 1))))\n \n train_loss, train_acc = evaluate.evaluate(net, False)\n val_loss, val_acc = evaluate.evaluate(net, True)\n\n plot_data['train_loss'] += [train_loss]\n plot_data['valid_loss'] += [val_loss]\n plot_data['train_acc'] += [train_acc]\n plot_data['valid_acc'] += [val_acc]\n plot_data['lr'] += [scheduler.get_lr()]\n\n scheduler.step()\n\n plot.plot_training_progress(SAVE_DIR, plot_data)\n PATH = './CIFAR_10/cifar_netAdam.pth'\n torch.save(net.state_dict(), PATH)","def main():\n\n NUM_TRAIN = noise.init_train_thresh\n NUM_TEST = 20\n XDIM = 1\n\n # Train the emulator\n x_train = np.random.uniform(size=(NUM_TRAIN, XDIM))\n y_train = np.array([noise(x) for x in x_train])\n\n # Output error estimates\n noise.output_err = True\n\n # Get values from the trained emulator\n x_emu = np.random.uniform(size=(NUM_TEST, XDIM))\n\n y_emu = np.zeros_like(x_emu)\n y_err = np.zeros_like(x_emu)\n\n for i, x in enumerate(x_emu):\n val, err = noise(x)\n y_emu[i] = val\n y_err[i] = err\n\n # Plot the results\n fig = plt.figure()\n ax = fig.add_subplot(111)\n\n ax.scatter(x_train[:, 0], y_train, marker=\"+\", label=\"training values\")\n ax.errorbar(\n x_emu,\n y_emu[:, 0],\n yerr=y_err.flatten(),\n linestyle=\"None\",\n marker=\"o\",\n capsize=3,\n label=\"emulator\",\n color=\"red\",\n )\n\n ax.legend()\n\n # `__file__` is undefined when running in sphinx\n try:\n fig.savefig(__file__ + \".png\")\n except NameError:\n pass","def represent():\n\tmodel.eval()\n\twith torch.no_grad():\n\n\t\tall_data = []\n\t\tall_targets = []\n\n\t\tfor batch_idx, (data, labels) in enumerate(nat_test_loader):\n\t\t\tall_data.append(data)\n\t\t\tall_targets.append(labels.float()+50) # +50 for nat data, for distinction between nat and syn\n\t\tfor batch_idx, (data, labels) in enumerate(syn_test_loader):\n\t\t\tall_data.append(data)\n\t\t\tall_targets.append(labels.float())\n\n\t\tall_data = torch.cat(all_data, 0) # Merges the list of tensors\n\t\tall_data = all_data.cuda()\n\t\tall_targets = torch.cat(all_targets, 0)\n\n\t\trepresentation = model.representation(all_data)\n\t\t\n\t\ttorch.save(representation, directory + \"/representations/repr\" + str(epoch) + \".pt\")\n\t\twith open(directory + \"/representations/tar\" + str(epoch) + \".log\", \"w\") as f:\n\t\t\tfor t in all_targets:\n\t\t\t\tf.write(str(t.item()) + \"\\n\")\n\n\t\t# Optional: Plotting of the UMAP in each represent()\n\t\t#sns.set(style='white', context='notebook', rc={'figure.figsize': (14, 10)})\n\t\t#reducer = umap.UMAP()\n\t\t#embedding = reducer.fit_transform(representation.cpu())\n\t\t# flatui = [\"#ff0000\", \"#000000\", \"#001800\", \"#003000\", \"#004800\", \"#006000\", \"#007800\", \"#009000\", \"#00a800\", \"#00c000\", \"#00d800\"]\n\t\t# plt.scatter(embedding[:, 0], embedding[:, 1], c=[sns.color_palette(flatui)[x] for x in all_targets.int()])\n\t\t#plt.scatter(embedding[:, 0], embedding[:, 1], c=all_targets.cpu())\n\t\t#plt.gca().set_aspect('equal', 'datalim')\n\t\t#plt.title('UMAP projection of cell data', fontsize=24);\n\t\t#plt.savefig(directory + \"/umap_\" + str(epoch) + \".png\")\n\t\t#plt.clf()","def testvis(layers='first'):\n\n\tfrom scipy.io import loadmat\n\tfrom setup import NeuralNetwork as nnsetup\n\n\tresult = loadmat(\"goodmatx.mat\")\n\tw1 = result['v1']\n\tw0 = result['v0']\n\tx,y = result['train_x'], result['train_y']\n\n\t# result = loadmat(\"ducky.mat\")\n\t# x = result['train_x']\n\t# y = result['train_y']\n\n\tsize = [x.shape[1], 1000, y.shape[1]]\n\n\tnn = nnsetup([size[0],size[1],size[0]],output='sigm')\n\n\tnn.W[0] = w0\n\tnn.W[1] = w1\n\t\n\tfor i in range(50):\n\t\tvisualize( nn, x, k = 3000+i*4, layers=layers, mode='save' )","def __call__(self, inputs, labels, train_iter, epoch):\n debug = False\n visualize_training = False\n tmp_show_epoches_list = []\n\n # if show_epochs_list is empty, all epoches should be plotted. Therefore, add current epoch to the list\n if not self.show_epochs_list:\n tmp_show_epoches_list.append(epoch)\n else:\n tmp_show_epoches_list = self.show_epochs_list\n\n # check if epoch should be visualized\n if epoch in tmp_show_epoches_list:\n # print the model's parameter dimensions etc in the first iter\n if train_iter == 0 and epoch == 0:\n debug = True\n # visualize training on the last iteration in that epoch\n elif (train_iter == 1 and epoch == 0) or (train_iter == self.max_train_iters):\n visualize_training = True\n\n # for nitorch models which have a 'debug' and 'visualize_training' switch in the\n # forward() method\n\n # Todo: Check if self.model.module.set_debug(debug) is still possible?\n\n if isinstance(self.model, nn.DataParallel):\n self.model.module.set_debug(debug)\n else:\n self.model.set_debug(debug)\n\n outputs, encoder_out = self.model(inputs)\n\n if visualize_training:\n # check if result should be plotted in PDF\n if self.plot_pdf_path != \"\":\n pp = PdfPages(os.path.join(self.plot_pdf_path, \"training_epoch_\" + str(epoch) + \"_visualization.pdf\"))\n else:\n pp = None\n\n # show only the first image in the batch\n if pp is None:\n # input image\n show_brain(inputs[0].squeeze().cpu().detach().numpy(), draw_cross=False, cmap=self.cmap)\n plt.suptitle(\"Input image\")\n plt.show()\n if not torch.all(torch.eq(inputs[0], labels[0])):\n show_brain(labels[0].squeeze().cpu().detach().numpy(), draw_cross=False, cmap=self.cmap)\n plt.suptitle(\"Expected reconstruction\")\n plt.show()\n # reconstructed image\n show_brain(outputs[0].squeeze().cpu().detach().numpy(), draw_cross=False, cmap=self.cmap)\n plt.suptitle(\"Reconstructed Image\")\n plt.show()\n # statistics\n print(\n \"\\nStatistics of expected reconstruction:\\n(min, max)=({:.4f}, {:.4f})\\nmean={:.4f}\\nstd={:.4f}\".format(\n labels[0].min(), labels[0].max(), labels[0].mean(), labels[0].std()))\n print(\n \"\\nStatistics of Reconstructed image:\\n(min, max)=({:.4f}, {:.4f})\\nmean={:.4f}\\nstd={:.4f}\".format(\n outputs[0].min(), outputs[0].max(), outputs[0].mean(), outputs[0].std()))\n # feature maps\n visualize_feature_maps(encoder_out[0])\n plt.suptitle(\"Encoder output\")\n plt.show()\n else:\n # input image\n fig = show_brain(inputs[0].squeeze().cpu().detach().numpy(), draw_cross=False, return_fig=True,\n cmap=self.cmap)\n plt.suptitle(\"Input image\")\n pp.savefig(fig)\n plt.close(fig)\n if not torch.all(torch.eq(inputs[0], labels[0])):\n fig = show_brain(labels[0].squeeze().cpu().detach().numpy(), draw_cross=False, cmap=self.cmap)\n plt.suptitle(\"Expected reconstruction\")\n pp.savefig(fig)\n plt.close(fig)\n # reconstructed image\n fig = show_brain(outputs[0].squeeze().cpu().detach().numpy(), draw_cross=False, return_fig=True,\n cmap=self.cmap)\n plt.suptitle(\"Reconstructed Image\")\n pp.savefig(fig)\n plt.close(fig)\n # feature maps\n if self.plotFeatures:\n fig = visualize_feature_maps(encoder_out[0], return_fig=True)\n plt.suptitle(\"Encoder output\")\n pp.savefig(fig)\n plt.close(fig)\n\n # close the PDF\n if pp is not None:\n pp.close()\n\n if isinstance(self.model, nn.DataParallel):\n self.model.module.set_debug(False)\n else:\n self.model.set_debug(False)\n\n return outputs","def run_net(inputs, **parameter):\n\n # ---- set numpy random state for each run----\n np.random.set_state(np_state)\n\n # -----parameter setting-------\n n_ex = 1600\n n_inh = int(n_ex / 4)\n n_input = MNIST_shape[1] * coding_n\n n_read = n_ex + n_inh\n\n R = parameter['R']\n f_in = parameter['f_in']\n f_EE = parameter['f_EE']\n f_EI = parameter['f_EI']\n f_IE = parameter['f_IE']\n f_II = parameter['f_II']\n\n A_EE = 60 * f_EE\n A_EI = 60 * f_EI\n A_IE = 60 * f_IE\n A_II = 60 * f_II\n A_inE = 60 * f_in\n A_inI = 60 * f_in\n\n tau_ex = parameter['tau_ex'] * coding_duration\n tau_inh = parameter['tau_inh'] * coding_duration\n tau_read = 30\n\n p_inE = parameter['p_in'] * 0.1\n p_inI = parameter['p_in'] * 0.1\n\n # ------definition of equation-------------\n neuron_in = '''\n I = stimulus(t,i) : 1\n '''\n\n neuron = '''\n tau : 1\n dv/dt = (I-v) / (tau*ms) : 1 (unless refractory)\n dg/dt = (-g)/(3*ms) : 1\n dh/dt = (-h)/(6*ms) : 1\n I = (g+h)+13.5: 1\n x : 1\n y : 1\n z : 1\n '''\n\n neuron_read = '''\n tau : 1\n dv/dt = (I-v) / (tau*ms) : 1\n dg/dt = (-g)/(3*ms) : 1 \n dh/dt = (-h)/(6*ms) : 1\n I = (g+h): 1\n '''\n\n synapse = '''\n w : 1\n '''\n\n on_pre_ex = '''\n g+=w\n '''\n\n on_pre_inh = '''\n h-=w\n '''\n\n # -----Neurons and Synapses setting-------\n Input = NeuronGroup(n_input, neuron_in, threshold='I > 0', method='euler', refractory=0 * ms,\n name='neurongroup_input')\n\n G_ex = NeuronGroup(n_ex, neuron, threshold='v > 15', reset='v = 13.5', method='euler', refractory=3 * ms,\n name='neurongroup_ex')\n\n G_inh = NeuronGroup(n_inh, neuron, threshold='v > 15', reset='v = 13.5', method='euler', refractory=2 * ms,\n name='neurongroup_in')\n\n G_readout = NeuronGroup(n_read, neuron_read, method='euler', name='neurongroup_read')\n\n S_inE = Synapses(Input, G_ex, synapse, on_pre=on_pre_ex, method='euler', name='synapses_inE')\n\n S_inI = Synapses(Input, G_inh, synapse, on_pre=on_pre_ex, method='euler', name='synapses_inI')\n\n S_EE = Synapses(G_ex, G_ex, synapse, on_pre=on_pre_ex, method='euler', name='synapses_EE')\n\n S_EI = Synapses(G_ex, G_inh, synapse, on_pre=on_pre_ex, method='euler', name='synapses_EI')\n\n S_IE = Synapses(G_inh, G_ex, synapse, on_pre=on_pre_inh, method='euler', name='synapses_IE')\n\n S_II = Synapses(G_inh, G_inh, synapse, on_pre=on_pre_inh, method='euler', name='synapses_I')\n\n S_E_readout = Synapses(G_ex, G_readout, 'w = 1 : 1', on_pre=on_pre_ex, method='euler')\n\n S_I_readout = Synapses(G_inh, G_readout, 'w = 1 : 1', on_pre=on_pre_inh, method='euler')\n\n # -------initialization of neuron parameters----------\n G_ex.v = '13.5+1.5*rand()'\n G_inh.v = '13.5+1.5*rand()'\n G_readout.v = '0'\n G_ex.g = '0'\n G_inh.g = '0'\n G_readout.g = '0'\n G_ex.h = '0'\n G_inh.h = '0'\n G_readout.h = '0'\n G_ex.tau = tau_ex\n G_inh.tau = tau_inh\n G_readout.tau = tau_read\n [G_ex, G_in] = base.allocate([G_ex, G_inh], 10, 10, 20)\n\n # -------initialization of network topology and synapses parameters----------\n S_inE.connect(condition='j<0.3*N_post', p=p_inE)\n S_inI.connect(condition='j<0.3*N_post', p=p_inI)\n S_EE.connect(condition='i != j', p='0.3*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\n S_EI.connect(p='0.2*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\n S_IE.connect(p='0.4*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\n S_II.connect(condition='i != j', p='0.1*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\n S_E_readout.connect(j='i')\n S_I_readout.connect(j='i+n_ex')\n\n S_inE.w = function.gamma(A_inE, S_inE.w.shape)\n S_inI.w = function.gamma(A_inI, S_inI.w.shape)\n S_EE.w = function.gamma(A_EE, S_EE.w.shape)\n S_IE.w = function.gamma(A_IE, S_IE.w.shape)\n S_EI.w = function.gamma(A_EI, S_EI.w.shape)\n S_II.w = function.gamma(A_II, S_II.w.shape)\n\n S_EE.pre.delay = '1.5*ms'\n S_EI.pre.delay = '0.8*ms'\n S_IE.pre.delay = '0.8*ms'\n S_II.pre.delay = '0.8*ms'\n\n # ------create network-------------\n net = Network(collect())\n net.store('init')\n\n # ------run network-------------\n stimulus = TimedArray(inputs[0], dt=Dt)\n net.run(duration * Dt)\n states = net.get_states()['neurongroup_read']['v']\n net.restore('init')\n return (states, inputs[1])","def _run(output_dir_name):\n\n file_system_utils.mkdir_recursive_if_necessary(\n directory_name=output_dir_name\n )\n\n # Housekeeping.\n y_tick_labels = [\n '{0:s}'.format(s) for s in MODEL_DEPTH_WIDTH_STRINGS\n ]\n x_tick_labels = [\n '{0:d}'.format(c) for c in FIRST_LAYER_CHANNEL_COUNTS\n ]\n\n y_axis_label = 'NN depth, width'\n x_axis_label = 'Spectral complexity'\n\n # Plot grid for U-net++ without deep supervision.\n dimensions_3d = (\n len(MODEL_WIDTHS), len(MODEL_DEPTHS), len(FIRST_LAYER_CHANNEL_COUNTS)\n )\n num_weights_matrix = numpy.reshape(NUM_WEIGHTS_ARRAY_PLUSPLUS, dimensions_3d)\n num_weights_matrix = numpy.swapaxes(num_weights_matrix, 0, 1)\n\n num_depth_width_combos = len(MODEL_DEPTH_WIDTH_STRINGS)\n num_channel_counts = len(FIRST_LAYER_CHANNEL_COUNTS)\n dimensions_2d = (num_depth_width_combos, num_channel_counts)\n num_weights_matrix = numpy.reshape(num_weights_matrix, dimensions_2d)\n\n all_weights = numpy.concatenate((\n NUM_WEIGHTS_ARRAY_PLUSPLUS, NUM_WEIGHTS_ARRAY_PLUSPLUSPLUS,\n NUM_WEIGHTS_ARRAY_PLUSPLUS_DEEP, NUM_WEIGHTS_ARRAY_PLUSPLUSPLUS_DEEP\n ), axis=0)\n\n min_colour_value = numpy.min(numpy.log10(all_weights))\n max_colour_value = numpy.max(numpy.log10(all_weights))\n\n figure_object, axes_object = _plot_scores_2d(\n score_matrix=numpy.log10(num_weights_matrix),\n min_colour_value=min_colour_value,\n max_colour_value=max_colour_value,\n x_tick_labels=x_tick_labels, y_tick_labels=y_tick_labels\n )\n\n figure_width_px = (\n figure_object.get_size_inches()[0] * figure_object.dpi\n )\n marker_size_px = figure_width_px * (\n MARKER_SIZE_GRID_CELLS / num_weights_matrix.shape[1]\n )\n\n if SELECTED_MARKER_INDICES[0] == 0:\n axes_object.plot(\n SELECTED_MARKER_INDICES[2], SELECTED_MARKER_INDICES[1],\n linestyle='None', marker=MARKER_TYPE,\n markersize=marker_size_px, markeredgewidth=0,\n markerfacecolor=MARKER_COLOUR,\n markeredgecolor=MARKER_COLOUR\n )\n\n axes_object.set_xlabel(x_axis_label)\n axes_object.set_ylabel(y_axis_label)\n axes_object.set_title(NN_TYPE_STRINGS_FANCY[0])\n\n panel_file_names = [\n '{0:s}/num_weights_log10_{1:s}.jpg'.format(\n output_dir_name, NN_TYPE_STRINGS[0].replace('_', '-')\n )\n ]\n\n print('Saving figure to: \"{0:s}\"...'.format(panel_file_names[-1]))\n figure_object.savefig(\n panel_file_names[-1], dpi=FIGURE_RESOLUTION_DPI,\n pad_inches=0, bbox_inches='tight'\n )\n pyplot.close(figure_object)\n\n # Plot grid for U-net++ with deep supervision.\n num_weights_matrix = numpy.reshape(\n NUM_WEIGHTS_ARRAY_PLUSPLUS_DEEP, dimensions_3d\n )\n num_weights_matrix = numpy.swapaxes(num_weights_matrix, 0, 1)\n num_weights_matrix = numpy.reshape(num_weights_matrix, dimensions_2d)\n\n figure_object, axes_object = _plot_scores_2d(\n score_matrix=numpy.log10(num_weights_matrix),\n min_colour_value=min_colour_value,\n max_colour_value=max_colour_value,\n x_tick_labels=x_tick_labels, y_tick_labels=y_tick_labels\n )\n\n if SELECTED_MARKER_INDICES[0] == 1:\n axes_object.plot(\n SELECTED_MARKER_INDICES[2], SELECTED_MARKER_INDICES[1],\n linestyle='None', marker=MARKER_TYPE,\n markersize=marker_size_px, markeredgewidth=0,\n markerfacecolor=MARKER_COLOUR,\n markeredgecolor=MARKER_COLOUR\n )\n\n axes_object.set_xlabel(x_axis_label)\n axes_object.set_ylabel(y_axis_label)\n axes_object.set_title(NN_TYPE_STRINGS_FANCY[1])\n\n panel_file_names.append(\n '{0:s}/num_weights_log10_{1:s}.jpg'.format(\n output_dir_name, NN_TYPE_STRINGS[1].replace('_', '-')\n )\n )\n\n print('Saving figure to: \"{0:s}\"...'.format(panel_file_names[-1]))\n figure_object.savefig(\n panel_file_names[-1], dpi=FIGURE_RESOLUTION_DPI,\n pad_inches=0, bbox_inches='tight'\n )\n pyplot.close(figure_object)\n\n # Plot grid for U-net3+ without deep supervision.\n num_weights_matrix = numpy.reshape(\n NUM_WEIGHTS_ARRAY_PLUSPLUSPLUS, dimensions_3d\n )\n num_weights_matrix = numpy.swapaxes(num_weights_matrix, 0, 1)\n num_weights_matrix = numpy.reshape(num_weights_matrix, dimensions_2d)\n\n figure_object, axes_object = _plot_scores_2d(\n score_matrix=numpy.log10(num_weights_matrix),\n min_colour_value=min_colour_value,\n max_colour_value=max_colour_value,\n x_tick_labels=x_tick_labels, y_tick_labels=y_tick_labels\n )\n\n if SELECTED_MARKER_INDICES[0] == 2:\n axes_object.plot(\n SELECTED_MARKER_INDICES[2], SELECTED_MARKER_INDICES[1],\n linestyle='None', marker=MARKER_TYPE,\n markersize=marker_size_px, markeredgewidth=0,\n markerfacecolor=MARKER_COLOUR,\n markeredgecolor=MARKER_COLOUR\n )\n\n axes_object.set_xlabel(x_axis_label)\n axes_object.set_ylabel(y_axis_label)\n axes_object.set_title(NN_TYPE_STRINGS_FANCY[2])\n\n panel_file_names.append(\n '{0:s}/num_weights_log10_{1:s}.jpg'.format(\n output_dir_name, NN_TYPE_STRINGS[2].replace('_', '-')\n )\n )\n\n print('Saving figure to: \"{0:s}\"...'.format(panel_file_names[-1]))\n figure_object.savefig(\n panel_file_names[-1], dpi=FIGURE_RESOLUTION_DPI,\n pad_inches=0, bbox_inches='tight'\n )\n pyplot.close(figure_object)\n\n # Plot grid for U-net3+ with deep supervision.\n num_weights_matrix = numpy.reshape(\n NUM_WEIGHTS_ARRAY_PLUSPLUSPLUS_DEEP, dimensions_3d\n )\n num_weights_matrix = numpy.swapaxes(num_weights_matrix, 0, 1)\n num_weights_matrix = numpy.reshape(num_weights_matrix, dimensions_2d)\n\n figure_object, axes_object = _plot_scores_2d(\n score_matrix=numpy.log10(num_weights_matrix),\n min_colour_value=min_colour_value,\n max_colour_value=max_colour_value,\n x_tick_labels=x_tick_labels, y_tick_labels=y_tick_labels\n )\n\n if SELECTED_MARKER_INDICES[0] == 3:\n axes_object.plot(\n SELECTED_MARKER_INDICES[2], SELECTED_MARKER_INDICES[1],\n linestyle='None', marker=MARKER_TYPE,\n markersize=marker_size_px, markeredgewidth=0,\n markerfacecolor=MARKER_COLOUR,\n markeredgecolor=MARKER_COLOUR\n )\n\n axes_object.set_xlabel(x_axis_label)\n axes_object.set_ylabel(y_axis_label)\n axes_object.set_title(NN_TYPE_STRINGS_FANCY[3])\n\n panel_file_names.append(\n '{0:s}/num_weights_log10_{1:s}.jpg'.format(\n output_dir_name, NN_TYPE_STRINGS[3].replace('_', '-')\n )\n )\n\n print('Saving figure to: \"{0:s}\"...'.format(panel_file_names[-1]))\n figure_object.savefig(\n panel_file_names[-1], dpi=FIGURE_RESOLUTION_DPI,\n pad_inches=0, bbox_inches='tight'\n )\n pyplot.close(figure_object)\n\n # Concatenate panels into one figure.\n concat_file_name = '{0:s}/num_weights_log10.jpg'.format(output_dir_name)\n print('Concatenating panels to: \"{0:s}\"...'.format(concat_file_name))\n imagemagick_utils.concatenate_images(\n input_file_names=panel_file_names,\n output_file_name=concat_file_name,\n num_panel_rows=2, num_panel_columns=2\n )\n imagemagick_utils.resize_image(\n input_file_name=concat_file_name,\n output_file_name=concat_file_name, output_size_pixels=int(1e7)\n )","def run_net(inputs, **parameter):\n\n #---- set numpy random state for each run----\n np.random.set_state(np_state)\n\n # -----parameter setting-------\n n_ex = 1600\n n_inh = int(n_ex/4)\n n_input = MNIST_shape[1]*coding_n\n n_read = n_ex+n_inh\n\n R = parameter['R']\n f_in = parameter['f_in']\n f_EE = parameter['f_EE']\n f_EI = parameter['f_EI']\n f_IE = parameter['f_IE']\n f_II = parameter['f_II']\n\n A_EE = 60*f_EE\n A_EI = 60*f_EI\n A_IE = 60*f_IE\n A_II = 60*f_II\n A_inE = 60*f_in\n A_inI = 60*f_in\n\n tau_ex = parameter['tau_ex']*coding_duration\n tau_inh = parameter['tau_inh']*coding_duration\n tau_read= 30\n\n p_inE = parameter['p_in']*0.1\n p_inI = parameter['p_in']*0.1\n\n #------definition of equation-------------\n neuron_in = '''\n I = stimulus(t,i) : 1\n '''\n\n neuron = '''\n tau : 1\n dv/dt = (I-v) / (tau*ms) : 1 (unless refractory)\n dg/dt = (-g)/(3*ms) : 1\n dh/dt = (-h)/(6*ms) : 1\n I = (g+h)+13.5: 1\n x : 1\n y : 1\n z : 1\n '''\n\n neuron_read = '''\n tau : 1\n dv/dt = (I-v) / (tau*ms) : 1\n dg/dt = (-g)/(3*ms) : 1 \n dh/dt = (-h)/(6*ms) : 1\n I = (g+h): 1\n '''\n\n synapse = '''\n w : 1\n '''\n\n on_pre_ex = '''\n g+=w\n '''\n\n on_pre_inh = '''\n h-=w\n '''\n\n # -----Neurons and Synapses setting-------\n Input = NeuronGroup(n_input, neuron_in, threshold='I > 0', method='euler', refractory=0 * ms,\n name = 'neurongroup_input')\n\n G_ex = NeuronGroup(n_ex, neuron, threshold='v > 15', reset='v = 13.5', method='euler', refractory=3 * ms,\n name ='neurongroup_ex')\n\n G_inh = NeuronGroup(n_inh, neuron, threshold='v > 15', reset='v = 13.5', method='euler', refractory=2 * ms,\n name ='neurongroup_in')\n\n G_readout = NeuronGroup(n_read, neuron_read, method='euler', name='neurongroup_read')\n\n S_inE = Synapses(Input, G_ex, synapse, on_pre = on_pre_ex ,method='euler', name='synapses_inE')\n\n S_inI = Synapses(Input, G_inh, synapse, on_pre = on_pre_ex ,method='euler', name='synapses_inI')\n\n S_EE = Synapses(G_ex, G_ex, synapse, on_pre = on_pre_ex ,method='euler', name='synapses_EE')\n\n S_EI = Synapses(G_ex, G_inh, synapse, on_pre = on_pre_ex ,method='euler', name='synapses_EI')\n\n S_IE = Synapses(G_inh, G_ex, synapse, on_pre = on_pre_inh ,method='euler', name='synapses_IE')\n\n S_II = Synapses(G_inh, G_inh, synapse, on_pre = on_pre_inh ,method='euler', name='synapses_I')\n\n S_E_readout = Synapses(G_ex, G_readout, 'w = 1 : 1', on_pre=on_pre_ex, method='euler')\n\n S_I_readout = Synapses(G_inh, G_readout, 'w = 1 : 1', on_pre=on_pre_inh, method='euler')\n\n #-------initialization of neuron parameters----------\n G_ex.v = '13.5+1.5*rand()'\n G_inh.v = '13.5+1.5*rand()'\n G_readout.v = '0'\n G_ex.g = '0'\n G_inh.g = '0'\n G_readout.g = '0'\n G_ex.h = '0'\n G_inh.h = '0'\n G_readout.h = '0'\n G_ex.tau = tau_ex\n G_inh.tau = tau_inh\n G_readout.tau = tau_read\n\n [G_ex,G_in] = base.allocate([G_ex,G_inh],10,10,20)\n\n # -------initialization of network topology and synapses parameters----------\n S_inE.connect(condition='j<0.3*N_post', p = p_inE)\n S_inI.connect(condition='j<0.3*N_post', p = p_inI)\n S_EE.connect(condition='i != j', p='0.3*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\n S_EI.connect(p='0.2*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\n S_IE.connect(p='0.4*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\n S_II.connect(condition='i != j', p='0.1*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\n S_E_readout.connect(j='i')\n S_I_readout.connect(j='i+n_ex')\n\n S_inE.w = function.gamma(A_inE, S_inE.w.shape)\n S_inI.w = function.gamma(A_inI, S_inI.w.shape)\n S_EE.w = function.gamma(A_EE, S_EE.w.shape)\n S_IE.w = function.gamma(A_IE, S_IE.w.shape)\n S_EI.w = function.gamma(A_EI, S_EI.w.shape)\n S_II.w = function.gamma(A_II, S_II.w.shape)\n\n S_EE.pre.delay = '1.5*ms'\n S_EI.pre.delay = '0.8*ms'\n S_IE.pre.delay = '0.8*ms'\n S_II.pre.delay = '0.8*ms'\n\n # ------create network-------------\n net = Network(collect())\n net.store('init')\n\n # ------run network-------------\n stimulus = TimedArray(inputs[0], dt=Dt)\n net.run(duration * Dt)\n states = net.get_states()['neurongroup_read']['v']\n net.restore('init')\n return (states, inputs[1])","def main():\n nn = CarsClassifierModel()\n train_x, train_y, test_x, test_y = nn.load_data_preprocess()\n history = nn.run(train_x,train_y)\n nn.evaluate(test_x, test_y)\n nn.save(\"keras_nn_5\")\n #nn.plots(history)\n #print(train_x.shape)\n #plt.imshow(train_x[52])\n #plt.title(\"Car\")\n #plt.show()\n #print(train_y[52])","def train():\n if os.path.isfile(load_model):\n all_weights = np.load(load_model) \n else:\n print(\"Model file does not exist. Exiting....\")\n return\n\n print(\"Build up the network\")\n\n\n # Two different types of input\n image_input_var = T.tensor4('original_inputs')\n rotated_image_input_var = T.tensor4('rotated_image_input')\n target_var = T.ivector('targets')\n\n # Build teacher network\n cnn_model, cnn_mid_output, weight_decay_penalty = cifar10_merge.build_cnn(image_input_var)\n\n # Get the intermediate layer of the teacher network\n original_model_mid_output = lasagne.layers.get_output(cnn_mid_output, image_input_var, deterministic = True)\n\n # Get the softmax output of the teacher network.\n\n original_model_output_val = lasagne.layers.get_output(cnn_model, image_input_var, deterministic = True)\n \n # Build the student network\n \n rotated_cnn_model, rotated_model_mid, rotated_weight_penalty = \\\n cifar10_merge.build_cnn(rotated_image_input_var)\n \n # Get the softmax output of the student network. Since it need to be trained on, deterministic = False\n rotated_model_mid_output = lasagne.layers.get_output(rotated_model_mid, rotated_image_input_var, deterministic = False)\n\n # Get the model output of the studenet network.\n rotated_model_output = lasagne.layers.get_output(rotated_cnn_model, rotated_image_input_var, deterministic = True)\n\n # Set the weights for the teacher network\n lasagne.layers.set_all_param_values(cnn_model, all_weights)\n\n # Get the initialized weights below the intermediate layer\n rotated_net_weights_below_mid = lasagne.layers.get_all_param_values(rotated_model_mid)\n\n # Get the parameter of the student network that needs to be trained.\n rotated_net_training_param = lasagne.layers.get_all_params(rotated_model_mid, trainable=True)\n\n # Set the weights for the student network\n lasagne.layers.set_all_param_values(rotated_cnn_model, all_weights)\n\n lasagne.layers.set_all_param_values(rotated_model_mid,\n rotated_net_weights_below_mid)\n \n # cross_entropy_loss = lasagne.objectives.categorical_crossentropy(rotated_model_mid_output, target_var)\n\n # cross_entropy_loss_mean = cross_entropy_loss.mean()\n\n # L = T.mean(lasagne.objectives.squared_error(original_model_mid_output, rotated_model_mid_output), axis = 1)\n L = lasagne.objectives.squared_error(original_model_mid_output, rotated_model_mid_output).mean()\n # cost = T.mean(L)\n\n # cost = cross_entropy_loss_mean\n cost = L\n\n # updates = lasagne.updates.adagrad(cost, rotated_net_training_param, learning_rate=0.1)\n updates = lasagne.updates.adam(cost, rotated_net_training_param, learning_rate=0.001)\n\n # cross_entropy_loss = lasagne.objectives.categorical_crossentropy(model_output, target_var)\n\n # cross_entropy_loss_mean = cross_entropy_loss.mean()\n\n # loss = cross_entropy_loss_mean + weight_decay_penalty\n\n\n train_acc = T.mean(T.eq(T.argmax(rotated_model_output, axis = 1), target_var),\n dtype=theano.config.floatX)\n\n original_model_acc = T.mean(T.eq(T.argmax(original_model_output_val, axis = 1), target_var),\n dtype=theano.config.floatX)\n\n train_fn = theano.function(inputs = [image_input_var, rotated_image_input_var, target_var],\n outputs = [original_model_mid_output, rotated_model_mid_output, train_acc], updates = updates)\n\n # Return the accuracy for teacher network and student network, respectively\n val_fn = theano.function(inputs = [image_input_var, rotated_image_input_var, target_var],\n outputs = [original_model_acc, train_acc])\n\n if os.path.isfile(os.path.join(train_dir, 'latest_model.txt')):\n weight_file = \"\"\n with open(os.path.join(train_dir, 'latest_model.txt'), 'r') as checkpoint_file:\n weight_file = checkpoint_file.read().replace('\\n', '')\n print(\"Loading from: \", weight_file)\n model_weights = np.load(weight_file)\n lasagne.layers.set_all_param_values(rotated_cnn_model, model_weights)\n\n # Get images and labels for CIFAR-10.\n\n cifar10_data = cifar10_merge_input.load_cifar10()\n\n bkgimg = np.array([np.mean(cifar10_data.train.images[cifar10_data.train.labels==i], axis = 0) for i in range(10)])\n for epoch in xrange(max_steps):\n start_time = time.time()\n\n original_test_image, rotated_test_image, test_label = cifar10_data.test.next_eval_batch(batch_size)\n total_t_net_for_original = 0\n total_s_net_for_original = 0\n total_t_net_for_rotation = 0\n total_s_net_for_rotation = 0\n total_count = 0\n\n print(\"Start Evaluating\")\n\n while(rotated_test_image is not None):\n t_net_for_original, s_net_for_original = val_fn(original_test_image, original_test_image, test_label)\n total_t_net_for_original += t_net_for_original * original_test_image.shape[0]\n total_s_net_for_original += s_net_for_original * original_test_image.shape[0]\n\n t_net_for_rotated, s_net_for_rotated = val_fn(rotated_test_image, rotated_test_image, test_label)\n total_t_net_for_rotation += t_net_for_rotated * rotated_test_image.shape[0]\n total_s_net_for_rotation += s_net_for_rotated * rotated_test_image.shape[0]\n\n total_count += rotated_test_image.shape[0]\n original_test_image, rotated_test_image, test_label = cifar10_data.test.next_eval_batch(batch_size)\n \n print(\"Student Network Accuracy on Original Image: %.4f\" % (float(total_s_net_for_original / total_count)))\n print(\"Teacher Network Accuracy on Original Image: %.4f\" % (float(total_t_net_for_original / total_count)))\n\n print(\"Student Network Accuracy on Rotated Image: %.4f\" % (float(total_s_net_for_rotation / total_count)))\n print(\"Teacher Network Accuracy on Rotated Image: %.4f\" % (float(total_t_net_for_rotation / total_count)))\n\n\n print(\"Start Training...\")\n original_train_image, rotated_train_image, train_label, start = cifar10_data.train.next_batch(batch_size)\n original_train_image = generate(original_train_image, train_label, bkgimg, 16, 32, None, batch_size)\n # rotated_train_image = random_rotated_image(original_train_image[::-1])\n rotated_train_image = random_rotated_image(original_train_image)\n\n end_time_1 = time.time() - start_time\n step = 1\n loss_total = 0\n original_start = start\n\n while(start != 0):\n #loss_value, train_acc = train_fn(original_train_image, rotated_train_image, train_label)\n \n ori_mid, rot_mid, train_acc = train_fn(original_train_image, rotated_train_image, train_label)\n # ori_mid, rot_mid, train_acc = train_fn(original_train_image, np.array(np.random.rand(batch_size, 3, 32, 32), dtype = np.float32), train_label)\n step += 1\n if start == original_start:\n print(ori_mid[0])\n print(rot_mid[0])\n print(train_label)\n \n original_train_image, rotated_train_image, train_label, start = cifar10_data.train.next_batch(batch_size)\n original_train_image = generate(original_train_image, train_label, bkgimg, 16, 32, None, batch_size)\n rotated_train_image = random_rotated_image(original_train_image)\n # assert not np.isnan(loss_value), 'Model diverged with loss = NaN'\n # loss_total += loss_value\n if 1:\n if epoch % 100 == 0 or (step + 1) == max_steps:\n checkpoint_path = os.path.join(train_dir, 'model_step%d.npy' % epoch)\n weightsOfParams = lasagne.layers.get_all_param_values(rotated_cnn_model)\n np.save(checkpoint_path, weightsOfParams)\n latest_model_path = os.path.join(train_dir, 'latest_model.txt')\n try:\n os.remove(latest_model_path)\n except OSError:\n pass\n latest_model_file = open(latest_model_path, \"w\")\n latest_model_file.write(checkpoint_path)\n latest_model_file.close()\n\n # print(\"Epoch Stop, loss_averge\", float(loss_total) / float(step))\n duration = time.time() - start_time\n print(\"Duration is\", duration)","def neural_net_ex4_ng():\n # ==================\n # read data\n dataset = loadmat('data/ex4data1.mat')\n print(dataset.keys())\n\n y = dataset['y'] # 5000 x 1\n print('dims y: ', y.shape)\n # print('y[0]: ', y[0])\n\n X = dataset['X'] # 5000 x 400\n print('dims X: ', X.shape)\n # print('X[0]: ', X[0])\n\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n\n num_samples_test = X_test.shape[0]\n\n # ==================\n # display data\n\n # pick 20 examples and visualize them\n fig = plt.figure(figsize=(10, 8), facecolor='white')\n fig.add_subplot(651)\n samples = np.random.choice(num_samples_test, 10)\n print('samples:', samples)\n plt.imshow(X_test[samples, :].reshape(-1, 20).T, cmap=\"Greys\")\n plt.axis('off')\n\n # ==================\n # run neural net\n hidden_layer_size = 25\n\n mlp = MLPClassifier(hidden_layer_sizes=(25,), max_iter=20, alpha=1e-4,\n solver='sgd', verbose=False, tol=1e-4, random_state=1,\n learning_rate_init=.1)\n mlp.fit(X_train, y_train.ravel())\n\n predictions = mlp.predict(X_test)\n print('Test set accuracy: {} %'.format(np.mean(predictions == y_test.ravel())*100))\n\n # print(confusion_matrix(y_test, predictions))\n # print(classification_report(y_test, predictions))\n print(\"Training set score: %f\" % mlp.score(X_train, y_train))\n print(\"Test set score: %f\" % mlp.score(X_test, y_test))\n print('coeffs shape', (mlp.coefs_[0]).shape)\n\n # ==================\n # display coefficients of hidden layer\n fig.add_subplot(652)\n plt.imshow(mlp.coefs_[0][:, 0].reshape(20, 20))\n plt.axis('off')\n\n gs = gridspec.GridSpec(6, 5)\n cur_img_idx = 5\n\n # use global min / max to ensure all weights are shown on the same scale\n vmin, vmax = mlp.coefs_[0].min(), mlp.coefs_[0].max()\n for coef, ax in zip(mlp.coefs_[0].T, range(hidden_layer_size)):\n fig.add_subplot(gs[cur_img_idx])\n plt.imshow(coef.reshape(20, 20), cmap=plt.cm.gray, vmin=.5 * vmin, vmax=.5 * vmax)\n plt.axis('off')\n cur_img_idx += 1\n\n plt.show()","def __init__(self):\n super(SimpleNet, self).__init__()\n\n self.conv_layers = None\n self.fc_layers = None\n self.loss_criterion = None\n\n #######################################################################\n # Student code begins\n #######################################################################\n\n self.conv_layers = nn.Sequential(\n nn.Conv2d(1, 10, kernel_size=5, stride=1),\n nn.ReLU(),\n nn.MaxPool2d(3),\n nn.Conv2d(10, 20, kernel_size=5, stride=1),\n nn.ReLU(),\n nn.MaxPool2d(3)\n )\n\n conv_out = int(20*5*5)\n\n self.fc_layers = nn.Sequential(\n nn.Linear(conv_out, 100),\n nn.Linear(100, 15)\n )\n\n self.loss_criterion = nn.MSELoss(reduction='mean')\n\n #######################################################################\n # Student code ends\n #######################################################################","def __init__(self, input_dim, output_dim, hidden_dim=100, num_layers=2,\r\n num_epochs=100, learning_rate=0.001, threshold=0.1):\r\n super(ReluNet, self).__init__()\r\n\r\n self.input_dim = input_dim\r\n self.output_dim = output_dim\r\n self.hidden_dim = hidden_dim\r\n self.num_layers = num_layers\r\n self.num_epochs = num_epochs\r\n self.threshold = threshold\r\n self.learning_rate = learning_rate\r\n\r\n\r\n \r\n self.layers = nn.ModuleList()\r\n self.layers.append(nn.Linear(input_dim, hidden_dim))\r\n self.layers.append(nn.ReLU())\r\n for i in range(num_layers-1):\r\n self.layers.append(nn.Linear(hidden_dim, hidden_dim))\r\n self.layers.append(nn.ReLU())\r\n # output layer\r\n self.layers.append(nn.Linear(hidden_dim, output_dim))","def unsup_train_exp(model, criterions, optimizer, scheduler, dataloaders,unsup_path,margin,num_epochs=10, vis=None):\n print('>> Fine-tune a Model.')\n best_roc = 0.0\n \n iters = 0\n plot_data = {'X': [], 'Y': [], 'legend': ['Sup. Loss', 'Unsup. Loss', 'Tot. Loss']}\n\n for epoch in range(num_epochs):\n scheduler.step()\n # Training\n model.train()\n for i, sup_data in enumerate(dataloaders['sup_train']):\n unsup_data = dataloaders['unsup_train'][i % len(dataloaders['unsup_train'])]\n sup_inputs = sup_data[0]\n sup_labels = sup_data[1].cuda()\n unsup_inputs = unsup_data[0]\n data_inputs=torch.cat((sup_inputs,unsup_inputs),axis=0).cuda()\n \n # unsup_labels = unsup_data[1].cuda()\n iters += 1\n\n optimizer.zero_grad()\n out_1, out_2 = model(data_inputs)\n sup_out_1,sup_out_2=out_1[:sup_inputs.shape[0]],out_2[:sup_inputs.shape[0]]\n unsup_out_1,unsup_out_2=out_1[sup_inputs.shape[0]:],out_2[sup_inputs.shape[0]:]\n\n loss_sup = criterions['sup'](sup_out_1, sup_labels) + criterions['sup'](sup_out_2, sup_labels) # Step A\n\n loss_unsup = criterions['unsup'](unsup_out_1, unsup_out_2,margin) # Step B\n loss = loss_unsup + loss_sup\n loss.backward()\n optimizer.step()\n\n # visualize\n if (iters % 10 == 0) and (vis != None) and (plot_data != None):\n plot_data['X'].append(iters)\n plot_data['Y'].append([\n loss_sup.item(),\n loss_unsup.item(),\n loss.item()\n ])\n vis.line(\n X=np.stack([np.array(plot_data['X'])] * len(plot_data['legend']), 1),\n Y=np.array(plot_data['Y']),\n opts={\n 'title': 'Loss over Time',\n 'legend': plot_data['legend'],\n 'xlabel': 'Iterations',\n 'ylabel': 'Loss',\n 'width': 1200,\n 'height': 390,\n },\n win=2\n )\n \"\"\"\n path_dir='/'.join(unsup_path.split('/')[:-1])\n if not os.path.exists(path_dir):\n os.makedirs(path_dir)\n torch.save(model.state_dict(),'{}'.format(unsup_path))\n print('Model saved.')\n \"\"\"\n # Validate\n model.eval()\n labels = torch.zeros((0, )).cuda() # initialize\n discs = torch.zeros((0, )).cuda() \n with torch.no_grad():\n for i, (input, label,cls) in enumerate(dataloaders['unsup_val']):\n inputs = input.cuda()\n label = label.cuda()\n\n out_1, out_2 = model(inputs)\n score_1 = F.softmax(out_1, dim=1)\n score_2 = F.softmax(out_2, dim=1)\n disc = torch.sum(torch.abs(score_1 - score_2), dim=1).reshape((label.shape[0], ))\n\n discs=torch.cat((discs,disc))\n label=label.reshape((label.shape[0], )).float()\n labels=torch.cat((labels,label))\n\n #labels = 1 - labels\n\n labels = labels.cpu()\n discs = discs.cpu()\n roc = evaluate(labels, discs, metric='roc',save_to='./pic.png')\n print('Epoch{} AUROC: {:.3f}'.format(epoch, roc))\n if best_roc < roc:\n best_roc = roc\n path_dir='/'.join(unsup_path.split('/')[:-1])\n if not os.path.exists(path_dir):\n os.makedirs(path_dir)\n torch.save(model.state_dict(),'{}'.format(unsup_path))\n print('Model saved.')\n print('>> Finished.')","def train(epoch, net, device, train_data, optimizer, batches_per_epoch, vis=False):\n results = {\n 'loss': 0,\n 'losses': {\n }\n }\n\n net.train()\n\n batch_idx = 0\n # Use batches per epoch to make training on different sized datasets (cornell/jacquard) more equivalent.\n while batch_idx < batches_per_epoch:\n for x, y, _, _, _ in train_data:\n batch_idx += 1\n if batch_idx >= batches_per_epoch:\n break\n\n xc = x.to(device)\n yc = [yy.to(device) for yy in y]\n lossd = net.compute_loss(xc, yc)\n\n loss = lossd['loss']\n\n if batch_idx % 100 == 0:\n logout('Epoch: {}, Batch: {}, Loss: {:0.4f}'.format(epoch, batch_idx, loss.item()))\n\n results['loss'] += loss.item()\n for ln, l in lossd['losses'].items():\n if ln not in results['losses']:\n results['losses'][ln] = 0\n results['losses'][ln] += l.item()\n\n optimizer.zero_grad()\n loss.backward()\n optimizer.step()\n\n # Display the images\n if vis:\n imgs = []\n n_img = min(4, x.shape[0])\n for idx in range(n_img):\n imgs.extend([x[idx,].numpy().squeeze()] + [yi[idx,].numpy().squeeze() for yi in y] + [\n x[idx,].numpy().squeeze()] + [pc[idx,].detach().cpu().numpy().squeeze() for pc in lossd['pred'].values()])\n gridshow('Display', imgs,\n [(xc.min().item(), xc.max().item()), (0.0, 1.0), (0.0, 1.0), (-1.0, 1.0), (0.0, 1.0)] * 2 * n_img,\n [cv2.COLORMAP_BONE] * 10 * n_img, 10)\n cv2.waitKey(2)\n\n results['loss'] /= batch_idx\n for l in results['losses']:\n results['losses'][l] /= batch_idx\n\n return results","def to_neptune(self, **kwargs) -> 'PlotLosses':\n self.outputs.append(outputs.NeptuneLogger(**kwargs))\n return self","def run_experiments():\n nets = []\n nets.extend(shallow(n=1))\n nets.extend(basic_conv(n=1))\n nets.extend(omit_FC(n=1))\n nets.extend(dbl_conv(n=1, activation_fn=sigmoid))\n # omitted, but still interesting: regularized_dbl_conv()\n nets.extend(dbl_conv_relu(n=1))\n nets.extend(expanded_data(n=1, FC_n=100))\n nets.extend(expanded_data(n=1, FC_n=300))\n nets.extend(expanded_data(n=1, FC_n=1000))\n nets.extend(expanded_data_double_fc(n=1, FC_n=100)) \n nets.extend(expanded_data_double_fc(n=1, FC_n=300))\n nets.extend(expanded_data_double_fc(n=1, FC_n=1000))\n nets.extend(double_fc_dropout(0.5, 0.5, 0.5, n=5))\n # plot the erroneous digits in the ensemble of nets just trained\n error_locations, erroneous_predictions = ensemble(nets)\n plt = plot_errors(error_locations, erroneous_predictions)\n plt.savefig(\"ensemble_errors.png\")\n # plot the filters learned by the first of the nets just trained\n plt = plot_filters(nets[0], 0, 5, 4)\n plt.savefig(\"net_full_layer_0.png\")\n plt = plot_filters(nets[0], 1, 8, 5)\n plt.savefig(\"net_full_layer_1.png\")","def visualize(self):\n\n self.check_model()\n show(prepare(self.model, self.vectorized_data, self.vectorizer, mds='tsne'))","def trainSN(options, epoch, device):\n \"\"\"-------------------------------CONFIG----------------------------------\"\"\"\n parser = argparse.ArgumentParser(description=\"PyTorch Regression GAN\")\n parser = general_parser(parser)\n opt = specific_parser(\n parser=parser, run_folder=options.log_dir, mode='train', tot_epochs=30, pretrained_GAN=options.checkpoint_dir,\n GAN_epoch=epoch, acc_log_freq=options.acc_log_freq, loss_log_freq=options.loss_log_freq,\n batch_size_SN=options.batch_size_SN, images_log_freq=options.images_log_freq,\n data_dir_train=options.data_dir_train2, data_dir_test=options.data_dir_test2,\n experiment_name='SN'+str(epoch), sar_c=options.sar_c, optical_c=options.optical_c,\n save_model_freq=1000, res_block_N=options.res_block_N)\n\n opt = config_routine(opt)\n\n \"\"\"-----------------------------DATA LOADER--------------------------------\"\"\"\n train_dataset = EUSARDataset(os.path.join(options.data_dir_train2), True, False, options.sar_c, options.optical_c)\n train_dataset = get_subset(train_dataset, options.prc_test)\n train_dataset = DataLoader(train_dataset, batch_size=options.batch_size_SN, shuffle=True,\n num_workers=options.workers, pin_memory=True, drop_last=False)\n\n test_dataset = EUSARDataset(os.path.join(options.data_dir_test2), True, False, options.sar_c, options.optical_c)\n test_dataset = get_subset(test_dataset, options.prc_test, True)\n test_dataset = DataLoader(test_dataset, batch_size=options.batch_size_SN, shuffle=False,\n num_workers=options.workers, pin_memory=True, drop_last=False)\n\n \"\"\"--------------------------------TRAIN-----------------------------------\"\"\"\n # Init model\n model = SN(opt, device)\n\n # set up tensorboard logging\n writer = SummaryWriter(log_dir=os.path.join(opt.tb_dir))\n # Model Training\n model.train(train_dataset, test_dataset, writer)","def UNet(input_size=(256, 256, 1)):\n inputs = Input(input_size)\n c1 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(inputs)\n c1 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c1)\n p1 = MaxPooling2D((2, 2))(c1)\n\n c2 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(p1)\n c2 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c2)\n p2 = MaxPooling2D((2, 2))(c2)\n\n c3 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(p2)\n c3 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c3)\n p3 = MaxPooling2D((2, 2))(c3)\n\n c4 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(p3)\n c4 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c4)\n p4 = MaxPooling2D(pool_size=(2, 2))(c4)\n\n c5 = Conv2D(256, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(p4)\n c5 = Conv2D(256, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c5)\n\n u6 = Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same')(c5)\n u6 = concatenate([u6, c4])\n c6 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(u6)\n c6 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c6)\n\n u7 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same')(c6)\n u7 = concatenate([u7, c3])\n c7 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(u7)\n c7 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c7)\n\n u8 = Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same')(c7)\n u8 = concatenate([u8, c2])\n c8 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(u8)\n c8 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c8)\n\n u9 = Conv2DTranspose(16, (2, 2), strides=(2, 2), padding='same')(c8)\n u9 = concatenate([u9, c1], axis=3)\n c9 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(u9)\n c9 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c9)\n\n outputs = Conv2D(1, (1, 1), activation='sigmoid')(c9)\n model = Model(inputs=[inputs], outputs=[outputs])\n model.compile(optimizer=Adam(lr=1e-4), loss=dice_coef_loss, metrics=['accuracy', dice_coef])\n return model","def main():\n\n # first figure: betas for each predictor\n fig, axes = plt.subplots(figsize=(8, 18), nrows=3)\n\n image_paths = {\n \"3T\": (\n f\"{PATHS['figures_misc']}/figure_3_images/\"\n f\"C1051_20161006_childVSall_depth_1.png\"\n ),\n \"7T\": (\n f\"{PATHS['figures_misc']}/figure_3_images/\"\n f\"C1051_20160212_childVSall_depth_1_sim2pt4.png\"\n ),\n \"7T_noise\": (\n f\"{PATHS['figures_misc']}/figure_3_images/\"\n f\"C1051_20160212_childVSall_depth_1_sim2pt4_noise.png\"\n ),\n }\n\n for ax, (_, image_path) in zip(axes, image_paths.items()):\n assert os.path.isfile(image_path)\n img = imread(image_path)\n img[np.where(np.sum(img, axis=2) == 0.0)] = 1.0\n\n ax.imshow(img[200:-100, 50:-50, :])\n ax.axis(\"off\")\n\n savefig(f\"{PATHS['figures']}/figure_3ac.png\")\n plt.close(fig)","def setUp(self):\n # The short NSC used in this example\n self.net_nsc = [\n (1, 4, 0, 0, 0), # Layer 1: Identity(input)\n (2, 1, 3, 1, 0), # Layer 2: Convolution(Layer1)\n (3, 1, 3, 2, 0), # Layer 3: Convolution(Layer2)\n (4, 5, 0, 1, 3), # Layer 4: Convolution(Layer1)\n (5, 7, 0, 0, 0), # Layer 5: Convolution(Layer4)\n ]","def train(epochs, batch_size, lr, verbose):\n # autograd globally off\n torch.set_grad_enabled(False)\n # generate training and testing datasets\n train_data, train_label = generate_data()\n test_data, test_label = generate_data()\n # normalize data be centered at 0\n train_data, test_data = normalize(train_data, test_data)\n\n if verbose:\n print(\"--- Dataset ---\")\n print(\"Train X: \", train_data.size(), \" | Train y: \", train_label.size())\n print(\" Test X: \", test_data.size(), \" | Test y: \", test_label.size())\n\n layers =[]\n # input layer (2 input units)\n linear1 = Linear(2, 25, bias= True, weight_init=xavier_uniform)\n\n # 3 hidden layers (each 25 units)\n linear2 = Linear(25, 25, bias= True, weight_init=xavier_uniform)\n linear3 = Linear(25, 25, bias= True, weight_init=xavier_uniform)\n linear4 = Linear(25, 25, bias= True, weight_init=xavier_uniform)\n\n # output layer (2 output units)\n linear5 = Linear(25, 2, bias= True, weight_init=xavier_uniform)\n\n\n layers.append(linear1)\n layers.append(Relu())\n layers.append(linear2)\n layers.append(Relu())\n layers.append(linear3)\n layers.append(Relu())\n layers.append(linear4)\n layers.append(Tanh())\n layers.append(linear5)\n\n model = Sequential(layers)\n if verbose: print(\"Number of model parameters: {}\".format(sum([len(p) for p in model.param()])))\n\n criterion = MSE()\n optimizer = SGD(model, lr=lr)\n\n train_losses, test_losses = [], []\n train_accuracies, test_accuracies = [], []\n train_errors, test_errors = [], []\n\n if verbose: print(\"--- Training ---\")\n for epoch in range(1, epochs+1):\n if verbose:print(\"Epoch: {}\".format(epoch))\n\n # TRAINING\n for batch_idx in range(0, train_data.size(0), batch_size):\n # axis 0, start from batch_idx until batch_idx+batch_size\n output = model.forward(train_data.narrow(0, batch_idx, batch_size))\n\n # Calculate loss\n loss = criterion.forward(output, train_label.narrow(0, batch_idx, batch_size))\n train_losses.append(loss)\n if verbose: print(\"Train Loss: {:.2f}\".format(loss.item()))\n\n # put to zero weights and bias\n optimizer.zero_grad()\n\n ## Backpropagation\n # Calculate grad of loss\n loss_grad = criterion.backward()\n\n # Grad of the model\n model.backward(loss_grad)\n\n # Update parameters\n optimizer.step()\n\n train_prediction = model.forward(train_data)\n acc = accuracy(train_prediction, train_label)\n train_accuracies.append(acc)\n train_errors.append(1-acc)\n if verbose: print(\"Train Accuracy: {:.2f}\".format(acc.item()))\n\n # EVALUATION\n for batch_idx in range(0, test_data.size(0), batch_size):\n # axis 0, start from batch_idx until batch_idx+batch_size\n output = model.forward(test_data.narrow(0, batch_idx, batch_size))\n\n # Calculate loss\n loss = criterion.forward(output, test_label.narrow(0, batch_idx, batch_size))\n test_losses.append(loss)\n if verbose: print(\"Test Loss: {:.2f}\".format(loss.item()))\n\n test_prediction = model.forward(test_data)\n acc = accuracy(test_prediction, test_label)\n test_accuracies.append(acc) \n test_errors.append(1-acc)\n if verbose: print(\"Test Accuracy: {:.2f}\".format(acc.item()))\n\n return train_losses, test_losses, train_accuracies, test_accuracies, train_errors, test_errors","def setup_net(self):\n\t\tself.src_net = get_model(self.base_model, num_cls=self.num_cls, \\\n\t\t\t\t\t\t\t\t l2_normalize=self.l2_normalize, temperature=self.temperature)\n\t\tself.tgt_net = self.custom_copy(self.src_net, self.weight_sharing)\n\n\t\tinput_dim = self.num_cls\n\t\tself.discriminator = nn.Sequential(\n\t\t\t\tnn.Linear(input_dim, 500),\n\t\t\t\tnn.ReLU(),\n\t\t\t\tnn.Linear(500, 500),\n\t\t\t\tnn.ReLU(),\n\t\t\t\tnn.Linear(500, 2),\n\t\t\t\t)\n\n\t\tself.image_size = self.src_net.image_size\n\t\tself.num_channels = self.src_net.num_channels","def plot_run_lenet():\n strNames = ['Dropout','N image', 'Learning rate', 'Regul.']\n df = CNN.get_acc_run_lenet()\n df = df.dropna()\n \n fig = plt.figure(figsize=(16,12))\n for i, name in enumerate(strNames):\n df_sub = df.drop_duplicates([name])\n df_sub = df_sub.sort_values(by=name)\n CNN.subplot_run_lenet(df_sub, name, subplotids=[2,2,i+1])","def torch_NN(nn_in, \n nn_out, \n min_ar, \n max_ar, \n er_tar,\n main_win: tk.Toplevel, \n min_n=0, \n max_n=0, \n n_epochs=200, \n conf=[1,1,1], \n funs=[tr.nn.Sigmoid(), 0], \n lr=0.001, \n sect_ner=False, \n train_test=False, \n retrain=False, \n spl_coef=0.1,\n root_width=200, \n root_height=200, \n root_x=50, \n root_y=50):\n tr.manual_seed(42)\n in_orig=tr.from_numpy(np.array(nn_in.copy())).float()\n out_orig=tr.from_numpy(np.array(nn_out.copy())).float()\n if train_test or retrain:\n nn_in=tr.from_numpy(np.array(nn_in)).float()\n nn_out=tr.from_numpy(np.array(nn_out)).float()\n dataset = tr.utils.data.TensorDataset(nn_in, nn_out)\n a=int(len(dataset)*(1-spl_coef))\n data_trn, data_test=tr.utils.data.random_split(dataset, [a,int(len(dataset)-a)],generator=tr.Generator().manual_seed(42))\n dataloader = tr.utils.data.DataLoader(data_trn, shuffle=False, batch_size=len(data_trn))\n else:\n nn_in=tr.from_numpy(np.array(nn_in)).float()\n nn_out=tr.from_numpy(np.array(nn_out)).float()\n dataset = tr.utils.data.TensorDataset(nn_in, nn_out)\n dataloader = tr.utils.data.DataLoader(dataset, shuffle=False, batch_size=len(dataset))\n data_test = 0\n if sect_ner:\n for i in range(len(conf)-2):\n conf[i+1] = min_n\n for i in range(1, len(conf)-1):\n min_loss=200000\n b=conf[i]\n for j in range(min_n, max_n+1):\n conf[i]=j\n nn_obj = Net_tr(conf, funs)\n nn_obj.alph_bet(in_orig,out_orig, min_ar, max_ar)\n optimizer = tr.optim.Adam(nn_obj.parameters(), lr=lr)\n y_pred = nn_obj.forward(nn_in)\n loss_val = loss(y_pred, nn_out, nn_obj)\n a=loss_val.item()\n print(\"Current configuration:\", conf, \";\\t Loss:\", a, \"%\")\n loss_val.backward()\n optimizer.step()\n if a<min_loss:\n min_loss=a\n b=j\n conf[i]=b\n neurons_number_info(conf, root_height + root_y, root_x)\n print(\"Best configuration:\", conf)\n nn_obj = Net_tr(conf, funs)\n optimizer = tr.optim.Adam(nn_obj.parameters(), lr=lr)\n nn_obj.alph_bet(in_orig,out_orig, min_ar, max_ar)\n loss_test=[]\n loss_tr=[]\n epochs_sum = 0\n train = True\n lin_tr = None\n can_tr = None\n lin_test = None \n can_test = None\n vert_coef = None\n hor_coef = None\n while train == True:\n nn_obj, vert_coef, hor_coef, epochs_sum, err, lin_tr, can_tr, lin_test, can_test = train_body_torch(nn_obj, dataloader, data_test, n_epochs, epochs_sum, optimizer, loss_tr, loss_test, er_tar, train_test, retrain, root_width, root_height, root_x, root_y, lin_tr, can_tr, lin_test, can_test, vert_coef, hor_coef)\n train_win = Continue_Train(err, epochs_sum)\n main_win.wait_window(train_win)\n train = train_win.answer\n if not train_win.answer:\n return nn_obj, conf, vert_coef, hor_coef\n #train = False\n nn_obj.eval()\n return nn_obj, conf, vert_coef, hor_coef","def train(self):\n self.mode = \"train\"\n self.online_net.train()","def train(self):\n self.mode = \"train\"\n self.online_net.train()","def train():\n pass","def visualize_training(features, labels, pl):\n print(\"Visualizing training\")\n fig = plt.figure()\n ax = fig.add_subplot(111)\n\n # Take out each feature type, one at a time\n label_map = get_label_map(labels)\n\n for key in label_map.keys():\n like_ind = label_map[key]\n like_data = np.array([features[i] for i in like_ind])\n\n plt.scatter(like_data[:,0],like_data[:,1],label=key)\n\n # get limits\n xmin = features.column_min(0) - .5\n xmax = features.column_max(0) + .5\n ymin = features.column_min(1) - .5\n ymax = features.column_max(1) + .5\n\n plt.xlim(xmin,xmax)\n plt.ylim(ymin,ymax)\n\n # Track the current dividing line, as well as the number of epochs passed\n divider, = plt.plot([],[])\n epoch_tracker = plt.text(-1,.9, '', fontsize=15)\n\n def update(i):\n \"\"\"\n 1.) Get the next set of weights from the tracker\n 2.) Calculate and draw the new divider line\n 3.) Update the epoch counter\n 4.) If we are at the end of an epoch, plot a dashed divider line to track progress\n \"\"\"\n epoch = i//features.instance_count\n w = pl.weights_tracker[i]\n a = pl.accuracy_tracker[epoch]\n divider.set_data([xmin,xmax],[(-xmin * w[0] - w[2]) / w[1], (-xmax * w[0] - w[2]) / w[1]])\n epoch_tracker.set_text(\"{} {}\".format(epoch + 1, a))\n\n # Keep a shadow of the hyperplane at the end of each epoch\n if i % features.instance_count == 0:\n plot_hyperplane(w,xmin,xmax,iter = i, alpha = .3, color='black',linestyle='dashed')\n\n return divider\n\n ani = animation.FuncAnimation(fig, update, frames=range(len(pl.weights_tracker)), interval=250,repeat=False)\n plt.legend()\n\n # optional save file\n if len(sys.argv) >= 3 :\n ani.save(sys.argv[2], writer='imagemagick', fps=5)\n\n plt.show()","def train(self):\n self.ae_train(self.net0, self.ae0_optimizer, self.train0_loader, self.val_loader, name='Net0')\n self.ae_train(self.net1, self.ae1_optimizer, self.train1_loader, self.val_loader, name='Net1')\n self.ae_train(self.net2, self.ae2_optimizer, self.train2_loader, self.val_loader, name='Net2')\n\n self.classifier_train(self.net0, self.optimizer0, self.train0_loader, self.val_loader, name='Net0')\n self.classifier_train(self.net1, self.optimizer1, self.train1_loader, self.val_loader, name='Net1')\n self.classifier_train(self.net2, self.optimizer2, self.train2_loader, self.val_loader, name='Net2')","def run():\n cons_in, soln_in, disc = make_discriminator()\n target, loss, accuracy, optimiser = make_training_nodes(disc)\n training_set_sampler = make_sampler(cons_in, soln_in, target)\n test_set_sampler = make_sampler(cons_in, soln_in, target)\n\n disc.get_session().run(tf.global_variables_initializer())\n\n fit(\n disc.get_session(),\n optimiser,\n training_set_sampler,\n 250,\n 2000,\n 32,\n [(\"Loss\", loss), (\"Accuracy\", accuracy)],\n )\n\n print(\n \"Validation accuracy: {}\".format(\n disc.feed(accuracy, test_set_sampler.batch(1024))\n )\n )\n\n plot_surface(\n evaluate_surface(\n lambda x, y: Circles.solve([0, 0, 0.25], [x, y, 0.25]),\n (-1, 1, 0.08),\n (-1, 1, 0.08),\n ),\n x_label=\"Solution x\",\n y_label=\"Solution y\",\n z_label=\"p(satisfied | x, y)\",\n )\n\n plot_surface(\n evaluate_surface(\n lambda x, y: disc.feed(\n disc.output_node, {cons_in: [[0, 0, 0.25]], soln_in: [[x, y, 0.25]]}\n )[0],\n (-1, 1, 0.08),\n (-1, 1, 0.08),\n ),\n x_label=\"Solution x\",\n y_label=\"Solution y\",\n z_label=\"p(satisfied | x, y)\",\n )","def main():\n # Load and preprocess the data.\n ((x_train, y_train), (x_test, y_test)) = (\n preprocess_dataset(x, y) for (x, y) in datasets.mnist.load_data()\n )\n (_, n_classes) = y_train.shape\n\n # Create and fit the original model.\n model = create_model(\n LAYER_SIZES,\n n_classes,\n layer_fn=functools.partial(layers.Dense, use_bias=False),\n layer_kwargs_fn=dense_kwargs,\n )\n model.fit(x_train, y_train, batch_size=BATCH_SIZE, epochs=N_EPOCHS)\n\n # Evaluate the pruning methods.\n pruning_methods = [(\"weight\", prune_weights), (\"neuron\", prune_neurons)]\n for (method_name, pruning_fn) in pruning_methods:\n # Compute the evaluation curves.\n (accuracy_curve, time_curve) = zip(\n *[\n evaluate_fraction(pruning_fn, model, (x_test, y_test), fraction)\n for fraction in PRUNING_FRACTIONS\n ]\n )\n # Plot them.\n for (subplot, curve) in [(211, accuracy_curve), (212, time_curve)]:\n plt.subplot(subplot)\n plt.plot(PRUNING_FRACTIONS, curve, label=method_name)\n\n if method_name == \"neuron\":\n # The first evaluated model in neuron pruning is the unpruned\n # one. Use it as a baseline.\n (baseline, *_) = curve\n plt.plot((0, 1), (baseline, baseline), \"--\", label=\"unpruned\")\n\n # Add some labels to the plots.\n for (subplot, y_label) in [(211, \"accuracy\"), (212, \"inference time\")]:\n plt.subplot(subplot)\n plt.xlabel(\"pruning fraction\")\n plt.ylabel(y_label)\n plt.legend()\n plt.show()","def testNonLinearity():\n vis = VISinformation()\n data = np.linspace(1, vis['fullwellcapacity'], 10000)\n nonlin = CCDnonLinearityModel(data.copy())\n\n txt = '%s' % datetime.datetime.isoformat(datetime.datetime.now())\n\n fig = plt.figure(frameon=False)\n\n left, width = 0.1, 0.8\n rect1 = [left, 0.3, width, 0.65]\n rect2 = [left, 0.1, width, 0.2]\n\n ax1 = fig.add_axes(rect1, title='VIS Non-linearity Model')\n ax2 = fig.add_axes(rect2) #left, bottom, width, height\n\n ax1.axhline(y=0, c='k', ls='--')\n ax1.plot(data, (nonlin/data - 1.)*100, 'r-', label='Model')\n\n ax2.axhline(y=0, c='k', ls='--')\n ax2.plot(data, (nonlin - data)/vis['gain'], 'g-')\n\n ax1.axvline(x=97, c='k', ls='--')\n ax2.axvline(x=97, c='k', ls='--')\n\n ax1.set_xticklabels([])\n ax2.set_xlabel('Real Charge [electrons]')\n ax1.set_ylabel('(Output / Real - 1)*100')\n ax2.set_ylabel('O - R [ADUs]')\n\n ax1.set_xlim(0, vis['fullwellcapacity'])\n ax2.set_xlim(0, vis['fullwellcapacity'])\n ax1.set_ylim(-.15, .2)\n\n ax1.text(0.83, 1.12, txt, ha='left', va='top', fontsize=9, transform=ax1.transAxes, alpha=0.2)\n ax1.legend(shadow=True, fancybox=True, numpoints=1, scatterpoints=1, markerscale=1.0)\n plt.savefig('NonlinearityModel.pdf')\n\n ax1.set_ylim(-.1, 8)\n ax2.set_ylim(0, 2)\n ax1.set_xlim(50, 800)\n ax2.set_xlim(50, 800)\n plt.savefig('NonlinearityModel2.pdf')\n\n plt.close()","def main(): # pylint: disable=R0914, R0915\n args = parse_args()\n\n # load dataset\n test_dataset = load_dataset(dataset_name=args.dataset, dataset_part='test')\n\n # load model\n model_name = args.model\n model = load_model(model_name)\n model.load_state_dict(torch.load(args.checkpoint_path)['model'])\n model.eval()\n\n # create sets of samples of images and their corresponding saliency maps\n all_samples = []\n all_saliency_maps = []\n sample_to_image = lambda x: np.transpose(x, (1, 2, 0))\n\n for _ in range(6):\n samples, true_labels = next(iter(DataLoader(test_dataset,\n batch_size=6,\n shuffle=True)))\n all_samples.append(torch.cat([sample_to_image(s).unsqueeze(0)\n for s in samples]))\n saliency_maps = compute_gradient_saliency_maps(samples.to(device),\n true_labels.to(device),\n model)\n all_saliency_maps.append(saliency_maps.cpu().detach())\n\n all_samples = torch.cat(all_samples)\n all_saliency_maps = torch.cat(all_saliency_maps)\n\n saliency_maps_and_images_pairs = plt.figure()\n plt.suptitle('Images and their saliency maps')\n for idx, (image, saliency_map) in enumerate(zip(all_samples,\n all_saliency_maps)):\n plt.subplot(6, 6 * 2, 2 * idx + 1)\n # plot image\n image -= image.min()\n image /= image.max()\n plt.imshow(image)\n plt.xticks([])\n plt.yticks([])\n # plot saliency map\n plt.subplot(6, 6 * 2, 2 * idx + 2)\n saliency_map -= saliency_map.min()\n saliency_map /= saliency_map.max()\n plt.imshow(saliency_map)\n plt.xticks([])\n plt.yticks([])\n\n saliency_maps_and_images_pairs.set_size_inches((8, 8))\n saliency_maps_and_images_pairs.savefig(\n os.path.join(FIGURES_DIR,\n f'{args.dataset}_{args.model}_'\n f'saliency_maps_and_images_pairs.png'))\n\n # loop through the images in the test set and compute saliency map for\n # each image. Compute the average map of all real face image and\n # all fake face image images.\n dataloader = DataLoader(test_dataset, batch_size=32, shuffle=True)\n real_images_saliency_maps = []\n fake_images_saliency_maps = []\n\n for samples, true_labels in dataloader:\n fake_samples = samples[true_labels == 1].to(device)\n fake_labels = true_labels[true_labels == 1].to(device)\n real_samples = samples[true_labels == 0].to(device)\n real_labels = true_labels[true_labels == 0].to(device)\n saliency_maps = compute_gradient_saliency_maps(fake_samples,\n fake_labels,\n model)\n fake_images_saliency_maps.append(saliency_maps.cpu().detach())\n saliency_maps = compute_gradient_saliency_maps(real_samples,\n real_labels,\n model)\n real_images_saliency_maps.append(saliency_maps.cpu().detach())\n\n all_real_saliency_maps = torch.cat(real_images_saliency_maps)\n all_fake_saliency_maps = torch.cat(fake_images_saliency_maps)\n\n for idx in range(all_real_saliency_maps.shape[0]):\n all_real_saliency_maps[idx] -= all_real_saliency_maps[idx].min()\n all_real_saliency_maps[idx] /= all_real_saliency_maps[idx].max()\n\n for idx in range(all_fake_saliency_maps.shape[0]):\n all_fake_saliency_maps[idx] -= all_fake_saliency_maps[idx].min()\n all_fake_saliency_maps[idx] /= all_fake_saliency_maps[idx].max()\n\n mean_saliency_maps = plt.figure()\n plt.subplot(1, 2, 1)\n mean_map = all_fake_saliency_maps.mean(axis=0)\n mean_map -= mean_map.min()\n mean_map /= mean_map.max()\n plt.imshow(mean_map)\n plt.title('mean of fake images saliency maps')\n plt.subplot(1, 2, 2)\n mean_map = all_real_saliency_maps.mean(axis=0)\n mean_map -= mean_map.min()\n mean_map /= mean_map.max()\n plt.imshow(mean_map)\n plt.title('mean of real images saliency maps')\n mean_saliency_maps.set_size_inches((8, 6))\n mean_saliency_maps.savefig(\n os.path.join(FIGURES_DIR,\n f'{args.dataset}_{args.model}_mean_saliency_maps.png'))","def visualize_network_samples(net,\n outputs_per_example=5,\n color_map=\"gray\",\n setsize=[1, 6],\n f_ext=\"pdf\"):\n n_examples = net.batch_size\n if net.name == \"cifar\":\n inputs, targets = generate_training_data(\n None,\n None,\n dataset=net.dataset,\n train_test=\"test\",\n conv=True,\n data_dir=net.trainingset_dir)[0:2]\n inputs, targets = net.get_batch(inputs, targets, None)[0:2]\n sig = True # For predicting decisions\n elif net.name == \"fruits\":\n inputs, recall_targets = net.generate_batch(\"test\")\n targets = inputs\n sig = True\n elif net.name == \"popout\":\n inputs, recall_targets = net.generate_training_data(n_examples)\n targets = inputs\n sig = False\n else:\n inputs = generate_training_data(\n n_examples,\n net.image_width,\n task_weights=net.task_weights,\n dataset=net.dataset,\n conv=net.layer_type == \"conv\",\n data_dir=net.trainingset_dir,\n setsize=setsize,\n mean=net.input_mean,\n std=net.input_std,\n dim=net.input_distribution_dim)[0]\n targets = inputs\n sig = False\n if net.image_channels > 1:\n shp = [net.image_width, net.image_width, net.image_channels]\n else:\n shp = [net.image_width, net.image_width]\n preds0, dec0 = zip(*[\n net.predict_both(\n inputs, np.zeros_like(inputs), sigmoid=sig, keep_session=True)\n for i in range(outputs_per_example)\n ])\n preds1 = np.array(preds0)\n preds2 = preds1.swapaxes(0, 1)\n preds = preds2.reshape([n_examples, outputs_per_example] + shp)\n preds = preds.clip(0, 1)\n # dec = np.array(dec0).swapaxes(0, 1)\n # print(\"decisions: \", dec)\n # print(dec)\n save_dir = make_memnet_checkpoint_dir(\n Path(\"plots/vis_memnet_samples/\"), net)\n if not save_dir.exists():\n save_dir.makedirs()\n print(\"Saving images to: \", save_dir)\n for i in range(n_examples):\n fig, axes = plt.subplots(\n nrows=1, ncols=outputs_per_example + 1, figsize=(45, 10))\n if net.RGB:\n axes[0].imshow(targets[i], cmap=color_map)\n else:\n axes[0].imshow(\n targets[i].reshape(net.image_width, net.image_width),\n cmap=color_map)\n [\n axes[j + 1].imshow(preds[i][j], cmap=color_map)\n for j in range(outputs_per_example)\n ]\n [ax.set_aspect('equal') for ax in axes]\n xlabs = [\"Target\"] + [\n \"Sample {}\".format(j) for j in range(1, outputs_per_example + 1)\n ]\n [ax.set_xlabel(l, size=50) for ax, l in zip(axes, xlabs)]\n for ax in axes:\n ax.set_xticks([])\n ax.set_xticklabels(\"\")\n ax.set_yticks([])\n ax.set_yticklabels(\"\")\n plt.tight_layout()\n plt.savefig(\n save_dir.joinpath('setsize_{}_sample{}.{}'.format(\n \"_\".join([str(x) for x in setsize]),\n str(i).zfill(2), f_ext)))","def train_one_epoch(self):\n print('Training......')\n\n # set mode train\n self.network.train()\n\n # prepare data\n train_loss = 0\n transform = transforms.Compose([Rescale(params.rescale_size),\n RandomCrop(params.image_size),\n RandomHorizontalFlip(),\n ToTensor()\n ])\n\n\n\n dataset = Cityscapes(params.dataset_root, mode='train', transforms = transform)\n\n train_loader = DataLoader(dataset,\n batch_size=params.train_batch,\n shuffle=params.shuffle,\n num_workers=params.dataloader_workers)\n \n train_size = 1896\n if train_size % self.params.train_batch != 0:\n total_batch = train_size // self.params.train_batch + 1\n else:\n total_batch = train_size // self.params.train_batch\n recal = 0\n precision = 0\n F_one = 0\n IOU = 0\n accuracy_new = 0 \n # train through dataset\n for batch_idx, batch in enumerate(train_loader):\n self.pb.click(batch_idx, total_batch)\n image, label = batch['image'], batch['label']\n image_cuda, label_cuda = image.cuda(), label.cuda()\n\n # checkpoint split\n if self.params.should_split:\n image_cuda.requires_grad_()\n out = checkpoint_sequential(self.network, self.params.split, image_cuda)\n else:\n out = self.network(image_cuda)\n\n\n loss = self.loss_fn(out, label_cuda)\n \n #display_image(out, label_cuda)\n TP, FP, TN, FN = confusion(out, label_cuda)\n recal = recal+TP\n precision = precision+FP\n F_one = F_one + TN\n IOU = IOU+ FN \n accuracy_final = accuracy(out, label_cuda)\n accuracy_new = accuracy_new + accuracy_final\n\n # optimize\n self.opt.zero_grad()\n loss.backward()\n self.opt.step()\n\n # accumulate\n train_loss += loss.item()\n\n # record first loss\n if self.train_loss == []:\n self.train_loss.append(train_loss)\n self.summary_writer.add_scalar('loss/train_loss', train_loss, 0)\n \n print(\"\\t\")\n print(recal/total_batch, precision/ total_batch, F_one/ total_batch, IOU/ total_batch)\n print(accuracy_new/total_batch)\n \n self.pb.close()\n train_loss /= total_batch\n self.train_loss.append(train_loss)\n\n # add to summary\n self.summary_writer.add_scalar('loss/train_loss', train_loss, self.epoch)","def run_the_training(args, clus=None, expert=None):\n # load data\n cfg, lbl = util.get_label_cfg_by_args(args)\n uid = cfg['uniqueid']\n print('We are playing with %s' % uid)\n data = npload(cfg['file_path'], uid)\n data_feed = {'x': data[cfg['x_name']], 'y': data[cfg['y_name']]}\n dimx = data_feed['x'].shape[1]\n dimy = data_feed['y'].shape[1]\n\n # create gate and expert\n if clus is None:\n n_model = 5\n clus = GaoNet([dimx, 100, n_model])\n expert = Experts([[dimx, 60, dimy]] * n_model)\n # cuda it\n clus.cuda()\n expert.cuda()\n\n # set data loader\n xname, yname = 'x', 'y'\n factory = KeyFactory(data_feed, xname, yname, scalex=True, scaley=True)\n factory.shuffle(None)\n\n draw_clus_region(clus, data_feed['x'], factory)\n\n # create two sets\n trainsize = 0.8\n trainSet = SubFactory(factory, 0.0, trainsize)\n testSet = SubFactory(factory, trainsize, 1.0)\n batch_size = 32\n test_batch_size = -1\n trainLder = DataLoader(trainSet, batch_size=batch_size, shuffle=False)\n testLder = DataLoader(testSet, batch_size=test_batch_size, shuffle=False)\n\n # set up file output\n outname = 'gate_expert_model.pt'\n outdir = 'models/pen/gate_expert'\n if KLLOSS:\n outname = 'gate_expert_kldiv_model.pt'\n if args.warm:\n outname = outname.replace('.pt', '_warm.pt')\n\n # set optimizer\n lr = 1e-3\n opt_G = torch.optim.Adam(clus.parameters(), lr=lr)\n opt_E = torch.optim.Adam(expert.parameters(), lr=lr)\n\n # set other training stuff\n n_epoch = 500\n back_check_epoch = 8\n best_test_loss = np.inf\n best_test_loss_expert = np.inf\n best_test_epoch = 0\n\n def get_mean_error(g_y, exp_y, feedy):\n \"\"\"Calculate two loss\"\"\"\n error_traj = torch.mean((exp_y - feedy.expand_as(exp_y)) ** 2, dim=2).t()\n g = f.softmax(g_y)\n log_g = f.log_softmax(g_y)\n posterior = g * torch.exp(-0.5 * error_traj) # b by r probability, not scaled to 1\n traj_prob = torch.mean(-torch.log(torch.sum(posterior, dim=1)))\n if KLLOSS:\n posterior_scale = Variable((posterior / torch.sum(posterior, dim=1, keepdim=True)).data) # do not use gradient of it\n div_error = f.kl_div(log_g, posterior_scale)\n return traj_prob, div_error\n else:\n Og = torch.sum(exp_y * g.t().unsqueeze(2), dim=0)\n traj_error = f.smooth_l1_loss(Og, feedy)\n return traj_prob, traj_error\n\n # start training\n for epoch in range(n_epoch):\n sum_train_loss = 0\n sum_train_loss_prob = 0\n for idx, batch_data in enumerate(trainLder):\n feedy = Variable(batch_data[yname], requires_grad=False).cuda()\n feedx = Variable(batch_data[xname], requires_grad=False).cuda()\n # train experts\n opt_E.zero_grad()\n opt_G.zero_grad()\n exp_y = expert(feedx)\n g_y = clus(feedx)\n g = f.softmax(g_y) # this is prior\n log_g = f.log_softmax(g_y)\n error_traj = torch.mean((exp_y - feedy.expand_as(exp_y)) ** 2, dim=2).t()\n posterior = g * torch.exp(-0.5 * error_traj) # b by r probability, not scaled to 1\n posterior_scale = Variable((posterior / torch.sum(posterior, dim=1, keepdim=True)).data) # do not use gradient of it\n lossi = torch.mean(-torch.log(torch.sum(posterior, dim=1)))\n lossi.backward(retain_graph=True)\n sum_train_loss_prob += lossi.cpu().data.numpy() * feedx.size()[0]\n opt_E.step()\n # update h by regression error\n all_pred = exp_y\n if KLLOSS:\n error = f.kl_div(log_g, posterior_scale)\n else:\n Og_before = all_pred * g.t().unsqueeze(2)\n Og = torch.sum(Og_before, dim=0)\n error = f.smooth_l1_loss(Og, feedy)\n sum_train_loss += error.cpu().data.numpy() * feedx.size()[0]\n error.backward()\n opt_G.step()\n # val = clus.printWeights(3)\n mean_train_loss = sum_train_loss / trainLder.getNumData()\n mean_train_loss_prob = sum_train_loss_prob / trainLder.getNumData()\n\n # evaluate on test data\n sum_test_loss_gate = 0\n sum_test_loss_expert = 0\n n_test_data = testLder.getNumData()\n for idx, batch_data in enumerate(testLder):\n feedy = Variable(batch_data[yname], volatile=True).cuda()\n feedx = Variable(batch_data[xname], volatile=True).cuda()\n exp_y = expert(feedx)\n g_y = clus(feedx)\n traj_prob, div_error = get_mean_error(g_y, exp_y, feedy)\n sum_test_loss_gate += div_error.cpu().data.numpy() * feedx.size()[0]\n sum_test_loss_expert += traj_prob.cpu().data.numpy() * feedx.size()[0]\n mean_test_loss_gate = sum_test_loss_gate / n_test_data\n mean_test_loss_expert = sum_test_loss_expert / n_test_data\n print('epoch %d gate loss %f expert loss %f test gate loss %f expert loss %f' \\\n % (epoch, mean_train_loss, mean_train_loss_prob, mean_test_loss_gate, mean_test_loss_expert))\n if mean_test_loss_gate < best_test_loss:\n best_test_loss = mean_test_loss_gate\n best_test_epoch = epoch\n if mean_test_loss_expert < best_test_loss_expert:\n best_test_loss_expert = mean_test_loss_expert\n best_test_epoch = epoch\n if epoch > best_test_epoch + back_check_epoch:\n break\n print('Save model now')\n\n # draw region for classifier\n draw_clus_region(clus, data_feed['x'], factory)\n\n clus.cpu()\n expert.cpu()\n model = {'gate': clus, 'expert': expert, 'xScale': [trainLder.xmean, trainLder.xstd], 'yScale': [trainLder.ymean, trainLder.ystd]}\n if not os.path.exists(outdir):\n os.mkdir(outdir)\n torch.save(model, os.path.join(outdir, outname))","def train(self, uInputInfo):\n if self.node_sharing:\n ## train just one node,\n self.pipes[0][0].send((\"train\", uInputInfo))\n self.pipes[0][0].recv()\n \n else:\n ## start each node's training\n for i in range(len(self.nodes)):\n for j in range(len(self.nodes[i])):\n self.pipes[i][j].send((\"train\", uInputInfo))\n\n ## wait for the training to be finished\n for i in range(len(self.nodes)):\n for j in range(len(self.nodes[i])):\n self.pipes[i][j].recv()","def fit_unet(self):\n logger.info(f\"Training model with optimizer:{self.optimizer}\")\n logger.info(f\"Optimizer params: {self.optimizer_params}\")\n self.model.fit_generator(\n self.train_generator,\n steps_per_epoch=self.steps_per_epoch,\n validation_data=self.val_generator,\n validation_steps=self.validation_steps,\n epochs=self.epochs,\n callbacks=self.callbacks,\n verbose=1)","def get_unet():\n inputs = Input((img_rows, img_cols, 1))\n conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(inputs)\n conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv1)\n pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)\n\n conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(pool1)\n conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv2)\n pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)\n\n conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(pool2)\n conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv3)\n pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)\n\n conv4 = Conv2D(256, (3, 3), activation='relu', padding='same')(pool3)\n conv4 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv4)\n pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)\n\n conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(pool4)\n conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(conv5)\n\n up6 = concatenate([Conv2DTranspose(256, (2, 2), strides=(2, 2),\n padding='same')(conv5), conv4], axis=3)\n conv6 = Conv2D(256, (3, 3), activation='relu', padding='same')(up6)\n conv6 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv6)\n\n up7 = concatenate([Conv2DTranspose(128, (2, 2), strides=(2, 2),\n padding='same')(conv6), conv3], axis=3)\n conv7 = Conv2D(128, (3, 3), activation='relu', padding='same')(up7)\n conv7 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv7)\n\n up8 = concatenate([Conv2DTranspose(64, (2, 2), strides=(2, 2),\n padding='same')(conv7), conv2], axis=3)\n conv8 = Conv2D(64, (3, 3), activation='relu', padding='same')(up8)\n conv8 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv8)\n\n up9 = concatenate([Conv2DTranspose(32, (2, 2), strides=(2, 2),\n padding='same')(conv8), conv1], axis=3)\n conv9 = Conv2D(32, (3, 3), activation='relu', padding='same')(up9)\n conv9 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv9)\n\n conv10 = Conv2D(1, (1, 1), activation='sigmoid')(conv9)\n\n model = Model(inputs=[inputs], outputs=[conv10])\n\n model.compile(optimizer=Adam(lr=1e-4), loss=dice_coef_loss,\n metrics=[dice_coef])\n\n return model","def visualize(self, U, **kwargs):\n raise NotImplementedError","def train_conv_net(datasets,datasets_weights,\n U, U_Topical,\n img_w=300, \n filter_hs=[3,4,5],\n hidden_units=[100,2], \n dropout_rate=[0.5],\n shuffle_batch=True,\n n_epochs=25, \n batch_size=50, \n lr_decay = 0.95,\n conv_non_linear=\"relu\",\n use_valid_set=True,\n show_states=False,\n activations=[Iden],\n sqr_norm_lim=9,\n non_static=True): \n rng = np.random.RandomState(3435)\n img_h = len(datasets[0][0])-1 \n U_Topical.dtype = \"float32\"\n (num_topics,topic_dim) = U_Topical.shape\n word_w = img_w\n img_w = int(img_w + num_topics*topic_dim)\n filter_w = img_w \n feature_maps = hidden_units[0]\n filter_shapes = []\n pool_sizes = []\n for filter_h in filter_hs: \n filter_shapes.append((feature_maps, 1, filter_h, filter_w)) # 100 1 3 300\n pool_sizes.append((img_h-filter_h+1, img_w-filter_w+1)) # size of words samples one\n parameters = [(\"image shape\",img_h,img_w),(\"filter shape\",filter_shapes), (\"hidden_units\",hidden_units),\n (\"dropout\", dropout_rate), (\"batch_size\",batch_size),(\"non_static\", non_static),\n (\"learn_decay\",lr_decay), (\"conv_non_linear\", conv_non_linear), (\"non_static\", non_static)\n ,(\"sqr_norm_lim\",sqr_norm_lim),(\"shuffle_batch\",shuffle_batch)]\n #print parameters \n \n #define model architecture\n index = T.lscalar()\n x = T.matrix('x') \n y = T.ivector('y')\n x_topic = T.tensor3('x_topic')\n Words = theano.shared(value = U, name = \"Words\")\n Topics = theano.shared(value=U_Topical,name=\"Topics\")\n zero_vec_tensor = T.vector()\n zero_vec = np.zeros(word_w, dtype='float32')\n set_zero = theano.function([zero_vec_tensor], updates=[(Words, T.set_subtensor(Words[0,:], zero_vec_tensor))])\n layer0_input_words = Words[T.cast(x.flatten(),dtype=\"int32\")].reshape((x.shape[0],1,x.shape[1],Words.shape[1])) \n layer0_inputs_topics = []\n for i in range(num_topics):\n sin_topic = x_topic[:,:,i]\n Topic = Topics[i].reshape((1,Topics[i].shape[0]))\n weights = sin_topic.flatten()\n weights = weights.reshape((weights.shape[0],1))\n layer0_inputs_topics.append(T.dot(weights, Topic))\n layer0_input_topics = T.concatenate(layer0_inputs_topics,1)\n layer0_input_topics = layer0_input_topics.reshape((x_topic.shape[0],1,x_topic.shape[1],num_topics*topic_dim))\n layer0_input = T.concatenate([layer0_input_words,layer0_input_topics],3) \n conv_layers = []\n layer1_inputs = []\n for i in xrange(len(filter_hs)):\n filter_shape = filter_shapes[i]\n pool_size = pool_sizes[i]\n conv_layer = LeNetConvPoolLayer(rng, input=layer0_input,image_shape=(batch_size, 1, img_h, img_w),\n filter_shape=filter_shape, poolsize=pool_size, non_linear=conv_non_linear)\n layer1_input = conv_layer.output.flatten(2)\n conv_layers.append(conv_layer)\n layer1_inputs.append(layer1_input)\n layer1_input = T.concatenate(layer1_inputs,1)\n hidden_units[0] = feature_maps*len(filter_hs) \n classifier = MLPDropout(rng, input=layer1_input, layer_sizes=hidden_units, activations=activations, dropout_rates=dropout_rate)\n \n #define parameters of the model and update functions using adadelta\n params = classifier.params \n for conv_layer in conv_layers:\n params += conv_layer.params\n \n if non_static:\n #if word vectors are allowed to change, add them as model parameters\n params += [Words] #params are model parameters\n params += [Topics] #Topics embedding are adjusted\n cost = classifier.negative_log_likelihood(y) \n dropout_cost = classifier.dropout_negative_log_likelihood(y) \n grad_updates = sgd_updates_adadelta(params, dropout_cost, lr_decay, 1e-6, sqr_norm_lim)\n \n #shuffle dataset and assign to mini batches. if dataset size is not a multiple of mini batches, replicate \n #extra data (at random)\n np.random.seed(3435)\n if datasets[0].shape[0] % batch_size > 0:\n extra_data_num = batch_size - datasets[0].shape[0] % batch_size\n random_index = np.random.permutation(np.arange(datasets[0].shape[0])) \n random_index.astype('int32')\n train_set = datasets[0][random_index,:]\n train_set_weights = datasets_weights[0][random_index,:,:]\n extra_data = train_set[:extra_data_num]\n extra_data_weights = train_set_weights[:extra_data_num]\n new_data=np.append(datasets[0],extra_data,axis=0)\n new_data_weights = np.append(datasets_weights[0],extra_data_weights,axis = 0)\n else:\n new_data = datasets[0]\n new_data_weights = datasets_weights[0]\n random_index = np.random.permutation(np.arange(new_data.shape[0])) \n random_index.astype('int32')\n new_data = new_data[random_index]\n new_data_weights = new_data_weights[random_index]\n n_batches = new_data.shape[0]/batch_size\n n_train_batches = int(np.round(n_batches*0.9))\n \n test_set_x = np.asarray(datasets[1][:,:img_h] ,\"float32\")\n test_set_x_topic = np.asarray(datasets_weights[1][:,:img_h,:] ,\"float32\")\n test_set_y = np.asarray(datasets[1][:,-1],\"int32\")\n if use_valid_set:\n train_set = new_data[:n_train_batches*batch_size,:]\n train_set_weights = new_data_weights[:n_train_batches*batch_size,:,:]\n val_set = new_data[n_train_batches*batch_size:,:]\n val_set_weights = new_data_weights[n_train_batches*batch_size:,:,:] \n train_set_x, train_set_x_topic, train_set_y = shared_dataset((train_set[:,:img_h],train_set_weights,train_set[:,-1]))\n val_set_x, val_set_x_topic, val_set_y = shared_dataset((val_set[:,:img_h],val_set_weights,val_set[:,-1]))\n n_val_batches = n_batches - n_train_batches\n val_model = theano.function([index], classifier.errors(y),\n givens={\n x: val_set_x[index * batch_size: (index + 1) * batch_size],\n x_topic: val_set_x_topic[index * batch_size: (index + 1) * batch_size],\n y: val_set_y[index * batch_size: (index + 1) * batch_size]})\n else:\n train_set = new_data[:,:] \n train_set_x, train_set_x_topic, train_set_y = shared_dataset((train_set[:,:img_h],train_set_weights,train_set[:,-1])) \n \n #make theano functions to get train/val/test errors\n test_model = theano.function([index], classifier.errors(y),\n givens={\n x: train_set_x[index * batch_size: (index + 1) * batch_size],\n x_topic: train_set_x_topic[index * batch_size: (index + 1) * batch_size],\n y: train_set_y[index * batch_size: (index + 1) * batch_size]}) \n train_model = theano.function([index], cost, updates=grad_updates,\n givens={\n x: train_set_x[index*batch_size:(index+1)*batch_size],\n x_topic: train_set_x_topic[index * batch_size: (index + 1) * batch_size],\n y: train_set_y[index*batch_size:(index+1)*batch_size]}) \n test_pred_layers = []\n test_size = test_set_x.shape[0]\n \n \n\n test_layer0_input_words = Words[T.cast(x.flatten(),dtype=\"int32\")].reshape((test_size,1,img_h,Words.shape[1])) \n test_layer0_inputs_topics = []\n for i in range(num_topics):\n sin_topic = x_topic[:,:,i]\n Topic = Topics[i].reshape((1,Topics[i].shape[0]))\n weights = sin_topic.flatten()\n weights = weights.reshape((weights.shape[0],1))\n test_layer0_inputs_topics.append(T.dot(weights, Topic))\n test_layer0_input_topics = T.concatenate(test_layer0_inputs_topics,1)\n test_layer0_input_topics = test_layer0_input_topics.reshape((test_size,1,img_h,num_topics*topic_dim))\n test_layer0_input = T.concatenate([test_layer0_input_words,test_layer0_input_topics],3) \n\n\n\n for conv_layer in conv_layers:\n test_layer0_output = conv_layer.predict(test_layer0_input, test_size)\n test_pred_layers.append(test_layer0_output.flatten(2))\n test_layer1_input = T.concatenate(test_pred_layers, 1)\n test_y_pred = classifier.predict(test_layer1_input)\n\n test_error = T.mean(T.neq(test_y_pred, y))\n test_model_all = theano.function([x,x_topic,y], test_error) \n \n #start training over mini-batches\n print '... training'\n epoch = 0\n best_val_perf = 0\n val_perf = 0\n test_perf = 0 \n cost_epoch = 0 \n while (epoch < n_epochs): \n epoch = epoch + 1\n if shuffle_batch:\n for minibatch_index in np.random.permutation(range(n_train_batches)):\n cost_epoch = train_model(minibatch_index)\n set_zero(zero_vec)\n else:\n for minibatch_index in xrange(n_train_batches):\n cost_epoch = train_model(minibatch_index) \n set_zero(zero_vec)\n train_losses = [test_model(i) for i in xrange(n_train_batches)]\n train_perf = 1 - np.mean(train_losses)\n if use_valid_set:\n val_losses = [val_model(i) for i in xrange(n_val_batches)]\n val_perf = 1- np.mean(val_losses)\n\n if val_perf >= best_val_perf:\n params_conv = [] \n params_output = {}\n test_loss = test_model_all(test_set_x,test_set_x_topic, test_set_y) \n test_perf = 1- test_loss \n best_val_perf = val_perf \n for conv_layer in conv_layers:\n params_conv.append(conv_layer.get_params())\n params_output = classifier.get_params()\n word_vec = Words.get_value()\n Topic_vec = Topics.get_value()\n else :\n val_perf = 0 \n if show_states:\n print('epoch %i, train perf %f %%, val perf %f' % (epoch, train_perf * 100., val_perf*100.))\n \n if not use_valid_set:\n params_conv = [] \n params_output = {}\n test_loss = test_model_all(test_set_x,test_set_x_topic, test_set_y) \n test_perf = 1- test_loss \n \n for conv_layer in conv_layers:\n params_conv.append(conv_layer.get_params())\n params_output = classifier.get_params()\n word_vec = Words.get_value()\n Topic_vec = Topics.get_value() \n \n return test_perf, [params_conv, params_output, word_vec,Topic_vec]","def plotGraph(self, title = \"Multi Layer Perceptron (MLP)\"):\n graph, pos, colorMap = self.getGraph()\n\n fig = plt.figure()\n fig.canvas.set_window_title(\"Neural Network\")\n plt.plot()\n nx.draw_networkx_nodes(graph,pos, node_color = colorMap)\n nx.draw_networkx_edges(graph,pos)\n plt.axis('off')\n plt.title(title)\n #plt.savefig(\"autoencoder.svg\", transparent = True)\n plt.show()","def visualize_train(train_data_full, train_labels, train_data, thetas, losses, niter):\n fig1, ax1 = plt.subplots()\n ax1.scatter(train_data_full[\"Weight\"], train_data_full[\"Height\"], color = 'blue')\n\n # De-standarize\n train_mean = train_data_full[\"Weight\"].mean()\n train_std = train_data_full[\"Weight\"].std()\n train_data_for_plot = train_mean + train_data[\"Weight\"] * train_std\n\n ax1.plot(train_data_for_plot, predict(train_data, thetas[niter - 1]), color = 'red', linewidth = 2)\n ax1.set_xlabel(\"Height\")\n ax1.set_ylabel(\"Weight\")\n\n fig2, ax2 = plt.subplots()\n ax2.plot(range(len(losses)), losses, color = 'blue', linewidth = 2)\n ax2.set_xlabel(\"Iteration\")\n ax2.set_ylabel(\"MSE\")\n\n fig3, ax3 = plt.subplots()\n np_gradient_ws = np.array(thetas)\n\n w = np.linspace(min(np_gradient_ws[:, 0]), max(np_gradient_ws[:, 0]), len(np_gradient_ws[:, 0]))\n b = np.linspace(min(np_gradient_ws[:, 1]), max(np_gradient_ws[:, 1]), len(np_gradient_ws[:, 1]))\n x, y = np.meshgrid(w, b)\n z = compute_z_loss(train_labels, train_data, np.stack((w,b)).T)\n cp = ax3.contourf(x, y, z, cmap = plt.cm.jet)\n fig3.colorbar(cp, ax = ax3)\n ax3.plot(3.54794951, 66.63949115837143, color = 'red', marker = '*', markersize = 20)\n if niter > 0:\n thetas_to_plot = np_gradient_ws[:niter]\n ax3.plot(thetas_to_plot[:, 0], thetas_to_plot[:, 1], marker = 'o', color = 'w', markersize = 10)\n ax3.set_xlabel(r'$w$')\n ax3.set_ylabel(r'$b$')\n return fig1, fig2, fig3","def train():\n import trace\n trace.train()","def __init__(self, args):\n \n super(MicroNet, self).__init__()\n self.conv1 = nn.Conv2d(3, 1, kernel_size=1)\n self.conv2 = nn.Conv2d(1, 29, kernel_size=5)\n self.maxpool2 = nn.MaxPool2d(3, stride=2 , ceil_mode=True)\n self.conv3 = nn.Conv2d(29, 59, kernel_size=3)\n self.maxpool3 = nn.MaxPool2d(3, stride=2 , ceil_mode=True)\n self.conv4 = nn.Conv2d(59, 74, kernel_size=3)\n self.maxpool4 = nn.MaxPool2d(3, stride=2 , ceil_mode=True)\n self.conv2_drop = nn.Dropout2d()\n self.conv3_drop = nn.Dropout2d()\n self.fc1 = nn.Linear(1184, 300)\n self.fc2 = nn.Linear(300, args.num_classes)\n self.conv0_bn = nn.BatchNorm2d(3)\n self.conv1_bn = nn.BatchNorm2d(1)\n self.conv2_bn = nn.BatchNorm2d(29)\n self.conv3_bn = nn.BatchNorm2d(59)\n self.conv4_bn = nn.BatchNorm2d(74)\n self.dense1_bn = nn.BatchNorm1d(300)","def classify_lenet5(batch_size=500, output_size=20):\n\n rng = numpy.random.RandomState(23455)\n\n\n # start-snippet-1\n x = T.matrix('x') # the data is presented as rasterized images\n ######################\n # BUILD ACTUAL MODEL #\n ######################\n print '... building the model'\n\n # Reshape matrix of rasterized images of shape (batch_size, 28 * 28)\n # to a 4D tensor, compatible with our LeNetConvPoolLayer\n # (28, 28) is the size of MNIST images.\n layer0_input = x.reshape((batch_size, 1, 37, 23))\n\n # Construct the first convolutional pooling layer:\n # filtering reduces the image size to (28-5+1 , 28-5+1) = (24, 24)\n # maxpooling reduces this further to (24/2, 24/2) = (12, 12)\n # 4D output tensor is thus of shape (batch_size, nkerns[0], 12, 12)\n layer0 = LeNetConvPoolLayer(\n rng,\n input=layer0_input,\n image_shape=(batch_size, 1, 37, 23),\n filter_shape=(20, 1, 4, 2),\n poolsize=(2, 2),\n )\n\n # layer1 = LeNetConvPoolLayer(\n # rng,\n # input=layer0.output,\n # image_shape=(batch_size, 20, 17, 11),\n # filter_shape=(50, 20, 4, 2),\n # poolsize=(2, 2),\n # )\n #\n # layer4 = LeNetConvPoolLayer(\n # rng,\n # input=layer1.output,\n # image_shape=(batch_size, 50, 7, 5),\n # filter_shape=(100, 50, 4, 2),\n # poolsize=(2, 2),\n # )\n\n layer2_input = layer0.output.flatten(2)\n\n # construct a fully-connected sigmoidal layer\n layer2 = HiddenLayer(\n rng,\n input=layer2_input,\n n_in=3740,\n n_out=output_size,\n activation=T.tanh,\n use_bias=True\n )\n\n # layer5 = HiddenLayer(\n # rng,\n # input=layer2.output,\n # n_in=200,\n # n_out=output_size,\n # activation=T.tanh,\n # use_bias=True\n # )\n\n # classify the values of the fully-connected sigmoidal layer\n layer3 = LogisticRegression(input=layer2.output, n_in=output_size, n_out=2)\n\n model_params = pickle.load(open('../model/cnn_dist_'+str(output_size)+'.pkl'))\n #\n layer0.W = theano.shared(\n value=numpy.array(\n model_params[2].get_value(True),\n dtype=theano.config.floatX\n ),\n name='W',\n borrow=True\n )\n\n layer0.b = theano.shared(\n value=numpy.array(\n model_params[3].get_value(True),\n dtype=theano.config.floatX\n ),\n name='b',\n borrow=True\n )\n\n # layer1.W = theano.shared(\n # value=numpy.array(\n # model_params[-4].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='W',\n # borrow=True\n # )\n #\n # layer1.b = theano.shared(\n # value=numpy.array(\n # model_params[-3].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='b',\n # borrow=True\n # )\n #\n # layer4.W = theano.shared(\n # value=numpy.array(\n # model_params[-6].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='W',\n # borrow=True\n # )\n #\n # layer4.b = theano.shared(\n # value=numpy.array(\n # model_params[-5].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='b',\n # borrow=True\n # )\n\n layer2.W = theano.shared(\n value=numpy.array(\n model_params[0].get_value(True),\n dtype=theano.config.floatX\n ),\n name='W',\n borrow=True\n )\n\n layer2.b = theano.shared(\n value=numpy.array(\n model_params[1].get_value(True),\n dtype=theano.config.floatX\n ),\n name='b',\n borrow=True\n )\n\n # layer5.W = theano.shared(\n # value=numpy.array(\n # model_params[-10].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='W',\n # borrow=True\n # )\n #\n # layer5.b = theano.shared(\n # value=numpy.array(\n # model_params[-9].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='b',\n # borrow=True\n # )\n\n layer3.W = theano.shared(\n value=numpy.array(\n model_params[4].get_value(True),\n dtype=theano.config.floatX\n ),\n name='W',\n borrow=True\n )\n\n layer3.b = theano.shared(\n value=numpy.array(\n model_params[5].get_value(True),\n dtype=theano.config.floatX\n ),\n name='b',\n borrow=True\n )\n\n # params = layer3.params + layer5.params + layer2.params + layer4.params + layer1.params + layer0.params\n\n datasets = load_data(None)\n\n sets = ['train', 'dev', 'test']\n dimension = [20000, 20000, 20000]\n for k in range(3):\n if k == 0:\n classify_set_x, classify_set_y, classify_set_z, classify_set_m, classify_set_c, classify_set_b= datasets[k]\n else:\n classify_set_x, classify_set_y, classify_set_z= datasets[k]\n\n # compute number of minibatches for training, validation and testing\n n_classify_batches = classify_set_x.get_value(borrow=True).shape[0]\n n_classify_batches /= batch_size\n\n # allocate symbolic variables for the data\n index = T.lscalar() # index to a [mini]batch\n classify = theano.function(\n [index],\n layer2.output,\n givens={\n x: classify_set_x[index * batch_size: (index + 1) * batch_size],\n }\n )\n\n r = []\n\n for i in xrange(n_classify_batches):\n m = classify(i)\n r.extend(m)\n r = np.array(r)\n print r.shape\n r = np.append(r, np.reshape(classify_set_y.eval(),(dimension[k], 1)), 1)\n numpy.savetxt('../extractedInformation/cnn_dist_'+str(output_size)+'/'+sets[k]+'.csv', r, delimiter=\",\")","def __init__(self, opt):\n BaseModel.__init__(self, opt)\n # specify the training losses you want to print out. The training/test scripts will call <BaseModel.get_current_losses>\n self.loss_names = ['G_GAN', 'G_L1', 'D_real', 'D_fake']\n # specify the images you want to save/display. The training/test scripts will call <BaseModel.get_current_visuals>\n self.visual_names = ['real_A', 'fake_B', 'real_B']\n # specify the models you want to save to the disk. The training/test scripts will call <BaseModel.save_networks> and <BaseModel.load_networks>\n if self.isTrain:\n self.model_names = ['G', 'D']\n else: # during test time, only load G\n self.model_names = ['G']\n\n # Set TPN_enabled to true if opt.TPN is defined\n if opt.TPN:\n self.TPN_enabled = True\n else:\n self.TPN_enabled = False\n\n # Conditional GANs need to take both input and output images; Therefore, #channels for D is input_nc + output_nc\n discr_input_nc = opt.input_nc + opt.output_nc\n\n # If TPN is enabled, switch to the U-Net with TPN architecture\n if self.TPN_enabled:\n opt.netG = 'unet_256_TPN'\n discr_input_nc +=1 # Additional Channel for Time Input\n\n # define networks (both generator and discriminator)\n self.netG = networks.define_G(opt.input_nc, opt.output_nc, opt.ngf, opt.netG, opt.norm,\n not opt.no_dropout, opt.init_type, opt.init_gain, self.gpu_ids)\n\n if self.isTrain: # define a discriminator; \n self.netD = networks.define_D(discr_input_nc, opt.ndf, opt.netD,\n opt.n_layers_D, opt.norm, opt.init_type, opt.init_gain, self.gpu_ids)\n\n if self.TPN_enabled:\n self.loss_names = ['G_GAN', 'G_L1', 'G_TPN', 'D_real', 'D_fake']\n\n # Store final gamma value and then set it to 0\n self.final_gamma = deepcopy(opt.gamma)\n opt.gamma = 0\n\n # Initiliaze m and c to None\n self.update_m = None\n self.update_c = None\n\n # Setup TPN if set to True\n print(\"\\nSetting up TPN\\n\")\n opt_TPN = deepcopy(opt) # copy train options and change later\n opt_TPN.model = 'time_predictor'\n opt_TPN.name = opt.TPN\n opt_TPN.netD = 'time_input'\n opt_TPN.ndf = 16 # Change depending on the ndf size used with the TPN model specified\n # hard-code some parameters for TPN test phase\n opt_TPN.display_id = -1 # no visdom display;\n opt_TPN.isTrain = False\n print(\"Options TPN: {}\\n\\n\".format(opt_TPN))\n self.TPN = create_model(opt_TPN) # create a model given opt_TPN.model and other options\n self.TPN.setup(opt_TPN) # regular setup: load\n\n if self.isTrain:\n # define loss functions\n self.criterionGAN = networks.GANLoss(opt.gan_mode).to(self.device)\n self.criterionL1 = torch.nn.L1Loss()\n # initialize optimizers; schedulers will be automatically created by function <BaseModel.setup>.\n self.optimizer_G = torch.optim.Adam(self.netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))\n self.optimizer_D = torch.optim.Adam(self.netD.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))\n self.optimizers.append(self.optimizer_G)\n self.optimizers.append(self.optimizer_D)\n\n # Check if lambda_L2 is in range [0,1]\n assert (0 <= self.opt.lambda_L2 <= 1)","def train():\n\n ### DO NOT CHANGE SEEDS!\n # Set the random seeds for reproducibility\n np.random.seed(42)\n\n ## Prepare all functions\n # Get number of units in each hidden layer specified in the string such as 100,100\n if FLAGS.dnn_hidden_units:\n dnn_hidden_units = FLAGS.dnn_hidden_units.split(\",\")\n dnn_hidden_units = [int(dnn_hidden_unit_) for dnn_hidden_unit_ in dnn_hidden_units]\n else:\n dnn_hidden_units = []\n\n # Get negative slope parameter for LeakyReLU\n neg_slope = FLAGS.neg_slope\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n import matplotlib.pyplot as plt\n\n data = cifar10_utils.get_cifar10(FLAGS.data_dir)\n train = data['train']\n test = data['test']\n dim_x = train.images.shape[1]*train.images.shape[2]*train.images.shape[3]\n\n mlp = MLP(dim_x, dnn_hidden_units, train.labels.shape[1], neg_slope)\n loss_module = CrossEntropyModule()\n\n loss_train = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n loss_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n accuracy_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n\n images_test = test.images\n labels_test = test.labels\n images_test = np.reshape(images_test, (images_test.shape[0], dim_x))\n\n for i in range(0, FLAGS.max_steps):\n if PRINTS:\n print('iter', i+1, end='\\r')\n images, labels = train.next_batch(FLAGS.batch_size) \n images = np.reshape(images, (images.shape[0], dim_x))\n\n pred = mlp.forward(images)\n loss = loss_module.forward(pred, labels)\n loss_grad = loss_module.backward(pred, labels)\n mlp.backward(loss_grad)\n\n for module in reversed(mlp.modules):\n if isinstance(module, LinearModule):\n module.params['weight'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['weight']\n module.params['bias'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['bias']\n if (i+1) % FLAGS.eval_freq == 0:\n pred_test = mlp.forward(images_test)\n loss_train[i // FLAGS.eval_freq] = loss\n accuracy_test[i // FLAGS.eval_freq] = accuracy(pred_test, labels_test)\n loss_test[i // FLAGS.eval_freq] = loss_module.forward(pred_test, labels_test)\n if PRINTS:\n print()\n print('test_loss:', loss_test[i // FLAGS.eval_freq])\n print('test_accuracy:', accuracy_test[i // FLAGS.eval_freq])\n print('train_loss:', loss_train[i // FLAGS.eval_freq])\n\n if PLOTS:\n fig, ax = plt.subplots(1, 2, figsize=(10,5))\n fig.suptitle('Training curves for Numpy MLP\\nFinal test accuracy: {:0.4f}, default configuration'.format(accuracy_test[i // FLAGS.eval_freq]))\n\n ax[0].set_title('Loss')\n ax[0].set_ylabel('Loss value')\n ax[0].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\n ax[0].plot(loss_train, label='Train')\n ax[0].plot(loss_test, label='Test')\n ax[0].legend()\n\n ax[1].set_title('Accuracy')\n ax[1].set_ylabel('Accuracy value')\n ax[1].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\n ax[1].plot(accuracy_test, label='Test')\n ax[1].legend()\n plt.show()\n\n\n ########################\n # END OF YOUR CODE #\n #######################","def __init__(\n self,\n numpy_rng,\n train_set_x,\n train_set_y,\n hidden_layers_sizes,\n n_ins=784,\n n_outs=10\n ):\n\n self.sigmoid_layers = []\n self.AE_layers = []\n self.params = []\n self.n_layers = len(hidden_layers_sizes)\n self.train_set_x = train_set_x\n self.train_set_y = train_set_y\n\n assert self.n_layers > 0\n\n self.x = T.matrix('x') # the data is presented as rasterized images\n self.y = T.ivector('y') # the labels are presented as 1D vector of\n\n for i in xrange(self.n_layers): # used to be n layers\n\n # construct the sigmoid layer = encoder stack\n if i == 0:\n layer_input = self.x\n else:\n layer_input = self.sigmoid_layers[-1].output\n\n sigmoid_layer = HiddenLayer(rng=numpy_rng,\n input=layer_input,\n n_in=(n_ins if i == 0 else\n hidden_layers_sizes[i-1]),\n n_out=hidden_layers_sizes[i],\n activation=T.nnet.sigmoid)\n\n # add the layer to our list of layers\n self.sigmoid_layers.append(sigmoid_layer)\n self.params.extend(sigmoid_layer.params)\n\n # init the DA_layer, takes weights from sigmoid layer\n AE_layer = AutoEncoder(\n numpy_rng=numpy_rng,\n input=layer_input,\n n_visible=(n_ins if i == 0 else hidden_layers_sizes[i-1]),\n n_hidden=hidden_layers_sizes[i],\n W=sigmoid_layer.W,\n bhid=sigmoid_layer.b)\n\n self.AE_layers.append(AE_layer)\n\n # on top of the layers\n # log layer for fine-tuning\n self.logLayer = LogisticRegression(\n input=self.sigmoid_layers[-1].output,\n n_in=hidden_layers_sizes[-1],\n n_out=n_outs\n )\n self.params.extend(self.logLayer.params)\n self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)\n self.errors = self.logLayer.errors(self.y)","def _train(args): \n\n #device = 'cuda' if torch.cuda.is_available() else 'cpu'\n device = 'cpu'\n logger.info(\"Device Type: {}\".format(device))\n\n logger.info(\"Loading SUN360 dataset\")\n transform = transforms.Compose(\n [transforms.Resize((224,224)),\n transforms.ToTensor(),\n transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\n target_transform = transforms.Compose([transforms.Resize((224,224)),\n transforms.ToTensor()]) \n\n trainset = SUN360Dataset(\"imagedata.json\",transform = transform, target_transform = target_transform)\n train_loader = DataLoader(trainset, batch_size=args.batch_size,\n shuffle=True, num_workers=args.workers)\n \"\"\"\n testset = torchvision.datasets.CIFAR10(root=args.data_dir, train=False,\n download=False, transform=transform)\n test_loader = DataLoader(testset, batch_size=args.batch_size,\n shuffle=False, num_workers=args.workers)\n \"\"\" \n\n logger.info(\"Model loaded\")\n model = EfficientNet.from_name('efficientnet-b0',conv_type='Equi')\n\n if torch.cuda.device_count() > 1:\n logger.info(\"Gpu count: {}\".format(torch.cuda.device_count()))\n model = nn.DataParallel(model)\n\n model = model.to(device)\n\n criterion = CELoss().to(device)\n optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)\n\n for epoch in range(0, args.epochs):\n running_loss = 0.0\n for i, data in enumerate(train_loader):\n # get the inputs\n inputs, EM , CM = data\n inputs, EM, CM = inputs.to(device), EM.to(device), CM.to(device)\n\n # zero the parameter gradients\n optimizer.zero_grad()\n\n # forward + backward + optimize\n outputs = model(inputs)\n EMLoss, CMLoss = map_loss(outputs,EM,CM,criterion)\n loss = EMLoss + CMLoss\n loss.backward()\n optimizer.step()\n\n # print statistics\n running_loss += loss.item()\n if i % 2000 == 1999: # print every 2000 mini-batches\n print('[%d, %5d] loss: %.3f' %\n (epoch + 1, i + 1, running_loss / 2000))\n running_loss = 0.0\n print('Finished Training')\n return _save_model(model, args.model_dir)","def train_neural_network(x_train, train_labels, x_test, orig_test):\n train_features = np.array(x_train)\n test_features = np.array(x_test)\n train_labels = np.array(train_labels['Col2'])\n\n model = models.make_model(params=train_features,\n model_name='neural_network_1')\n\n checkpoint_cb, tensorboard_cb = models.callbacks(\n model_name='nn_submission03_s_1_m1_f_2165.ckpt')\n epochs = 6\n batch_size = 32\n\n history = model.fit(train_features,\n train_labels,\n batch_size=batch_size,\n epochs=epochs,\n callbacks=[checkpoint_cb, tensorboard_cb]\n # validation_data=(val_features, val_labels)\n )\n\n evaluation.evaluation(model, train_features, train_labels)\n evaluation.plot_metrices(epochs, history, if_val=False)\n evaluation.plot_confusion_matrix(model, train_features, train_labels)\n evaluation.submission_nn(model=model,\n test_features=test_features,\n orig_test_df=orig_test,\n submission_name='nn_submission03_s_1_m1_f_2165.csv')","def test():\n\n # load image and adjust its format\n if MEMORY_CACHE:\n test_input = dataset[0]['file']\n oriImg = test_input.byte().permute((1, 2, 0)).numpy() # B,G,R order\n else:\n oriImg = cv2.imread(dataset[0]['file']) # B,G,R order\n test_input = torch.from_numpy(oriImg).permute((2, 0, 1)).float()\n \n # transfer data on GPU on demand\n if CUDA:\n test_input = test_input.cuda()\n\n # perform prediction\n net.eval()\n with torch.no_grad():\n result = net(test_input.unsqueeze(0))[0]\n\n print(result)\n\n # draw rectangles and its class\n img = cv2.cvtColor(oriImg, cv2.COLOR_BGR2RGB)\n for box, label, score in zip(result['boxes'], result['labels'], result['scores']):\n # if score > 0.5:\n if label < len(orig_labels):\n img = cv2.rectangle(img, (box[0], box[1]), (box[2], box[3]), (0, 0, 255), 3)\n img = cv2.putText(img, '{}: {:.0%}'.format(orig_labels[label], score), (box[0] + 5, box[3] - 5), cv2.FONT_HERSHEY_SIMPLEX, .7, (0, 255, 0), 2, cv2.LINE_AA)\n plt.imshow(img)\n plt.axis('off')\n plt.show()","def train_step(self, image, cur_epoch):\n noise = np.random.normal(loc=0.0, scale=1.0, size=[self.batch_size, self.noise_dim])\n true_labels, generated_labels = self.generate_labels(\n self.config.trainer.soft_labels, self.config.trainer.flip_labels\n )\n # Train the discriminator\n real_noise, fake_noise = self.generate_noise(self.config.trainer.include_noise, cur_epoch)\n image_eval = self.sess.run(image)\n feed_dict = {\n self.model.image_tensor: image_eval,\n self.model.noise_tensor: noise,\n self.model.generated_labels: generated_labels,\n self.model.true_labels: true_labels,\n self.model.real_noise: real_noise,\n self.model.fake_noise: fake_noise,\n self.model.is_training: True,\n }\n _, _, _, ld, ldxz, ldxx, ldzz = self.sess.run(\n [\n self.model.train_dis_op_xz,\n self.model.train_dis_op_xx,\n self.model.train_dis_op_zz,\n self.model.loss_discriminator,\n self.model.dis_loss_xz,\n self.model.dis_loss_xx,\n self.model.dis_loss_zz,\n ],\n feed_dict=feed_dict,\n )\n # Train the Generator and Encoder\n noise = np.random.normal(loc=0.0, scale=1.0, size=[self.batch_size, self.noise_dim])\n true_labels, generated_labels = self.generate_labels(\n self.config.trainer.soft_labels, self.config.trainer.flip_labels\n )\n real_noise, fake_noise = self.generate_noise(self.config.trainer.include_noise, cur_epoch)\n feed_dict = {\n self.model.image_tensor: image_eval,\n self.model.noise_tensor: noise,\n self.model.generated_labels: generated_labels,\n self.model.true_labels: true_labels,\n self.model.real_noise: real_noise,\n self.model.fake_noise: fake_noise,\n self.model.is_training: True,\n }\n _, _, le, lg = self.sess.run(\n [\n self.model.train_gen_op,\n self.model.train_enc_op,\n self.model.loss_encoder,\n self.model.loss_generator,\n ],\n feed_dict=feed_dict,\n )\n\n if self.config.log.enable_summary:\n sm = self.sess.run(self.model.sum_op, feed_dict=feed_dict)\n else:\n sm = None\n\n return lg, le, ld, ldxz, ldxx, ldzz, sm","def main(tetrode_number=TETRODE_NUMBER,num_hidden_units=300,num_hidden_units_2=200,num_code_units=50):\n print(\"Loading the data...\")\n dataset = load_data(tetrode_number)\n print(\"Done!\")\n\n print(\"Tetrode number: {}, Num outputs: {}\".format(tetrode_number,dataset['output_dim']))\n\n print(dataset['input_shape'])\n print(dataset['output_dim'])\n \n print(\"Making the model...\")\n network = model(dataset['input_shape'],dataset['output_dim'],num_hidden_units,num_hidden_units_2,num_code_units,(4,1))\n print(\"Done!\")\n\n print(\"Setting up the training functions...\")\n training = funcs(dataset,network)\n print(\"Done!\")\n\n accuracies = []\n trainvalidation = []\n\n print(\"Begining to train the network...\")\n epochsDone = 0\n autoencoderSameLabels = []\n try:\n for i in range(NUM_EPOCHS):\n costs = []\n valid_costs = []\n\n for start, end in zip(range(0, dataset['num_examples_train'], BATCH_SIZE), range(BATCH_SIZE, dataset['num_examples_train'], BATCH_SIZE)):\n cost = training['train'](dataset['X_train'][start:end],dataset['y_train'][start:end])\n costs.append(cost)\n \n for start, end in zip(range(0, dataset['num_examples_valid'], BATCH_SIZE), range(BATCH_SIZE, dataset['num_examples_valid'], BATCH_SIZE)):\n cost = training['valid'](dataset['X_valid'][start:end],dataset['y_valid'][start:end])\n valid_costs.append(cost)\n\n\n meanValidCost = np.mean(np.asarray(valid_costs),dtype=np.float32) \n meanTrainCost = np.mean(np.asarray(costs,dtype=np.float32))\n accuracy = training['accuracy'](dataset['X_test'],dataset['y_test'])\n\n print(\"Epoch: {}, Accuracy: {}, Training cost / validation cost: {}\".format(i+1,accuracy,meanTrainCost/meanValidCost))\n\n if(np.isnan(meanTrainCost/meanValidCost)):\n print(\"Nan value\")\n break\n\n\n # this is the test to see if the autoencoder is learning how to \n if i%10==0:\n acs = []\n for j in range(dataset['caswells_dim']):\n # print(dataset['labeled_test'][j].shape)\n codes = training['code'](dataset['labeled_test'][j])\n np.mean(np.argmax(dataset['y_test'], axis=1) == np.argmax(training['predict'](dataset['X_test']), axis=1))\n format_codes = []\n for code in codes:\n # if(j==0):\n format_codes.append(np.argmax(code))\n\n prev = sorted(format_codes)[0]\n # print(sorted(format_codes))\n k = 0\n same = [1]\n for code in sorted(format_codes)[1:]:\n if(code == prev):\n same[k] = same[k] + 1\n else:\n k+=1\n same.append(1)\n prev = code\n\n same = np.asarray(same)\n # print(same,np.argmax(same),same[np.argmax(same)],np.sum(same))\n label_acc = same[np.argmax(same)]*1.0/np.sum(same)\n acs.append(label_acc)\n print(\"Label: {}, Num examples: {}, Same label with autoencoder: {} \".format(j,dataset['labeled_test'][j].shape[0],label_acc))\n acs = np.asarray(acs)\n autoencoderSameLabels.append(np.mean(acs))\n print(\"Average agreement: {}\".format(np.mean(acs)))\n\n\n if i%50 == 0:\n ran = randint(0,dataset['num_examples_test']-20)\n now = datetime.datetime.now()\n for j in range(10):\n testing = [dataset['X_test'][ran]]\n # print(testing[0].shape)\n output = dataset['y_test'][ran].reshape((1, 200))[0]\n print(output)\n\n # print(np.arange(dataset['output_dim']))\n # print(output)\n prediction = training['predict'](testing)[0].reshape((1, 200))[0]\n print(prediction)\n # print(prediction)\n # print(testing[0][0])\n \n code = training['code'](testing).reshape((1, 50))\n\n # print(code)\n \n # plotting the figure\n\n fig = plt.figure(1)\n sub1 = fig.add_subplot(311)\n sub2 = fig.add_subplot(312)\n sub3 = fig.add_subplot(313)\n\n # add titles\n\n sub1.set_title('Desired output')\n sub2.set_title('Net output')\n sub3.set_title('Code layer output')\n\n # adding x labels\n\n sub1.set_xlabel('Time')\n sub2.set_xlabel('Time')\n sub3.set_xlabel('Code label')\n\n # adding y labels\n\n sub1.set_ylabel('Amplitude')\n sub2.set_ylabel('Amplitude')\n sub3.set_ylabel('Probability')\n\n # Plotting data\n\n # print(testing[0][0])\n # inp = []\n # for z in range(4):\n # inp += list(testing[0][0][z])\n\n\n sub1.plot(output)\n # sub1.bar(x_axis, output, width=1)\n sub1.grid(True)\n\n sub2.plot(prediction)\n sub2.grid(True)\n\n x_axis = list(np.arange(len(code[0])))\n\n # sub3.plot(code[0])\n sub3.bar(x_axis, code[0], width=1)\n # plt.show()\n\n fig.tight_layout()\n\n # plt.plot(var2)\n # fig.tight_layout()\n plt.savefig('../logs/convAuto/fig{}_{}_{}.png'.format(i,j,now), bbox_inches='tight')\n plt.close()\n \n ran += 1\n # break\n\n\n trainvalidation.append([meanTrainCost,meanValidCost])\n accuracies.append(accuracy)\n if(EARLY_STOPPING):\n if(len(accuracies) < STOPPING_RANGE):\n pass\n else:\n test = [k for k in accuracies if k < accuracy]\n if not test:\n print('Early stopping causing training to finish at epoch {}'.format(i+1))\n break\n del accuracies[0]\n accuracies.append(accuracy)\n\n epochsDone = epochsDone + 1\n\n except KeyboardInterrupt:\n pass\n\n # plt.plot(trainvalidation)\n # plt.show()\n\n if(LOG_EXPERIMENT):\n print(\"Logging the experiment details...\")\n log = dict(\n NET_TYPE = \"Conv auto encoder 2 hidden 1 code\",\n TETRODE_NUMBER = tetrode_number,\n BASENAME = BASENAME,\n NUM_EPOCHS = epochsDone,\n BATCH_SIZE = BATCH_SIZE,\n TRAIN_VALIDATION = trainvalidation,\n LEARNING_RATE = LEARNING_RATE,\n MOMENTUM = MOMENTUM,\n SAME_LABEL_AVERAGES = autoencoderSameLabels,\n ACCURACY = accuracies,\n NETWORK_LAYERS = [str(type(layer)) for layer in lasagne.layers.get_all_layers(network)],\n OUTPUT_DIM = dataset['output_dim'],\n # NETWORK_PARAMS = lasagne.layers.get_all_params_values(network)\n )\n now = datetime.datetime.now()\n filename = \"experiments/convAuto/{}_{}_{}_NUMLAYERS_{}_OUTPUTDIM_{}\".format(now,NUM_EPOCHS,NUM_HIDDEN_UNITS,len(log['NETWORK_LAYERS']),log['OUTPUT_DIM'])\n filename = re.sub(\"[^A-Za-z0-9_/,-:]\", \"\", filename)\n with open(filename,\"w\") as outfile:\n outfile.write(str(log))","def train():\n # YOUR TRAINING CODE GOES HERE","def run(self):\n\n # initializing random network activity\n s_rand_T = np.zeros((self.T, self.N_rand))\n p_rand_T = np.zeros((self.T, self.N_rand))\n r_rand_T = np.zeros((self.T, self.N_rand))\n\n s_rand_T[0, :] = np.random.uniform(low=0, high=0.01, size=(self.N_rand))\n\n # initializing sensory networks\n s_sens_T = np.zeros((self.T, self.N_sensory_nets * self.N_sensory))\n p_sens_T = np.zeros((self.T, self.N_sensory_nets * self.N_sensory))\n r_sens_T = np.zeros((self.T, self.N_sensory_nets * self.N_sensory))\n s_sens_T[0, :] = np.random.uniform(low=0, high=0.01, size=(self.N_sensory_nets * self.N_sensory))\n\n # extend input to be T timesteps and only nonzero for 100 ts\n s_ext_T = np.broadcast_to(self.s_ext, (self.T, self.N_sensory * self.N_sensory_nets)).copy()\n # stimulus is presented for 100 ms\n stim_T = int(200/self.rand_net.dt)\n s_ext_T[:100] = 0\n s_ext_T[100+stim_T:] = 0\n # s_ext_T *= 0\n\n for t in range(1, self.T):\n if (t + 1) % 100 == 0:\n print(f'step {t} of {self.T}')\n s_sens_prev = s_sens_T[t - 1]\n s_rand_prev = s_rand_T[t - 1]\n p_rand_prev = p_rand_T[t - 1]\n s_ext = s_ext_T[t - 1]\n step = self.forward(s_ext=s_ext, s_rand_prev=s_rand_prev, s_sens_prev=s_sens_prev, p_rand_prev=p_rand_prev)\n s_sens_T[t] = step['s_sens']\n p_sens_T[t] = step['p_sens']\n r_sens_T[t] = step['r_sens']\n s_rand_T[t] = step['s_rand']\n r_rand_T[t] = step['r_rand']\n p_rand_T[t] = step['p_rand']\n\n p_sens_T = p_sens_T.reshape(self.T, self.N_sensory_nets, self.N_sensory)\n s_ext_T = s_ext_T.reshape(self.T, self.N_sensory_nets, self.N_sensory)\n r_sens_T = r_sens_T.reshape(self.T, self.N_sensory_nets, self.N_sensory)\n s_sens_T = s_sens_T.reshape(self.T, self.N_sensory_nets, self.N_sensory)\n\n return dict(\n n_sensory=self.N_sensory,\n n_rand=self.N_rand,\n mus=self.mus,\n sigma=self.sigma,\n s_ext=s_ext_T,\n s_sens=s_sens_T,\n r_sens=r_sens_T,\n p_sens=p_sens_T,\n s_rand=s_rand_T,\n r_rand=r_rand_T,\n p_rand=p_rand_T\n )","def inference():\n inf_dataset = dataset\n net.eval()\n frames_gen, frame_cnt, rel_props, prop_ticks, prop_scaling = inf_dataset[index]\n \n num_crop = args.test_crops\n length = 3\n if args.modality == 'Flow':\n length = 10\n elif args.modality == 'RGBDiff':\n length = 18\n \n # First get the base_out outputs\n base_output = torch.autograd.Variable(torch.zeros((num_crop, frame_cnt, base_out_dim)).cuda(),\n volatile=True)\n cnt = 0\n for frames in frames_gen:\n # frames.shape == [frame_batch_size * num_crops * 3, 224, 224]\n # frame_batch_size is 4 by default\n input_var = torch.autograd.Variable(frames.view(-1, length, frames.size(-2), frames.size(-1)).cuda(),\n volatile=True)\n base_out = net(input_var, None, None, None, None)\n bsc = base_out.view(num_crop, -1, base_out_dim)\n base_output[:, cnt:cnt+bsc.size(1), :] = bsc\n cnt += bsc.size(1)\n\n n_frames = base_output.size(1)\n assert frame_cnt == n_frames\n # GLCU\n step_features = base_output.mean(dim=0).mean(dim=0).unsqueeze(0)\n gate, glcu_task_pred = net.glcu(step_features)\n glcu_task_pred = F.softmax(glcu_task_pred.squeeze(), dim=0).data.cpu().numpy()\n gate = gate.repeat(1, num_crop * n_frames).view(num_crop, n_frames, base_out_dim)\n if net.additive_glcu:\n base_output = base_output + gate\n else:\n base_output = base_output * gate\n\n # output.shape == [num_frames, 7791]\n output = torch.zeros((frame_cnt, output_dim)).cuda()\n cnt = 0\n for i in range(0, frame_cnt, 4):\n base_out = base_output[:, i:i+4, :].contiguous().view(-1, base_out_dim)\n rst = net.test_fc(base_out)\n sc = rst.data.view(num_crop, -1, output_dim).mean(dim=0)\n output[cnt: cnt + sc.size(0), :] = sc\n cnt += sc.size(0)\n base_output = base_output.mean(dim=0).data\n\n # act_scores.shape == [num_proposals, K+1]\n # comp_scores.shape == [num_proposals, K]\n act_scores, comp_scores, reg_scores = reorg_stpp.forward(output, prop_ticks, prop_scaling)\n act_scores = torch.autograd.Variable(act_scores, volatile=True)\n comp_scores = torch.autograd.Variable(comp_scores, volatile=True)\n\n # Task Head\n combined_scores = F.softmax(act_scores[:, 1:], dim=1) * torch.exp(comp_scores)\n combined_scores = combined_scores.mean(dim=0).unsqueeze(0)\n task_pred = F.softmax(net.task_head(combined_scores).squeeze(), dim=0).data.cpu().numpy()\n\n act_scores = act_scores.data\n comp_scores = comp_scores.data\n\n if reg_scores is not None:\n reg_scores = reg_scores.view(-1, num_class, 2)\n reg_scores[:, :, 0] = reg_scores[:, :, 0] * stats[1, 0] + stats[0, 0]\n reg_scores[:, :, 1] = reg_scores[:, :, 1] * stats[1, 1] + stats[0, 1]\n\n torch.cuda.empty_cache() # To empty the cache from previous iterations\n\n # perform stpp on scores\n return ((inf_dataset.video_list[index].id,\n (rel_props.numpy(), act_scores.cpu().numpy(), comp_scores.cpu().numpy(), reg_scores.cpu().numpy(), \n glcu_task_pred, task_pred),\n output.cpu().numpy(),\n base_output.cpu().numpy()))","def run_preliminary(args, device):\n subs_train = [1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 15000, 20000, 30000, 40000, 50000, 60000]\n subs_test = [1000, 1500, 2000, 3000, 4000, 5000, 7000, 8000, 9000, 10000]\n epochs = [2, 5, 10, 15, 17, 20, 22, 25, 27, 30]\n\n train_loader, test_loader = nnvis.data_load()\n\n model = prep.get_net(device, train_loader, test_loader, args.epochs)\n model.load_state_dict(torch.load(nnvis.init_state))\n\n nnvis.pre_train_subset(model, device, subs_train, args.epochs, test_loader)\n nnvis.pre_test_subset(model, device, subs_test)\n nnvis.pre_epochs(model, device, epochs)\n\n nnvis.plot_impact(subs_train, nnvis.train_subs_loss, nnvis.train_subs_acc, xlabel=\"Size of training dataset\")\n nnvis.plot_impact(epochs, nnvis.epochs_loss, nnvis.epochs_acc, annotate=False, xlabel=\"Number of epochs\")\n nnvis.plot_box(subs_test, show=False, xlabel=\"Size of test subset\")","def main():\n \"\"\"\n This is just for testing the functions\n \"\"\"\n\n x1 = np.array([1, 1, 1, 1, -1, -1, 1, 1, 1])\n x2 = np.array([1, -1, 1, 1, 1, 1, 1, -1, 1])\n x3 = np.array([-1, 1, -1, -1, 1, -1, -1, 1, -1])\n train_set = np.vstack((x1, x2))\n train_set = np.vstack((train_set, x3))\n\n\n params = {\n \"epochs\": 100,\n \"neurons\": len(x1),\n \"learn_method\": 'classic'\n }\n\n hop = hop_net.HopfieldNet(train_set, **params)\n hop.batch_train()\n show_trained(train_set)\n\n x4d = [1,1,1,1,1,1,1,1,1]\n x5d = [1,1,1,1,-1,-1,1,-1,-1]\n x45d = np.vstack((x4d, x5d))\n test_set = np.vstack((x45d, train_set))\n recalled_set = hop.recall(test_set)\n for i in range(test_set.shape[0]):\n show_tested(test_set[i], recalled_set[i])","def ternausnetv1(input_shape=(512, 512, 3), base_depth=64):\n inputs = Input(input_shape)\n conv1 = Conv2D(base_depth, 3, activation='relu', padding='same')(inputs)\n pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)\n\n conv2_1 = Conv2D(base_depth*2, 3, activation='relu',\n padding='same')(pool1)\n pool2 = MaxPooling2D(pool_size=(2, 2))(conv2_1)\n\n conv3_1 = Conv2D(base_depth*4, 3, activation='relu',\n padding='same')(pool2)\n conv3_2 = Conv2D(base_depth*4, 3, activation='relu',\n padding='same')(conv3_1)\n pool3 = MaxPooling2D(pool_size=(2, 2))(conv3_2)\n\n conv4_1 = Conv2D(base_depth*8, 3, activation='relu',\n padding='same')(pool3)\n conv4_2 = Conv2D(base_depth*8, 3, activation='relu',\n padding='same')(conv4_1)\n pool4 = MaxPooling2D(pool_size=(2, 2))(conv4_2)\n\n conv5_1 = Conv2D(base_depth*8, 3, activation='relu',\n padding='same')(pool4)\n conv5_2 = Conv2D(base_depth*8, 3, activation='relu',\n padding='same')(conv5_1)\n pool5 = MaxPooling2D(pool_size=(2, 2))(conv5_2)\n\n conv6_1 = Conv2D(base_depth*8, 3, activation='relu',\n padding='same')(pool5)\n\n up7 = Conv2DTranspose(base_depth*4, 2, strides=(2, 2), activation='relu',\n padding='same')(conv6_1)\n concat7 = concatenate([up7, conv5_2])\n conv7_1 = Conv2D(base_depth*8, 3, activation='relu',\n padding='same')(concat7)\n\n up8 = Conv2DTranspose(base_depth*4, 2, strides=(2, 2), activation='relu',\n padding='same')(conv7_1)\n concat8 = concatenate([up8, conv4_2])\n conv8_1 = Conv2D(base_depth*8, 3, activation='relu',\n padding='same')(concat8)\n\n up9 = Conv2DTranspose(base_depth*2, 2, strides=(2, 2), activation='relu',\n padding='same')(conv8_1)\n concat9 = concatenate([up9, conv3_2])\n conv9_1 = Conv2D(base_depth*4, 3, activation='relu',\n padding='same')(concat9)\n\n up10 = Conv2DTranspose(base_depth, 2, strides=(2, 2), activation='relu',\n padding='same')(conv9_1)\n concat10 = concatenate([up10, conv2_1])\n conv10_1 = Conv2D(base_depth*2, 3, activation='relu',\n padding='same')(concat10)\n\n up11 = Conv2DTranspose(int(base_depth/2), 2, strides=(2, 2),\n activation='relu', padding='same')(conv10_1)\n concat11 = concatenate([up11, conv1])\n\n out = Conv2D(1, 1, activation='sigmoid', padding='same')(concat11)\n\n return Model(input=inputs, output=out)","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def plot_orig(self, conf, nn_in_trn, nn_out_trn, y_pred, a, vert_coef):\n plot_win=tk.Toplevel()\n plot_win.title(\"Predict data plot\")\n fig = Figure(figsize=(5, 4), dpi=80)\n ax=fig.add_subplot(111)\n ax.plot(nn_in_trn[:, 0], nn_out_trn[:, 0], label=\"Train data\")\n ax.plot(nn_in_trn[:, 0], y_pred[:, 0], label=\"Prediction data\")\n ax.set_xlabel('IN[1]')\n ax.set_ylabel('OUT[1]')\n fig.legend()\n canvas = FigureCanvasTkAgg(fig, master=plot_win)\n canvas.draw()\n canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)\n\n toolbar = NavigationToolbar2Tk(canvas, plot_win)\n toolbar.update()\n canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)\n lab1=tk.Label(plot_win,width=35, text=\"Model configuration\"+str(conf))\n lab1.pack()\n lab2=tk.Label(plot_win,width=35, text=\"Loss= \" + str(round(a,4))+ \" %\")\n lab2.pack()\n plot_win.geometry(f'+{self.winfo_x()+self.winfo_width()+20}+{self.winfo_y() + vert_coef}')","def lm_NN(nn_in, \n nn_out, \n er_tar,\n main_win: tk.Toplevel, \n min_n=0, \n max_n=0, \n n_epochs=50, \n conf=[1,1,1], \n sect_ner=False, \n train_test=False, \n retrain=False, \n spl_coef=0.1,\n root_width=200, \n root_height=200, \n root_x=50, \n root_y=50):\n if train_test or retrain:\n x=tr.from_numpy(nn_in).float()\n y=tr.from_numpy((nn_out)).float()\n dataset = tr.utils.data.TensorDataset(x, y)\n a=int(len(dataset)*(1-spl_coef))\n data_trn,data_test=tr.utils.data.random_split(dataset, [a,int(len(dataset)-a)],generator=tr.Generator().manual_seed(42))\n dataloader = tr.utils.data.DataLoader(data_trn, shuffle=False, batch_size=len(data_trn))\n nn_in=(next(iter(dataloader))[0].numpy()).T\n nn_out=(next(iter(dataloader))[1].numpy()).T\n nn_in_test=data_test[:][0].numpy().T\n nn_out_test=data_test[:][1].numpy().T\n else:\n nn_in_test = 0\n nn_out_test = 0\n nn_in=nn_in.T\n nn_out=nn_out.T\n\n if sect_ner:\n if min_n>max_n:\n print(\"Error: minimum neurons>maximum neurons\")\n for i in range(len(conf)-2):\n conf[i+1] = min_n\n for i in range(1, len(conf)-1):\n min_loss=20000\n b=conf[i]\n for j in range(min_n, max_n+1):\n conf[i] = j\n nn_obj = prn.CreateNN(conf)\n nn_obj = prn.train_LM(nn_in,nn_out,nn_obj,verbose=False,k_max=1,E_stop=1e-10)\n y_pred = prn.NNOut(nn_in, nn_obj)\n a=loss(y_pred, nn_out, nn_obj)\n print(\"Current configuration:\", conf, \";\\t Loss:\", a, \"%\")\n if a<min_loss:\n min_loss=a\n b=j\n conf[i]=b\n neurons_number_info(conf, root_height + root_y, root_x)\n print(\"Best configuration:\", conf)\n \n nn_obj = prn.CreateNN(conf)\n loss_val=[]\n loss_test=[]\n epochs_sum = 0\n train = True\n lin_tr = None\n can_tr = None\n lin_test = None \n can_test = None\n vert_coef = None\n hor_coef = None\n while train == True:\n nn_obj, vert_coef, hor_coef, epochs_sum, err, lin_tr, can_tr, lin_test, can_test = train_body_LM(nn_obj, nn_in, nn_in_test, nn_out, nn_out_test, n_epochs, epochs_sum, loss_val, loss_test, er_tar, train_test, retrain, root_width, root_height, root_x, root_y, lin_tr, can_tr, lin_test, can_test, vert_coef, hor_coef)\n train_win = Continue_Train(err, epochs_sum)\n main_win.wait_window(train_win)\n train = train_win.answer\n if not train_win.answer:\n return nn_obj, conf, vert_coef, hor_coef\n #train = False\n return nn_obj, conf, vert_coef, hor_coef","def unet_network(input_tensor, nb_classes):\n # contraction 1\n conv1 = Conv2D(\n filters=64,\n kernel_size=(3, 3),\n activation='relu',\n name='conv1')(\n input_tensor) # (batch_size, ?, ?, 64)\n conv2 = Conv2D(\n filters=64,\n kernel_size=(3, 3),\n activation='relu',\n name='conv2')(\n conv1) # (batch_size, ?, ?, 64)\n crop2 = Cropping2D(\n cropping=((88, 88), (88, 88)),\n name=\"crop2\")(\n conv2) # (batch_size, ?, ?, 64)\n maxpool2 = MaxPooling2D(\n pool_size=(3, 3),\n strides=(2, 2),\n name=\"maxpool2\")(\n conv2) # (batch_size, ?, ?, 64)\n\n # contraction 2\n conv3 = Conv2D(\n filters=128,\n kernel_size=(3, 3),\n activation='relu',\n name='conv3')(\n maxpool2) # (batch_size, ?, ?, 128)\n conv4 = Conv2D(\n filters=128,\n kernel_size=(3, 3),\n activation='relu',\n name='conv4')(\n conv3) # (batch_size, ?, ?, 128)\n crop4 = Cropping2D(\n cropping=((40, 40), (40, 40)),\n name=\"crop4\")(\n conv4) # (batch_size, ?, ?, 128)\n maxpool4 = MaxPooling2D(\n pool_size=(3, 3),\n strides=(2, 2),\n name=\"maxpool4\")(\n conv4) # ((batch_size, ?, ?, 128)\n\n # contraction 3\n conv5 = Conv2D(\n filters=256,\n kernel_size=(3, 3),\n activation='relu',\n name='conv5')(\n maxpool4) # (batch_size, ?, ?, 256)\n conv6 = Conv2D(\n filters=256,\n kernel_size=(3, 3),\n activation='relu',\n name='conv6')(\n conv5) # (batch_size, ?, ?, 256)\n crop6 = Cropping2D(\n cropping=((16, 16), (16, 16)),\n name=\"crop6\")(\n conv6) # (batch_size, ?, ?, 256)\n maxpool6 = MaxPooling2D(\n pool_size=(3, 3),\n strides=(2, 2),\n name=\"maxpool6\")(\n conv6) # (batch_size, ?, ?, 256)\n\n # contraction 4\n conv7 = Conv2D(\n filters=512,\n kernel_size=(3, 3),\n activation='relu',\n name='conv7')(\n maxpool6) # (batch_size, ?, ?, 512)\n conv8 = Conv2D(\n filters=512,\n kernel_size=(3, 3),\n activation='relu',\n name='conv8')(\n conv7) # (batch_size, ?, ?, 512)\n crop8 = Cropping2D(\n cropping=((4, 4), (4, 4)),\n name=\"crop8\")(\n conv8) # (batch_size, ?, ?, 512)\n maxpool8 = MaxPooling2D(\n pool_size=(3, 3),\n strides=(2, 2),\n name=\"maxpool8\")(\n conv8) # (batch_size, ?, ?, 512)\n\n # bottom\n conv9 = Conv2D(\n filters=1024,\n kernel_size=(3, 3),\n activation='relu',\n name='conv9')(\n maxpool8) # (batch_size, ?, ?, 1024)\n conv10 = Conv2D(\n filters=1024,\n kernel_size=(3, 3),\n activation='relu',\n name='conv10')(\n conv9) # (batch_size, ?, ?, 1024)\n\n # expansion 1\n upconv11 = up_conv_2d(\n input_tensor=conv10,\n nb_filters=512,\n name='upconv11') # (batch_size, ?, ?, 512)\n concat11 = tf.concat(\n values=[crop8, upconv11],\n axis=-1,\n name='concat11') # (batch_size, ?, ?, 1024)\n conv12 = Conv2D(\n filters=512,\n kernel_size=(3, 3),\n activation='relu',\n name='conv12')(\n concat11) # (batch_size, ?, ?, 512)\n conv13 = Conv2D(\n filters=512,\n kernel_size=(3, 3),\n activation='relu',\n name='conv13')(\n conv12) # (batch_size, ?, ?, 512)\n\n # expansion 2\n upconv14 = up_conv_2d(\n input_tensor=conv13,\n nb_filters=256,\n name='upconv14') # (batch_size, ?, ?, 256)\n concat14 = tf.concat(\n values=[crop6, upconv14],\n axis=-1,\n name='concat14') # (batch_size, ?, ?, 512)\n conv15 = Conv2D(\n filters=256,\n kernel_size=(3, 3),\n activation='relu',\n name='conv15')(\n concat14) # (batch_size, ?, ?, 256)\n conv16 = Conv2D(\n filters=256,\n kernel_size=(3, 3),\n activation='relu',\n name='conv16')(\n conv15) # (batch_size, ?, ?, 256)\n\n # expansion 3\n upconv17 = up_conv_2d(\n input_tensor=conv16,\n nb_filters=128,\n name='upconv17') # (batch_size, ?, ?, 128)\n concat17 = tf.concat(\n values=[crop4, upconv17],\n axis=-1,\n name='concat17') # (batch_size, ?, ?, 256)\n conv18 = Conv2D(\n filters=128,\n kernel_size=(3, 3),\n activation='relu',\n name='conv18')(\n concat17) # (batch_size, ?, ?, 128)\n conv19 = Conv2D(\n filters=128,\n kernel_size=(3, 3),\n activation='relu',\n name='conv19')(\n conv18) # (batch_size, ?, ?, 128)\n\n # expansion 4\n upconv20 = up_conv_2d(\n input_tensor=conv19,\n nb_filters=64,\n name='upconv20') # (batch_size, ?, ?, 64)\n concat20 = tf.concat(\n values=[crop2, upconv20],\n axis=-1,\n name='concat20') # (batch_size, ?, ?, 128)\n conv21 = Conv2D(\n filters=64,\n kernel_size=(3, 3),\n activation='relu',\n name='conv21')(\n concat20) # (batch_size, ?, ?, 64)\n conv22 = Conv2D(\n filters=64,\n kernel_size=(3, 3),\n activation='relu',\n name='conv22')(\n conv21) # (batch_size, ?, ?, 64)\n conv23 = Conv2D(\n filters=nb_classes,\n kernel_size=(1, 1),\n activation='sigmoid',\n name='conv23')(\n conv22) # (batch_size, ?, ?, nb_classes)\n\n return conv23","def train(self):\r\n raw_dataset = pd.read_csv(self.datafile, sep = ',', header = 0,\r\n na_values = '?', comment = '\\t',\r\n skipinitialspace = True)\r\n\r\n dataset = raw_dataset.copy()\r\n dataset.tail()\r\n\r\n # Clear unknown values\r\n dataset.isna().sum()\r\n dataset = dataset.dropna()\r\n\r\n # takes a sample of 80% of the data points\r\n train_dataset = dataset.sample(frac = 0.8, random_state = 0)\r\n test_dataset = dataset.drop(train_dataset.index)\r\n\r\n # Split features from labels for training and test datasets\r\n train_features = train_dataset.copy()\r\n test_features = test_dataset.copy()\r\n train_labels = train_features.pop('Quality')\r\n test_labels = test_features.pop('Quality')\r\n\r\n # normalize data\r\n normalizer = preprocessing.Normalization()\r\n normalizer.adapt(np.array(train_features))\r\n\r\n # builds the model\r\n def build_and_compile_model(norm):\r\n model = keras.Sequential([\r\n norm,\r\n layers.Dense(64, activation='relu'),\r\n layers.Dense(64, activation='relu'),\r\n layers.Dense(1)\r\n ])\r\n\r\n model.compile(loss='mean_absolute_error',\r\n optimizer=tf.keras.optimizers.Adam(0.001))\r\n return model\r\n\r\n deep_neural_network_model = build_and_compile_model(normalizer)\r\n\r\n history = deep_neural_network_model.fit(\r\n train_features, train_labels,\r\n validation_split=0.2,\r\n verbose=0, epochs=100)\r\n\r\n deep_neural_network_model.save('deep_neural_network_model')","def run_net(self,\n pre_trained_chckpnt_dir ='' #for resuming training, load the model from this directory\n ):\n\n _rd = _read_data(data=self.data)\n\n self.alpha_coeff=1\n\n #read path of the images for train, test, and validation\n train_CTs, train_GTVs, train_Torso, train_penalize, train_surface,\\\n validation_CTs, validation_GTVs, validation_Torso, validation_penalize, validation_surface,\\\n test_CTs, test_GTVs, test_Torso, test_penalize,test_surface=_rd.read_data_path(fold=self.fold)\n self.img_width = self.img_width\n self.img_height = self.img_height\n # ======================================\n #validation instances\n bunch_of_images_no=20\n _image_class_vl = image_class(validation_CTs, validation_GTVs, validation_Torso,validation_penalize,validation_surface\n , bunch_of_images_no=bunch_of_images_no, is_training=0,\n patch_window=self.patch_window)\n _patch_extractor_thread_vl = _patch_extractor_thread(_image_class=_image_class_vl,\n sample_no=self.sample_no, patch_window=self.patch_window,\n GTV_patchs_size=self.GTV_patchs_size,\n tumor_percent=self.tumor_percent,\n img_no=bunch_of_images_no,\n mutex=settings.mutex,is_training=0,vl_sample_no=self.validation_samples\n )\n _fill_thread_vl = fill_thread(validation_CTs,\n validation_GTVs,\n validation_Torso,\n validation_penalize,\n validation_surface,\n _image_class_vl,\n sample_no=self.sample_no,\n total_sample_no=self.validation_samples,\n patch_window=self.patch_window,\n GTV_patchs_size=self.GTV_patchs_size,\n img_width=self.img_width, img_height=self.img_height,\n mutex=settings.mutex,\n tumor_percent=self.tumor_percent,\n is_training=0,\n patch_extractor=_patch_extractor_thread_vl,\n fold=self.fold)\n\n\n _fill_thread_vl.start()\n _patch_extractor_thread_vl.start()\n _read_thread_vl = read_thread(_fill_thread_vl, mutex=settings.mutex,\n validation_sample_no=self.validation_samples, is_training=0)\n _read_thread_vl.start()\n # ======================================\n #training instances\n bunch_of_images_no = 24\n _image_class = image_class(train_CTs, train_GTVs, train_Torso,train_penalize,train_surface\n , bunch_of_images_no=bunch_of_images_no,is_training=1,patch_window=self.patch_window\n )\n patch_extractor_thread = _patch_extractor_thread(_image_class=_image_class,\n sample_no=240, patch_window=self.patch_window,\n GTV_patchs_size=self.GTV_patchs_size,\n tumor_percent=self.tumor_percent,\n img_no=bunch_of_images_no,\n mutex=settings.mutex,is_training=1)\n _fill_thread = fill_thread(train_CTs, train_GTVs, train_Torso,train_penalize,train_surface,\n _image_class,\n sample_no=self.sample_no,total_sample_no=self.sample_no,\n patch_window=self.patch_window,\n GTV_patchs_size=self.GTV_patchs_size,\n img_width=self.img_width,\n img_height=self.img_height,mutex=settings.mutex,\n tumor_percent=self.tumor_percent,\n is_training=1,\n patch_extractor=patch_extractor_thread,\n fold=self.fold)\n\n _fill_thread.start()\n patch_extractor_thread.start()\n\n _read_thread = read_thread(_fill_thread,mutex=settings.mutex,is_training=1)\n _read_thread.start()\n # ======================================\n\n image = tf.placeholder(tf.float32, shape=[None, None, None, None, 1])\n label = tf.placeholder(tf.float32, shape=[None, None, None, None, 2])\n penalize = tf.placeholder(tf.float32, shape=[None, None, None, None,1])\n surf_map = tf.placeholder(tf.float32, shape=[None, None, None, None,1])\n loss_coef = tf.placeholder(tf.float32, shape=[None, 2]) # shape: batchno * 2 values for each class\n alpha = tf.placeholder(tf.float32, name='alpha') # background coeff\n beta = tf.placeholder(tf.float32, name='beta') # tumor coeff\n\n ave_vali_acc=tf.placeholder(tf.float32)\n ave_loss_vali=tf.placeholder(tf.float32)\n ave_dsc_vali=tf.placeholder(tf.float32)\n\n dropout=tf.placeholder(tf.float32,name='dropout')\n is_training = tf.placeholder(tf.bool, name='is_training')\n is_training_bn = tf.placeholder(tf.bool, name='is_training_bn')\n dense_net_dim = tf.placeholder(tf.int32, name='dense_net_dim')\n\n _dn = _densenet_unet(self.densnet_unet_config,self.compression_coefficient,self.growth_rate) #create object\n y=_dn.dens_net(image=image,is_training=is_training,dropout_rate1=0,dropout_rate2=0,dim=dense_net_dim,is_training_bn=is_training_bn)\n # y = _dn.vgg(image)\n\n y_dirX = ((y[:, int(self.GTV_patchs_size / 2), :, :, 0, np.newaxis]))\n label_dirX = (label[:, int(self.GTV_patchs_size / 2), :, :, 0, np.newaxis])\n penalize_dirX = (penalize[:,16,:,:,0,np.newaxis])\n surf_map_dirX = (surf_map[:,16,:,:,0,np.newaxis])\n image_dirX = ((image[:, int(self.patch_window / 2), :, :, 0, np.newaxis]))\n\n show_img=tf.nn.softmax(y)[:, int(self.GTV_patchs_size / 2) , :, :, 0, np.newaxis]\n tf.summary.image('outprunut',show_img , 3)\n tf.summary.image('output without softmax',y_dirX ,3)\n tf.summary.image('groundtruth', label_dirX,3)\n tf.summary.image('penalize', penalize_dirX,3)\n tf.summary.image('surf_map', surf_map_dirX,3)\n tf.summary.image('image',image_dirX ,3)\n\n print('*****************************************')\n print('*****************************************')\n print('*****************************************')\n sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))\n devices = sess.list_devices()\n print(devices)\n\n print(device_lib.list_local_devices())\n print('*****************************************')\n print('*****************************************')\n print('*****************************************')\n\n train_writer = tf.summary.FileWriter(self.LOGDIR + '/train' ,graph=tf.get_default_graph())\n validation_writer = tf.summary.FileWriter(self.LOGDIR + '/validation' , graph=sess.graph)\n\n extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n saver=tf.train.Saver(tf.global_variables(), max_to_keep=1000)\n\n\n\n #define the loss function\n with tf.name_scope('cost'):\n penalize_weight=0\n [ penalized_loss,\n soft_dice_coef,logt,lbl]=self.loss_instance.dice_plus_distance_penalize(logits=y, labels=label,penalize=penalize)\n surface_loss= self.loss_instance.surface_loss(logits=y, labels=label, surf_map=surf_map)\n cost = tf.reduce_mean((1.0 - soft_dice_coef[1])+penalize_weight*penalized_loss+surface_loss, name=\"cost\")\n\n #Setup the Tensorboard plots\n tf.summary.scalar(\"cost\", cost)\n f1_measure = self.loss_instance.f1_measure(logits=y, labels=label)\n tf.summary.scalar(\"dice_bakground\", f1_measure[0])\n tf.summary.scalar(\"dice_tumor\", f1_measure[1])\n\n pwc = self.loss_instance.PWC(y, label)\n tf.summary.scalar(\"pwc_bakground\", pwc[0])\n tf.summary.scalar(\"pwc_tumor\", pwc[1])\n\n recall = self.loss_instance.Recall(y, label)\n tf.summary.scalar(\"recall_bakground\", recall[0])\n tf.summary.scalar(\"recall_tumor\", recall[1])\n\n precision = self.loss_instance.Precision(y, label)\n tf.summary.scalar(\"precision_bakground\", precision[0])\n tf.summary.scalar(\"precision_tumor\", precision[1])\n\n fpr = self.loss_instance.FPR(y, label)\n tf.summary.scalar(\"FPR_bakground\", fpr[0])\n tf.summary.scalar(\"FPR_tumor\", fpr[1])\n\n fnr = self.loss_instance.FNR(y, label)\n tf.summary.scalar(\"FNR_bakground\", fnr[0])\n tf.summary.scalar(\"FNR_tumor\", fnr[1])\n\n extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n with tf.control_dependencies(extra_update_ops):\n optimizer_tmp = tf.train.AdamOptimizer(self.learning_rate,epsilon=0.001)\n optimizer = optimizer_tmp.minimize(cost)\n\n with tf.name_scope('validation'):\n average_validation_accuracy=ave_vali_acc\n average_validation_loss=ave_loss_vali\n average_dsc_loss=ave_dsc_vali\n tf.summary.scalar(\"average_validation_accuracy\",average_validation_accuracy)\n tf.summary.scalar(\"average_validation_loss\",average_validation_loss)\n tf.summary.scalar(\"average_dsc_loss\",average_dsc_loss)\n\n with tf.name_scope('accuracy'):\n accuracy=self.loss_instance.accuracy_fn(y, label)\n\n tf.summary.scalar(\"accuracy\", accuracy)\n\n sess.run(tf.global_variables_initializer())\n logging.debug('total number of variables %s' % (\n np.sum([np.prod(v.get_shape().as_list()) for v in tf.trainable_variables()])))\n summ=tf.summary.merge_all()\n\n point = 0 # starting point, starts from a value > 0 if training is resumed\n itr1 = 0 # number of iterations\n if len(pre_trained_chckpnt_dir):\n ckpt = tf.train.get_checkpoint_state(pre_trained_chckpnt_dir)\n saver.restore(sess, ckpt.model_checkpoint_path)\n point=int(ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])\n itr1=point\n\n\n # patch_radius = 49\n '''loop for epochs'''\n\n for epoch in range(self.total_epochs):\n while self.no_sample_per_each_itr*int(point/self.no_sample_per_each_itr)<self.sample_no:\n print('0')\n print(\"epoch #: %d\" %(epoch))\n startTime = time.time()\n step = 0\n self.beta_coeff=1+1 * np.exp(-point/2000)\n # =============start validation================\n if itr1 % self.display_validation_step ==0:\n '''Validation: '''\n loss_validation = 0\n acc_validation = 0\n validation_step = 0\n dsc_validation=0\n while (validation_step * self.batch_no_validation <settings.validation_totalimg_patch):\n [validation_CT_image, validation_GTV_image,validation_Penalize_patch,validation_Surface_patch] = _image_class_vl.return_patches_validation( validation_step * self.batch_no_validation, (validation_step + 1) *self.batch_no_validation)\n if (len(validation_CT_image)<self.batch_no_validation) | (len(validation_GTV_image)<self.batch_no_validation) | (len(validation_Penalize_patch)<self.batch_no_validation) | (len(validation_Surface_patch)<self.batch_no_validation) :\n _read_thread_vl.resume()\n time.sleep(0.5)\n continue\n\n validation_CT_image_patchs = validation_CT_image\n validation_GTV_label = validation_GTV_image\n tic=time.time()\n\n [acc_vali, loss_vali,dsc_vali,surface_loss1] = sess.run([accuracy, cost,f1_measure,surface_loss],\n feed_dict={image: validation_CT_image_patchs,\n label: validation_GTV_label,\n penalize: validation_Penalize_patch,\n dropout: 1,\n is_training: False,\n ave_vali_acc: -1,\n ave_loss_vali: -1,\n ave_dsc_vali:-1,\n dense_net_dim: self.patch_window,\n is_training_bn:False,\n alpha:1,\n beta:1,\n surf_map:validation_Surface_patch,\n })\n elapsed=time.time()-tic\n\n acc_validation += acc_vali\n loss_validation += loss_vali\n dsc_validation+=dsc_vali[1]\n validation_step += 1\n if np.isnan(dsc_validation) or np.isnan(loss_validation) or np.isnan(acc_validation):\n print('nan problem')\n process = psutil.Process(os.getpid())\n\n print(\n '%d - > %d: elapsed_time:%d acc_validation: %f, loss_validation: %f, memory_percent: %4s' % (\n validation_step,validation_step * self.batch_no_validation\n , elapsed, acc_vali, loss_vali, str(process.memory_percent()),\n ))\n\n settings.queue_isready_vl = False\n acc_validation = acc_validation / (validation_step)\n loss_validation = loss_validation / (validation_step)\n dsc_validation = dsc_validation / (validation_step)\n if np.isnan(dsc_validation) or np.isnan(loss_validation) or np.isnan(acc_validation):\n print('nan problem')\n _fill_thread_vl.kill_thread()\n print('******Validation, step: %d , accuracy: %.4f, loss: %f*******' % (\n itr1, acc_validation, loss_validation))\n\n [sum_validation] = sess.run([summ],\n feed_dict={image: validation_CT_image_patchs,\n label: validation_GTV_label,\n penalize: validation_Penalize_patch,\n dropout: 1,\n is_training: False,\n ave_vali_acc: acc_validation,\n ave_loss_vali: loss_validation,\n ave_dsc_vali:dsc_validation,\n dense_net_dim: self.patch_window,\n is_training_bn: False,\n alpha: 1,\n beta: 1,\n surf_map: validation_Surface_patch,\n\n })\n validation_writer.add_summary(sum_validation, point)\n print('end of validation---------%d' % (point))\n\n #loop for training batches\n while(step*self.batch_no<self.no_sample_per_each_itr):\n [train_CT_image_patchs, train_GTV_label, train_Penalize_patch,loss_coef_weights,train_Surface_patch] = _image_class.return_patches( self.batch_no)\n\n if (len(train_CT_image_patchs)<self.batch_no)|(len(train_GTV_label)<self.batch_no)\\\n |(len(train_Penalize_patch)<self.batch_no)|(len(train_Surface_patch)<self.batch_no):\n time.sleep(0.5)\n _read_thread.resume()\n continue\n\n tic=time.time()\n [acc_train1, loss_train1, optimizing,out,dsc_train11] = sess.run([accuracy, cost, optimizer,y,f1_measure],\n feed_dict={image: train_CT_image_patchs,\n label: train_GTV_label,\n penalize: train_Penalize_patch,\n # loss_coef: loss_coef_weights,\n dropout: self.dropout_keep,\n is_training: True,\n ave_vali_acc: -1,\n ave_loss_vali: -1,\n ave_dsc_vali: -1,\n dense_net_dim: self.patch_window,\n is_training_bn: True,\n alpha: self.alpha_coeff,\n beta: self.beta_coeff,\n surf_map: train_Surface_patch,\n\n })\n elapsed=time.time()-tic\n dsc_train1=dsc_train11[1]\n\n self.x_hist=self.x_hist+1\n # np.hstack((self.x_hist, [np.ceil(\n\n [sum_train] = sess.run([summ],\n feed_dict={image: train_CT_image_patchs,\n label: train_GTV_label,\n penalize: train_Penalize_patch,\n dropout: self.dropout_keep, is_training: True,\n ave_vali_acc: acc_train1,\n ave_loss_vali: loss_train1,\n ave_dsc_vali: dsc_train1,\n dense_net_dim: self.patch_window,\n is_training_bn: True,\n alpha: self.alpha_coeff,\n beta: self.beta_coeff,\n surf_map: train_Surface_patch,\n\n })\n train_writer.add_summary(sum_train,point)\n step = step + 1\n\n process = psutil.Process(os.getpid())\n\n print(\n 'point: %d, elapsed_time:%d step*self.batch_no:%f , LR: %.15f, acc_train1:%f, loss_train1:%f,memory_percent: %4s' % (\n int((point)),elapsed,\n step * self.batch_no, self.learning_rate, acc_train1, loss_train1,\n str(process.memory_percent())))\n\n\n point=int((point))\n if point%100==0:\n '''saveing model inter epoch'''\n chckpnt_path = os.path.join(self.chckpnt_dir,\n ('densenet_unet_inter_epoch%d_point%d.ckpt' % (epoch, point)))\n saver.save(sess, chckpnt_path, global_step=point)\n itr1 = itr1 + 1\n point=point+1\n endTime = time.time()\n\n #==============\n '''saveing model after each epoch'''\n chckpnt_path = os.path.join(self.chckpnt_dir, 'densenet_unet.ckpt')\n saver.save(sess, chckpnt_path, global_step=epoch)\n print(\"End of epoch----> %d, elapsed time: %d\" % (epoch, endTime - startTime))","def create_img(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled, IMG_OUTPUT_FILEPATH):\n viz = Visualizer(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled=upsampled)\n viz.evaluate()\n if upsampled == True:\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '_upsampled.png'\n else:\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '.png'\n viz.visualizer.show(outpath=outpath_, clear_figure=True)","def train(**kwargs):\n\n # Roll out the parameters\n batch_size = kwargs[\"batch_size\"]\n n_batch_per_epoch = kwargs[\"n_batch_per_epoch\"]\n nb_epoch = kwargs[\"nb_epoch\"]\n model_name = kwargs[\"model_name\"]\n generator = kwargs[\"generator\"]\n image_dim_ordering = kwargs[\"image_dim_ordering\"]\n img_dim = kwargs[\"img_dim\"]\n patch_size = kwargs[\"patch_size\"]\n bn_mode = kwargs[\"bn_mode\"]\n label_smoothing = kwargs[\"use_label_smoothing\"]\n label_flipping = kwargs[\"label_flipping\"]\n dset = kwargs[\"dset\"]\n use_mbd = kwargs[\"use_mbd\"]\n\n epoch_size = n_batch_per_epoch * batch_size\n\n # Setup environment (logging directory etc)\n general_utils.setup_logging(model_name)\n\n # Load and rescale data\n X_full_train, X_sketch_train, X_full_val, X_sketch_val = data_utils.load_data(dset, image_dim_ordering)\n img_dim = X_full_train.shape[-3:]\n\n # Get the number of non overlapping patch and the size of input image to the discriminator\n nb_patch, img_dim_disc = data_utils.get_nb_patch(img_dim, patch_size, image_dim_ordering)\n\n try:\n\n # Create optimizers\n opt_dcgan = Adam(lr=1E-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08)\n # opt_discriminator = SGD(lr=1E-3, momentum=0.9, nesterov=True)\n opt_discriminator = Adam(lr=1E-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08)\n\n # Load generator model\n generator_model = models.load(\"generator_unet_%s\" % generator,\n img_dim,\n nb_patch,\n bn_mode,\n use_mbd,\n batch_size)\n # Load discriminator model\n discriminator_model = models.load(\"DCGAN_discriminator\",\n img_dim_disc,\n nb_patch,\n bn_mode,\n use_mbd,\n batch_size)\n\n generator_model.compile(loss='mae', optimizer=opt_discriminator)\n discriminator_model.trainable = False\n\n DCGAN_model = models.DCGAN(generator_model,\n discriminator_model,\n img_dim,\n patch_size,\n image_dim_ordering)\n\n loss = ['mae', 'binary_crossentropy']\n loss_weights = [1E2, 1]\n DCGAN_model.compile(loss=loss, loss_weights=loss_weights, optimizer=opt_dcgan)\n\n discriminator_model.trainable = True\n discriminator_model.compile(loss='binary_crossentropy', optimizer=opt_discriminator)\n\n gen_loss = 100\n disc_loss = 100\n\n # Start training\n print(\"Start training\")\n for e in range(nb_epoch):\n # Initialize progbar and batch counter\n progbar = generic_utils.Progbar(epoch_size)\n batch_counter = 1\n start = time.time()\n\n for X_full_batch, X_sketch_batch in data_utils.gen_batch(X_full_train, X_sketch_train, batch_size):\n\n # Create a batch to feed the discriminator model\n X_disc, y_disc = data_utils.get_disc_batch(X_full_batch,\n X_sketch_batch,\n generator_model,\n batch_counter,\n patch_size,\n image_dim_ordering,\n label_smoothing=label_smoothing,\n label_flipping=label_flipping)\n\n # Update the discriminator\n disc_loss = discriminator_model.train_on_batch(X_disc, y_disc)\n\n # Create a batch to feed the generator model\n X_gen_target, X_gen = next(data_utils.gen_batch(X_full_train, X_sketch_train, batch_size))\n y_gen = np.zeros((X_gen.shape[0], 2), dtype=np.uint8)\n y_gen[:, 1] = 1\n\n # Freeze the discriminator\n discriminator_model.trainable = False\n gen_loss = DCGAN_model.train_on_batch(X_gen, [X_gen_target, y_gen])\n # Unfreeze the discriminator\n discriminator_model.trainable = True\n\n batch_counter += 1\n progbar.add(batch_size, values=[(\"D logloss\", disc_loss),\n (\"G tot\", gen_loss[0]),\n (\"G mae\", gen_loss[1]),\n (\"G logloss\", gen_loss[2])])\n\n # Save images for visualization\n if batch_counter % (n_batch_per_epoch / 2) == 0:\n # Get new images from validation\n data_utils.plot_generated_batch(X_full_batch, X_sketch_batch, generator_model,\n batch_size, image_dim_ordering, \"training\")\n X_full_batch, X_sketch_batch = next(data_utils.gen_batch(X_full_val, X_sketch_val, batch_size))\n data_utils.plot_generated_batch(X_full_batch, X_sketch_batch, generator_model,\n batch_size, image_dim_ordering, \"validation\")\n\n if batch_counter >= n_batch_per_epoch:\n break\n\n print(\"\")\n print('Epoch %s/%s, Time: %s' % (e + 1, nb_epoch, time.time() - start))\n\n if e % 5 == 0:\n gen_weights_path = os.path.join('../../models/%s/gen_weights_epoch%s.h5' % (model_name, e))\n generator_model.save_weights(gen_weights_path, overwrite=True)\n\n disc_weights_path = os.path.join('../../models/%s/disc_weights_epoch%s.h5' % (model_name, e))\n discriminator_model.save_weights(disc_weights_path, overwrite=True)\n\n DCGAN_weights_path = os.path.join('../../models/%s/DCGAN_weights_epoch%s.h5' % (model_name, e))\n DCGAN_model.save_weights(DCGAN_weights_path, overwrite=True)\n\n except KeyboardInterrupt:\n pass","def main():\n df = prof_conv_bwd_filter()\n df.to_csv(\"prof.cudnnConvBwdFilter.csv\")\n\n \"\"\"visualization, Roofline model\"\"\"\n df = pd.read_csv('prof.cudnnConvBwdFilter.csv', header=0, index_col=0)\n fig = plt.figure(figsize=(10,5))\n ax = fig.add_subplot(1, 1, 1)\n plot_rooline (ax, MACHINE_SPEC, PEAK_PERF, BAND_WIDTH)\n plot_result (ax, df)\n # fig.subplots_adjust(right=0.8)\n plt.subplots_adjust(left=0.1, right=0.6)\n plt.savefig('roofline.png')\n return","def train_network(self):\n if self.trainData:\n if self.verbose:\n print('Started training...')\n\n for epoch in range(135):\n pass\n # save the model\n else:\n if self.verbose:\n print('No train data available')","def __init__(self, in_channels=3, n_classes=21):\n super(U_Net, self).__init__()\n\n self.layer_0 = UNet_Encoder_Particular(in_channels, 64)\n\n self.layer_1 = UNet_Encoder(64, 128)\n self.layer_2 = UNet_Encoder(128, 256)\n self.layer_3 = UNet_Encoder(256, 512)\n self.layer_4 = UNet_Encoder(512, 512)\n\n self.layer_7 = UNet_Decoder(1024, 256)\n self.layer_8 = UNet_Decoder(512, 128)\n self.layer_9 = UNet_Decoder(256, 64)\n self.layer_10 = UNet_Decoder(128, 64)\n\n self.layer_11 = UNet_Decoder_Particular(64, n_classes)","def train(self):\n\n # Set the pretrain log\n trlog = {}\n trlog['args'] = vars(self.args)\n trlog['train_loss'] = []\n trlog['val_loss'] = []\n trlog['train_acc'] = []\n trlog['val_acc'] = []\n trlog['train_iou']=[]\n trlog['val_iou']=[]\n trlog['max_iou'] = 0.0\n trlog['max_iou_epoch'] = 0\n\n # Set the timer\n timer = Timer()\n # Set global count to zero\n global_count = 0\n # Set tensorboardX\n writer = SummaryWriter(comment=self.args.save_path)\n\n # Start pretrain\n for epoch in range(1, self.args.pre_max_epoch + 1):\n # Update learning rate\n self.lr_scheduler.step()\n # Set the model to train mode\n self.model.train()\n self.model.mode = 'train'\n # Set averager classes to record training losses and accuracies\n train_loss_averager = Averager()\n train_acc_averager = Averager()\n train_iou_averager = Averager()\n\n # Using tqdm to read samples from train loader\n tqdm_gen = tqdm.tqdm(self.train_loader)\n\n for i, batch in enumerate(tqdm_gen, 1):\n # Update global count number \n global_count = global_count + 1\n if torch.cuda.is_available():\n data, label = [_.cuda() for _ in batch]\n else:\n data = batch[0]\n label = batch[1]\n\n # Output logits for model\n logits = self.model(data)\n # Calculate train loss\n # CD loss is modified in the whole project to incorporate ony Cross Entropy loss. Modify as per requirement.\n #loss = self.FL(logits, label) + self.CD(logits,label) + self.LS(logits,label)\n loss = self.CD(logits,label) \n \n # Calculate train accuracy\n self._reset_metrics()\n seg_metrics = eval_metrics(logits, label, self.args.num_classes)\n self._update_seg_metrics(*seg_metrics)\n pixAcc, mIoU, _ = self._get_seg_metrics(self.args.num_classes).values()\n\n # Add loss and accuracy for the averagers\n train_loss_averager.add(loss.item())\n train_acc_averager.add(pixAcc)\n train_iou_averager.add(mIoU)\n\n # Print loss and accuracy till this step\n tqdm_gen.set_description('Epoch {}, Loss={:.4f} Acc={:.4f} IOU={:.4f}'.format(epoch, train_loss_averager.item(),train_acc_averager.item()*100.0,train_iou_averager.item()))\n \n # Loss backwards and optimizer updates\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # Update the averagers\n train_loss_averager = train_loss_averager.item()\n train_acc_averager = train_acc_averager.item()\n train_iou_averager = train_iou_averager.item()\n\n writer.add_scalar('data/train_loss(Pre)', float(train_loss_averager), epoch)\n writer.add_scalar('data/train_acc(Pre)', float(train_acc_averager)*100.0, epoch) \n writer.add_scalar('data/train_iou (Pre)', float(train_iou_averager), epoch)\n \n print('Epoch {}, Train: Loss={:.4f}, Acc={:.4f}, IoU={:.4f}'.format(epoch, train_loss_averager, train_acc_averager*100.0,train_iou_averager)) \n \n # Start validation for this epoch, set model to eval mode\n self.model.eval()\n self.model.mode = 'val'\n\n # Set averager classes to record validation losses and accuracies\n val_loss_averager = Averager()\n val_acc_averager = Averager()\n val_iou_averager = Averager()\n\n # Print previous information \n if epoch % 1 == 0:\n print('Best Val Epoch {}, Best Val IoU={:.4f}'.format(trlog['max_iou_epoch'], trlog['max_iou']))\n\n # Run validation\n for i, batch in enumerate(self.val_loader, 1):\n if torch.cuda.is_available():\n data, labels,_ = [_.cuda() for _ in batch]\n else:\n data = batch[0]\n label=labels[0]\n p = self.args.way*self.args.shot\n data_shot, data_query = data[:p], data[p:]\n label_shot,label=labels[:p],labels[p:]\n \n par=data_shot, label_shot, data_query\n logits = self.model(par)\n # Calculate preval loss\n \n #loss = self.FL(logits, label) + self.CD(logits,label) + self.LS(logits,label)\n loss = self.CD(logits,label) \n \n # Calculate val accuracy\n self._reset_metrics()\n seg_metrics = eval_metrics(logits, label, self.args.way)\n self._update_seg_metrics(*seg_metrics)\n pixAcc, mIoU, _ = self._get_seg_metrics(self.args.way).values()\n\n val_loss_averager.add(loss.item())\n val_acc_averager.add(pixAcc)\n val_iou_averager.add(mIoU) \n\n # Update validation averagers\n val_loss_averager = val_loss_averager.item()\n val_acc_averager = val_acc_averager.item()\n val_iou_averager = val_iou_averager.item()\n \n writer.add_scalar('data/val_loss(Pre)', float(val_loss_averager), epoch)\n writer.add_scalar('data/val_acc(Pre)', float(val_acc_averager)*100.0, epoch) \n writer.add_scalar('data/val_iou (Pre)', float(val_iou_averager), epoch) \n \n # Print loss and accuracy for this epoch\n print('Epoch {}, Val: Loss={:.4f} Acc={:.4f} IoU={:.4f}'.format(epoch, val_loss_averager, val_acc_averager*100.0,val_iou_averager))\n\n # Update best saved model\n if val_iou_averager > trlog['max_iou']:\n trlog['max_iou'] = val_iou_averager\n trlog['max_iou_epoch'] = epoch\n print(\"model saved in max_iou\")\n self.save_model('max_iou')\n\n # Save model every 10 epochs\n if epoch % 10 == 0:\n self.save_model('epoch'+str(epoch))\n\n # Update the logs\n trlog['train_loss'].append(train_loss_averager)\n trlog['train_acc'].append(train_acc_averager)\n trlog['val_loss'].append(val_loss_averager)\n trlog['val_acc'].append(val_acc_averager)\n trlog['train_iou'].append(train_iou_averager)\n trlog['val_iou'].append(val_iou_averager)\n\n # Save log\n torch.save(trlog, osp.join(self.args.save_path, 'trlog'))\n\n if epoch % 1 == 0:\n print('Running Time: {}, Estimated Time: {}'.format(timer.measure(), timer.measure(epoch / self.args.max_epoch)))\n writer.close()","def __init__(self):\n\n TEST_RATIO = 0.05\n mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=None)\n idxs = np.arange(mnist_trainset.train_data.size(0))\n np.random.shuffle(idxs)\n\n #print(torch.min(mnist_trainset.train_labels), torch.max(mnist_trainset.train_labels))\n #print(mnist_trainset.train_labels.size())\n \n # reshape input data to (1, 784) and normalize to range [0., 1.]\n self.train_data = torch.reshape(\n mnist_trainset.train_data[idxs].float(), (-1,1,28,28))/255.\n self.data_size = self.train_data.size(0)\n self.train_len = self.train_data.size(0)\n self.train_label = torch.Tensor([1]).float() # since there is only one class - 'real' image\n\n print('Train images -- {}'.format(self.train_data.size()))","def train_nn(train_nn_results, label, title, yaxis):\n plt.figure(figsize=(12,5))\n for i in range(len(label)):\n plt.plot(train_nn_results[i], label=label[i], alpha=0.75)\n plt.title(title)\n plt.xlabel('epoch')\n plt.ylabel(yaxis)\n plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')\n plt.tight_layout()\n plt.show()","def main(tetrode_number=TETRODE_NUMBER,num_hidden_units=500,num_hidden_units_2=300,num_hidden_units_3=200,num_code_units=50):\n \n print(\"Making the model...\")\n network = model((None,200),200,num_hidden_units,num_hidden_units_2,num_hidden_units_3,num_code_units)\n print(\"Done!\")\n\n\n for tetrode_number in [10]:\n\n print(\"Loading the model parameters from {}\".format(MODEL_FILENAME+str(tetrode_number)))\n f = open(MODEL_FILENAME+str(tetrode_number),'r')\n all_param_values = pickle.load(f)\n f.close()\n # print(all_param_values)\n lasagne.layers.set_all_param_values(network, all_param_values)\n\n print(\"Loading the data...\")\n dataset = load_data(tetrode_number)\n print(\"Done!\")\n\n print(dataset['data'].shape)\n\n print(\"Setting up the training functions...\")\n training = funcs(dataset,network)\n print(\"Done!\")\n\n for i in range(NUM_EPOCHS):\n costs = []\n\n for start, end in zip(range(0, dataset['data'].shape[0], BATCH_SIZE), range(BATCH_SIZE, dataset['data'].shape[0], BATCH_SIZE)):\n cost = training['train'](dataset['data'][start:end],dataset['data'][start:end])\n costs.append(cost)\n\n meanTrainCost = np.mean(np.asarray(costs,dtype=np.float32))\n # accuracy = training['accuracy'](dataset['X_test'],dataset['y_test'])\n\n print(\"Epoch: {}, Training cost: {}\".format(i+1,meanTrainCost))\n # NUM_POINTS = 5000\n codes = training['code'](dataset['data'][0:NUM_POINTS])\n\n \n\n # y = set(list(d.predict(dataset['data'][0:NUM_POINTS])))\n\n # print(y)\n\n # activations_1 = training['activations_1'](dataset['data'][0:NUM_POINTS])\n # activations_2 = training['activations_2'](dataset['data'][0:NUM_POINTS])\n # codes = training['code'](dataset['data'][0:NUM_POINTS])\n # # print(codes.shape)\n # # codes_2d = bh_sne(codes)\n\n # for k in range(3):\n # print(k)\n\n # codes_2d = bh_sne(np.asarray(codes[:(k+1)*12000],dtype=np.float64))\n\n # # d = DPGMM(n_components=10, covariance_type='full')\n # d = DPGMM(n_components=15,n_iter=100)\n\n # d.fit(codes_2d[:(k+1)*12000])\n\n # hdp = d.predict_proba(codes_2d[:(k+1)*12000])\n\n # hdp_1d = [np.argmax(z) for z in hdp]\n\n # print(set(list(hdp_1d)))\n\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=hdp_1d, alpha=0.8,lw=0)\n # plt.savefig('dbscan_labels/deep/sparse/hdp_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\n # plt.close()\n\n # # m = TSNE(n_components=2, random_state=0)\n \n # # codes_2d = m.fit_transform(codes[:NUM_POINTS])\n # # activations_1_2d = bh_sne(activations_1)\n # # activations_2_2d = bh_sne(activations_2)\n\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=dataset['labels'][0:NUM_POINTS][:(k+1)*12000],alpha=0.8,lw=0)\n # plt.savefig('dbscan_labels/deep/sparse/tsne_codes_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\n # plt.close()\n\n # # This is where the code for the video will go\n # ##############################################################################\n # # Compute DBSCAN\n # db = None\n # core_samples_mask = None\n # labels = None\n\n # num_labels = 0\n # eps=1.0\n # while(num_labels < 10):\n # db = DBSCAN(eps=eps, min_samples=10).fit(codes_2d)\n # core_samples_mask = np.zeros_like(db.labels_, dtype=bool)\n # core_samples_mask[db.core_sample_indices_] = True\n # labels = db.labels_\n # num_labels = np.amax(labels)\n # eps -= 0.1\n\n # print(\"Num learned labels: {}\".format(num_labels))\n\n # plt.title('Estimated number of clusters: {}'.format(np.amax(labels)))\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=labels[0:NUM_POINTS][:(k+1)*12000],lw=0)\n # plt.savefig('dbscan_labels/deep/sparse/dbscan_codes_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\n # plt.close()\n\n # # f=open('dbscan_labels/deep/sparse/tetrode_{}.npy'.format(tetrode_number),'w')\n # # pickle.dump(labels, f)\n # # f.close()\n\n codes_2d = bh_sne(np.asarray(codes,dtype=np.float64),theta=0.4)\n\n # d = DPGMM(n_components=10, covariance_type='full')\n d = DPGMM(n_components=15,n_iter=1000)\n\n d.fit(codes_2d)\n\n hdp = d.predict_proba(codes_2d)\n\n hdp_1d = [np.argmax(z) for z in hdp]\n\n print(set(list(hdp_1d)))\n\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=hdp_1d, alpha=0.8,lw=0)\n plt.savefig('dbscan_labels/deep/sparse/hdp_{}.png'.format(tetrode_number), bbox_inches='tight')\n plt.close()\n\n # m = TSNE(n_components=2, random_state=0)\n \n # codes_2d = m.fit_transform(codes[:NUM_POINTS])\n # activations_1_2d = bh_sne(activations_1)\n # activations_2_2d = bh_sne(activations_2)\n\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=dataset['labels'][0:NUM_POINTS],alpha=0.8,lw=0)\n plt.savefig('dbscan_labels/deep/sparse/tsne_codes_{}.png'.format(tetrode_number), bbox_inches='tight')\n plt.close()\n\n # This is where the code for the video will go\n ##############################################################################\n # Compute DBSCAN\n db = None\n core_samples_mask = None\n labels = None\n\n num_labels = 0\n eps=1.0\n while(num_labels < 10):\n db = DBSCAN(eps=eps, min_samples=10).fit(codes_2d)\n core_samples_mask = np.zeros_like(db.labels_, dtype=bool)\n core_samples_mask[db.core_sample_indices_] = True\n labels = db.labels_\n num_labels = np.amax(labels)\n eps -= 0.1\n\n print(\"Num learned labels: {}\".format(num_labels))\n\n plt.title('Estimated number of clusters: {}'.format(np.amax(labels)))\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=labels[0:NUM_POINTS],lw=0)\n plt.savefig('dbscan_labels/deep/sparse/dbscan_codes_{}.png'.format(tetrode_number), bbox_inches='tight')\n plt.close()\n\n # f=open('dbscan_labels/deep/sparse/tetrode_{}.npy'.format(tetrode_number),'w')\n # pickle.dump(labels, f)\n # f.close()","def train_callback(self):\n self.input_weight_1 = 1.0\n self.input_weight_2 = 1.0\n self.bias = 0\n weights = np.array([self.input_weight_1, self.input_weight_2])\n outer_loop = False\n error_array = np.array([5.0, 5.0, 5.0, 5.0])\n \n # ==========================\n # Training starts from here\n # ==========================\n for i in range(0, 100):\n for j in range(0, 4):\n # =======================\n # Getting the input point\n # =======================\n point = self.data_points[j, :]\n \n # =======================\n # Calculating net value\n # =======================\n net_value = np.sum(weights * point) + self.bias # [1x2] * [2x1]\n \n # =======================\n # Calculating error\n # =======================\n error = self.targets[j] - self.get_activation(net_value)\n error_array[j] = error\n \n # ============================================\n # Keeping the error in range from -700 to 700\n # this is to avoid nan or overflow error\n # ============================================\n if error > 1000 or error < -700:\n error /= 10000\n\n # ==========================\n # Updating Weights and bias\n # ==========================\n weights += error * point\n self.bias += error * 1.0 # While updating bias input is always 1\n \n # if weights[0] > 5000 or weights[0] < -5000:\n # weights[0] /= 10000\n # if weights[1] > 5000 or weights[1] < -5000:\n # weights[1] /= 10000\n # if self.bias > 5000 or self.bias < -5000:\n # self.bias /= 10000\n \n # ==================================\n # Printing out the updated weights\n # ==================================\n # print(weights)\n \n if (error_array == np.array([0.0, 0.0, 0.0, 0.0])).all():\n outer_loop = True\n break\n self.x_values = np.linspace(-10, 10, 256)\n \n # ========================================================\n # Getting the y values to plot a linear decision boundary\n # ========================================================\n self.y_values = ((- weights[0] * self.x_values) - self.bias) / weights[1] # Equation of a line\n self.input_weight_1 = weights[0]\n self.input_weight_2 = weights[1]\n \n # ================================\n # plotting the decision boundary\n # ================================\n if i % 20 == 0:\n self.plot_graph()\n \n if outer_loop:\n break\n \n self.plot_graph()\n self.input_weight_1 = weights[0]\n self.input_weight_2 = weights[1]","def plot_train_output(self, n, show=False, amount=10):\n\n fig, axes = plt.subplots(3, 1, sharex = True, figsize = (8, 6))\n ax = axes[0]\n\n # track 'amount' random outputs of the 1000 input simulations\n random_indices = np.random.randint(0,self.n_s, amount)\n outputs = np.asarray(n.history['train output'])[:,random_indices,0]\n end = len(n.history['train output'])\n epochs = np.arange(end)\n\n # plot 'amount' random outputs vs epochs\n for i in range(amount):\n ax.plot(epochs,outputs[:,i],alpha=0.5,ls='dashed')\n\n # plot the network mean of all the input simulations\n ax.plot(epochs, np.array(n.history[\"μ\"])[:,0],ls='solid',label='μ')\n ax.set_ylabel('Network output')\n ax.set_title(f'Output of {amount} random input simulations')\n ax.legend()\n\n # plot the network mean of all the input simulations, in a separate plot\n ax = axes[1]\n ax.plot(epochs, np.array(n.history[\"μ\"])[:,0],ls='solid',label='μ')\n ax.set_title(f'Network mean')\n ax.set_ylabel('Network output')\n\n # plot the numpy mean of this subset\n ax = axes[2]\n ax.set_title('numpy mean/std of the random subset of simulations')\n ax.errorbar(epochs, np.mean(outputs,axis=1), yerr=np.std(outputs,axis=1),label=r'$1\\sigma$',zorder=1)\n ax.plot(epochs, np.mean(outputs,axis=1),label='mean',zorder=2)\n ax.set_ylabel('Value')\n ax.legend()\n \n # print (np.std(outputs,axis=1))\n\n axes[-1].set_xlabel('Epoch')\n plt.tight_layout()\n plt.savefig(f'{self.figuredir}output_vs_epochs_{self.modelversion}.png')\n if show: plt.show()\n plt.close()","def learning_viz(self) :\n self.train\n history = self.history\n plot_loss(history)","def train_network(self, batch_size, epochs):\n\n if self.eq_train: self.model.fit([self.X_train_high_level, self.X_train_low_level], self.y_train, epochs=epochs, batch_size=batch_size, sample_weight=self.train_weights_eq) \n else: self.model.fit([self.X_train_high_level, self.X_train_low_level], self.y_train, epochs=epochs, batch_size=batch_size, sample_weight=self.train_weights)","def train_nasnetmobile():\n\n # load data\n training_sets = load_augmented_dataset()\n\n # build models\n model_nas = build_nasnet()\n\n baseWeights_t = model_nas.get_weights()\n\n # NOTE: You can still leave this alone if you've only downloaded the fully augmented set.\n for training_set in training_sets:\n print(\" Starting training for set {}\".format(str(training_set)))\n model_nas.set_weights(baseWeights_t) # Resets model\n train_x = np.load(os.path.join(\"./model_cache/train_data\", training_sets[training_set][0]))\n train_y = np.load(os.path.join(\"./model_cache/train_data\", training_sets[training_set][1]))\n\n early_stopping_monitor = EarlyStopping(patience=2)\n history = model_nas.fit(train_x, train_y, batch_size=32, epochs=20, verbose=1, validation_split=0.2,\n shuffle=True,\n callbacks=[early_stopping_monitor])\n\n mpu.plot_accuracy_loss(history,\n \"./model_cache/train_data/{}_nasnetmobile_plots.png\".format(str(training_set)))\n\n upload_blob(BUCKET_NAME, \"./model_cache/train_data/{}_nasnetmobile_plots.png\".format(str(training_set)),\n \"model_charts/{}_nasnetmobile_plots.png\".format(str(training_set)))\n\n model_nas.save(\"./model_cache/train_data/{}_nasnetmobile.h5\".format(str(training_set)))\n\n upload_blob(BUCKET_NAME, \"./model_cache/train_data/{}_nasnetmobile.h5\".format(str(training_set)),\n \"saved_models/{}_nasnetmobile.h5\".format(str(training_set)))"],"string":"[\n \"def trainNet():\",\n \"def demo(image, model_class, do_add_noise=True):\\n Log.enable_output = True\\n Log.set_log_max_depth(8)\\n\\n image = normalise(image)\\n image = numpy.expand_dims(image, axis=0)\\n image = numpy.expand_dims(image, axis=0)\\n noisy = add_noise(image) if do_add_noise else image\\n print(noisy.shape)\\n\\n # noisy = models.tensor(noisy)\\n image = torch.tensor(image)\\n\\n model = model_class(\\n nb_unet_levels=2,\\n spacetime_ndim=2,\\n )\\n\\n print(\\\"training starts\\\")\\n\\n start = time.time()\\n n2t_train(noisy, model, nb_epochs=128)\\n stop = time.time()\\n print(f\\\"Training: elapsed time: {stop - start} \\\")\\n\\n noisy = torch.tensor(noisy)\\n model.eval()\\n model = model.cpu()\\n print(f\\\"noisy tensor shape: {noisy.shape}\\\")\\n # in case of batching we have to do this:\\n start = time.time()\\n denoised = model(noisy)\\n stop = time.time()\\n print(f\\\"inference: elapsed time: {stop - start} \\\")\\n\\n noisy = noisy.detach().numpy()[0, 0, :, :]\\n image = image.detach().numpy()[0, 0, :, :]\\n denoised = denoised.detach().numpy()[0, 0, :, :]\\n\\n image = numpy.clip(image, 0, 1)\\n noisy = numpy.clip(noisy, 0, 1)\\n denoised = numpy.clip(denoised, 0, 1)\\n\\n return calculate_print_psnr_ssim(image, noisy, denoised)\\n\\n # import napari\\n #\\n # viewer = napari.Viewer() # no prior setup needed\\n # viewer.add_image(image, name='image')\\n # viewer.add_image(noisy, name='noisy')\\n # viewer.add_image(denoised, name='denoised')\\n # napari.run()\",\n \"def main(u_net_settings):\\n model = build_u_net(*u_net_settings)\\n print(model.summary())\",\n \"def train(args):\\n # Create the data loader\\n loader = sunnerData.DataLoader(\\n dataset = sunnerData.ImageDataset(\\n root = [[args.train]],\\n transforms = transforms.Compose([\\n \\n# transforms.RandomCrop(720,720)\\n# transforms.RandomRotation(45)\\n# transforms.RandomHorizontalFlip(), \\n# transforms.ColorJitter(brightness=0.5, contrast=0.5),\\n \\n\\n sunnerTransforms.Resize(output_size = (args.H, args.W)),\\n #transforms.RandomCrop(512,512)\\n sunnerTransforms.ToTensor(),\\n sunnerTransforms.ToFloat(),\\n # sunnerTransforms.Transpose(),\\n sunnerTransforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),\\n ])\\n ), batch_size = args.batch_size, shuffle = True, num_workers = 2\\n )\\n loader = sunnerData.IterationLoader(loader, max_iter = args.n_iter)\\n\\n # Create the model\\n model = GANomaly2D(r = args.r, device = args.device)\\n model.IO(args.resume, direction = 'load')\\n model.train()\\n \\n # Train!\\n bar = tqdm(loader)\\n for i, (normal_img,) in enumerate(bar):\\n model.forward(normal_img)\\n model.backward()\\n loss_G, loss_D = model.getLoss()\\n bar.set_description(\\\"Loss_G: \\\" + str(loss_G) + \\\" loss_D: \\\" + str(loss_D))\\n bar.refresh()\\n if i % args.record_iter == 0:\\n model.eval()\\n with torch.no_grad():\\n z, z_ = model.forward(normal_img)\\n img, img_ = model.getImg()\\n visualizeEncoderDecoder(img, img_, z, z_,i)\\n model.train()\\n model.IO(args.det, direction = 'save')\\n model.IO(args.det, direction = 'save')\",\n \"def nn(data):\\n training_set = SupervisedDataSet*\\n\\n\\n input_nodes = 3\\n hidden_layer_1 = 10\\n hidden_layer_2 = 10\\n output_layer = 5\\n\\n net = buildNetwork(input_nodes, hidden_layer_1, hidden_layer_2, output_layer, bias=True, hiddenclass=TanhLayer)\",\n \"def train(self, nsamples = 1, verbose = False, random = True):\\n imgs, skels = self.images.get_batch(nimages = nsamples, random = random);\\n self.trainer.run(session = self.session, feed_dict={self.input : imgs, self.skeleton : skels})\\n if verbose:\\n self.plot_results(imgs);\",\n \"def run_simple_CNN():\\n [train_set, test_set, train_sampler, val_sampler, test_sampler] = pre_processing_and_samples()\\n CNN = SimpleCNN()\\n # Using GPU for training\\n device = torch.device(\\\"cuda:0\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n print(device)\\n if torch.cuda.is_available():\\n print(\\\"cuda is available\\\")\\n CNN.to(device)\\n\\n # Multiple GPUs\\n if torch.cuda.device_count() > 1:\\n CNN = nn.DataParallel(CNN)\\n\\n num_epochs = 100\\n\\n train_loss_hist, train_acc_hist, val_loss_hist, val_acc_hist = \\\\\\n trainCNN(net=CNN, device=device, batch_size=64, n_epochs=num_epochs, learning_rate=0.001,\\n train_set=train_set, test_set=test_set, train_sampler=train_sampler, val_sampler=val_sampler)\\n test(net=CNN, device=device, test_set=test_set, test_sampler=test_sampler)\\n\\n fig, (ax1, ax2) = plt.subplots(2)\\n\\n ax1.set_title(\\\"Loss vs. Number of Training Epochs\\\")\\n ax1.set(xlabel=\\\"Training Epoch\\\", ylabel=\\\"Loss\\\")\\n ax1.plot(range(1, len(train_loss_hist) + 1), train_loss_hist, label=\\\"Training\\\")\\n ax1.plot(range(1, len(val_loss_hist) + 1), val_loss_hist, label=\\\"Validation\\\")\\n print(np.concatenate((train_loss_hist, val_loss_hist)))\\n print(np.amax(np.concatenate((train_loss_hist, val_loss_hist))))\\n ax1.set_ylim(\\n (0, 1.25 * np.amax(np.concatenate((train_loss_hist, val_loss_hist), axis=0, out=None)).detach().cpu()))\\n ax1.set_xticks(np.arange(1, num_epochs + 1, 1.0))\\n ax1.legend()\\n\\n ax2.set_title(\\\"Accuracy vs. Number of Training Epochs\\\")\\n ax2.set(xlabel=\\\"Training Epoch\\\", ylabel=\\\"Accuracy\\\")\\n ax2.plot(range(1, num_epochs + 1), train_acc_hist, label=\\\"Training\\\")\\n ax2.plot(range(1, num_epochs + 1), val_acc_hist, label=\\\"Validation\\\")\\n ax2.set_ylim(0, 100) # Sets y bounds\\n ax2.set_xticks(np.arange(1, num_epochs + 1, 1.0))\\n ax2.legend()\\n\\n plt.tight_layout() # Call after plotting all subplots\\n plt.savefig('basic_cifar_10.png')\",\n \"def train_segmentation():\\n\\n start = time.time()\\n\\n model_base = load_pretrained(get_base(), PRETRAINED)\\n cut, lr = model_meta[arch]\\n m = to_gpu(Unet34(model_base))\\n model = UnetModel(m)\\n\\n sz = 256\\n bs = 64\\n\\n md = get_data(sz, bs)\\n\\n learn = ConvLearner(md, model)\\n learn.opt_fn = optim.Adam()\\n learn.crit = LossBinary(jaccard_weight=5)\\n learn.metrics = [accuracy_thresh(0.5), dice, IoU]\\n wd = 1e-7\\n lr = 1e-2\\n\\n learn.freeze_to(1)\\n learn.fit(lr, 1, wds=wd, cycle_len=1, use_clr=(5,8))\\n learn.unfreeze() # unfreeze encoder\\n learn.bn_freeze(True)\\n\\n lrs = np.array([lr/100, lr/10, lr])\\n learn.fit(lrs/3, 2, wds=wd, cycle_len=2, use_clr=(20,8))\\n\\n learn.save('./models/weighted_unet_256_p1')\\n\\n sz = 384\\n bs = 32\\n\\n md = get_data(sz, bs)\\n learn.set_data(md)\\n learn.unfreeze()\\n learn.bn_freeze(True)\\n\\n learn.fit(lrs/5, 1, wds=wd, cycle_len=2, use_clr(10,8)) # first increase in image size with decreased bs\\n learn.save('./models/weighted_unet_384_p1')\\n\\n sz = 512\\n bs = 16\\n\\n md = get_data(sz, bs)\\n learn.set_data(md)\\n learn.unfreeze()\\n learn.bn_freeze(True)\\n\\n learn.fit(lrs/10, 2, wds=wd, cycle_len=1, use_clr=(10,8), best_save_name='./models/weighted_unet_512_p1') # second increase in image size with further decreased bs\\n\\n sz = 768\\n bs = 8\\n\\n md = get_data(sz, bs)\\n learn.set_data(md)\\n learn.unfreeze()\\n learn.bn_freeze(True)\\n\\n learn.fit(lrs/50, 10, wds=5e-8, cycle_len=1, use_clr=(10,10), best_save_name='./models/weighted_unet_768_p1') # full image size with further decreased bs\\n\\n learn.crit = MixedLoss(10., 2.)\\n learn.fit(lrs/50, 10, wds=5e-8, cycle_len=1, use_clr=(10,10), best_save_name='./models/weighted_unet_768_p2') # full image size with further decreased bs (final run)\\n\\n learn.save('./models/weighted_unet_768_final')\\n\\n print(f'Training finished in {time.time() - start) / 60 :.3} minutes.')\",\n \"def train(net):\\n\\n # Set SGD hyperparameters\\n n_iter = 200 # number of iterations of SGD\\n learning_rate = 1e-3 # learning rate for SGD\\n momentum = .99 # momentum parameter for SGD\\n batch_size = 100 # number of data points in each mini-batch\\n\\n # Initialize binary cross-entropy loss function\\n loss_fn = nn.BCELoss()\\n\\n # Initialize SGD optimizer with momentum\\n optimizer = optim.SGD(net.parameters(), lr=learning_rate, momentum=momentum)\\n\\n # Placeholder to save loss at each iteration\\n track_loss = []\\n\\n # Loop over iterations\\n for i in range(n_iter):\\n\\n # Sample minibatch of oriented grating stimuli\\n stimuli, tilt = sample_stimuli(batch_size)\\n\\n # Evaluate loss and update network weights\\n out = net(stimuli) # predicted probability of tilt right\\n loss = loss_fn(out, tilt) # evaluate loss\\n optimizer.zero_grad() # clear gradients\\n loss.backward() # compute gradients\\n optimizer.step() # update weights\\n \\n # Keep track of loss at each iteration\\n track_loss.append(loss.item())\\n\\n # Track progress\\n if (i + 1) % (n_iter / 10) == 0:\\n print('iteration %i | loss: %.3f | percent correct: %.2f%%' % (i + 1, loss.item(), 100 * pcorrect(out, tilt)))\\n \\n # Plot loss\\n plt.plot(track_loss)\\n plt.xlabel('iterations of SGD')\\n plt.ylabel('binary cross-entropy loss')\\n plt.xlim([0, None])\\n plt.ylim([0, None])\\n plt.show()\",\n \"def visualize_manipulation_training(flow, epoch, save_dir=None):\\n\\n # Basic figure setup\\n images_x = 3\\n images_y = 3 if isinstance(flow.codec, DCN) else 2\\n fig = Figure(figsize=(18, 10 / images_x * images_y))\\n conf = np.array(flow.fan.performance['confusion'])\\n \\n # Draw the plots\\n ax = fig.add_subplot(images_y, images_x, 1)\\n ax.plot(flow.nip.performance['loss']['training'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['loss']['training'], 0))\\n ax.set_ylabel('{} NIP loss'.format(flow.nip.class_name))\\n ax.set_title('Loss')\\n\\n ax = fig.add_subplot(images_y, images_x, 2)\\n ax.plot(flow.nip.performance['psnr']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['psnr']['validation'], 0))\\n ax.set_ylabel('{} NIP psnr'.format(flow.nip.class_name))\\n ax.set_title('PSNR')\\n ax.set_ylim([30, 50])\\n\\n ax = fig.add_subplot(images_y, images_x, 3)\\n ax.plot(flow.nip.performance['ssim']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['ssim']['validation'], 0))\\n ax.set_ylabel('{} NIP ssim'.format(flow.nip.class_name))\\n ax.set_title('SSIM')\\n ax.set_ylim([0.8, 1])\\n \\n ax = fig.add_subplot(images_y, images_x, 4)\\n ax.plot(flow.fan.performance['loss']['training'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.fan.performance['loss']['training'], 0))\\n ax.set_ylabel('FAN loss')\\n\\n ax = fig.add_subplot(images_y, images_x, 5)\\n ax.plot(flow.fan.performance['accuracy']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.fan.performance['accuracy']['validation'], 0))\\n ax.set_ylabel('FAN accuracy')\\n ax.set_ylim([0, 1])\\n\\n # The confusion matrix\\n ax = fig.add_subplot(images_y, images_x, 6)\\n ax.imshow(conf, vmin=0, vmax=1)\\n\\n ax.set_xticks(range(flow.n_classes))\\n ax.set_xticklabels(flow._forensics_classes, rotation='vertical')\\n ax.set_yticks(range(flow.n_classes))\\n ax.set_yticklabels(flow._forensics_classes)\\n\\n for r in range(flow.n_classes):\\n ax.text(r, r, '{:.2f}'.format(conf[r, r]), horizontalalignment='center', color='b' if conf[r, r] > 0.5 else 'w')\\n\\n ax.set_xlabel('PREDICTED class')\\n ax.set_ylabel('TRUE class')\\n ax.set_title('Accuracy: {:.2f}'.format(np.mean(np.diag(conf))))\\n\\n # If the compression model is a trainable DCN, include it's validation metrics\\n if images_y == 3:\\n ax = fig.add_subplot(images_y, images_x, 7)\\n ax.plot(flow.codec.performance['loss']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['loss']['validation'], 0))\\n ax.set_ylabel('DCN loss')\\n\\n ax = fig.add_subplot(images_y, images_x, 8)\\n ax.plot(flow.codec.performance['ssim']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['ssim']['validation'], 0))\\n ax.set_ylabel('DCN ssim')\\n ax.set_ylim([0.8, 1])\\n\\n ax = fig.add_subplot(images_y, images_x, 9)\\n ax.plot(flow.codec.performance['entropy']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['entropy']['validation'], 0))\\n ax.set_ylabel('DCN entropy')\\n\\n if save_dir is not None:\\n if not os.path.exists(save_dir):\\n os.makedirs(save_dir)\\n fig.savefig('{}/manip_validation_{:05d}.jpg'.format(save_dir, epoch), bbox_inches='tight', dpi=100)\\n del fig\\n\\n else:\\n return fig\",\n \"def main(self):\\r\\n\\r\\n #Train the GEN and DISC\\r\\n self.modelTrain.main()\\r\\n self.disp.show()\",\n \"def train(self, dat_in, dat_out):\\n self.net.fit(dat_in, dat_out)\\n # Oftentimes, the training log statements do not end with a newline.\\n print()\",\n \"def train_visualization(output_path): \\n log_path = output_path + 'output.log'\\n Train_Cost, Valid_Cost, Test_Cost, Train_Acc, Valid_Acc, Test_Acc = log_reader(log_path)\\n n_epoch = len(Train_Cost)\\n\\n x1 = range(n_epoch)\\n x2 = range(n_epoch)\\n y1 = Train_Cost\\n y2 = Valid_Cost\\n y3 = Test_Cost\\n y4 = Train_Acc\\n y5 = Valid_Acc\\n y6 = Test_Acc\\n plt.subplot(2, 1, 1)\\n plt.plot(x1, y1, label=\\\"Train_Cost\\\", linewidth=2)\\n plt.plot(x1, y2, label=\\\"Valid_Cost\\\", linewidth=2)\\n plt.plot(x1, y3, label=\\\"Test_Cost\\\", linewidth=2)\\n\\n plt.title('binary cross entropy vs. epoches')\\n plt.ylabel('binary cross entropy')\\n plt.legend(loc='best')\\n plt.subplot(2, 1, 2)\\n plt.plot(x2, y4, label=\\\"Train_Acc\\\", linewidth=2)\\n plt.plot(x2, y5, label=\\\"Valid_Acc\\\", linewidth=2)\\n plt.plot(x2, y6, label=\\\"Test_Acc\\\", linewidth=2)\\n plt.xlabel('Accuracy@20 vs. epoches')\\n plt.ylabel('Accuracy@20')\\n plt.legend(loc='best')\\n plt.savefig(output_path + 'loss_fig.png')\\n # plt.show()\",\n \"def train_one_epoch_Image_display(self):\\n print('Training......')\\n\\n # set mode train\\n self.network.train()\\n\\n # prepare data\\n train_loss = 0\\n transform = transforms.Compose([Rescale(params.rescale_size),\\n RandomCrop(params.image_size),\\n RandomHorizontalFlip(),\\n ToTensor()\\n ])\\n\\n\\n\\n dataset = Cityscapes(params.dataset_root, mode='train', transforms = transform)\\n\\n train_loader = DataLoader(dataset,\\n batch_size=params.train_batch,\\n shuffle=params.shuffle,\\n num_workers=params.dataloader_workers)\\n \\n train_size = 1896\\n if train_size % self.params.train_batch != 0:\\n total_batch = train_size // self.params.train_batch + 1\\n else:\\n total_batch = train_size // self.params.train_batch\\n recal = 0\\n precision = 0\\n F_one = 0\\n IOU = 0\\n accuracy_new = 0 \\n # train through dataset\\n for batch_idx, batch in enumerate(train_loader):\\n self.pb.click(batch_idx, total_batch)\\n image, label = batch['image'], batch['label']\\n image_cuda, label_cuda = image.cuda(), label.cuda()\\n\\n # checkpoint split\\n if self.params.should_split:\\n image_cuda.requires_grad_()\\n out = checkpoint_sequential(self.network, self.params.split, image_cuda)\\n else:\\n out = self.network(image_cuda)\\n \\n pred = image_cuda\\n pred = pred.to(torch.device(\\\"cpu\\\"))\\n pred = pred.detach()\\n img_grid = pred[0]\\n #img_grid = torchvision.utils.make_grid(out) \\n img_grid = img_grid.numpy().transpose(1, 2, 0)*255\\n cv2.imwrite(\\\"/content/drive/My Drive/Train_images/original%d.jpg\\\" % batch_idx, img_grid)\\n\\n \\n loss = self.loss_fn(out, label_cuda)\\n \\n #display_image(out, label_cuda)\\n TP, FP, TN, FN = confusion(out, label_cuda)\\n recal = recal+TP\\n precision = precision+FP\\n F_one = F_one + TN\\n IOU = IOU+ FN \\n _,predict = torch.max(out.data,1)\\n predict = predict.to(torch.device(\\\"cpu\\\"))\\n predict = predict.detach()\\n img = predict[0]\\n img = img.numpy()*255\\n #img_grid = torchvision.utils.make_grid(out) \\n cv2.imwrite(\\\"/content/drive/My Drive/Train_images/predict_label%d.png\\\" % batch_idx, img)\\n label = label_cuda.to(torch.device(\\\"cpu\\\"))\\n label = label.detach()\\n label = label[0].numpy()*255\\n cv2.imwrite(\\\"/content/drive/My Drive/Train_images/original_label%d.png\\\" % batch_idx, label)\\n\\n \\n \\n\\n accuracy_final = accuracy(out, label_cuda)\\n accuracy_new = accuracy_new + accuracy_final\\n\\n \\n print(\\\"\\\\t\\\")\\n print(recal/total_batch, precision/ total_batch, F_one/ total_batch, IOU/ total_batch)\\n print(accuracy_new/total_batch)\",\n \"def TrainNetwork(self):\\n\\n self.logger.info('Train Network')\\n self.netWork.TrainGenerator()\\n\\n # # train NetworkLSTM\\n self.logger.info('Train NetworkLSTM')\\n self.netWork.TrainLSTM()\",\n \"def trainNetwork():\\n plot_data = {}\\n plot_data['train_loss'] = []\\n plot_data['valid_loss'] = []\\n plot_data['train_acc'] = []\\n plot_data['valid_acc'] = []\\n plot_data['lr'] = []\\n SAVE_DIR = 'C:/Users/Dario/Desktop/Projekt/Drugi labos/lab2_torch/figures'\\n device = torch.device('cuda')\\n\\n net = ConvolutionalModel(3, 16, 128, 10).to(device=device)\\n\\n lossFunc = nn.CrossEntropyLoss()\\n optimizer = optim.Adam(net.parameters(), lr=0.001)\\n scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.95)\\n\\n epoch = 10\\n \\n\\n for e in range(epoch):\\n \\n accLoss = 0.0\\n\\n for i, data in enumerate(data_load.trainloader, 0):\\n inputs, labels = data\\n inputs = inputs.to(device=device)\\n labels = labels.to(device=device)\\n\\n optimizer.zero_grad()\\n\\n outputs = net.forward(inputs)\\n loss = lossFunc(outputs, labels)\\n loss.backward()\\n optimizer.step()\\n\\n accLoss += loss.item()\\n\\n if i % 100 == 0:\\n print(\\\"Epoch: %d, Iteration: %5d, Loss: %.3f\\\" % ((e + 1), (i), (accLoss / (i + 1))))\\n \\n train_loss, train_acc = evaluate.evaluate(net, False)\\n val_loss, val_acc = evaluate.evaluate(net, True)\\n\\n plot_data['train_loss'] += [train_loss]\\n plot_data['valid_loss'] += [val_loss]\\n plot_data['train_acc'] += [train_acc]\\n plot_data['valid_acc'] += [val_acc]\\n plot_data['lr'] += [scheduler.get_lr()]\\n\\n scheduler.step()\\n\\n plot.plot_training_progress(SAVE_DIR, plot_data)\\n PATH = './CIFAR_10/cifar_netAdam.pth'\\n torch.save(net.state_dict(), PATH)\",\n \"def main():\\n\\n NUM_TRAIN = noise.init_train_thresh\\n NUM_TEST = 20\\n XDIM = 1\\n\\n # Train the emulator\\n x_train = np.random.uniform(size=(NUM_TRAIN, XDIM))\\n y_train = np.array([noise(x) for x in x_train])\\n\\n # Output error estimates\\n noise.output_err = True\\n\\n # Get values from the trained emulator\\n x_emu = np.random.uniform(size=(NUM_TEST, XDIM))\\n\\n y_emu = np.zeros_like(x_emu)\\n y_err = np.zeros_like(x_emu)\\n\\n for i, x in enumerate(x_emu):\\n val, err = noise(x)\\n y_emu[i] = val\\n y_err[i] = err\\n\\n # Plot the results\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n\\n ax.scatter(x_train[:, 0], y_train, marker=\\\"+\\\", label=\\\"training values\\\")\\n ax.errorbar(\\n x_emu,\\n y_emu[:, 0],\\n yerr=y_err.flatten(),\\n linestyle=\\\"None\\\",\\n marker=\\\"o\\\",\\n capsize=3,\\n label=\\\"emulator\\\",\\n color=\\\"red\\\",\\n )\\n\\n ax.legend()\\n\\n # `__file__` is undefined when running in sphinx\\n try:\\n fig.savefig(__file__ + \\\".png\\\")\\n except NameError:\\n pass\",\n \"def represent():\\n\\tmodel.eval()\\n\\twith torch.no_grad():\\n\\n\\t\\tall_data = []\\n\\t\\tall_targets = []\\n\\n\\t\\tfor batch_idx, (data, labels) in enumerate(nat_test_loader):\\n\\t\\t\\tall_data.append(data)\\n\\t\\t\\tall_targets.append(labels.float()+50) # +50 for nat data, for distinction between nat and syn\\n\\t\\tfor batch_idx, (data, labels) in enumerate(syn_test_loader):\\n\\t\\t\\tall_data.append(data)\\n\\t\\t\\tall_targets.append(labels.float())\\n\\n\\t\\tall_data = torch.cat(all_data, 0) # Merges the list of tensors\\n\\t\\tall_data = all_data.cuda()\\n\\t\\tall_targets = torch.cat(all_targets, 0)\\n\\n\\t\\trepresentation = model.representation(all_data)\\n\\t\\t\\n\\t\\ttorch.save(representation, directory + \\\"/representations/repr\\\" + str(epoch) + \\\".pt\\\")\\n\\t\\twith open(directory + \\\"/representations/tar\\\" + str(epoch) + \\\".log\\\", \\\"w\\\") as f:\\n\\t\\t\\tfor t in all_targets:\\n\\t\\t\\t\\tf.write(str(t.item()) + \\\"\\\\n\\\")\\n\\n\\t\\t# Optional: Plotting of the UMAP in each represent()\\n\\t\\t#sns.set(style='white', context='notebook', rc={'figure.figsize': (14, 10)})\\n\\t\\t#reducer = umap.UMAP()\\n\\t\\t#embedding = reducer.fit_transform(representation.cpu())\\n\\t\\t# flatui = [\\\"#ff0000\\\", \\\"#000000\\\", \\\"#001800\\\", \\\"#003000\\\", \\\"#004800\\\", \\\"#006000\\\", \\\"#007800\\\", \\\"#009000\\\", \\\"#00a800\\\", \\\"#00c000\\\", \\\"#00d800\\\"]\\n\\t\\t# plt.scatter(embedding[:, 0], embedding[:, 1], c=[sns.color_palette(flatui)[x] for x in all_targets.int()])\\n\\t\\t#plt.scatter(embedding[:, 0], embedding[:, 1], c=all_targets.cpu())\\n\\t\\t#plt.gca().set_aspect('equal', 'datalim')\\n\\t\\t#plt.title('UMAP projection of cell data', fontsize=24);\\n\\t\\t#plt.savefig(directory + \\\"/umap_\\\" + str(epoch) + \\\".png\\\")\\n\\t\\t#plt.clf()\",\n \"def testvis(layers='first'):\\n\\n\\tfrom scipy.io import loadmat\\n\\tfrom setup import NeuralNetwork as nnsetup\\n\\n\\tresult = loadmat(\\\"goodmatx.mat\\\")\\n\\tw1 = result['v1']\\n\\tw0 = result['v0']\\n\\tx,y = result['train_x'], result['train_y']\\n\\n\\t# result = loadmat(\\\"ducky.mat\\\")\\n\\t# x = result['train_x']\\n\\t# y = result['train_y']\\n\\n\\tsize = [x.shape[1], 1000, y.shape[1]]\\n\\n\\tnn = nnsetup([size[0],size[1],size[0]],output='sigm')\\n\\n\\tnn.W[0] = w0\\n\\tnn.W[1] = w1\\n\\t\\n\\tfor i in range(50):\\n\\t\\tvisualize( nn, x, k = 3000+i*4, layers=layers, mode='save' )\",\n \"def __call__(self, inputs, labels, train_iter, epoch):\\n debug = False\\n visualize_training = False\\n tmp_show_epoches_list = []\\n\\n # if show_epochs_list is empty, all epoches should be plotted. Therefore, add current epoch to the list\\n if not self.show_epochs_list:\\n tmp_show_epoches_list.append(epoch)\\n else:\\n tmp_show_epoches_list = self.show_epochs_list\\n\\n # check if epoch should be visualized\\n if epoch in tmp_show_epoches_list:\\n # print the model's parameter dimensions etc in the first iter\\n if train_iter == 0 and epoch == 0:\\n debug = True\\n # visualize training on the last iteration in that epoch\\n elif (train_iter == 1 and epoch == 0) or (train_iter == self.max_train_iters):\\n visualize_training = True\\n\\n # for nitorch models which have a 'debug' and 'visualize_training' switch in the\\n # forward() method\\n\\n # Todo: Check if self.model.module.set_debug(debug) is still possible?\\n\\n if isinstance(self.model, nn.DataParallel):\\n self.model.module.set_debug(debug)\\n else:\\n self.model.set_debug(debug)\\n\\n outputs, encoder_out = self.model(inputs)\\n\\n if visualize_training:\\n # check if result should be plotted in PDF\\n if self.plot_pdf_path != \\\"\\\":\\n pp = PdfPages(os.path.join(self.plot_pdf_path, \\\"training_epoch_\\\" + str(epoch) + \\\"_visualization.pdf\\\"))\\n else:\\n pp = None\\n\\n # show only the first image in the batch\\n if pp is None:\\n # input image\\n show_brain(inputs[0].squeeze().cpu().detach().numpy(), draw_cross=False, cmap=self.cmap)\\n plt.suptitle(\\\"Input image\\\")\\n plt.show()\\n if not torch.all(torch.eq(inputs[0], labels[0])):\\n show_brain(labels[0].squeeze().cpu().detach().numpy(), draw_cross=False, cmap=self.cmap)\\n plt.suptitle(\\\"Expected reconstruction\\\")\\n plt.show()\\n # reconstructed image\\n show_brain(outputs[0].squeeze().cpu().detach().numpy(), draw_cross=False, cmap=self.cmap)\\n plt.suptitle(\\\"Reconstructed Image\\\")\\n plt.show()\\n # statistics\\n print(\\n \\\"\\\\nStatistics of expected reconstruction:\\\\n(min, max)=({:.4f}, {:.4f})\\\\nmean={:.4f}\\\\nstd={:.4f}\\\".format(\\n labels[0].min(), labels[0].max(), labels[0].mean(), labels[0].std()))\\n print(\\n \\\"\\\\nStatistics of Reconstructed image:\\\\n(min, max)=({:.4f}, {:.4f})\\\\nmean={:.4f}\\\\nstd={:.4f}\\\".format(\\n outputs[0].min(), outputs[0].max(), outputs[0].mean(), outputs[0].std()))\\n # feature maps\\n visualize_feature_maps(encoder_out[0])\\n plt.suptitle(\\\"Encoder output\\\")\\n plt.show()\\n else:\\n # input image\\n fig = show_brain(inputs[0].squeeze().cpu().detach().numpy(), draw_cross=False, return_fig=True,\\n cmap=self.cmap)\\n plt.suptitle(\\\"Input image\\\")\\n pp.savefig(fig)\\n plt.close(fig)\\n if not torch.all(torch.eq(inputs[0], labels[0])):\\n fig = show_brain(labels[0].squeeze().cpu().detach().numpy(), draw_cross=False, cmap=self.cmap)\\n plt.suptitle(\\\"Expected reconstruction\\\")\\n pp.savefig(fig)\\n plt.close(fig)\\n # reconstructed image\\n fig = show_brain(outputs[0].squeeze().cpu().detach().numpy(), draw_cross=False, return_fig=True,\\n cmap=self.cmap)\\n plt.suptitle(\\\"Reconstructed Image\\\")\\n pp.savefig(fig)\\n plt.close(fig)\\n # feature maps\\n if self.plotFeatures:\\n fig = visualize_feature_maps(encoder_out[0], return_fig=True)\\n plt.suptitle(\\\"Encoder output\\\")\\n pp.savefig(fig)\\n plt.close(fig)\\n\\n # close the PDF\\n if pp is not None:\\n pp.close()\\n\\n if isinstance(self.model, nn.DataParallel):\\n self.model.module.set_debug(False)\\n else:\\n self.model.set_debug(False)\\n\\n return outputs\",\n \"def run_net(inputs, **parameter):\\n\\n # ---- set numpy random state for each run----\\n np.random.set_state(np_state)\\n\\n # -----parameter setting-------\\n n_ex = 1600\\n n_inh = int(n_ex / 4)\\n n_input = MNIST_shape[1] * coding_n\\n n_read = n_ex + n_inh\\n\\n R = parameter['R']\\n f_in = parameter['f_in']\\n f_EE = parameter['f_EE']\\n f_EI = parameter['f_EI']\\n f_IE = parameter['f_IE']\\n f_II = parameter['f_II']\\n\\n A_EE = 60 * f_EE\\n A_EI = 60 * f_EI\\n A_IE = 60 * f_IE\\n A_II = 60 * f_II\\n A_inE = 60 * f_in\\n A_inI = 60 * f_in\\n\\n tau_ex = parameter['tau_ex'] * coding_duration\\n tau_inh = parameter['tau_inh'] * coding_duration\\n tau_read = 30\\n\\n p_inE = parameter['p_in'] * 0.1\\n p_inI = parameter['p_in'] * 0.1\\n\\n # ------definition of equation-------------\\n neuron_in = '''\\n I = stimulus(t,i) : 1\\n '''\\n\\n neuron = '''\\n tau : 1\\n dv/dt = (I-v) / (tau*ms) : 1 (unless refractory)\\n dg/dt = (-g)/(3*ms) : 1\\n dh/dt = (-h)/(6*ms) : 1\\n I = (g+h)+13.5: 1\\n x : 1\\n y : 1\\n z : 1\\n '''\\n\\n neuron_read = '''\\n tau : 1\\n dv/dt = (I-v) / (tau*ms) : 1\\n dg/dt = (-g)/(3*ms) : 1 \\n dh/dt = (-h)/(6*ms) : 1\\n I = (g+h): 1\\n '''\\n\\n synapse = '''\\n w : 1\\n '''\\n\\n on_pre_ex = '''\\n g+=w\\n '''\\n\\n on_pre_inh = '''\\n h-=w\\n '''\\n\\n # -----Neurons and Synapses setting-------\\n Input = NeuronGroup(n_input, neuron_in, threshold='I > 0', method='euler', refractory=0 * ms,\\n name='neurongroup_input')\\n\\n G_ex = NeuronGroup(n_ex, neuron, threshold='v > 15', reset='v = 13.5', method='euler', refractory=3 * ms,\\n name='neurongroup_ex')\\n\\n G_inh = NeuronGroup(n_inh, neuron, threshold='v > 15', reset='v = 13.5', method='euler', refractory=2 * ms,\\n name='neurongroup_in')\\n\\n G_readout = NeuronGroup(n_read, neuron_read, method='euler', name='neurongroup_read')\\n\\n S_inE = Synapses(Input, G_ex, synapse, on_pre=on_pre_ex, method='euler', name='synapses_inE')\\n\\n S_inI = Synapses(Input, G_inh, synapse, on_pre=on_pre_ex, method='euler', name='synapses_inI')\\n\\n S_EE = Synapses(G_ex, G_ex, synapse, on_pre=on_pre_ex, method='euler', name='synapses_EE')\\n\\n S_EI = Synapses(G_ex, G_inh, synapse, on_pre=on_pre_ex, method='euler', name='synapses_EI')\\n\\n S_IE = Synapses(G_inh, G_ex, synapse, on_pre=on_pre_inh, method='euler', name='synapses_IE')\\n\\n S_II = Synapses(G_inh, G_inh, synapse, on_pre=on_pre_inh, method='euler', name='synapses_I')\\n\\n S_E_readout = Synapses(G_ex, G_readout, 'w = 1 : 1', on_pre=on_pre_ex, method='euler')\\n\\n S_I_readout = Synapses(G_inh, G_readout, 'w = 1 : 1', on_pre=on_pre_inh, method='euler')\\n\\n # -------initialization of neuron parameters----------\\n G_ex.v = '13.5+1.5*rand()'\\n G_inh.v = '13.5+1.5*rand()'\\n G_readout.v = '0'\\n G_ex.g = '0'\\n G_inh.g = '0'\\n G_readout.g = '0'\\n G_ex.h = '0'\\n G_inh.h = '0'\\n G_readout.h = '0'\\n G_ex.tau = tau_ex\\n G_inh.tau = tau_inh\\n G_readout.tau = tau_read\\n [G_ex, G_in] = base.allocate([G_ex, G_inh], 10, 10, 20)\\n\\n # -------initialization of network topology and synapses parameters----------\\n S_inE.connect(condition='j<0.3*N_post', p=p_inE)\\n S_inI.connect(condition='j<0.3*N_post', p=p_inI)\\n S_EE.connect(condition='i != j', p='0.3*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\\n S_EI.connect(p='0.2*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\\n S_IE.connect(p='0.4*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\\n S_II.connect(condition='i != j', p='0.1*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\\n S_E_readout.connect(j='i')\\n S_I_readout.connect(j='i+n_ex')\\n\\n S_inE.w = function.gamma(A_inE, S_inE.w.shape)\\n S_inI.w = function.gamma(A_inI, S_inI.w.shape)\\n S_EE.w = function.gamma(A_EE, S_EE.w.shape)\\n S_IE.w = function.gamma(A_IE, S_IE.w.shape)\\n S_EI.w = function.gamma(A_EI, S_EI.w.shape)\\n S_II.w = function.gamma(A_II, S_II.w.shape)\\n\\n S_EE.pre.delay = '1.5*ms'\\n S_EI.pre.delay = '0.8*ms'\\n S_IE.pre.delay = '0.8*ms'\\n S_II.pre.delay = '0.8*ms'\\n\\n # ------create network-------------\\n net = Network(collect())\\n net.store('init')\\n\\n # ------run network-------------\\n stimulus = TimedArray(inputs[0], dt=Dt)\\n net.run(duration * Dt)\\n states = net.get_states()['neurongroup_read']['v']\\n net.restore('init')\\n return (states, inputs[1])\",\n \"def _run(output_dir_name):\\n\\n file_system_utils.mkdir_recursive_if_necessary(\\n directory_name=output_dir_name\\n )\\n\\n # Housekeeping.\\n y_tick_labels = [\\n '{0:s}'.format(s) for s in MODEL_DEPTH_WIDTH_STRINGS\\n ]\\n x_tick_labels = [\\n '{0:d}'.format(c) for c in FIRST_LAYER_CHANNEL_COUNTS\\n ]\\n\\n y_axis_label = 'NN depth, width'\\n x_axis_label = 'Spectral complexity'\\n\\n # Plot grid for U-net++ without deep supervision.\\n dimensions_3d = (\\n len(MODEL_WIDTHS), len(MODEL_DEPTHS), len(FIRST_LAYER_CHANNEL_COUNTS)\\n )\\n num_weights_matrix = numpy.reshape(NUM_WEIGHTS_ARRAY_PLUSPLUS, dimensions_3d)\\n num_weights_matrix = numpy.swapaxes(num_weights_matrix, 0, 1)\\n\\n num_depth_width_combos = len(MODEL_DEPTH_WIDTH_STRINGS)\\n num_channel_counts = len(FIRST_LAYER_CHANNEL_COUNTS)\\n dimensions_2d = (num_depth_width_combos, num_channel_counts)\\n num_weights_matrix = numpy.reshape(num_weights_matrix, dimensions_2d)\\n\\n all_weights = numpy.concatenate((\\n NUM_WEIGHTS_ARRAY_PLUSPLUS, NUM_WEIGHTS_ARRAY_PLUSPLUSPLUS,\\n NUM_WEIGHTS_ARRAY_PLUSPLUS_DEEP, NUM_WEIGHTS_ARRAY_PLUSPLUSPLUS_DEEP\\n ), axis=0)\\n\\n min_colour_value = numpy.min(numpy.log10(all_weights))\\n max_colour_value = numpy.max(numpy.log10(all_weights))\\n\\n figure_object, axes_object = _plot_scores_2d(\\n score_matrix=numpy.log10(num_weights_matrix),\\n min_colour_value=min_colour_value,\\n max_colour_value=max_colour_value,\\n x_tick_labels=x_tick_labels, y_tick_labels=y_tick_labels\\n )\\n\\n figure_width_px = (\\n figure_object.get_size_inches()[0] * figure_object.dpi\\n )\\n marker_size_px = figure_width_px * (\\n MARKER_SIZE_GRID_CELLS / num_weights_matrix.shape[1]\\n )\\n\\n if SELECTED_MARKER_INDICES[0] == 0:\\n axes_object.plot(\\n SELECTED_MARKER_INDICES[2], SELECTED_MARKER_INDICES[1],\\n linestyle='None', marker=MARKER_TYPE,\\n markersize=marker_size_px, markeredgewidth=0,\\n markerfacecolor=MARKER_COLOUR,\\n markeredgecolor=MARKER_COLOUR\\n )\\n\\n axes_object.set_xlabel(x_axis_label)\\n axes_object.set_ylabel(y_axis_label)\\n axes_object.set_title(NN_TYPE_STRINGS_FANCY[0])\\n\\n panel_file_names = [\\n '{0:s}/num_weights_log10_{1:s}.jpg'.format(\\n output_dir_name, NN_TYPE_STRINGS[0].replace('_', '-')\\n )\\n ]\\n\\n print('Saving figure to: \\\"{0:s}\\\"...'.format(panel_file_names[-1]))\\n figure_object.savefig(\\n panel_file_names[-1], dpi=FIGURE_RESOLUTION_DPI,\\n pad_inches=0, bbox_inches='tight'\\n )\\n pyplot.close(figure_object)\\n\\n # Plot grid for U-net++ with deep supervision.\\n num_weights_matrix = numpy.reshape(\\n NUM_WEIGHTS_ARRAY_PLUSPLUS_DEEP, dimensions_3d\\n )\\n num_weights_matrix = numpy.swapaxes(num_weights_matrix, 0, 1)\\n num_weights_matrix = numpy.reshape(num_weights_matrix, dimensions_2d)\\n\\n figure_object, axes_object = _plot_scores_2d(\\n score_matrix=numpy.log10(num_weights_matrix),\\n min_colour_value=min_colour_value,\\n max_colour_value=max_colour_value,\\n x_tick_labels=x_tick_labels, y_tick_labels=y_tick_labels\\n )\\n\\n if SELECTED_MARKER_INDICES[0] == 1:\\n axes_object.plot(\\n SELECTED_MARKER_INDICES[2], SELECTED_MARKER_INDICES[1],\\n linestyle='None', marker=MARKER_TYPE,\\n markersize=marker_size_px, markeredgewidth=0,\\n markerfacecolor=MARKER_COLOUR,\\n markeredgecolor=MARKER_COLOUR\\n )\\n\\n axes_object.set_xlabel(x_axis_label)\\n axes_object.set_ylabel(y_axis_label)\\n axes_object.set_title(NN_TYPE_STRINGS_FANCY[1])\\n\\n panel_file_names.append(\\n '{0:s}/num_weights_log10_{1:s}.jpg'.format(\\n output_dir_name, NN_TYPE_STRINGS[1].replace('_', '-')\\n )\\n )\\n\\n print('Saving figure to: \\\"{0:s}\\\"...'.format(panel_file_names[-1]))\\n figure_object.savefig(\\n panel_file_names[-1], dpi=FIGURE_RESOLUTION_DPI,\\n pad_inches=0, bbox_inches='tight'\\n )\\n pyplot.close(figure_object)\\n\\n # Plot grid for U-net3+ without deep supervision.\\n num_weights_matrix = numpy.reshape(\\n NUM_WEIGHTS_ARRAY_PLUSPLUSPLUS, dimensions_3d\\n )\\n num_weights_matrix = numpy.swapaxes(num_weights_matrix, 0, 1)\\n num_weights_matrix = numpy.reshape(num_weights_matrix, dimensions_2d)\\n\\n figure_object, axes_object = _plot_scores_2d(\\n score_matrix=numpy.log10(num_weights_matrix),\\n min_colour_value=min_colour_value,\\n max_colour_value=max_colour_value,\\n x_tick_labels=x_tick_labels, y_tick_labels=y_tick_labels\\n )\\n\\n if SELECTED_MARKER_INDICES[0] == 2:\\n axes_object.plot(\\n SELECTED_MARKER_INDICES[2], SELECTED_MARKER_INDICES[1],\\n linestyle='None', marker=MARKER_TYPE,\\n markersize=marker_size_px, markeredgewidth=0,\\n markerfacecolor=MARKER_COLOUR,\\n markeredgecolor=MARKER_COLOUR\\n )\\n\\n axes_object.set_xlabel(x_axis_label)\\n axes_object.set_ylabel(y_axis_label)\\n axes_object.set_title(NN_TYPE_STRINGS_FANCY[2])\\n\\n panel_file_names.append(\\n '{0:s}/num_weights_log10_{1:s}.jpg'.format(\\n output_dir_name, NN_TYPE_STRINGS[2].replace('_', '-')\\n )\\n )\\n\\n print('Saving figure to: \\\"{0:s}\\\"...'.format(panel_file_names[-1]))\\n figure_object.savefig(\\n panel_file_names[-1], dpi=FIGURE_RESOLUTION_DPI,\\n pad_inches=0, bbox_inches='tight'\\n )\\n pyplot.close(figure_object)\\n\\n # Plot grid for U-net3+ with deep supervision.\\n num_weights_matrix = numpy.reshape(\\n NUM_WEIGHTS_ARRAY_PLUSPLUSPLUS_DEEP, dimensions_3d\\n )\\n num_weights_matrix = numpy.swapaxes(num_weights_matrix, 0, 1)\\n num_weights_matrix = numpy.reshape(num_weights_matrix, dimensions_2d)\\n\\n figure_object, axes_object = _plot_scores_2d(\\n score_matrix=numpy.log10(num_weights_matrix),\\n min_colour_value=min_colour_value,\\n max_colour_value=max_colour_value,\\n x_tick_labels=x_tick_labels, y_tick_labels=y_tick_labels\\n )\\n\\n if SELECTED_MARKER_INDICES[0] == 3:\\n axes_object.plot(\\n SELECTED_MARKER_INDICES[2], SELECTED_MARKER_INDICES[1],\\n linestyle='None', marker=MARKER_TYPE,\\n markersize=marker_size_px, markeredgewidth=0,\\n markerfacecolor=MARKER_COLOUR,\\n markeredgecolor=MARKER_COLOUR\\n )\\n\\n axes_object.set_xlabel(x_axis_label)\\n axes_object.set_ylabel(y_axis_label)\\n axes_object.set_title(NN_TYPE_STRINGS_FANCY[3])\\n\\n panel_file_names.append(\\n '{0:s}/num_weights_log10_{1:s}.jpg'.format(\\n output_dir_name, NN_TYPE_STRINGS[3].replace('_', '-')\\n )\\n )\\n\\n print('Saving figure to: \\\"{0:s}\\\"...'.format(panel_file_names[-1]))\\n figure_object.savefig(\\n panel_file_names[-1], dpi=FIGURE_RESOLUTION_DPI,\\n pad_inches=0, bbox_inches='tight'\\n )\\n pyplot.close(figure_object)\\n\\n # Concatenate panels into one figure.\\n concat_file_name = '{0:s}/num_weights_log10.jpg'.format(output_dir_name)\\n print('Concatenating panels to: \\\"{0:s}\\\"...'.format(concat_file_name))\\n imagemagick_utils.concatenate_images(\\n input_file_names=panel_file_names,\\n output_file_name=concat_file_name,\\n num_panel_rows=2, num_panel_columns=2\\n )\\n imagemagick_utils.resize_image(\\n input_file_name=concat_file_name,\\n output_file_name=concat_file_name, output_size_pixels=int(1e7)\\n )\",\n \"def run_net(inputs, **parameter):\\n\\n #---- set numpy random state for each run----\\n np.random.set_state(np_state)\\n\\n # -----parameter setting-------\\n n_ex = 1600\\n n_inh = int(n_ex/4)\\n n_input = MNIST_shape[1]*coding_n\\n n_read = n_ex+n_inh\\n\\n R = parameter['R']\\n f_in = parameter['f_in']\\n f_EE = parameter['f_EE']\\n f_EI = parameter['f_EI']\\n f_IE = parameter['f_IE']\\n f_II = parameter['f_II']\\n\\n A_EE = 60*f_EE\\n A_EI = 60*f_EI\\n A_IE = 60*f_IE\\n A_II = 60*f_II\\n A_inE = 60*f_in\\n A_inI = 60*f_in\\n\\n tau_ex = parameter['tau_ex']*coding_duration\\n tau_inh = parameter['tau_inh']*coding_duration\\n tau_read= 30\\n\\n p_inE = parameter['p_in']*0.1\\n p_inI = parameter['p_in']*0.1\\n\\n #------definition of equation-------------\\n neuron_in = '''\\n I = stimulus(t,i) : 1\\n '''\\n\\n neuron = '''\\n tau : 1\\n dv/dt = (I-v) / (tau*ms) : 1 (unless refractory)\\n dg/dt = (-g)/(3*ms) : 1\\n dh/dt = (-h)/(6*ms) : 1\\n I = (g+h)+13.5: 1\\n x : 1\\n y : 1\\n z : 1\\n '''\\n\\n neuron_read = '''\\n tau : 1\\n dv/dt = (I-v) / (tau*ms) : 1\\n dg/dt = (-g)/(3*ms) : 1 \\n dh/dt = (-h)/(6*ms) : 1\\n I = (g+h): 1\\n '''\\n\\n synapse = '''\\n w : 1\\n '''\\n\\n on_pre_ex = '''\\n g+=w\\n '''\\n\\n on_pre_inh = '''\\n h-=w\\n '''\\n\\n # -----Neurons and Synapses setting-------\\n Input = NeuronGroup(n_input, neuron_in, threshold='I > 0', method='euler', refractory=0 * ms,\\n name = 'neurongroup_input')\\n\\n G_ex = NeuronGroup(n_ex, neuron, threshold='v > 15', reset='v = 13.5', method='euler', refractory=3 * ms,\\n name ='neurongroup_ex')\\n\\n G_inh = NeuronGroup(n_inh, neuron, threshold='v > 15', reset='v = 13.5', method='euler', refractory=2 * ms,\\n name ='neurongroup_in')\\n\\n G_readout = NeuronGroup(n_read, neuron_read, method='euler', name='neurongroup_read')\\n\\n S_inE = Synapses(Input, G_ex, synapse, on_pre = on_pre_ex ,method='euler', name='synapses_inE')\\n\\n S_inI = Synapses(Input, G_inh, synapse, on_pre = on_pre_ex ,method='euler', name='synapses_inI')\\n\\n S_EE = Synapses(G_ex, G_ex, synapse, on_pre = on_pre_ex ,method='euler', name='synapses_EE')\\n\\n S_EI = Synapses(G_ex, G_inh, synapse, on_pre = on_pre_ex ,method='euler', name='synapses_EI')\\n\\n S_IE = Synapses(G_inh, G_ex, synapse, on_pre = on_pre_inh ,method='euler', name='synapses_IE')\\n\\n S_II = Synapses(G_inh, G_inh, synapse, on_pre = on_pre_inh ,method='euler', name='synapses_I')\\n\\n S_E_readout = Synapses(G_ex, G_readout, 'w = 1 : 1', on_pre=on_pre_ex, method='euler')\\n\\n S_I_readout = Synapses(G_inh, G_readout, 'w = 1 : 1', on_pre=on_pre_inh, method='euler')\\n\\n #-------initialization of neuron parameters----------\\n G_ex.v = '13.5+1.5*rand()'\\n G_inh.v = '13.5+1.5*rand()'\\n G_readout.v = '0'\\n G_ex.g = '0'\\n G_inh.g = '0'\\n G_readout.g = '0'\\n G_ex.h = '0'\\n G_inh.h = '0'\\n G_readout.h = '0'\\n G_ex.tau = tau_ex\\n G_inh.tau = tau_inh\\n G_readout.tau = tau_read\\n\\n [G_ex,G_in] = base.allocate([G_ex,G_inh],10,10,20)\\n\\n # -------initialization of network topology and synapses parameters----------\\n S_inE.connect(condition='j<0.3*N_post', p = p_inE)\\n S_inI.connect(condition='j<0.3*N_post', p = p_inI)\\n S_EE.connect(condition='i != j', p='0.3*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\\n S_EI.connect(p='0.2*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\\n S_IE.connect(p='0.4*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\\n S_II.connect(condition='i != j', p='0.1*exp(-((x_pre-x_post)**2+(y_pre-y_post)**2+(z_pre-z_post)**2)/R**2)')\\n S_E_readout.connect(j='i')\\n S_I_readout.connect(j='i+n_ex')\\n\\n S_inE.w = function.gamma(A_inE, S_inE.w.shape)\\n S_inI.w = function.gamma(A_inI, S_inI.w.shape)\\n S_EE.w = function.gamma(A_EE, S_EE.w.shape)\\n S_IE.w = function.gamma(A_IE, S_IE.w.shape)\\n S_EI.w = function.gamma(A_EI, S_EI.w.shape)\\n S_II.w = function.gamma(A_II, S_II.w.shape)\\n\\n S_EE.pre.delay = '1.5*ms'\\n S_EI.pre.delay = '0.8*ms'\\n S_IE.pre.delay = '0.8*ms'\\n S_II.pre.delay = '0.8*ms'\\n\\n # ------create network-------------\\n net = Network(collect())\\n net.store('init')\\n\\n # ------run network-------------\\n stimulus = TimedArray(inputs[0], dt=Dt)\\n net.run(duration * Dt)\\n states = net.get_states()['neurongroup_read']['v']\\n net.restore('init')\\n return (states, inputs[1])\",\n \"def main():\\n nn = CarsClassifierModel()\\n train_x, train_y, test_x, test_y = nn.load_data_preprocess()\\n history = nn.run(train_x,train_y)\\n nn.evaluate(test_x, test_y)\\n nn.save(\\\"keras_nn_5\\\")\\n #nn.plots(history)\\n #print(train_x.shape)\\n #plt.imshow(train_x[52])\\n #plt.title(\\\"Car\\\")\\n #plt.show()\\n #print(train_y[52])\",\n \"def train():\\n if os.path.isfile(load_model):\\n all_weights = np.load(load_model) \\n else:\\n print(\\\"Model file does not exist. Exiting....\\\")\\n return\\n\\n print(\\\"Build up the network\\\")\\n\\n\\n # Two different types of input\\n image_input_var = T.tensor4('original_inputs')\\n rotated_image_input_var = T.tensor4('rotated_image_input')\\n target_var = T.ivector('targets')\\n\\n # Build teacher network\\n cnn_model, cnn_mid_output, weight_decay_penalty = cifar10_merge.build_cnn(image_input_var)\\n\\n # Get the intermediate layer of the teacher network\\n original_model_mid_output = lasagne.layers.get_output(cnn_mid_output, image_input_var, deterministic = True)\\n\\n # Get the softmax output of the teacher network.\\n\\n original_model_output_val = lasagne.layers.get_output(cnn_model, image_input_var, deterministic = True)\\n \\n # Build the student network\\n \\n rotated_cnn_model, rotated_model_mid, rotated_weight_penalty = \\\\\\n cifar10_merge.build_cnn(rotated_image_input_var)\\n \\n # Get the softmax output of the student network. Since it need to be trained on, deterministic = False\\n rotated_model_mid_output = lasagne.layers.get_output(rotated_model_mid, rotated_image_input_var, deterministic = False)\\n\\n # Get the model output of the studenet network.\\n rotated_model_output = lasagne.layers.get_output(rotated_cnn_model, rotated_image_input_var, deterministic = True)\\n\\n # Set the weights for the teacher network\\n lasagne.layers.set_all_param_values(cnn_model, all_weights)\\n\\n # Get the initialized weights below the intermediate layer\\n rotated_net_weights_below_mid = lasagne.layers.get_all_param_values(rotated_model_mid)\\n\\n # Get the parameter of the student network that needs to be trained.\\n rotated_net_training_param = lasagne.layers.get_all_params(rotated_model_mid, trainable=True)\\n\\n # Set the weights for the student network\\n lasagne.layers.set_all_param_values(rotated_cnn_model, all_weights)\\n\\n lasagne.layers.set_all_param_values(rotated_model_mid,\\n rotated_net_weights_below_mid)\\n \\n # cross_entropy_loss = lasagne.objectives.categorical_crossentropy(rotated_model_mid_output, target_var)\\n\\n # cross_entropy_loss_mean = cross_entropy_loss.mean()\\n\\n # L = T.mean(lasagne.objectives.squared_error(original_model_mid_output, rotated_model_mid_output), axis = 1)\\n L = lasagne.objectives.squared_error(original_model_mid_output, rotated_model_mid_output).mean()\\n # cost = T.mean(L)\\n\\n # cost = cross_entropy_loss_mean\\n cost = L\\n\\n # updates = lasagne.updates.adagrad(cost, rotated_net_training_param, learning_rate=0.1)\\n updates = lasagne.updates.adam(cost, rotated_net_training_param, learning_rate=0.001)\\n\\n # cross_entropy_loss = lasagne.objectives.categorical_crossentropy(model_output, target_var)\\n\\n # cross_entropy_loss_mean = cross_entropy_loss.mean()\\n\\n # loss = cross_entropy_loss_mean + weight_decay_penalty\\n\\n\\n train_acc = T.mean(T.eq(T.argmax(rotated_model_output, axis = 1), target_var),\\n dtype=theano.config.floatX)\\n\\n original_model_acc = T.mean(T.eq(T.argmax(original_model_output_val, axis = 1), target_var),\\n dtype=theano.config.floatX)\\n\\n train_fn = theano.function(inputs = [image_input_var, rotated_image_input_var, target_var],\\n outputs = [original_model_mid_output, rotated_model_mid_output, train_acc], updates = updates)\\n\\n # Return the accuracy for teacher network and student network, respectively\\n val_fn = theano.function(inputs = [image_input_var, rotated_image_input_var, target_var],\\n outputs = [original_model_acc, train_acc])\\n\\n if os.path.isfile(os.path.join(train_dir, 'latest_model.txt')):\\n weight_file = \\\"\\\"\\n with open(os.path.join(train_dir, 'latest_model.txt'), 'r') as checkpoint_file:\\n weight_file = checkpoint_file.read().replace('\\\\n', '')\\n print(\\\"Loading from: \\\", weight_file)\\n model_weights = np.load(weight_file)\\n lasagne.layers.set_all_param_values(rotated_cnn_model, model_weights)\\n\\n # Get images and labels for CIFAR-10.\\n\\n cifar10_data = cifar10_merge_input.load_cifar10()\\n\\n bkgimg = np.array([np.mean(cifar10_data.train.images[cifar10_data.train.labels==i], axis = 0) for i in range(10)])\\n for epoch in xrange(max_steps):\\n start_time = time.time()\\n\\n original_test_image, rotated_test_image, test_label = cifar10_data.test.next_eval_batch(batch_size)\\n total_t_net_for_original = 0\\n total_s_net_for_original = 0\\n total_t_net_for_rotation = 0\\n total_s_net_for_rotation = 0\\n total_count = 0\\n\\n print(\\\"Start Evaluating\\\")\\n\\n while(rotated_test_image is not None):\\n t_net_for_original, s_net_for_original = val_fn(original_test_image, original_test_image, test_label)\\n total_t_net_for_original += t_net_for_original * original_test_image.shape[0]\\n total_s_net_for_original += s_net_for_original * original_test_image.shape[0]\\n\\n t_net_for_rotated, s_net_for_rotated = val_fn(rotated_test_image, rotated_test_image, test_label)\\n total_t_net_for_rotation += t_net_for_rotated * rotated_test_image.shape[0]\\n total_s_net_for_rotation += s_net_for_rotated * rotated_test_image.shape[0]\\n\\n total_count += rotated_test_image.shape[0]\\n original_test_image, rotated_test_image, test_label = cifar10_data.test.next_eval_batch(batch_size)\\n \\n print(\\\"Student Network Accuracy on Original Image: %.4f\\\" % (float(total_s_net_for_original / total_count)))\\n print(\\\"Teacher Network Accuracy on Original Image: %.4f\\\" % (float(total_t_net_for_original / total_count)))\\n\\n print(\\\"Student Network Accuracy on Rotated Image: %.4f\\\" % (float(total_s_net_for_rotation / total_count)))\\n print(\\\"Teacher Network Accuracy on Rotated Image: %.4f\\\" % (float(total_t_net_for_rotation / total_count)))\\n\\n\\n print(\\\"Start Training...\\\")\\n original_train_image, rotated_train_image, train_label, start = cifar10_data.train.next_batch(batch_size)\\n original_train_image = generate(original_train_image, train_label, bkgimg, 16, 32, None, batch_size)\\n # rotated_train_image = random_rotated_image(original_train_image[::-1])\\n rotated_train_image = random_rotated_image(original_train_image)\\n\\n end_time_1 = time.time() - start_time\\n step = 1\\n loss_total = 0\\n original_start = start\\n\\n while(start != 0):\\n #loss_value, train_acc = train_fn(original_train_image, rotated_train_image, train_label)\\n \\n ori_mid, rot_mid, train_acc = train_fn(original_train_image, rotated_train_image, train_label)\\n # ori_mid, rot_mid, train_acc = train_fn(original_train_image, np.array(np.random.rand(batch_size, 3, 32, 32), dtype = np.float32), train_label)\\n step += 1\\n if start == original_start:\\n print(ori_mid[0])\\n print(rot_mid[0])\\n print(train_label)\\n \\n original_train_image, rotated_train_image, train_label, start = cifar10_data.train.next_batch(batch_size)\\n original_train_image = generate(original_train_image, train_label, bkgimg, 16, 32, None, batch_size)\\n rotated_train_image = random_rotated_image(original_train_image)\\n # assert not np.isnan(loss_value), 'Model diverged with loss = NaN'\\n # loss_total += loss_value\\n if 1:\\n if epoch % 100 == 0 or (step + 1) == max_steps:\\n checkpoint_path = os.path.join(train_dir, 'model_step%d.npy' % epoch)\\n weightsOfParams = lasagne.layers.get_all_param_values(rotated_cnn_model)\\n np.save(checkpoint_path, weightsOfParams)\\n latest_model_path = os.path.join(train_dir, 'latest_model.txt')\\n try:\\n os.remove(latest_model_path)\\n except OSError:\\n pass\\n latest_model_file = open(latest_model_path, \\\"w\\\")\\n latest_model_file.write(checkpoint_path)\\n latest_model_file.close()\\n\\n # print(\\\"Epoch Stop, loss_averge\\\", float(loss_total) / float(step))\\n duration = time.time() - start_time\\n print(\\\"Duration is\\\", duration)\",\n \"def neural_net_ex4_ng():\\n # ==================\\n # read data\\n dataset = loadmat('data/ex4data1.mat')\\n print(dataset.keys())\\n\\n y = dataset['y'] # 5000 x 1\\n print('dims y: ', y.shape)\\n # print('y[0]: ', y[0])\\n\\n X = dataset['X'] # 5000 x 400\\n print('dims X: ', X.shape)\\n # print('X[0]: ', X[0])\\n\\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\\n\\n num_samples_test = X_test.shape[0]\\n\\n # ==================\\n # display data\\n\\n # pick 20 examples and visualize them\\n fig = plt.figure(figsize=(10, 8), facecolor='white')\\n fig.add_subplot(651)\\n samples = np.random.choice(num_samples_test, 10)\\n print('samples:', samples)\\n plt.imshow(X_test[samples, :].reshape(-1, 20).T, cmap=\\\"Greys\\\")\\n plt.axis('off')\\n\\n # ==================\\n # run neural net\\n hidden_layer_size = 25\\n\\n mlp = MLPClassifier(hidden_layer_sizes=(25,), max_iter=20, alpha=1e-4,\\n solver='sgd', verbose=False, tol=1e-4, random_state=1,\\n learning_rate_init=.1)\\n mlp.fit(X_train, y_train.ravel())\\n\\n predictions = mlp.predict(X_test)\\n print('Test set accuracy: {} %'.format(np.mean(predictions == y_test.ravel())*100))\\n\\n # print(confusion_matrix(y_test, predictions))\\n # print(classification_report(y_test, predictions))\\n print(\\\"Training set score: %f\\\" % mlp.score(X_train, y_train))\\n print(\\\"Test set score: %f\\\" % mlp.score(X_test, y_test))\\n print('coeffs shape', (mlp.coefs_[0]).shape)\\n\\n # ==================\\n # display coefficients of hidden layer\\n fig.add_subplot(652)\\n plt.imshow(mlp.coefs_[0][:, 0].reshape(20, 20))\\n plt.axis('off')\\n\\n gs = gridspec.GridSpec(6, 5)\\n cur_img_idx = 5\\n\\n # use global min / max to ensure all weights are shown on the same scale\\n vmin, vmax = mlp.coefs_[0].min(), mlp.coefs_[0].max()\\n for coef, ax in zip(mlp.coefs_[0].T, range(hidden_layer_size)):\\n fig.add_subplot(gs[cur_img_idx])\\n plt.imshow(coef.reshape(20, 20), cmap=plt.cm.gray, vmin=.5 * vmin, vmax=.5 * vmax)\\n plt.axis('off')\\n cur_img_idx += 1\\n\\n plt.show()\",\n \"def __init__(self):\\n super(SimpleNet, self).__init__()\\n\\n self.conv_layers = None\\n self.fc_layers = None\\n self.loss_criterion = None\\n\\n #######################################################################\\n # Student code begins\\n #######################################################################\\n\\n self.conv_layers = nn.Sequential(\\n nn.Conv2d(1, 10, kernel_size=5, stride=1),\\n nn.ReLU(),\\n nn.MaxPool2d(3),\\n nn.Conv2d(10, 20, kernel_size=5, stride=1),\\n nn.ReLU(),\\n nn.MaxPool2d(3)\\n )\\n\\n conv_out = int(20*5*5)\\n\\n self.fc_layers = nn.Sequential(\\n nn.Linear(conv_out, 100),\\n nn.Linear(100, 15)\\n )\\n\\n self.loss_criterion = nn.MSELoss(reduction='mean')\\n\\n #######################################################################\\n # Student code ends\\n #######################################################################\",\n \"def __init__(self, input_dim, output_dim, hidden_dim=100, num_layers=2,\\r\\n num_epochs=100, learning_rate=0.001, threshold=0.1):\\r\\n super(ReluNet, self).__init__()\\r\\n\\r\\n self.input_dim = input_dim\\r\\n self.output_dim = output_dim\\r\\n self.hidden_dim = hidden_dim\\r\\n self.num_layers = num_layers\\r\\n self.num_epochs = num_epochs\\r\\n self.threshold = threshold\\r\\n self.learning_rate = learning_rate\\r\\n\\r\\n\\r\\n \\r\\n self.layers = nn.ModuleList()\\r\\n self.layers.append(nn.Linear(input_dim, hidden_dim))\\r\\n self.layers.append(nn.ReLU())\\r\\n for i in range(num_layers-1):\\r\\n self.layers.append(nn.Linear(hidden_dim, hidden_dim))\\r\\n self.layers.append(nn.ReLU())\\r\\n # output layer\\r\\n self.layers.append(nn.Linear(hidden_dim, output_dim))\",\n \"def unsup_train_exp(model, criterions, optimizer, scheduler, dataloaders,unsup_path,margin,num_epochs=10, vis=None):\\n print('>> Fine-tune a Model.')\\n best_roc = 0.0\\n \\n iters = 0\\n plot_data = {'X': [], 'Y': [], 'legend': ['Sup. Loss', 'Unsup. Loss', 'Tot. Loss']}\\n\\n for epoch in range(num_epochs):\\n scheduler.step()\\n # Training\\n model.train()\\n for i, sup_data in enumerate(dataloaders['sup_train']):\\n unsup_data = dataloaders['unsup_train'][i % len(dataloaders['unsup_train'])]\\n sup_inputs = sup_data[0]\\n sup_labels = sup_data[1].cuda()\\n unsup_inputs = unsup_data[0]\\n data_inputs=torch.cat((sup_inputs,unsup_inputs),axis=0).cuda()\\n \\n # unsup_labels = unsup_data[1].cuda()\\n iters += 1\\n\\n optimizer.zero_grad()\\n out_1, out_2 = model(data_inputs)\\n sup_out_1,sup_out_2=out_1[:sup_inputs.shape[0]],out_2[:sup_inputs.shape[0]]\\n unsup_out_1,unsup_out_2=out_1[sup_inputs.shape[0]:],out_2[sup_inputs.shape[0]:]\\n\\n loss_sup = criterions['sup'](sup_out_1, sup_labels) + criterions['sup'](sup_out_2, sup_labels) # Step A\\n\\n loss_unsup = criterions['unsup'](unsup_out_1, unsup_out_2,margin) # Step B\\n loss = loss_unsup + loss_sup\\n loss.backward()\\n optimizer.step()\\n\\n # visualize\\n if (iters % 10 == 0) and (vis != None) and (plot_data != None):\\n plot_data['X'].append(iters)\\n plot_data['Y'].append([\\n loss_sup.item(),\\n loss_unsup.item(),\\n loss.item()\\n ])\\n vis.line(\\n X=np.stack([np.array(plot_data['X'])] * len(plot_data['legend']), 1),\\n Y=np.array(plot_data['Y']),\\n opts={\\n 'title': 'Loss over Time',\\n 'legend': plot_data['legend'],\\n 'xlabel': 'Iterations',\\n 'ylabel': 'Loss',\\n 'width': 1200,\\n 'height': 390,\\n },\\n win=2\\n )\\n \\\"\\\"\\\"\\n path_dir='/'.join(unsup_path.split('/')[:-1])\\n if not os.path.exists(path_dir):\\n os.makedirs(path_dir)\\n torch.save(model.state_dict(),'{}'.format(unsup_path))\\n print('Model saved.')\\n \\\"\\\"\\\"\\n # Validate\\n model.eval()\\n labels = torch.zeros((0, )).cuda() # initialize\\n discs = torch.zeros((0, )).cuda() \\n with torch.no_grad():\\n for i, (input, label,cls) in enumerate(dataloaders['unsup_val']):\\n inputs = input.cuda()\\n label = label.cuda()\\n\\n out_1, out_2 = model(inputs)\\n score_1 = F.softmax(out_1, dim=1)\\n score_2 = F.softmax(out_2, dim=1)\\n disc = torch.sum(torch.abs(score_1 - score_2), dim=1).reshape((label.shape[0], ))\\n\\n discs=torch.cat((discs,disc))\\n label=label.reshape((label.shape[0], )).float()\\n labels=torch.cat((labels,label))\\n\\n #labels = 1 - labels\\n\\n labels = labels.cpu()\\n discs = discs.cpu()\\n roc = evaluate(labels, discs, metric='roc',save_to='./pic.png')\\n print('Epoch{} AUROC: {:.3f}'.format(epoch, roc))\\n if best_roc < roc:\\n best_roc = roc\\n path_dir='/'.join(unsup_path.split('/')[:-1])\\n if not os.path.exists(path_dir):\\n os.makedirs(path_dir)\\n torch.save(model.state_dict(),'{}'.format(unsup_path))\\n print('Model saved.')\\n print('>> Finished.')\",\n \"def train(epoch, net, device, train_data, optimizer, batches_per_epoch, vis=False):\\n results = {\\n 'loss': 0,\\n 'losses': {\\n }\\n }\\n\\n net.train()\\n\\n batch_idx = 0\\n # Use batches per epoch to make training on different sized datasets (cornell/jacquard) more equivalent.\\n while batch_idx < batches_per_epoch:\\n for x, y, _, _, _ in train_data:\\n batch_idx += 1\\n if batch_idx >= batches_per_epoch:\\n break\\n\\n xc = x.to(device)\\n yc = [yy.to(device) for yy in y]\\n lossd = net.compute_loss(xc, yc)\\n\\n loss = lossd['loss']\\n\\n if batch_idx % 100 == 0:\\n logout('Epoch: {}, Batch: {}, Loss: {:0.4f}'.format(epoch, batch_idx, loss.item()))\\n\\n results['loss'] += loss.item()\\n for ln, l in lossd['losses'].items():\\n if ln not in results['losses']:\\n results['losses'][ln] = 0\\n results['losses'][ln] += l.item()\\n\\n optimizer.zero_grad()\\n loss.backward()\\n optimizer.step()\\n\\n # Display the images\\n if vis:\\n imgs = []\\n n_img = min(4, x.shape[0])\\n for idx in range(n_img):\\n imgs.extend([x[idx,].numpy().squeeze()] + [yi[idx,].numpy().squeeze() for yi in y] + [\\n x[idx,].numpy().squeeze()] + [pc[idx,].detach().cpu().numpy().squeeze() for pc in lossd['pred'].values()])\\n gridshow('Display', imgs,\\n [(xc.min().item(), xc.max().item()), (0.0, 1.0), (0.0, 1.0), (-1.0, 1.0), (0.0, 1.0)] * 2 * n_img,\\n [cv2.COLORMAP_BONE] * 10 * n_img, 10)\\n cv2.waitKey(2)\\n\\n results['loss'] /= batch_idx\\n for l in results['losses']:\\n results['losses'][l] /= batch_idx\\n\\n return results\",\n \"def to_neptune(self, **kwargs) -> 'PlotLosses':\\n self.outputs.append(outputs.NeptuneLogger(**kwargs))\\n return self\",\n \"def run_experiments():\\n nets = []\\n nets.extend(shallow(n=1))\\n nets.extend(basic_conv(n=1))\\n nets.extend(omit_FC(n=1))\\n nets.extend(dbl_conv(n=1, activation_fn=sigmoid))\\n # omitted, but still interesting: regularized_dbl_conv()\\n nets.extend(dbl_conv_relu(n=1))\\n nets.extend(expanded_data(n=1, FC_n=100))\\n nets.extend(expanded_data(n=1, FC_n=300))\\n nets.extend(expanded_data(n=1, FC_n=1000))\\n nets.extend(expanded_data_double_fc(n=1, FC_n=100)) \\n nets.extend(expanded_data_double_fc(n=1, FC_n=300))\\n nets.extend(expanded_data_double_fc(n=1, FC_n=1000))\\n nets.extend(double_fc_dropout(0.5, 0.5, 0.5, n=5))\\n # plot the erroneous digits in the ensemble of nets just trained\\n error_locations, erroneous_predictions = ensemble(nets)\\n plt = plot_errors(error_locations, erroneous_predictions)\\n plt.savefig(\\\"ensemble_errors.png\\\")\\n # plot the filters learned by the first of the nets just trained\\n plt = plot_filters(nets[0], 0, 5, 4)\\n plt.savefig(\\\"net_full_layer_0.png\\\")\\n plt = plot_filters(nets[0], 1, 8, 5)\\n plt.savefig(\\\"net_full_layer_1.png\\\")\",\n \"def visualize(self):\\n\\n self.check_model()\\n show(prepare(self.model, self.vectorized_data, self.vectorizer, mds='tsne'))\",\n \"def trainSN(options, epoch, device):\\n \\\"\\\"\\\"-------------------------------CONFIG----------------------------------\\\"\\\"\\\"\\n parser = argparse.ArgumentParser(description=\\\"PyTorch Regression GAN\\\")\\n parser = general_parser(parser)\\n opt = specific_parser(\\n parser=parser, run_folder=options.log_dir, mode='train', tot_epochs=30, pretrained_GAN=options.checkpoint_dir,\\n GAN_epoch=epoch, acc_log_freq=options.acc_log_freq, loss_log_freq=options.loss_log_freq,\\n batch_size_SN=options.batch_size_SN, images_log_freq=options.images_log_freq,\\n data_dir_train=options.data_dir_train2, data_dir_test=options.data_dir_test2,\\n experiment_name='SN'+str(epoch), sar_c=options.sar_c, optical_c=options.optical_c,\\n save_model_freq=1000, res_block_N=options.res_block_N)\\n\\n opt = config_routine(opt)\\n\\n \\\"\\\"\\\"-----------------------------DATA LOADER--------------------------------\\\"\\\"\\\"\\n train_dataset = EUSARDataset(os.path.join(options.data_dir_train2), True, False, options.sar_c, options.optical_c)\\n train_dataset = get_subset(train_dataset, options.prc_test)\\n train_dataset = DataLoader(train_dataset, batch_size=options.batch_size_SN, shuffle=True,\\n num_workers=options.workers, pin_memory=True, drop_last=False)\\n\\n test_dataset = EUSARDataset(os.path.join(options.data_dir_test2), True, False, options.sar_c, options.optical_c)\\n test_dataset = get_subset(test_dataset, options.prc_test, True)\\n test_dataset = DataLoader(test_dataset, batch_size=options.batch_size_SN, shuffle=False,\\n num_workers=options.workers, pin_memory=True, drop_last=False)\\n\\n \\\"\\\"\\\"--------------------------------TRAIN-----------------------------------\\\"\\\"\\\"\\n # Init model\\n model = SN(opt, device)\\n\\n # set up tensorboard logging\\n writer = SummaryWriter(log_dir=os.path.join(opt.tb_dir))\\n # Model Training\\n model.train(train_dataset, test_dataset, writer)\",\n \"def UNet(input_size=(256, 256, 1)):\\n inputs = Input(input_size)\\n c1 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(inputs)\\n c1 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c1)\\n p1 = MaxPooling2D((2, 2))(c1)\\n\\n c2 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(p1)\\n c2 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c2)\\n p2 = MaxPooling2D((2, 2))(c2)\\n\\n c3 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(p2)\\n c3 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c3)\\n p3 = MaxPooling2D((2, 2))(c3)\\n\\n c4 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(p3)\\n c4 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c4)\\n p4 = MaxPooling2D(pool_size=(2, 2))(c4)\\n\\n c5 = Conv2D(256, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(p4)\\n c5 = Conv2D(256, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c5)\\n\\n u6 = Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same')(c5)\\n u6 = concatenate([u6, c4])\\n c6 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(u6)\\n c6 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c6)\\n\\n u7 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same')(c6)\\n u7 = concatenate([u7, c3])\\n c7 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(u7)\\n c7 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c7)\\n\\n u8 = Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same')(c7)\\n u8 = concatenate([u8, c2])\\n c8 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(u8)\\n c8 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c8)\\n\\n u9 = Conv2DTranspose(16, (2, 2), strides=(2, 2), padding='same')(c8)\\n u9 = concatenate([u9, c1], axis=3)\\n c9 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(u9)\\n c9 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same')(c9)\\n\\n outputs = Conv2D(1, (1, 1), activation='sigmoid')(c9)\\n model = Model(inputs=[inputs], outputs=[outputs])\\n model.compile(optimizer=Adam(lr=1e-4), loss=dice_coef_loss, metrics=['accuracy', dice_coef])\\n return model\",\n \"def main():\\n\\n # first figure: betas for each predictor\\n fig, axes = plt.subplots(figsize=(8, 18), nrows=3)\\n\\n image_paths = {\\n \\\"3T\\\": (\\n f\\\"{PATHS['figures_misc']}/figure_3_images/\\\"\\n f\\\"C1051_20161006_childVSall_depth_1.png\\\"\\n ),\\n \\\"7T\\\": (\\n f\\\"{PATHS['figures_misc']}/figure_3_images/\\\"\\n f\\\"C1051_20160212_childVSall_depth_1_sim2pt4.png\\\"\\n ),\\n \\\"7T_noise\\\": (\\n f\\\"{PATHS['figures_misc']}/figure_3_images/\\\"\\n f\\\"C1051_20160212_childVSall_depth_1_sim2pt4_noise.png\\\"\\n ),\\n }\\n\\n for ax, (_, image_path) in zip(axes, image_paths.items()):\\n assert os.path.isfile(image_path)\\n img = imread(image_path)\\n img[np.where(np.sum(img, axis=2) == 0.0)] = 1.0\\n\\n ax.imshow(img[200:-100, 50:-50, :])\\n ax.axis(\\\"off\\\")\\n\\n savefig(f\\\"{PATHS['figures']}/figure_3ac.png\\\")\\n plt.close(fig)\",\n \"def setUp(self):\\n # The short NSC used in this example\\n self.net_nsc = [\\n (1, 4, 0, 0, 0), # Layer 1: Identity(input)\\n (2, 1, 3, 1, 0), # Layer 2: Convolution(Layer1)\\n (3, 1, 3, 2, 0), # Layer 3: Convolution(Layer2)\\n (4, 5, 0, 1, 3), # Layer 4: Convolution(Layer1)\\n (5, 7, 0, 0, 0), # Layer 5: Convolution(Layer4)\\n ]\",\n \"def train(epochs, batch_size, lr, verbose):\\n # autograd globally off\\n torch.set_grad_enabled(False)\\n # generate training and testing datasets\\n train_data, train_label = generate_data()\\n test_data, test_label = generate_data()\\n # normalize data be centered at 0\\n train_data, test_data = normalize(train_data, test_data)\\n\\n if verbose:\\n print(\\\"--- Dataset ---\\\")\\n print(\\\"Train X: \\\", train_data.size(), \\\" | Train y: \\\", train_label.size())\\n print(\\\" Test X: \\\", test_data.size(), \\\" | Test y: \\\", test_label.size())\\n\\n layers =[]\\n # input layer (2 input units)\\n linear1 = Linear(2, 25, bias= True, weight_init=xavier_uniform)\\n\\n # 3 hidden layers (each 25 units)\\n linear2 = Linear(25, 25, bias= True, weight_init=xavier_uniform)\\n linear3 = Linear(25, 25, bias= True, weight_init=xavier_uniform)\\n linear4 = Linear(25, 25, bias= True, weight_init=xavier_uniform)\\n\\n # output layer (2 output units)\\n linear5 = Linear(25, 2, bias= True, weight_init=xavier_uniform)\\n\\n\\n layers.append(linear1)\\n layers.append(Relu())\\n layers.append(linear2)\\n layers.append(Relu())\\n layers.append(linear3)\\n layers.append(Relu())\\n layers.append(linear4)\\n layers.append(Tanh())\\n layers.append(linear5)\\n\\n model = Sequential(layers)\\n if verbose: print(\\\"Number of model parameters: {}\\\".format(sum([len(p) for p in model.param()])))\\n\\n criterion = MSE()\\n optimizer = SGD(model, lr=lr)\\n\\n train_losses, test_losses = [], []\\n train_accuracies, test_accuracies = [], []\\n train_errors, test_errors = [], []\\n\\n if verbose: print(\\\"--- Training ---\\\")\\n for epoch in range(1, epochs+1):\\n if verbose:print(\\\"Epoch: {}\\\".format(epoch))\\n\\n # TRAINING\\n for batch_idx in range(0, train_data.size(0), batch_size):\\n # axis 0, start from batch_idx until batch_idx+batch_size\\n output = model.forward(train_data.narrow(0, batch_idx, batch_size))\\n\\n # Calculate loss\\n loss = criterion.forward(output, train_label.narrow(0, batch_idx, batch_size))\\n train_losses.append(loss)\\n if verbose: print(\\\"Train Loss: {:.2f}\\\".format(loss.item()))\\n\\n # put to zero weights and bias\\n optimizer.zero_grad()\\n\\n ## Backpropagation\\n # Calculate grad of loss\\n loss_grad = criterion.backward()\\n\\n # Grad of the model\\n model.backward(loss_grad)\\n\\n # Update parameters\\n optimizer.step()\\n\\n train_prediction = model.forward(train_data)\\n acc = accuracy(train_prediction, train_label)\\n train_accuracies.append(acc)\\n train_errors.append(1-acc)\\n if verbose: print(\\\"Train Accuracy: {:.2f}\\\".format(acc.item()))\\n\\n # EVALUATION\\n for batch_idx in range(0, test_data.size(0), batch_size):\\n # axis 0, start from batch_idx until batch_idx+batch_size\\n output = model.forward(test_data.narrow(0, batch_idx, batch_size))\\n\\n # Calculate loss\\n loss = criterion.forward(output, test_label.narrow(0, batch_idx, batch_size))\\n test_losses.append(loss)\\n if verbose: print(\\\"Test Loss: {:.2f}\\\".format(loss.item()))\\n\\n test_prediction = model.forward(test_data)\\n acc = accuracy(test_prediction, test_label)\\n test_accuracies.append(acc) \\n test_errors.append(1-acc)\\n if verbose: print(\\\"Test Accuracy: {:.2f}\\\".format(acc.item()))\\n\\n return train_losses, test_losses, train_accuracies, test_accuracies, train_errors, test_errors\",\n \"def setup_net(self):\\n\\t\\tself.src_net = get_model(self.base_model, num_cls=self.num_cls, \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t l2_normalize=self.l2_normalize, temperature=self.temperature)\\n\\t\\tself.tgt_net = self.custom_copy(self.src_net, self.weight_sharing)\\n\\n\\t\\tinput_dim = self.num_cls\\n\\t\\tself.discriminator = nn.Sequential(\\n\\t\\t\\t\\tnn.Linear(input_dim, 500),\\n\\t\\t\\t\\tnn.ReLU(),\\n\\t\\t\\t\\tnn.Linear(500, 500),\\n\\t\\t\\t\\tnn.ReLU(),\\n\\t\\t\\t\\tnn.Linear(500, 2),\\n\\t\\t\\t\\t)\\n\\n\\t\\tself.image_size = self.src_net.image_size\\n\\t\\tself.num_channels = self.src_net.num_channels\",\n \"def plot_run_lenet():\\n strNames = ['Dropout','N image', 'Learning rate', 'Regul.']\\n df = CNN.get_acc_run_lenet()\\n df = df.dropna()\\n \\n fig = plt.figure(figsize=(16,12))\\n for i, name in enumerate(strNames):\\n df_sub = df.drop_duplicates([name])\\n df_sub = df_sub.sort_values(by=name)\\n CNN.subplot_run_lenet(df_sub, name, subplotids=[2,2,i+1])\",\n \"def torch_NN(nn_in, \\n nn_out, \\n min_ar, \\n max_ar, \\n er_tar,\\n main_win: tk.Toplevel, \\n min_n=0, \\n max_n=0, \\n n_epochs=200, \\n conf=[1,1,1], \\n funs=[tr.nn.Sigmoid(), 0], \\n lr=0.001, \\n sect_ner=False, \\n train_test=False, \\n retrain=False, \\n spl_coef=0.1,\\n root_width=200, \\n root_height=200, \\n root_x=50, \\n root_y=50):\\n tr.manual_seed(42)\\n in_orig=tr.from_numpy(np.array(nn_in.copy())).float()\\n out_orig=tr.from_numpy(np.array(nn_out.copy())).float()\\n if train_test or retrain:\\n nn_in=tr.from_numpy(np.array(nn_in)).float()\\n nn_out=tr.from_numpy(np.array(nn_out)).float()\\n dataset = tr.utils.data.TensorDataset(nn_in, nn_out)\\n a=int(len(dataset)*(1-spl_coef))\\n data_trn, data_test=tr.utils.data.random_split(dataset, [a,int(len(dataset)-a)],generator=tr.Generator().manual_seed(42))\\n dataloader = tr.utils.data.DataLoader(data_trn, shuffle=False, batch_size=len(data_trn))\\n else:\\n nn_in=tr.from_numpy(np.array(nn_in)).float()\\n nn_out=tr.from_numpy(np.array(nn_out)).float()\\n dataset = tr.utils.data.TensorDataset(nn_in, nn_out)\\n dataloader = tr.utils.data.DataLoader(dataset, shuffle=False, batch_size=len(dataset))\\n data_test = 0\\n if sect_ner:\\n for i in range(len(conf)-2):\\n conf[i+1] = min_n\\n for i in range(1, len(conf)-1):\\n min_loss=200000\\n b=conf[i]\\n for j in range(min_n, max_n+1):\\n conf[i]=j\\n nn_obj = Net_tr(conf, funs)\\n nn_obj.alph_bet(in_orig,out_orig, min_ar, max_ar)\\n optimizer = tr.optim.Adam(nn_obj.parameters(), lr=lr)\\n y_pred = nn_obj.forward(nn_in)\\n loss_val = loss(y_pred, nn_out, nn_obj)\\n a=loss_val.item()\\n print(\\\"Current configuration:\\\", conf, \\\";\\\\t Loss:\\\", a, \\\"%\\\")\\n loss_val.backward()\\n optimizer.step()\\n if a<min_loss:\\n min_loss=a\\n b=j\\n conf[i]=b\\n neurons_number_info(conf, root_height + root_y, root_x)\\n print(\\\"Best configuration:\\\", conf)\\n nn_obj = Net_tr(conf, funs)\\n optimizer = tr.optim.Adam(nn_obj.parameters(), lr=lr)\\n nn_obj.alph_bet(in_orig,out_orig, min_ar, max_ar)\\n loss_test=[]\\n loss_tr=[]\\n epochs_sum = 0\\n train = True\\n lin_tr = None\\n can_tr = None\\n lin_test = None \\n can_test = None\\n vert_coef = None\\n hor_coef = None\\n while train == True:\\n nn_obj, vert_coef, hor_coef, epochs_sum, err, lin_tr, can_tr, lin_test, can_test = train_body_torch(nn_obj, dataloader, data_test, n_epochs, epochs_sum, optimizer, loss_tr, loss_test, er_tar, train_test, retrain, root_width, root_height, root_x, root_y, lin_tr, can_tr, lin_test, can_test, vert_coef, hor_coef)\\n train_win = Continue_Train(err, epochs_sum)\\n main_win.wait_window(train_win)\\n train = train_win.answer\\n if not train_win.answer:\\n return nn_obj, conf, vert_coef, hor_coef\\n #train = False\\n nn_obj.eval()\\n return nn_obj, conf, vert_coef, hor_coef\",\n \"def train(self):\\n self.mode = \\\"train\\\"\\n self.online_net.train()\",\n \"def train(self):\\n self.mode = \\\"train\\\"\\n self.online_net.train()\",\n \"def train():\\n pass\",\n \"def visualize_training(features, labels, pl):\\n print(\\\"Visualizing training\\\")\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n\\n # Take out each feature type, one at a time\\n label_map = get_label_map(labels)\\n\\n for key in label_map.keys():\\n like_ind = label_map[key]\\n like_data = np.array([features[i] for i in like_ind])\\n\\n plt.scatter(like_data[:,0],like_data[:,1],label=key)\\n\\n # get limits\\n xmin = features.column_min(0) - .5\\n xmax = features.column_max(0) + .5\\n ymin = features.column_min(1) - .5\\n ymax = features.column_max(1) + .5\\n\\n plt.xlim(xmin,xmax)\\n plt.ylim(ymin,ymax)\\n\\n # Track the current dividing line, as well as the number of epochs passed\\n divider, = plt.plot([],[])\\n epoch_tracker = plt.text(-1,.9, '', fontsize=15)\\n\\n def update(i):\\n \\\"\\\"\\\"\\n 1.) Get the next set of weights from the tracker\\n 2.) Calculate and draw the new divider line\\n 3.) Update the epoch counter\\n 4.) If we are at the end of an epoch, plot a dashed divider line to track progress\\n \\\"\\\"\\\"\\n epoch = i//features.instance_count\\n w = pl.weights_tracker[i]\\n a = pl.accuracy_tracker[epoch]\\n divider.set_data([xmin,xmax],[(-xmin * w[0] - w[2]) / w[1], (-xmax * w[0] - w[2]) / w[1]])\\n epoch_tracker.set_text(\\\"{} {}\\\".format(epoch + 1, a))\\n\\n # Keep a shadow of the hyperplane at the end of each epoch\\n if i % features.instance_count == 0:\\n plot_hyperplane(w,xmin,xmax,iter = i, alpha = .3, color='black',linestyle='dashed')\\n\\n return divider\\n\\n ani = animation.FuncAnimation(fig, update, frames=range(len(pl.weights_tracker)), interval=250,repeat=False)\\n plt.legend()\\n\\n # optional save file\\n if len(sys.argv) >= 3 :\\n ani.save(sys.argv[2], writer='imagemagick', fps=5)\\n\\n plt.show()\",\n \"def train(self):\\n self.ae_train(self.net0, self.ae0_optimizer, self.train0_loader, self.val_loader, name='Net0')\\n self.ae_train(self.net1, self.ae1_optimizer, self.train1_loader, self.val_loader, name='Net1')\\n self.ae_train(self.net2, self.ae2_optimizer, self.train2_loader, self.val_loader, name='Net2')\\n\\n self.classifier_train(self.net0, self.optimizer0, self.train0_loader, self.val_loader, name='Net0')\\n self.classifier_train(self.net1, self.optimizer1, self.train1_loader, self.val_loader, name='Net1')\\n self.classifier_train(self.net2, self.optimizer2, self.train2_loader, self.val_loader, name='Net2')\",\n \"def run():\\n cons_in, soln_in, disc = make_discriminator()\\n target, loss, accuracy, optimiser = make_training_nodes(disc)\\n training_set_sampler = make_sampler(cons_in, soln_in, target)\\n test_set_sampler = make_sampler(cons_in, soln_in, target)\\n\\n disc.get_session().run(tf.global_variables_initializer())\\n\\n fit(\\n disc.get_session(),\\n optimiser,\\n training_set_sampler,\\n 250,\\n 2000,\\n 32,\\n [(\\\"Loss\\\", loss), (\\\"Accuracy\\\", accuracy)],\\n )\\n\\n print(\\n \\\"Validation accuracy: {}\\\".format(\\n disc.feed(accuracy, test_set_sampler.batch(1024))\\n )\\n )\\n\\n plot_surface(\\n evaluate_surface(\\n lambda x, y: Circles.solve([0, 0, 0.25], [x, y, 0.25]),\\n (-1, 1, 0.08),\\n (-1, 1, 0.08),\\n ),\\n x_label=\\\"Solution x\\\",\\n y_label=\\\"Solution y\\\",\\n z_label=\\\"p(satisfied | x, y)\\\",\\n )\\n\\n plot_surface(\\n evaluate_surface(\\n lambda x, y: disc.feed(\\n disc.output_node, {cons_in: [[0, 0, 0.25]], soln_in: [[x, y, 0.25]]}\\n )[0],\\n (-1, 1, 0.08),\\n (-1, 1, 0.08),\\n ),\\n x_label=\\\"Solution x\\\",\\n y_label=\\\"Solution y\\\",\\n z_label=\\\"p(satisfied | x, y)\\\",\\n )\",\n \"def main():\\n # Load and preprocess the data.\\n ((x_train, y_train), (x_test, y_test)) = (\\n preprocess_dataset(x, y) for (x, y) in datasets.mnist.load_data()\\n )\\n (_, n_classes) = y_train.shape\\n\\n # Create and fit the original model.\\n model = create_model(\\n LAYER_SIZES,\\n n_classes,\\n layer_fn=functools.partial(layers.Dense, use_bias=False),\\n layer_kwargs_fn=dense_kwargs,\\n )\\n model.fit(x_train, y_train, batch_size=BATCH_SIZE, epochs=N_EPOCHS)\\n\\n # Evaluate the pruning methods.\\n pruning_methods = [(\\\"weight\\\", prune_weights), (\\\"neuron\\\", prune_neurons)]\\n for (method_name, pruning_fn) in pruning_methods:\\n # Compute the evaluation curves.\\n (accuracy_curve, time_curve) = zip(\\n *[\\n evaluate_fraction(pruning_fn, model, (x_test, y_test), fraction)\\n for fraction in PRUNING_FRACTIONS\\n ]\\n )\\n # Plot them.\\n for (subplot, curve) in [(211, accuracy_curve), (212, time_curve)]:\\n plt.subplot(subplot)\\n plt.plot(PRUNING_FRACTIONS, curve, label=method_name)\\n\\n if method_name == \\\"neuron\\\":\\n # The first evaluated model in neuron pruning is the unpruned\\n # one. Use it as a baseline.\\n (baseline, *_) = curve\\n plt.plot((0, 1), (baseline, baseline), \\\"--\\\", label=\\\"unpruned\\\")\\n\\n # Add some labels to the plots.\\n for (subplot, y_label) in [(211, \\\"accuracy\\\"), (212, \\\"inference time\\\")]:\\n plt.subplot(subplot)\\n plt.xlabel(\\\"pruning fraction\\\")\\n plt.ylabel(y_label)\\n plt.legend()\\n plt.show()\",\n \"def testNonLinearity():\\n vis = VISinformation()\\n data = np.linspace(1, vis['fullwellcapacity'], 10000)\\n nonlin = CCDnonLinearityModel(data.copy())\\n\\n txt = '%s' % datetime.datetime.isoformat(datetime.datetime.now())\\n\\n fig = plt.figure(frameon=False)\\n\\n left, width = 0.1, 0.8\\n rect1 = [left, 0.3, width, 0.65]\\n rect2 = [left, 0.1, width, 0.2]\\n\\n ax1 = fig.add_axes(rect1, title='VIS Non-linearity Model')\\n ax2 = fig.add_axes(rect2) #left, bottom, width, height\\n\\n ax1.axhline(y=0, c='k', ls='--')\\n ax1.plot(data, (nonlin/data - 1.)*100, 'r-', label='Model')\\n\\n ax2.axhline(y=0, c='k', ls='--')\\n ax2.plot(data, (nonlin - data)/vis['gain'], 'g-')\\n\\n ax1.axvline(x=97, c='k', ls='--')\\n ax2.axvline(x=97, c='k', ls='--')\\n\\n ax1.set_xticklabels([])\\n ax2.set_xlabel('Real Charge [electrons]')\\n ax1.set_ylabel('(Output / Real - 1)*100')\\n ax2.set_ylabel('O - R [ADUs]')\\n\\n ax1.set_xlim(0, vis['fullwellcapacity'])\\n ax2.set_xlim(0, vis['fullwellcapacity'])\\n ax1.set_ylim(-.15, .2)\\n\\n ax1.text(0.83, 1.12, txt, ha='left', va='top', fontsize=9, transform=ax1.transAxes, alpha=0.2)\\n ax1.legend(shadow=True, fancybox=True, numpoints=1, scatterpoints=1, markerscale=1.0)\\n plt.savefig('NonlinearityModel.pdf')\\n\\n ax1.set_ylim(-.1, 8)\\n ax2.set_ylim(0, 2)\\n ax1.set_xlim(50, 800)\\n ax2.set_xlim(50, 800)\\n plt.savefig('NonlinearityModel2.pdf')\\n\\n plt.close()\",\n \"def main(): # pylint: disable=R0914, R0915\\n args = parse_args()\\n\\n # load dataset\\n test_dataset = load_dataset(dataset_name=args.dataset, dataset_part='test')\\n\\n # load model\\n model_name = args.model\\n model = load_model(model_name)\\n model.load_state_dict(torch.load(args.checkpoint_path)['model'])\\n model.eval()\\n\\n # create sets of samples of images and their corresponding saliency maps\\n all_samples = []\\n all_saliency_maps = []\\n sample_to_image = lambda x: np.transpose(x, (1, 2, 0))\\n\\n for _ in range(6):\\n samples, true_labels = next(iter(DataLoader(test_dataset,\\n batch_size=6,\\n shuffle=True)))\\n all_samples.append(torch.cat([sample_to_image(s).unsqueeze(0)\\n for s in samples]))\\n saliency_maps = compute_gradient_saliency_maps(samples.to(device),\\n true_labels.to(device),\\n model)\\n all_saliency_maps.append(saliency_maps.cpu().detach())\\n\\n all_samples = torch.cat(all_samples)\\n all_saliency_maps = torch.cat(all_saliency_maps)\\n\\n saliency_maps_and_images_pairs = plt.figure()\\n plt.suptitle('Images and their saliency maps')\\n for idx, (image, saliency_map) in enumerate(zip(all_samples,\\n all_saliency_maps)):\\n plt.subplot(6, 6 * 2, 2 * idx + 1)\\n # plot image\\n image -= image.min()\\n image /= image.max()\\n plt.imshow(image)\\n plt.xticks([])\\n plt.yticks([])\\n # plot saliency map\\n plt.subplot(6, 6 * 2, 2 * idx + 2)\\n saliency_map -= saliency_map.min()\\n saliency_map /= saliency_map.max()\\n plt.imshow(saliency_map)\\n plt.xticks([])\\n plt.yticks([])\\n\\n saliency_maps_and_images_pairs.set_size_inches((8, 8))\\n saliency_maps_and_images_pairs.savefig(\\n os.path.join(FIGURES_DIR,\\n f'{args.dataset}_{args.model}_'\\n f'saliency_maps_and_images_pairs.png'))\\n\\n # loop through the images in the test set and compute saliency map for\\n # each image. Compute the average map of all real face image and\\n # all fake face image images.\\n dataloader = DataLoader(test_dataset, batch_size=32, shuffle=True)\\n real_images_saliency_maps = []\\n fake_images_saliency_maps = []\\n\\n for samples, true_labels in dataloader:\\n fake_samples = samples[true_labels == 1].to(device)\\n fake_labels = true_labels[true_labels == 1].to(device)\\n real_samples = samples[true_labels == 0].to(device)\\n real_labels = true_labels[true_labels == 0].to(device)\\n saliency_maps = compute_gradient_saliency_maps(fake_samples,\\n fake_labels,\\n model)\\n fake_images_saliency_maps.append(saliency_maps.cpu().detach())\\n saliency_maps = compute_gradient_saliency_maps(real_samples,\\n real_labels,\\n model)\\n real_images_saliency_maps.append(saliency_maps.cpu().detach())\\n\\n all_real_saliency_maps = torch.cat(real_images_saliency_maps)\\n all_fake_saliency_maps = torch.cat(fake_images_saliency_maps)\\n\\n for idx in range(all_real_saliency_maps.shape[0]):\\n all_real_saliency_maps[idx] -= all_real_saliency_maps[idx].min()\\n all_real_saliency_maps[idx] /= all_real_saliency_maps[idx].max()\\n\\n for idx in range(all_fake_saliency_maps.shape[0]):\\n all_fake_saliency_maps[idx] -= all_fake_saliency_maps[idx].min()\\n all_fake_saliency_maps[idx] /= all_fake_saliency_maps[idx].max()\\n\\n mean_saliency_maps = plt.figure()\\n plt.subplot(1, 2, 1)\\n mean_map = all_fake_saliency_maps.mean(axis=0)\\n mean_map -= mean_map.min()\\n mean_map /= mean_map.max()\\n plt.imshow(mean_map)\\n plt.title('mean of fake images saliency maps')\\n plt.subplot(1, 2, 2)\\n mean_map = all_real_saliency_maps.mean(axis=0)\\n mean_map -= mean_map.min()\\n mean_map /= mean_map.max()\\n plt.imshow(mean_map)\\n plt.title('mean of real images saliency maps')\\n mean_saliency_maps.set_size_inches((8, 6))\\n mean_saliency_maps.savefig(\\n os.path.join(FIGURES_DIR,\\n f'{args.dataset}_{args.model}_mean_saliency_maps.png'))\",\n \"def visualize_network_samples(net,\\n outputs_per_example=5,\\n color_map=\\\"gray\\\",\\n setsize=[1, 6],\\n f_ext=\\\"pdf\\\"):\\n n_examples = net.batch_size\\n if net.name == \\\"cifar\\\":\\n inputs, targets = generate_training_data(\\n None,\\n None,\\n dataset=net.dataset,\\n train_test=\\\"test\\\",\\n conv=True,\\n data_dir=net.trainingset_dir)[0:2]\\n inputs, targets = net.get_batch(inputs, targets, None)[0:2]\\n sig = True # For predicting decisions\\n elif net.name == \\\"fruits\\\":\\n inputs, recall_targets = net.generate_batch(\\\"test\\\")\\n targets = inputs\\n sig = True\\n elif net.name == \\\"popout\\\":\\n inputs, recall_targets = net.generate_training_data(n_examples)\\n targets = inputs\\n sig = False\\n else:\\n inputs = generate_training_data(\\n n_examples,\\n net.image_width,\\n task_weights=net.task_weights,\\n dataset=net.dataset,\\n conv=net.layer_type == \\\"conv\\\",\\n data_dir=net.trainingset_dir,\\n setsize=setsize,\\n mean=net.input_mean,\\n std=net.input_std,\\n dim=net.input_distribution_dim)[0]\\n targets = inputs\\n sig = False\\n if net.image_channels > 1:\\n shp = [net.image_width, net.image_width, net.image_channels]\\n else:\\n shp = [net.image_width, net.image_width]\\n preds0, dec0 = zip(*[\\n net.predict_both(\\n inputs, np.zeros_like(inputs), sigmoid=sig, keep_session=True)\\n for i in range(outputs_per_example)\\n ])\\n preds1 = np.array(preds0)\\n preds2 = preds1.swapaxes(0, 1)\\n preds = preds2.reshape([n_examples, outputs_per_example] + shp)\\n preds = preds.clip(0, 1)\\n # dec = np.array(dec0).swapaxes(0, 1)\\n # print(\\\"decisions: \\\", dec)\\n # print(dec)\\n save_dir = make_memnet_checkpoint_dir(\\n Path(\\\"plots/vis_memnet_samples/\\\"), net)\\n if not save_dir.exists():\\n save_dir.makedirs()\\n print(\\\"Saving images to: \\\", save_dir)\\n for i in range(n_examples):\\n fig, axes = plt.subplots(\\n nrows=1, ncols=outputs_per_example + 1, figsize=(45, 10))\\n if net.RGB:\\n axes[0].imshow(targets[i], cmap=color_map)\\n else:\\n axes[0].imshow(\\n targets[i].reshape(net.image_width, net.image_width),\\n cmap=color_map)\\n [\\n axes[j + 1].imshow(preds[i][j], cmap=color_map)\\n for j in range(outputs_per_example)\\n ]\\n [ax.set_aspect('equal') for ax in axes]\\n xlabs = [\\\"Target\\\"] + [\\n \\\"Sample {}\\\".format(j) for j in range(1, outputs_per_example + 1)\\n ]\\n [ax.set_xlabel(l, size=50) for ax, l in zip(axes, xlabs)]\\n for ax in axes:\\n ax.set_xticks([])\\n ax.set_xticklabels(\\\"\\\")\\n ax.set_yticks([])\\n ax.set_yticklabels(\\\"\\\")\\n plt.tight_layout()\\n plt.savefig(\\n save_dir.joinpath('setsize_{}_sample{}.{}'.format(\\n \\\"_\\\".join([str(x) for x in setsize]),\\n str(i).zfill(2), f_ext)))\",\n \"def train_one_epoch(self):\\n print('Training......')\\n\\n # set mode train\\n self.network.train()\\n\\n # prepare data\\n train_loss = 0\\n transform = transforms.Compose([Rescale(params.rescale_size),\\n RandomCrop(params.image_size),\\n RandomHorizontalFlip(),\\n ToTensor()\\n ])\\n\\n\\n\\n dataset = Cityscapes(params.dataset_root, mode='train', transforms = transform)\\n\\n train_loader = DataLoader(dataset,\\n batch_size=params.train_batch,\\n shuffle=params.shuffle,\\n num_workers=params.dataloader_workers)\\n \\n train_size = 1896\\n if train_size % self.params.train_batch != 0:\\n total_batch = train_size // self.params.train_batch + 1\\n else:\\n total_batch = train_size // self.params.train_batch\\n recal = 0\\n precision = 0\\n F_one = 0\\n IOU = 0\\n accuracy_new = 0 \\n # train through dataset\\n for batch_idx, batch in enumerate(train_loader):\\n self.pb.click(batch_idx, total_batch)\\n image, label = batch['image'], batch['label']\\n image_cuda, label_cuda = image.cuda(), label.cuda()\\n\\n # checkpoint split\\n if self.params.should_split:\\n image_cuda.requires_grad_()\\n out = checkpoint_sequential(self.network, self.params.split, image_cuda)\\n else:\\n out = self.network(image_cuda)\\n\\n\\n loss = self.loss_fn(out, label_cuda)\\n \\n #display_image(out, label_cuda)\\n TP, FP, TN, FN = confusion(out, label_cuda)\\n recal = recal+TP\\n precision = precision+FP\\n F_one = F_one + TN\\n IOU = IOU+ FN \\n accuracy_final = accuracy(out, label_cuda)\\n accuracy_new = accuracy_new + accuracy_final\\n\\n # optimize\\n self.opt.zero_grad()\\n loss.backward()\\n self.opt.step()\\n\\n # accumulate\\n train_loss += loss.item()\\n\\n # record first loss\\n if self.train_loss == []:\\n self.train_loss.append(train_loss)\\n self.summary_writer.add_scalar('loss/train_loss', train_loss, 0)\\n \\n print(\\\"\\\\t\\\")\\n print(recal/total_batch, precision/ total_batch, F_one/ total_batch, IOU/ total_batch)\\n print(accuracy_new/total_batch)\\n \\n self.pb.close()\\n train_loss /= total_batch\\n self.train_loss.append(train_loss)\\n\\n # add to summary\\n self.summary_writer.add_scalar('loss/train_loss', train_loss, self.epoch)\",\n \"def run_the_training(args, clus=None, expert=None):\\n # load data\\n cfg, lbl = util.get_label_cfg_by_args(args)\\n uid = cfg['uniqueid']\\n print('We are playing with %s' % uid)\\n data = npload(cfg['file_path'], uid)\\n data_feed = {'x': data[cfg['x_name']], 'y': data[cfg['y_name']]}\\n dimx = data_feed['x'].shape[1]\\n dimy = data_feed['y'].shape[1]\\n\\n # create gate and expert\\n if clus is None:\\n n_model = 5\\n clus = GaoNet([dimx, 100, n_model])\\n expert = Experts([[dimx, 60, dimy]] * n_model)\\n # cuda it\\n clus.cuda()\\n expert.cuda()\\n\\n # set data loader\\n xname, yname = 'x', 'y'\\n factory = KeyFactory(data_feed, xname, yname, scalex=True, scaley=True)\\n factory.shuffle(None)\\n\\n draw_clus_region(clus, data_feed['x'], factory)\\n\\n # create two sets\\n trainsize = 0.8\\n trainSet = SubFactory(factory, 0.0, trainsize)\\n testSet = SubFactory(factory, trainsize, 1.0)\\n batch_size = 32\\n test_batch_size = -1\\n trainLder = DataLoader(trainSet, batch_size=batch_size, shuffle=False)\\n testLder = DataLoader(testSet, batch_size=test_batch_size, shuffle=False)\\n\\n # set up file output\\n outname = 'gate_expert_model.pt'\\n outdir = 'models/pen/gate_expert'\\n if KLLOSS:\\n outname = 'gate_expert_kldiv_model.pt'\\n if args.warm:\\n outname = outname.replace('.pt', '_warm.pt')\\n\\n # set optimizer\\n lr = 1e-3\\n opt_G = torch.optim.Adam(clus.parameters(), lr=lr)\\n opt_E = torch.optim.Adam(expert.parameters(), lr=lr)\\n\\n # set other training stuff\\n n_epoch = 500\\n back_check_epoch = 8\\n best_test_loss = np.inf\\n best_test_loss_expert = np.inf\\n best_test_epoch = 0\\n\\n def get_mean_error(g_y, exp_y, feedy):\\n \\\"\\\"\\\"Calculate two loss\\\"\\\"\\\"\\n error_traj = torch.mean((exp_y - feedy.expand_as(exp_y)) ** 2, dim=2).t()\\n g = f.softmax(g_y)\\n log_g = f.log_softmax(g_y)\\n posterior = g * torch.exp(-0.5 * error_traj) # b by r probability, not scaled to 1\\n traj_prob = torch.mean(-torch.log(torch.sum(posterior, dim=1)))\\n if KLLOSS:\\n posterior_scale = Variable((posterior / torch.sum(posterior, dim=1, keepdim=True)).data) # do not use gradient of it\\n div_error = f.kl_div(log_g, posterior_scale)\\n return traj_prob, div_error\\n else:\\n Og = torch.sum(exp_y * g.t().unsqueeze(2), dim=0)\\n traj_error = f.smooth_l1_loss(Og, feedy)\\n return traj_prob, traj_error\\n\\n # start training\\n for epoch in range(n_epoch):\\n sum_train_loss = 0\\n sum_train_loss_prob = 0\\n for idx, batch_data in enumerate(trainLder):\\n feedy = Variable(batch_data[yname], requires_grad=False).cuda()\\n feedx = Variable(batch_data[xname], requires_grad=False).cuda()\\n # train experts\\n opt_E.zero_grad()\\n opt_G.zero_grad()\\n exp_y = expert(feedx)\\n g_y = clus(feedx)\\n g = f.softmax(g_y) # this is prior\\n log_g = f.log_softmax(g_y)\\n error_traj = torch.mean((exp_y - feedy.expand_as(exp_y)) ** 2, dim=2).t()\\n posterior = g * torch.exp(-0.5 * error_traj) # b by r probability, not scaled to 1\\n posterior_scale = Variable((posterior / torch.sum(posterior, dim=1, keepdim=True)).data) # do not use gradient of it\\n lossi = torch.mean(-torch.log(torch.sum(posterior, dim=1)))\\n lossi.backward(retain_graph=True)\\n sum_train_loss_prob += lossi.cpu().data.numpy() * feedx.size()[0]\\n opt_E.step()\\n # update h by regression error\\n all_pred = exp_y\\n if KLLOSS:\\n error = f.kl_div(log_g, posterior_scale)\\n else:\\n Og_before = all_pred * g.t().unsqueeze(2)\\n Og = torch.sum(Og_before, dim=0)\\n error = f.smooth_l1_loss(Og, feedy)\\n sum_train_loss += error.cpu().data.numpy() * feedx.size()[0]\\n error.backward()\\n opt_G.step()\\n # val = clus.printWeights(3)\\n mean_train_loss = sum_train_loss / trainLder.getNumData()\\n mean_train_loss_prob = sum_train_loss_prob / trainLder.getNumData()\\n\\n # evaluate on test data\\n sum_test_loss_gate = 0\\n sum_test_loss_expert = 0\\n n_test_data = testLder.getNumData()\\n for idx, batch_data in enumerate(testLder):\\n feedy = Variable(batch_data[yname], volatile=True).cuda()\\n feedx = Variable(batch_data[xname], volatile=True).cuda()\\n exp_y = expert(feedx)\\n g_y = clus(feedx)\\n traj_prob, div_error = get_mean_error(g_y, exp_y, feedy)\\n sum_test_loss_gate += div_error.cpu().data.numpy() * feedx.size()[0]\\n sum_test_loss_expert += traj_prob.cpu().data.numpy() * feedx.size()[0]\\n mean_test_loss_gate = sum_test_loss_gate / n_test_data\\n mean_test_loss_expert = sum_test_loss_expert / n_test_data\\n print('epoch %d gate loss %f expert loss %f test gate loss %f expert loss %f' \\\\\\n % (epoch, mean_train_loss, mean_train_loss_prob, mean_test_loss_gate, mean_test_loss_expert))\\n if mean_test_loss_gate < best_test_loss:\\n best_test_loss = mean_test_loss_gate\\n best_test_epoch = epoch\\n if mean_test_loss_expert < best_test_loss_expert:\\n best_test_loss_expert = mean_test_loss_expert\\n best_test_epoch = epoch\\n if epoch > best_test_epoch + back_check_epoch:\\n break\\n print('Save model now')\\n\\n # draw region for classifier\\n draw_clus_region(clus, data_feed['x'], factory)\\n\\n clus.cpu()\\n expert.cpu()\\n model = {'gate': clus, 'expert': expert, 'xScale': [trainLder.xmean, trainLder.xstd], 'yScale': [trainLder.ymean, trainLder.ystd]}\\n if not os.path.exists(outdir):\\n os.mkdir(outdir)\\n torch.save(model, os.path.join(outdir, outname))\",\n \"def train(self, uInputInfo):\\n if self.node_sharing:\\n ## train just one node,\\n self.pipes[0][0].send((\\\"train\\\", uInputInfo))\\n self.pipes[0][0].recv()\\n \\n else:\\n ## start each node's training\\n for i in range(len(self.nodes)):\\n for j in range(len(self.nodes[i])):\\n self.pipes[i][j].send((\\\"train\\\", uInputInfo))\\n\\n ## wait for the training to be finished\\n for i in range(len(self.nodes)):\\n for j in range(len(self.nodes[i])):\\n self.pipes[i][j].recv()\",\n \"def fit_unet(self):\\n logger.info(f\\\"Training model with optimizer:{self.optimizer}\\\")\\n logger.info(f\\\"Optimizer params: {self.optimizer_params}\\\")\\n self.model.fit_generator(\\n self.train_generator,\\n steps_per_epoch=self.steps_per_epoch,\\n validation_data=self.val_generator,\\n validation_steps=self.validation_steps,\\n epochs=self.epochs,\\n callbacks=self.callbacks,\\n verbose=1)\",\n \"def get_unet():\\n inputs = Input((img_rows, img_cols, 1))\\n conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(inputs)\\n conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv1)\\n pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)\\n\\n conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(pool1)\\n conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv2)\\n pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)\\n\\n conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(pool2)\\n conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv3)\\n pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)\\n\\n conv4 = Conv2D(256, (3, 3), activation='relu', padding='same')(pool3)\\n conv4 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv4)\\n pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)\\n\\n conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(pool4)\\n conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(conv5)\\n\\n up6 = concatenate([Conv2DTranspose(256, (2, 2), strides=(2, 2),\\n padding='same')(conv5), conv4], axis=3)\\n conv6 = Conv2D(256, (3, 3), activation='relu', padding='same')(up6)\\n conv6 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv6)\\n\\n up7 = concatenate([Conv2DTranspose(128, (2, 2), strides=(2, 2),\\n padding='same')(conv6), conv3], axis=3)\\n conv7 = Conv2D(128, (3, 3), activation='relu', padding='same')(up7)\\n conv7 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv7)\\n\\n up8 = concatenate([Conv2DTranspose(64, (2, 2), strides=(2, 2),\\n padding='same')(conv7), conv2], axis=3)\\n conv8 = Conv2D(64, (3, 3), activation='relu', padding='same')(up8)\\n conv8 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv8)\\n\\n up9 = concatenate([Conv2DTranspose(32, (2, 2), strides=(2, 2),\\n padding='same')(conv8), conv1], axis=3)\\n conv9 = Conv2D(32, (3, 3), activation='relu', padding='same')(up9)\\n conv9 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv9)\\n\\n conv10 = Conv2D(1, (1, 1), activation='sigmoid')(conv9)\\n\\n model = Model(inputs=[inputs], outputs=[conv10])\\n\\n model.compile(optimizer=Adam(lr=1e-4), loss=dice_coef_loss,\\n metrics=[dice_coef])\\n\\n return model\",\n \"def visualize(self, U, **kwargs):\\n raise NotImplementedError\",\n \"def train_conv_net(datasets,datasets_weights,\\n U, U_Topical,\\n img_w=300, \\n filter_hs=[3,4,5],\\n hidden_units=[100,2], \\n dropout_rate=[0.5],\\n shuffle_batch=True,\\n n_epochs=25, \\n batch_size=50, \\n lr_decay = 0.95,\\n conv_non_linear=\\\"relu\\\",\\n use_valid_set=True,\\n show_states=False,\\n activations=[Iden],\\n sqr_norm_lim=9,\\n non_static=True): \\n rng = np.random.RandomState(3435)\\n img_h = len(datasets[0][0])-1 \\n U_Topical.dtype = \\\"float32\\\"\\n (num_topics,topic_dim) = U_Topical.shape\\n word_w = img_w\\n img_w = int(img_w + num_topics*topic_dim)\\n filter_w = img_w \\n feature_maps = hidden_units[0]\\n filter_shapes = []\\n pool_sizes = []\\n for filter_h in filter_hs: \\n filter_shapes.append((feature_maps, 1, filter_h, filter_w)) # 100 1 3 300\\n pool_sizes.append((img_h-filter_h+1, img_w-filter_w+1)) # size of words samples one\\n parameters = [(\\\"image shape\\\",img_h,img_w),(\\\"filter shape\\\",filter_shapes), (\\\"hidden_units\\\",hidden_units),\\n (\\\"dropout\\\", dropout_rate), (\\\"batch_size\\\",batch_size),(\\\"non_static\\\", non_static),\\n (\\\"learn_decay\\\",lr_decay), (\\\"conv_non_linear\\\", conv_non_linear), (\\\"non_static\\\", non_static)\\n ,(\\\"sqr_norm_lim\\\",sqr_norm_lim),(\\\"shuffle_batch\\\",shuffle_batch)]\\n #print parameters \\n \\n #define model architecture\\n index = T.lscalar()\\n x = T.matrix('x') \\n y = T.ivector('y')\\n x_topic = T.tensor3('x_topic')\\n Words = theano.shared(value = U, name = \\\"Words\\\")\\n Topics = theano.shared(value=U_Topical,name=\\\"Topics\\\")\\n zero_vec_tensor = T.vector()\\n zero_vec = np.zeros(word_w, dtype='float32')\\n set_zero = theano.function([zero_vec_tensor], updates=[(Words, T.set_subtensor(Words[0,:], zero_vec_tensor))])\\n layer0_input_words = Words[T.cast(x.flatten(),dtype=\\\"int32\\\")].reshape((x.shape[0],1,x.shape[1],Words.shape[1])) \\n layer0_inputs_topics = []\\n for i in range(num_topics):\\n sin_topic = x_topic[:,:,i]\\n Topic = Topics[i].reshape((1,Topics[i].shape[0]))\\n weights = sin_topic.flatten()\\n weights = weights.reshape((weights.shape[0],1))\\n layer0_inputs_topics.append(T.dot(weights, Topic))\\n layer0_input_topics = T.concatenate(layer0_inputs_topics,1)\\n layer0_input_topics = layer0_input_topics.reshape((x_topic.shape[0],1,x_topic.shape[1],num_topics*topic_dim))\\n layer0_input = T.concatenate([layer0_input_words,layer0_input_topics],3) \\n conv_layers = []\\n layer1_inputs = []\\n for i in xrange(len(filter_hs)):\\n filter_shape = filter_shapes[i]\\n pool_size = pool_sizes[i]\\n conv_layer = LeNetConvPoolLayer(rng, input=layer0_input,image_shape=(batch_size, 1, img_h, img_w),\\n filter_shape=filter_shape, poolsize=pool_size, non_linear=conv_non_linear)\\n layer1_input = conv_layer.output.flatten(2)\\n conv_layers.append(conv_layer)\\n layer1_inputs.append(layer1_input)\\n layer1_input = T.concatenate(layer1_inputs,1)\\n hidden_units[0] = feature_maps*len(filter_hs) \\n classifier = MLPDropout(rng, input=layer1_input, layer_sizes=hidden_units, activations=activations, dropout_rates=dropout_rate)\\n \\n #define parameters of the model and update functions using adadelta\\n params = classifier.params \\n for conv_layer in conv_layers:\\n params += conv_layer.params\\n \\n if non_static:\\n #if word vectors are allowed to change, add them as model parameters\\n params += [Words] #params are model parameters\\n params += [Topics] #Topics embedding are adjusted\\n cost = classifier.negative_log_likelihood(y) \\n dropout_cost = classifier.dropout_negative_log_likelihood(y) \\n grad_updates = sgd_updates_adadelta(params, dropout_cost, lr_decay, 1e-6, sqr_norm_lim)\\n \\n #shuffle dataset and assign to mini batches. if dataset size is not a multiple of mini batches, replicate \\n #extra data (at random)\\n np.random.seed(3435)\\n if datasets[0].shape[0] % batch_size > 0:\\n extra_data_num = batch_size - datasets[0].shape[0] % batch_size\\n random_index = np.random.permutation(np.arange(datasets[0].shape[0])) \\n random_index.astype('int32')\\n train_set = datasets[0][random_index,:]\\n train_set_weights = datasets_weights[0][random_index,:,:]\\n extra_data = train_set[:extra_data_num]\\n extra_data_weights = train_set_weights[:extra_data_num]\\n new_data=np.append(datasets[0],extra_data,axis=0)\\n new_data_weights = np.append(datasets_weights[0],extra_data_weights,axis = 0)\\n else:\\n new_data = datasets[0]\\n new_data_weights = datasets_weights[0]\\n random_index = np.random.permutation(np.arange(new_data.shape[0])) \\n random_index.astype('int32')\\n new_data = new_data[random_index]\\n new_data_weights = new_data_weights[random_index]\\n n_batches = new_data.shape[0]/batch_size\\n n_train_batches = int(np.round(n_batches*0.9))\\n \\n test_set_x = np.asarray(datasets[1][:,:img_h] ,\\\"float32\\\")\\n test_set_x_topic = np.asarray(datasets_weights[1][:,:img_h,:] ,\\\"float32\\\")\\n test_set_y = np.asarray(datasets[1][:,-1],\\\"int32\\\")\\n if use_valid_set:\\n train_set = new_data[:n_train_batches*batch_size,:]\\n train_set_weights = new_data_weights[:n_train_batches*batch_size,:,:]\\n val_set = new_data[n_train_batches*batch_size:,:]\\n val_set_weights = new_data_weights[n_train_batches*batch_size:,:,:] \\n train_set_x, train_set_x_topic, train_set_y = shared_dataset((train_set[:,:img_h],train_set_weights,train_set[:,-1]))\\n val_set_x, val_set_x_topic, val_set_y = shared_dataset((val_set[:,:img_h],val_set_weights,val_set[:,-1]))\\n n_val_batches = n_batches - n_train_batches\\n val_model = theano.function([index], classifier.errors(y),\\n givens={\\n x: val_set_x[index * batch_size: (index + 1) * batch_size],\\n x_topic: val_set_x_topic[index * batch_size: (index + 1) * batch_size],\\n y: val_set_y[index * batch_size: (index + 1) * batch_size]})\\n else:\\n train_set = new_data[:,:] \\n train_set_x, train_set_x_topic, train_set_y = shared_dataset((train_set[:,:img_h],train_set_weights,train_set[:,-1])) \\n \\n #make theano functions to get train/val/test errors\\n test_model = theano.function([index], classifier.errors(y),\\n givens={\\n x: train_set_x[index * batch_size: (index + 1) * batch_size],\\n x_topic: train_set_x_topic[index * batch_size: (index + 1) * batch_size],\\n y: train_set_y[index * batch_size: (index + 1) * batch_size]}) \\n train_model = theano.function([index], cost, updates=grad_updates,\\n givens={\\n x: train_set_x[index*batch_size:(index+1)*batch_size],\\n x_topic: train_set_x_topic[index * batch_size: (index + 1) * batch_size],\\n y: train_set_y[index*batch_size:(index+1)*batch_size]}) \\n test_pred_layers = []\\n test_size = test_set_x.shape[0]\\n \\n \\n\\n test_layer0_input_words = Words[T.cast(x.flatten(),dtype=\\\"int32\\\")].reshape((test_size,1,img_h,Words.shape[1])) \\n test_layer0_inputs_topics = []\\n for i in range(num_topics):\\n sin_topic = x_topic[:,:,i]\\n Topic = Topics[i].reshape((1,Topics[i].shape[0]))\\n weights = sin_topic.flatten()\\n weights = weights.reshape((weights.shape[0],1))\\n test_layer0_inputs_topics.append(T.dot(weights, Topic))\\n test_layer0_input_topics = T.concatenate(test_layer0_inputs_topics,1)\\n test_layer0_input_topics = test_layer0_input_topics.reshape((test_size,1,img_h,num_topics*topic_dim))\\n test_layer0_input = T.concatenate([test_layer0_input_words,test_layer0_input_topics],3) \\n\\n\\n\\n for conv_layer in conv_layers:\\n test_layer0_output = conv_layer.predict(test_layer0_input, test_size)\\n test_pred_layers.append(test_layer0_output.flatten(2))\\n test_layer1_input = T.concatenate(test_pred_layers, 1)\\n test_y_pred = classifier.predict(test_layer1_input)\\n\\n test_error = T.mean(T.neq(test_y_pred, y))\\n test_model_all = theano.function([x,x_topic,y], test_error) \\n \\n #start training over mini-batches\\n print '... training'\\n epoch = 0\\n best_val_perf = 0\\n val_perf = 0\\n test_perf = 0 \\n cost_epoch = 0 \\n while (epoch < n_epochs): \\n epoch = epoch + 1\\n if shuffle_batch:\\n for minibatch_index in np.random.permutation(range(n_train_batches)):\\n cost_epoch = train_model(minibatch_index)\\n set_zero(zero_vec)\\n else:\\n for minibatch_index in xrange(n_train_batches):\\n cost_epoch = train_model(minibatch_index) \\n set_zero(zero_vec)\\n train_losses = [test_model(i) for i in xrange(n_train_batches)]\\n train_perf = 1 - np.mean(train_losses)\\n if use_valid_set:\\n val_losses = [val_model(i) for i in xrange(n_val_batches)]\\n val_perf = 1- np.mean(val_losses)\\n\\n if val_perf >= best_val_perf:\\n params_conv = [] \\n params_output = {}\\n test_loss = test_model_all(test_set_x,test_set_x_topic, test_set_y) \\n test_perf = 1- test_loss \\n best_val_perf = val_perf \\n for conv_layer in conv_layers:\\n params_conv.append(conv_layer.get_params())\\n params_output = classifier.get_params()\\n word_vec = Words.get_value()\\n Topic_vec = Topics.get_value()\\n else :\\n val_perf = 0 \\n if show_states:\\n print('epoch %i, train perf %f %%, val perf %f' % (epoch, train_perf * 100., val_perf*100.))\\n \\n if not use_valid_set:\\n params_conv = [] \\n params_output = {}\\n test_loss = test_model_all(test_set_x,test_set_x_topic, test_set_y) \\n test_perf = 1- test_loss \\n \\n for conv_layer in conv_layers:\\n params_conv.append(conv_layer.get_params())\\n params_output = classifier.get_params()\\n word_vec = Words.get_value()\\n Topic_vec = Topics.get_value() \\n \\n return test_perf, [params_conv, params_output, word_vec,Topic_vec]\",\n \"def plotGraph(self, title = \\\"Multi Layer Perceptron (MLP)\\\"):\\n graph, pos, colorMap = self.getGraph()\\n\\n fig = plt.figure()\\n fig.canvas.set_window_title(\\\"Neural Network\\\")\\n plt.plot()\\n nx.draw_networkx_nodes(graph,pos, node_color = colorMap)\\n nx.draw_networkx_edges(graph,pos)\\n plt.axis('off')\\n plt.title(title)\\n #plt.savefig(\\\"autoencoder.svg\\\", transparent = True)\\n plt.show()\",\n \"def visualize_train(train_data_full, train_labels, train_data, thetas, losses, niter):\\n fig1, ax1 = plt.subplots()\\n ax1.scatter(train_data_full[\\\"Weight\\\"], train_data_full[\\\"Height\\\"], color = 'blue')\\n\\n # De-standarize\\n train_mean = train_data_full[\\\"Weight\\\"].mean()\\n train_std = train_data_full[\\\"Weight\\\"].std()\\n train_data_for_plot = train_mean + train_data[\\\"Weight\\\"] * train_std\\n\\n ax1.plot(train_data_for_plot, predict(train_data, thetas[niter - 1]), color = 'red', linewidth = 2)\\n ax1.set_xlabel(\\\"Height\\\")\\n ax1.set_ylabel(\\\"Weight\\\")\\n\\n fig2, ax2 = plt.subplots()\\n ax2.plot(range(len(losses)), losses, color = 'blue', linewidth = 2)\\n ax2.set_xlabel(\\\"Iteration\\\")\\n ax2.set_ylabel(\\\"MSE\\\")\\n\\n fig3, ax3 = plt.subplots()\\n np_gradient_ws = np.array(thetas)\\n\\n w = np.linspace(min(np_gradient_ws[:, 0]), max(np_gradient_ws[:, 0]), len(np_gradient_ws[:, 0]))\\n b = np.linspace(min(np_gradient_ws[:, 1]), max(np_gradient_ws[:, 1]), len(np_gradient_ws[:, 1]))\\n x, y = np.meshgrid(w, b)\\n z = compute_z_loss(train_labels, train_data, np.stack((w,b)).T)\\n cp = ax3.contourf(x, y, z, cmap = plt.cm.jet)\\n fig3.colorbar(cp, ax = ax3)\\n ax3.plot(3.54794951, 66.63949115837143, color = 'red', marker = '*', markersize = 20)\\n if niter > 0:\\n thetas_to_plot = np_gradient_ws[:niter]\\n ax3.plot(thetas_to_plot[:, 0], thetas_to_plot[:, 1], marker = 'o', color = 'w', markersize = 10)\\n ax3.set_xlabel(r'$w$')\\n ax3.set_ylabel(r'$b$')\\n return fig1, fig2, fig3\",\n \"def train():\\n import trace\\n trace.train()\",\n \"def __init__(self, args):\\n \\n super(MicroNet, self).__init__()\\n self.conv1 = nn.Conv2d(3, 1, kernel_size=1)\\n self.conv2 = nn.Conv2d(1, 29, kernel_size=5)\\n self.maxpool2 = nn.MaxPool2d(3, stride=2 , ceil_mode=True)\\n self.conv3 = nn.Conv2d(29, 59, kernel_size=3)\\n self.maxpool3 = nn.MaxPool2d(3, stride=2 , ceil_mode=True)\\n self.conv4 = nn.Conv2d(59, 74, kernel_size=3)\\n self.maxpool4 = nn.MaxPool2d(3, stride=2 , ceil_mode=True)\\n self.conv2_drop = nn.Dropout2d()\\n self.conv3_drop = nn.Dropout2d()\\n self.fc1 = nn.Linear(1184, 300)\\n self.fc2 = nn.Linear(300, args.num_classes)\\n self.conv0_bn = nn.BatchNorm2d(3)\\n self.conv1_bn = nn.BatchNorm2d(1)\\n self.conv2_bn = nn.BatchNorm2d(29)\\n self.conv3_bn = nn.BatchNorm2d(59)\\n self.conv4_bn = nn.BatchNorm2d(74)\\n self.dense1_bn = nn.BatchNorm1d(300)\",\n \"def classify_lenet5(batch_size=500, output_size=20):\\n\\n rng = numpy.random.RandomState(23455)\\n\\n\\n # start-snippet-1\\n x = T.matrix('x') # the data is presented as rasterized images\\n ######################\\n # BUILD ACTUAL MODEL #\\n ######################\\n print '... building the model'\\n\\n # Reshape matrix of rasterized images of shape (batch_size, 28 * 28)\\n # to a 4D tensor, compatible with our LeNetConvPoolLayer\\n # (28, 28) is the size of MNIST images.\\n layer0_input = x.reshape((batch_size, 1, 37, 23))\\n\\n # Construct the first convolutional pooling layer:\\n # filtering reduces the image size to (28-5+1 , 28-5+1) = (24, 24)\\n # maxpooling reduces this further to (24/2, 24/2) = (12, 12)\\n # 4D output tensor is thus of shape (batch_size, nkerns[0], 12, 12)\\n layer0 = LeNetConvPoolLayer(\\n rng,\\n input=layer0_input,\\n image_shape=(batch_size, 1, 37, 23),\\n filter_shape=(20, 1, 4, 2),\\n poolsize=(2, 2),\\n )\\n\\n # layer1 = LeNetConvPoolLayer(\\n # rng,\\n # input=layer0.output,\\n # image_shape=(batch_size, 20, 17, 11),\\n # filter_shape=(50, 20, 4, 2),\\n # poolsize=(2, 2),\\n # )\\n #\\n # layer4 = LeNetConvPoolLayer(\\n # rng,\\n # input=layer1.output,\\n # image_shape=(batch_size, 50, 7, 5),\\n # filter_shape=(100, 50, 4, 2),\\n # poolsize=(2, 2),\\n # )\\n\\n layer2_input = layer0.output.flatten(2)\\n\\n # construct a fully-connected sigmoidal layer\\n layer2 = HiddenLayer(\\n rng,\\n input=layer2_input,\\n n_in=3740,\\n n_out=output_size,\\n activation=T.tanh,\\n use_bias=True\\n )\\n\\n # layer5 = HiddenLayer(\\n # rng,\\n # input=layer2.output,\\n # n_in=200,\\n # n_out=output_size,\\n # activation=T.tanh,\\n # use_bias=True\\n # )\\n\\n # classify the values of the fully-connected sigmoidal layer\\n layer3 = LogisticRegression(input=layer2.output, n_in=output_size, n_out=2)\\n\\n model_params = pickle.load(open('../model/cnn_dist_'+str(output_size)+'.pkl'))\\n #\\n layer0.W = theano.shared(\\n value=numpy.array(\\n model_params[2].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='W',\\n borrow=True\\n )\\n\\n layer0.b = theano.shared(\\n value=numpy.array(\\n model_params[3].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='b',\\n borrow=True\\n )\\n\\n # layer1.W = theano.shared(\\n # value=numpy.array(\\n # model_params[-4].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='W',\\n # borrow=True\\n # )\\n #\\n # layer1.b = theano.shared(\\n # value=numpy.array(\\n # model_params[-3].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='b',\\n # borrow=True\\n # )\\n #\\n # layer4.W = theano.shared(\\n # value=numpy.array(\\n # model_params[-6].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='W',\\n # borrow=True\\n # )\\n #\\n # layer4.b = theano.shared(\\n # value=numpy.array(\\n # model_params[-5].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='b',\\n # borrow=True\\n # )\\n\\n layer2.W = theano.shared(\\n value=numpy.array(\\n model_params[0].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='W',\\n borrow=True\\n )\\n\\n layer2.b = theano.shared(\\n value=numpy.array(\\n model_params[1].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='b',\\n borrow=True\\n )\\n\\n # layer5.W = theano.shared(\\n # value=numpy.array(\\n # model_params[-10].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='W',\\n # borrow=True\\n # )\\n #\\n # layer5.b = theano.shared(\\n # value=numpy.array(\\n # model_params[-9].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='b',\\n # borrow=True\\n # )\\n\\n layer3.W = theano.shared(\\n value=numpy.array(\\n model_params[4].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='W',\\n borrow=True\\n )\\n\\n layer3.b = theano.shared(\\n value=numpy.array(\\n model_params[5].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='b',\\n borrow=True\\n )\\n\\n # params = layer3.params + layer5.params + layer2.params + layer4.params + layer1.params + layer0.params\\n\\n datasets = load_data(None)\\n\\n sets = ['train', 'dev', 'test']\\n dimension = [20000, 20000, 20000]\\n for k in range(3):\\n if k == 0:\\n classify_set_x, classify_set_y, classify_set_z, classify_set_m, classify_set_c, classify_set_b= datasets[k]\\n else:\\n classify_set_x, classify_set_y, classify_set_z= datasets[k]\\n\\n # compute number of minibatches for training, validation and testing\\n n_classify_batches = classify_set_x.get_value(borrow=True).shape[0]\\n n_classify_batches /= batch_size\\n\\n # allocate symbolic variables for the data\\n index = T.lscalar() # index to a [mini]batch\\n classify = theano.function(\\n [index],\\n layer2.output,\\n givens={\\n x: classify_set_x[index * batch_size: (index + 1) * batch_size],\\n }\\n )\\n\\n r = []\\n\\n for i in xrange(n_classify_batches):\\n m = classify(i)\\n r.extend(m)\\n r = np.array(r)\\n print r.shape\\n r = np.append(r, np.reshape(classify_set_y.eval(),(dimension[k], 1)), 1)\\n numpy.savetxt('../extractedInformation/cnn_dist_'+str(output_size)+'/'+sets[k]+'.csv', r, delimiter=\\\",\\\")\",\n \"def __init__(self, opt):\\n BaseModel.__init__(self, opt)\\n # specify the training losses you want to print out. The training/test scripts will call <BaseModel.get_current_losses>\\n self.loss_names = ['G_GAN', 'G_L1', 'D_real', 'D_fake']\\n # specify the images you want to save/display. The training/test scripts will call <BaseModel.get_current_visuals>\\n self.visual_names = ['real_A', 'fake_B', 'real_B']\\n # specify the models you want to save to the disk. The training/test scripts will call <BaseModel.save_networks> and <BaseModel.load_networks>\\n if self.isTrain:\\n self.model_names = ['G', 'D']\\n else: # during test time, only load G\\n self.model_names = ['G']\\n\\n # Set TPN_enabled to true if opt.TPN is defined\\n if opt.TPN:\\n self.TPN_enabled = True\\n else:\\n self.TPN_enabled = False\\n\\n # Conditional GANs need to take both input and output images; Therefore, #channels for D is input_nc + output_nc\\n discr_input_nc = opt.input_nc + opt.output_nc\\n\\n # If TPN is enabled, switch to the U-Net with TPN architecture\\n if self.TPN_enabled:\\n opt.netG = 'unet_256_TPN'\\n discr_input_nc +=1 # Additional Channel for Time Input\\n\\n # define networks (both generator and discriminator)\\n self.netG = networks.define_G(opt.input_nc, opt.output_nc, opt.ngf, opt.netG, opt.norm,\\n not opt.no_dropout, opt.init_type, opt.init_gain, self.gpu_ids)\\n\\n if self.isTrain: # define a discriminator; \\n self.netD = networks.define_D(discr_input_nc, opt.ndf, opt.netD,\\n opt.n_layers_D, opt.norm, opt.init_type, opt.init_gain, self.gpu_ids)\\n\\n if self.TPN_enabled:\\n self.loss_names = ['G_GAN', 'G_L1', 'G_TPN', 'D_real', 'D_fake']\\n\\n # Store final gamma value and then set it to 0\\n self.final_gamma = deepcopy(opt.gamma)\\n opt.gamma = 0\\n\\n # Initiliaze m and c to None\\n self.update_m = None\\n self.update_c = None\\n\\n # Setup TPN if set to True\\n print(\\\"\\\\nSetting up TPN\\\\n\\\")\\n opt_TPN = deepcopy(opt) # copy train options and change later\\n opt_TPN.model = 'time_predictor'\\n opt_TPN.name = opt.TPN\\n opt_TPN.netD = 'time_input'\\n opt_TPN.ndf = 16 # Change depending on the ndf size used with the TPN model specified\\n # hard-code some parameters for TPN test phase\\n opt_TPN.display_id = -1 # no visdom display;\\n opt_TPN.isTrain = False\\n print(\\\"Options TPN: {}\\\\n\\\\n\\\".format(opt_TPN))\\n self.TPN = create_model(opt_TPN) # create a model given opt_TPN.model and other options\\n self.TPN.setup(opt_TPN) # regular setup: load\\n\\n if self.isTrain:\\n # define loss functions\\n self.criterionGAN = networks.GANLoss(opt.gan_mode).to(self.device)\\n self.criterionL1 = torch.nn.L1Loss()\\n # initialize optimizers; schedulers will be automatically created by function <BaseModel.setup>.\\n self.optimizer_G = torch.optim.Adam(self.netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))\\n self.optimizer_D = torch.optim.Adam(self.netD.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))\\n self.optimizers.append(self.optimizer_G)\\n self.optimizers.append(self.optimizer_D)\\n\\n # Check if lambda_L2 is in range [0,1]\\n assert (0 <= self.opt.lambda_L2 <= 1)\",\n \"def train():\\n\\n ### DO NOT CHANGE SEEDS!\\n # Set the random seeds for reproducibility\\n np.random.seed(42)\\n\\n ## Prepare all functions\\n # Get number of units in each hidden layer specified in the string such as 100,100\\n if FLAGS.dnn_hidden_units:\\n dnn_hidden_units = FLAGS.dnn_hidden_units.split(\\\",\\\")\\n dnn_hidden_units = [int(dnn_hidden_unit_) for dnn_hidden_unit_ in dnn_hidden_units]\\n else:\\n dnn_hidden_units = []\\n\\n # Get negative slope parameter for LeakyReLU\\n neg_slope = FLAGS.neg_slope\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n import matplotlib.pyplot as plt\\n\\n data = cifar10_utils.get_cifar10(FLAGS.data_dir)\\n train = data['train']\\n test = data['test']\\n dim_x = train.images.shape[1]*train.images.shape[2]*train.images.shape[3]\\n\\n mlp = MLP(dim_x, dnn_hidden_units, train.labels.shape[1], neg_slope)\\n loss_module = CrossEntropyModule()\\n\\n loss_train = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n loss_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n accuracy_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n\\n images_test = test.images\\n labels_test = test.labels\\n images_test = np.reshape(images_test, (images_test.shape[0], dim_x))\\n\\n for i in range(0, FLAGS.max_steps):\\n if PRINTS:\\n print('iter', i+1, end='\\\\r')\\n images, labels = train.next_batch(FLAGS.batch_size) \\n images = np.reshape(images, (images.shape[0], dim_x))\\n\\n pred = mlp.forward(images)\\n loss = loss_module.forward(pred, labels)\\n loss_grad = loss_module.backward(pred, labels)\\n mlp.backward(loss_grad)\\n\\n for module in reversed(mlp.modules):\\n if isinstance(module, LinearModule):\\n module.params['weight'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['weight']\\n module.params['bias'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['bias']\\n if (i+1) % FLAGS.eval_freq == 0:\\n pred_test = mlp.forward(images_test)\\n loss_train[i // FLAGS.eval_freq] = loss\\n accuracy_test[i // FLAGS.eval_freq] = accuracy(pred_test, labels_test)\\n loss_test[i // FLAGS.eval_freq] = loss_module.forward(pred_test, labels_test)\\n if PRINTS:\\n print()\\n print('test_loss:', loss_test[i // FLAGS.eval_freq])\\n print('test_accuracy:', accuracy_test[i // FLAGS.eval_freq])\\n print('train_loss:', loss_train[i // FLAGS.eval_freq])\\n\\n if PLOTS:\\n fig, ax = plt.subplots(1, 2, figsize=(10,5))\\n fig.suptitle('Training curves for Numpy MLP\\\\nFinal test accuracy: {:0.4f}, default configuration'.format(accuracy_test[i // FLAGS.eval_freq]))\\n\\n ax[0].set_title('Loss')\\n ax[0].set_ylabel('Loss value')\\n ax[0].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\\n ax[0].plot(loss_train, label='Train')\\n ax[0].plot(loss_test, label='Test')\\n ax[0].legend()\\n\\n ax[1].set_title('Accuracy')\\n ax[1].set_ylabel('Accuracy value')\\n ax[1].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\\n ax[1].plot(accuracy_test, label='Test')\\n ax[1].legend()\\n plt.show()\\n\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def __init__(\\n self,\\n numpy_rng,\\n train_set_x,\\n train_set_y,\\n hidden_layers_sizes,\\n n_ins=784,\\n n_outs=10\\n ):\\n\\n self.sigmoid_layers = []\\n self.AE_layers = []\\n self.params = []\\n self.n_layers = len(hidden_layers_sizes)\\n self.train_set_x = train_set_x\\n self.train_set_y = train_set_y\\n\\n assert self.n_layers > 0\\n\\n self.x = T.matrix('x') # the data is presented as rasterized images\\n self.y = T.ivector('y') # the labels are presented as 1D vector of\\n\\n for i in xrange(self.n_layers): # used to be n layers\\n\\n # construct the sigmoid layer = encoder stack\\n if i == 0:\\n layer_input = self.x\\n else:\\n layer_input = self.sigmoid_layers[-1].output\\n\\n sigmoid_layer = HiddenLayer(rng=numpy_rng,\\n input=layer_input,\\n n_in=(n_ins if i == 0 else\\n hidden_layers_sizes[i-1]),\\n n_out=hidden_layers_sizes[i],\\n activation=T.nnet.sigmoid)\\n\\n # add the layer to our list of layers\\n self.sigmoid_layers.append(sigmoid_layer)\\n self.params.extend(sigmoid_layer.params)\\n\\n # init the DA_layer, takes weights from sigmoid layer\\n AE_layer = AutoEncoder(\\n numpy_rng=numpy_rng,\\n input=layer_input,\\n n_visible=(n_ins if i == 0 else hidden_layers_sizes[i-1]),\\n n_hidden=hidden_layers_sizes[i],\\n W=sigmoid_layer.W,\\n bhid=sigmoid_layer.b)\\n\\n self.AE_layers.append(AE_layer)\\n\\n # on top of the layers\\n # log layer for fine-tuning\\n self.logLayer = LogisticRegression(\\n input=self.sigmoid_layers[-1].output,\\n n_in=hidden_layers_sizes[-1],\\n n_out=n_outs\\n )\\n self.params.extend(self.logLayer.params)\\n self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)\\n self.errors = self.logLayer.errors(self.y)\",\n \"def _train(args): \\n\\n #device = 'cuda' if torch.cuda.is_available() else 'cpu'\\n device = 'cpu'\\n logger.info(\\\"Device Type: {}\\\".format(device))\\n\\n logger.info(\\\"Loading SUN360 dataset\\\")\\n transform = transforms.Compose(\\n [transforms.Resize((224,224)),\\n transforms.ToTensor(),\\n transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\\n target_transform = transforms.Compose([transforms.Resize((224,224)),\\n transforms.ToTensor()]) \\n\\n trainset = SUN360Dataset(\\\"imagedata.json\\\",transform = transform, target_transform = target_transform)\\n train_loader = DataLoader(trainset, batch_size=args.batch_size,\\n shuffle=True, num_workers=args.workers)\\n \\\"\\\"\\\"\\n testset = torchvision.datasets.CIFAR10(root=args.data_dir, train=False,\\n download=False, transform=transform)\\n test_loader = DataLoader(testset, batch_size=args.batch_size,\\n shuffle=False, num_workers=args.workers)\\n \\\"\\\"\\\" \\n\\n logger.info(\\\"Model loaded\\\")\\n model = EfficientNet.from_name('efficientnet-b0',conv_type='Equi')\\n\\n if torch.cuda.device_count() > 1:\\n logger.info(\\\"Gpu count: {}\\\".format(torch.cuda.device_count()))\\n model = nn.DataParallel(model)\\n\\n model = model.to(device)\\n\\n criterion = CELoss().to(device)\\n optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)\\n\\n for epoch in range(0, args.epochs):\\n running_loss = 0.0\\n for i, data in enumerate(train_loader):\\n # get the inputs\\n inputs, EM , CM = data\\n inputs, EM, CM = inputs.to(device), EM.to(device), CM.to(device)\\n\\n # zero the parameter gradients\\n optimizer.zero_grad()\\n\\n # forward + backward + optimize\\n outputs = model(inputs)\\n EMLoss, CMLoss = map_loss(outputs,EM,CM,criterion)\\n loss = EMLoss + CMLoss\\n loss.backward()\\n optimizer.step()\\n\\n # print statistics\\n running_loss += loss.item()\\n if i % 2000 == 1999: # print every 2000 mini-batches\\n print('[%d, %5d] loss: %.3f' %\\n (epoch + 1, i + 1, running_loss / 2000))\\n running_loss = 0.0\\n print('Finished Training')\\n return _save_model(model, args.model_dir)\",\n \"def train_neural_network(x_train, train_labels, x_test, orig_test):\\n train_features = np.array(x_train)\\n test_features = np.array(x_test)\\n train_labels = np.array(train_labels['Col2'])\\n\\n model = models.make_model(params=train_features,\\n model_name='neural_network_1')\\n\\n checkpoint_cb, tensorboard_cb = models.callbacks(\\n model_name='nn_submission03_s_1_m1_f_2165.ckpt')\\n epochs = 6\\n batch_size = 32\\n\\n history = model.fit(train_features,\\n train_labels,\\n batch_size=batch_size,\\n epochs=epochs,\\n callbacks=[checkpoint_cb, tensorboard_cb]\\n # validation_data=(val_features, val_labels)\\n )\\n\\n evaluation.evaluation(model, train_features, train_labels)\\n evaluation.plot_metrices(epochs, history, if_val=False)\\n evaluation.plot_confusion_matrix(model, train_features, train_labels)\\n evaluation.submission_nn(model=model,\\n test_features=test_features,\\n orig_test_df=orig_test,\\n submission_name='nn_submission03_s_1_m1_f_2165.csv')\",\n \"def test():\\n\\n # load image and adjust its format\\n if MEMORY_CACHE:\\n test_input = dataset[0]['file']\\n oriImg = test_input.byte().permute((1, 2, 0)).numpy() # B,G,R order\\n else:\\n oriImg = cv2.imread(dataset[0]['file']) # B,G,R order\\n test_input = torch.from_numpy(oriImg).permute((2, 0, 1)).float()\\n \\n # transfer data on GPU on demand\\n if CUDA:\\n test_input = test_input.cuda()\\n\\n # perform prediction\\n net.eval()\\n with torch.no_grad():\\n result = net(test_input.unsqueeze(0))[0]\\n\\n print(result)\\n\\n # draw rectangles and its class\\n img = cv2.cvtColor(oriImg, cv2.COLOR_BGR2RGB)\\n for box, label, score in zip(result['boxes'], result['labels'], result['scores']):\\n # if score > 0.5:\\n if label < len(orig_labels):\\n img = cv2.rectangle(img, (box[0], box[1]), (box[2], box[3]), (0, 0, 255), 3)\\n img = cv2.putText(img, '{}: {:.0%}'.format(orig_labels[label], score), (box[0] + 5, box[3] - 5), cv2.FONT_HERSHEY_SIMPLEX, .7, (0, 255, 0), 2, cv2.LINE_AA)\\n plt.imshow(img)\\n plt.axis('off')\\n plt.show()\",\n \"def train_step(self, image, cur_epoch):\\n noise = np.random.normal(loc=0.0, scale=1.0, size=[self.batch_size, self.noise_dim])\\n true_labels, generated_labels = self.generate_labels(\\n self.config.trainer.soft_labels, self.config.trainer.flip_labels\\n )\\n # Train the discriminator\\n real_noise, fake_noise = self.generate_noise(self.config.trainer.include_noise, cur_epoch)\\n image_eval = self.sess.run(image)\\n feed_dict = {\\n self.model.image_tensor: image_eval,\\n self.model.noise_tensor: noise,\\n self.model.generated_labels: generated_labels,\\n self.model.true_labels: true_labels,\\n self.model.real_noise: real_noise,\\n self.model.fake_noise: fake_noise,\\n self.model.is_training: True,\\n }\\n _, _, _, ld, ldxz, ldxx, ldzz = self.sess.run(\\n [\\n self.model.train_dis_op_xz,\\n self.model.train_dis_op_xx,\\n self.model.train_dis_op_zz,\\n self.model.loss_discriminator,\\n self.model.dis_loss_xz,\\n self.model.dis_loss_xx,\\n self.model.dis_loss_zz,\\n ],\\n feed_dict=feed_dict,\\n )\\n # Train the Generator and Encoder\\n noise = np.random.normal(loc=0.0, scale=1.0, size=[self.batch_size, self.noise_dim])\\n true_labels, generated_labels = self.generate_labels(\\n self.config.trainer.soft_labels, self.config.trainer.flip_labels\\n )\\n real_noise, fake_noise = self.generate_noise(self.config.trainer.include_noise, cur_epoch)\\n feed_dict = {\\n self.model.image_tensor: image_eval,\\n self.model.noise_tensor: noise,\\n self.model.generated_labels: generated_labels,\\n self.model.true_labels: true_labels,\\n self.model.real_noise: real_noise,\\n self.model.fake_noise: fake_noise,\\n self.model.is_training: True,\\n }\\n _, _, le, lg = self.sess.run(\\n [\\n self.model.train_gen_op,\\n self.model.train_enc_op,\\n self.model.loss_encoder,\\n self.model.loss_generator,\\n ],\\n feed_dict=feed_dict,\\n )\\n\\n if self.config.log.enable_summary:\\n sm = self.sess.run(self.model.sum_op, feed_dict=feed_dict)\\n else:\\n sm = None\\n\\n return lg, le, ld, ldxz, ldxx, ldzz, sm\",\n \"def main(tetrode_number=TETRODE_NUMBER,num_hidden_units=300,num_hidden_units_2=200,num_code_units=50):\\n print(\\\"Loading the data...\\\")\\n dataset = load_data(tetrode_number)\\n print(\\\"Done!\\\")\\n\\n print(\\\"Tetrode number: {}, Num outputs: {}\\\".format(tetrode_number,dataset['output_dim']))\\n\\n print(dataset['input_shape'])\\n print(dataset['output_dim'])\\n \\n print(\\\"Making the model...\\\")\\n network = model(dataset['input_shape'],dataset['output_dim'],num_hidden_units,num_hidden_units_2,num_code_units,(4,1))\\n print(\\\"Done!\\\")\\n\\n print(\\\"Setting up the training functions...\\\")\\n training = funcs(dataset,network)\\n print(\\\"Done!\\\")\\n\\n accuracies = []\\n trainvalidation = []\\n\\n print(\\\"Begining to train the network...\\\")\\n epochsDone = 0\\n autoencoderSameLabels = []\\n try:\\n for i in range(NUM_EPOCHS):\\n costs = []\\n valid_costs = []\\n\\n for start, end in zip(range(0, dataset['num_examples_train'], BATCH_SIZE), range(BATCH_SIZE, dataset['num_examples_train'], BATCH_SIZE)):\\n cost = training['train'](dataset['X_train'][start:end],dataset['y_train'][start:end])\\n costs.append(cost)\\n \\n for start, end in zip(range(0, dataset['num_examples_valid'], BATCH_SIZE), range(BATCH_SIZE, dataset['num_examples_valid'], BATCH_SIZE)):\\n cost = training['valid'](dataset['X_valid'][start:end],dataset['y_valid'][start:end])\\n valid_costs.append(cost)\\n\\n\\n meanValidCost = np.mean(np.asarray(valid_costs),dtype=np.float32) \\n meanTrainCost = np.mean(np.asarray(costs,dtype=np.float32))\\n accuracy = training['accuracy'](dataset['X_test'],dataset['y_test'])\\n\\n print(\\\"Epoch: {}, Accuracy: {}, Training cost / validation cost: {}\\\".format(i+1,accuracy,meanTrainCost/meanValidCost))\\n\\n if(np.isnan(meanTrainCost/meanValidCost)):\\n print(\\\"Nan value\\\")\\n break\\n\\n\\n # this is the test to see if the autoencoder is learning how to \\n if i%10==0:\\n acs = []\\n for j in range(dataset['caswells_dim']):\\n # print(dataset['labeled_test'][j].shape)\\n codes = training['code'](dataset['labeled_test'][j])\\n np.mean(np.argmax(dataset['y_test'], axis=1) == np.argmax(training['predict'](dataset['X_test']), axis=1))\\n format_codes = []\\n for code in codes:\\n # if(j==0):\\n format_codes.append(np.argmax(code))\\n\\n prev = sorted(format_codes)[0]\\n # print(sorted(format_codes))\\n k = 0\\n same = [1]\\n for code in sorted(format_codes)[1:]:\\n if(code == prev):\\n same[k] = same[k] + 1\\n else:\\n k+=1\\n same.append(1)\\n prev = code\\n\\n same = np.asarray(same)\\n # print(same,np.argmax(same),same[np.argmax(same)],np.sum(same))\\n label_acc = same[np.argmax(same)]*1.0/np.sum(same)\\n acs.append(label_acc)\\n print(\\\"Label: {}, Num examples: {}, Same label with autoencoder: {} \\\".format(j,dataset['labeled_test'][j].shape[0],label_acc))\\n acs = np.asarray(acs)\\n autoencoderSameLabels.append(np.mean(acs))\\n print(\\\"Average agreement: {}\\\".format(np.mean(acs)))\\n\\n\\n if i%50 == 0:\\n ran = randint(0,dataset['num_examples_test']-20)\\n now = datetime.datetime.now()\\n for j in range(10):\\n testing = [dataset['X_test'][ran]]\\n # print(testing[0].shape)\\n output = dataset['y_test'][ran].reshape((1, 200))[0]\\n print(output)\\n\\n # print(np.arange(dataset['output_dim']))\\n # print(output)\\n prediction = training['predict'](testing)[0].reshape((1, 200))[0]\\n print(prediction)\\n # print(prediction)\\n # print(testing[0][0])\\n \\n code = training['code'](testing).reshape((1, 50))\\n\\n # print(code)\\n \\n # plotting the figure\\n\\n fig = plt.figure(1)\\n sub1 = fig.add_subplot(311)\\n sub2 = fig.add_subplot(312)\\n sub3 = fig.add_subplot(313)\\n\\n # add titles\\n\\n sub1.set_title('Desired output')\\n sub2.set_title('Net output')\\n sub3.set_title('Code layer output')\\n\\n # adding x labels\\n\\n sub1.set_xlabel('Time')\\n sub2.set_xlabel('Time')\\n sub3.set_xlabel('Code label')\\n\\n # adding y labels\\n\\n sub1.set_ylabel('Amplitude')\\n sub2.set_ylabel('Amplitude')\\n sub3.set_ylabel('Probability')\\n\\n # Plotting data\\n\\n # print(testing[0][0])\\n # inp = []\\n # for z in range(4):\\n # inp += list(testing[0][0][z])\\n\\n\\n sub1.plot(output)\\n # sub1.bar(x_axis, output, width=1)\\n sub1.grid(True)\\n\\n sub2.plot(prediction)\\n sub2.grid(True)\\n\\n x_axis = list(np.arange(len(code[0])))\\n\\n # sub3.plot(code[0])\\n sub3.bar(x_axis, code[0], width=1)\\n # plt.show()\\n\\n fig.tight_layout()\\n\\n # plt.plot(var2)\\n # fig.tight_layout()\\n plt.savefig('../logs/convAuto/fig{}_{}_{}.png'.format(i,j,now), bbox_inches='tight')\\n plt.close()\\n \\n ran += 1\\n # break\\n\\n\\n trainvalidation.append([meanTrainCost,meanValidCost])\\n accuracies.append(accuracy)\\n if(EARLY_STOPPING):\\n if(len(accuracies) < STOPPING_RANGE):\\n pass\\n else:\\n test = [k for k in accuracies if k < accuracy]\\n if not test:\\n print('Early stopping causing training to finish at epoch {}'.format(i+1))\\n break\\n del accuracies[0]\\n accuracies.append(accuracy)\\n\\n epochsDone = epochsDone + 1\\n\\n except KeyboardInterrupt:\\n pass\\n\\n # plt.plot(trainvalidation)\\n # plt.show()\\n\\n if(LOG_EXPERIMENT):\\n print(\\\"Logging the experiment details...\\\")\\n log = dict(\\n NET_TYPE = \\\"Conv auto encoder 2 hidden 1 code\\\",\\n TETRODE_NUMBER = tetrode_number,\\n BASENAME = BASENAME,\\n NUM_EPOCHS = epochsDone,\\n BATCH_SIZE = BATCH_SIZE,\\n TRAIN_VALIDATION = trainvalidation,\\n LEARNING_RATE = LEARNING_RATE,\\n MOMENTUM = MOMENTUM,\\n SAME_LABEL_AVERAGES = autoencoderSameLabels,\\n ACCURACY = accuracies,\\n NETWORK_LAYERS = [str(type(layer)) for layer in lasagne.layers.get_all_layers(network)],\\n OUTPUT_DIM = dataset['output_dim'],\\n # NETWORK_PARAMS = lasagne.layers.get_all_params_values(network)\\n )\\n now = datetime.datetime.now()\\n filename = \\\"experiments/convAuto/{}_{}_{}_NUMLAYERS_{}_OUTPUTDIM_{}\\\".format(now,NUM_EPOCHS,NUM_HIDDEN_UNITS,len(log['NETWORK_LAYERS']),log['OUTPUT_DIM'])\\n filename = re.sub(\\\"[^A-Za-z0-9_/,-:]\\\", \\\"\\\", filename)\\n with open(filename,\\\"w\\\") as outfile:\\n outfile.write(str(log))\",\n \"def train():\\n # YOUR TRAINING CODE GOES HERE\",\n \"def run(self):\\n\\n # initializing random network activity\\n s_rand_T = np.zeros((self.T, self.N_rand))\\n p_rand_T = np.zeros((self.T, self.N_rand))\\n r_rand_T = np.zeros((self.T, self.N_rand))\\n\\n s_rand_T[0, :] = np.random.uniform(low=0, high=0.01, size=(self.N_rand))\\n\\n # initializing sensory networks\\n s_sens_T = np.zeros((self.T, self.N_sensory_nets * self.N_sensory))\\n p_sens_T = np.zeros((self.T, self.N_sensory_nets * self.N_sensory))\\n r_sens_T = np.zeros((self.T, self.N_sensory_nets * self.N_sensory))\\n s_sens_T[0, :] = np.random.uniform(low=0, high=0.01, size=(self.N_sensory_nets * self.N_sensory))\\n\\n # extend input to be T timesteps and only nonzero for 100 ts\\n s_ext_T = np.broadcast_to(self.s_ext, (self.T, self.N_sensory * self.N_sensory_nets)).copy()\\n # stimulus is presented for 100 ms\\n stim_T = int(200/self.rand_net.dt)\\n s_ext_T[:100] = 0\\n s_ext_T[100+stim_T:] = 0\\n # s_ext_T *= 0\\n\\n for t in range(1, self.T):\\n if (t + 1) % 100 == 0:\\n print(f'step {t} of {self.T}')\\n s_sens_prev = s_sens_T[t - 1]\\n s_rand_prev = s_rand_T[t - 1]\\n p_rand_prev = p_rand_T[t - 1]\\n s_ext = s_ext_T[t - 1]\\n step = self.forward(s_ext=s_ext, s_rand_prev=s_rand_prev, s_sens_prev=s_sens_prev, p_rand_prev=p_rand_prev)\\n s_sens_T[t] = step['s_sens']\\n p_sens_T[t] = step['p_sens']\\n r_sens_T[t] = step['r_sens']\\n s_rand_T[t] = step['s_rand']\\n r_rand_T[t] = step['r_rand']\\n p_rand_T[t] = step['p_rand']\\n\\n p_sens_T = p_sens_T.reshape(self.T, self.N_sensory_nets, self.N_sensory)\\n s_ext_T = s_ext_T.reshape(self.T, self.N_sensory_nets, self.N_sensory)\\n r_sens_T = r_sens_T.reshape(self.T, self.N_sensory_nets, self.N_sensory)\\n s_sens_T = s_sens_T.reshape(self.T, self.N_sensory_nets, self.N_sensory)\\n\\n return dict(\\n n_sensory=self.N_sensory,\\n n_rand=self.N_rand,\\n mus=self.mus,\\n sigma=self.sigma,\\n s_ext=s_ext_T,\\n s_sens=s_sens_T,\\n r_sens=r_sens_T,\\n p_sens=p_sens_T,\\n s_rand=s_rand_T,\\n r_rand=r_rand_T,\\n p_rand=p_rand_T\\n )\",\n \"def inference():\\n inf_dataset = dataset\\n net.eval()\\n frames_gen, frame_cnt, rel_props, prop_ticks, prop_scaling = inf_dataset[index]\\n \\n num_crop = args.test_crops\\n length = 3\\n if args.modality == 'Flow':\\n length = 10\\n elif args.modality == 'RGBDiff':\\n length = 18\\n \\n # First get the base_out outputs\\n base_output = torch.autograd.Variable(torch.zeros((num_crop, frame_cnt, base_out_dim)).cuda(),\\n volatile=True)\\n cnt = 0\\n for frames in frames_gen:\\n # frames.shape == [frame_batch_size * num_crops * 3, 224, 224]\\n # frame_batch_size is 4 by default\\n input_var = torch.autograd.Variable(frames.view(-1, length, frames.size(-2), frames.size(-1)).cuda(),\\n volatile=True)\\n base_out = net(input_var, None, None, None, None)\\n bsc = base_out.view(num_crop, -1, base_out_dim)\\n base_output[:, cnt:cnt+bsc.size(1), :] = bsc\\n cnt += bsc.size(1)\\n\\n n_frames = base_output.size(1)\\n assert frame_cnt == n_frames\\n # GLCU\\n step_features = base_output.mean(dim=0).mean(dim=0).unsqueeze(0)\\n gate, glcu_task_pred = net.glcu(step_features)\\n glcu_task_pred = F.softmax(glcu_task_pred.squeeze(), dim=0).data.cpu().numpy()\\n gate = gate.repeat(1, num_crop * n_frames).view(num_crop, n_frames, base_out_dim)\\n if net.additive_glcu:\\n base_output = base_output + gate\\n else:\\n base_output = base_output * gate\\n\\n # output.shape == [num_frames, 7791]\\n output = torch.zeros((frame_cnt, output_dim)).cuda()\\n cnt = 0\\n for i in range(0, frame_cnt, 4):\\n base_out = base_output[:, i:i+4, :].contiguous().view(-1, base_out_dim)\\n rst = net.test_fc(base_out)\\n sc = rst.data.view(num_crop, -1, output_dim).mean(dim=0)\\n output[cnt: cnt + sc.size(0), :] = sc\\n cnt += sc.size(0)\\n base_output = base_output.mean(dim=0).data\\n\\n # act_scores.shape == [num_proposals, K+1]\\n # comp_scores.shape == [num_proposals, K]\\n act_scores, comp_scores, reg_scores = reorg_stpp.forward(output, prop_ticks, prop_scaling)\\n act_scores = torch.autograd.Variable(act_scores, volatile=True)\\n comp_scores = torch.autograd.Variable(comp_scores, volatile=True)\\n\\n # Task Head\\n combined_scores = F.softmax(act_scores[:, 1:], dim=1) * torch.exp(comp_scores)\\n combined_scores = combined_scores.mean(dim=0).unsqueeze(0)\\n task_pred = F.softmax(net.task_head(combined_scores).squeeze(), dim=0).data.cpu().numpy()\\n\\n act_scores = act_scores.data\\n comp_scores = comp_scores.data\\n\\n if reg_scores is not None:\\n reg_scores = reg_scores.view(-1, num_class, 2)\\n reg_scores[:, :, 0] = reg_scores[:, :, 0] * stats[1, 0] + stats[0, 0]\\n reg_scores[:, :, 1] = reg_scores[:, :, 1] * stats[1, 1] + stats[0, 1]\\n\\n torch.cuda.empty_cache() # To empty the cache from previous iterations\\n\\n # perform stpp on scores\\n return ((inf_dataset.video_list[index].id,\\n (rel_props.numpy(), act_scores.cpu().numpy(), comp_scores.cpu().numpy(), reg_scores.cpu().numpy(), \\n glcu_task_pred, task_pred),\\n output.cpu().numpy(),\\n base_output.cpu().numpy()))\",\n \"def run_preliminary(args, device):\\n subs_train = [1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 15000, 20000, 30000, 40000, 50000, 60000]\\n subs_test = [1000, 1500, 2000, 3000, 4000, 5000, 7000, 8000, 9000, 10000]\\n epochs = [2, 5, 10, 15, 17, 20, 22, 25, 27, 30]\\n\\n train_loader, test_loader = nnvis.data_load()\\n\\n model = prep.get_net(device, train_loader, test_loader, args.epochs)\\n model.load_state_dict(torch.load(nnvis.init_state))\\n\\n nnvis.pre_train_subset(model, device, subs_train, args.epochs, test_loader)\\n nnvis.pre_test_subset(model, device, subs_test)\\n nnvis.pre_epochs(model, device, epochs)\\n\\n nnvis.plot_impact(subs_train, nnvis.train_subs_loss, nnvis.train_subs_acc, xlabel=\\\"Size of training dataset\\\")\\n nnvis.plot_impact(epochs, nnvis.epochs_loss, nnvis.epochs_acc, annotate=False, xlabel=\\\"Number of epochs\\\")\\n nnvis.plot_box(subs_test, show=False, xlabel=\\\"Size of test subset\\\")\",\n \"def main():\\n \\\"\\\"\\\"\\n This is just for testing the functions\\n \\\"\\\"\\\"\\n\\n x1 = np.array([1, 1, 1, 1, -1, -1, 1, 1, 1])\\n x2 = np.array([1, -1, 1, 1, 1, 1, 1, -1, 1])\\n x3 = np.array([-1, 1, -1, -1, 1, -1, -1, 1, -1])\\n train_set = np.vstack((x1, x2))\\n train_set = np.vstack((train_set, x3))\\n\\n\\n params = {\\n \\\"epochs\\\": 100,\\n \\\"neurons\\\": len(x1),\\n \\\"learn_method\\\": 'classic'\\n }\\n\\n hop = hop_net.HopfieldNet(train_set, **params)\\n hop.batch_train()\\n show_trained(train_set)\\n\\n x4d = [1,1,1,1,1,1,1,1,1]\\n x5d = [1,1,1,1,-1,-1,1,-1,-1]\\n x45d = np.vstack((x4d, x5d))\\n test_set = np.vstack((x45d, train_set))\\n recalled_set = hop.recall(test_set)\\n for i in range(test_set.shape[0]):\\n show_tested(test_set[i], recalled_set[i])\",\n \"def ternausnetv1(input_shape=(512, 512, 3), base_depth=64):\\n inputs = Input(input_shape)\\n conv1 = Conv2D(base_depth, 3, activation='relu', padding='same')(inputs)\\n pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)\\n\\n conv2_1 = Conv2D(base_depth*2, 3, activation='relu',\\n padding='same')(pool1)\\n pool2 = MaxPooling2D(pool_size=(2, 2))(conv2_1)\\n\\n conv3_1 = Conv2D(base_depth*4, 3, activation='relu',\\n padding='same')(pool2)\\n conv3_2 = Conv2D(base_depth*4, 3, activation='relu',\\n padding='same')(conv3_1)\\n pool3 = MaxPooling2D(pool_size=(2, 2))(conv3_2)\\n\\n conv4_1 = Conv2D(base_depth*8, 3, activation='relu',\\n padding='same')(pool3)\\n conv4_2 = Conv2D(base_depth*8, 3, activation='relu',\\n padding='same')(conv4_1)\\n pool4 = MaxPooling2D(pool_size=(2, 2))(conv4_2)\\n\\n conv5_1 = Conv2D(base_depth*8, 3, activation='relu',\\n padding='same')(pool4)\\n conv5_2 = Conv2D(base_depth*8, 3, activation='relu',\\n padding='same')(conv5_1)\\n pool5 = MaxPooling2D(pool_size=(2, 2))(conv5_2)\\n\\n conv6_1 = Conv2D(base_depth*8, 3, activation='relu',\\n padding='same')(pool5)\\n\\n up7 = Conv2DTranspose(base_depth*4, 2, strides=(2, 2), activation='relu',\\n padding='same')(conv6_1)\\n concat7 = concatenate([up7, conv5_2])\\n conv7_1 = Conv2D(base_depth*8, 3, activation='relu',\\n padding='same')(concat7)\\n\\n up8 = Conv2DTranspose(base_depth*4, 2, strides=(2, 2), activation='relu',\\n padding='same')(conv7_1)\\n concat8 = concatenate([up8, conv4_2])\\n conv8_1 = Conv2D(base_depth*8, 3, activation='relu',\\n padding='same')(concat8)\\n\\n up9 = Conv2DTranspose(base_depth*2, 2, strides=(2, 2), activation='relu',\\n padding='same')(conv8_1)\\n concat9 = concatenate([up9, conv3_2])\\n conv9_1 = Conv2D(base_depth*4, 3, activation='relu',\\n padding='same')(concat9)\\n\\n up10 = Conv2DTranspose(base_depth, 2, strides=(2, 2), activation='relu',\\n padding='same')(conv9_1)\\n concat10 = concatenate([up10, conv2_1])\\n conv10_1 = Conv2D(base_depth*2, 3, activation='relu',\\n padding='same')(concat10)\\n\\n up11 = Conv2DTranspose(int(base_depth/2), 2, strides=(2, 2),\\n activation='relu', padding='same')(conv10_1)\\n concat11 = concatenate([up11, conv1])\\n\\n out = Conv2D(1, 1, activation='sigmoid', padding='same')(concat11)\\n\\n return Model(input=inputs, output=out)\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def plot_orig(self, conf, nn_in_trn, nn_out_trn, y_pred, a, vert_coef):\\n plot_win=tk.Toplevel()\\n plot_win.title(\\\"Predict data plot\\\")\\n fig = Figure(figsize=(5, 4), dpi=80)\\n ax=fig.add_subplot(111)\\n ax.plot(nn_in_trn[:, 0], nn_out_trn[:, 0], label=\\\"Train data\\\")\\n ax.plot(nn_in_trn[:, 0], y_pred[:, 0], label=\\\"Prediction data\\\")\\n ax.set_xlabel('IN[1]')\\n ax.set_ylabel('OUT[1]')\\n fig.legend()\\n canvas = FigureCanvasTkAgg(fig, master=plot_win)\\n canvas.draw()\\n canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)\\n\\n toolbar = NavigationToolbar2Tk(canvas, plot_win)\\n toolbar.update()\\n canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)\\n lab1=tk.Label(plot_win,width=35, text=\\\"Model configuration\\\"+str(conf))\\n lab1.pack()\\n lab2=tk.Label(plot_win,width=35, text=\\\"Loss= \\\" + str(round(a,4))+ \\\" %\\\")\\n lab2.pack()\\n plot_win.geometry(f'+{self.winfo_x()+self.winfo_width()+20}+{self.winfo_y() + vert_coef}')\",\n \"def lm_NN(nn_in, \\n nn_out, \\n er_tar,\\n main_win: tk.Toplevel, \\n min_n=0, \\n max_n=0, \\n n_epochs=50, \\n conf=[1,1,1], \\n sect_ner=False, \\n train_test=False, \\n retrain=False, \\n spl_coef=0.1,\\n root_width=200, \\n root_height=200, \\n root_x=50, \\n root_y=50):\\n if train_test or retrain:\\n x=tr.from_numpy(nn_in).float()\\n y=tr.from_numpy((nn_out)).float()\\n dataset = tr.utils.data.TensorDataset(x, y)\\n a=int(len(dataset)*(1-spl_coef))\\n data_trn,data_test=tr.utils.data.random_split(dataset, [a,int(len(dataset)-a)],generator=tr.Generator().manual_seed(42))\\n dataloader = tr.utils.data.DataLoader(data_trn, shuffle=False, batch_size=len(data_trn))\\n nn_in=(next(iter(dataloader))[0].numpy()).T\\n nn_out=(next(iter(dataloader))[1].numpy()).T\\n nn_in_test=data_test[:][0].numpy().T\\n nn_out_test=data_test[:][1].numpy().T\\n else:\\n nn_in_test = 0\\n nn_out_test = 0\\n nn_in=nn_in.T\\n nn_out=nn_out.T\\n\\n if sect_ner:\\n if min_n>max_n:\\n print(\\\"Error: minimum neurons>maximum neurons\\\")\\n for i in range(len(conf)-2):\\n conf[i+1] = min_n\\n for i in range(1, len(conf)-1):\\n min_loss=20000\\n b=conf[i]\\n for j in range(min_n, max_n+1):\\n conf[i] = j\\n nn_obj = prn.CreateNN(conf)\\n nn_obj = prn.train_LM(nn_in,nn_out,nn_obj,verbose=False,k_max=1,E_stop=1e-10)\\n y_pred = prn.NNOut(nn_in, nn_obj)\\n a=loss(y_pred, nn_out, nn_obj)\\n print(\\\"Current configuration:\\\", conf, \\\";\\\\t Loss:\\\", a, \\\"%\\\")\\n if a<min_loss:\\n min_loss=a\\n b=j\\n conf[i]=b\\n neurons_number_info(conf, root_height + root_y, root_x)\\n print(\\\"Best configuration:\\\", conf)\\n \\n nn_obj = prn.CreateNN(conf)\\n loss_val=[]\\n loss_test=[]\\n epochs_sum = 0\\n train = True\\n lin_tr = None\\n can_tr = None\\n lin_test = None \\n can_test = None\\n vert_coef = None\\n hor_coef = None\\n while train == True:\\n nn_obj, vert_coef, hor_coef, epochs_sum, err, lin_tr, can_tr, lin_test, can_test = train_body_LM(nn_obj, nn_in, nn_in_test, nn_out, nn_out_test, n_epochs, epochs_sum, loss_val, loss_test, er_tar, train_test, retrain, root_width, root_height, root_x, root_y, lin_tr, can_tr, lin_test, can_test, vert_coef, hor_coef)\\n train_win = Continue_Train(err, epochs_sum)\\n main_win.wait_window(train_win)\\n train = train_win.answer\\n if not train_win.answer:\\n return nn_obj, conf, vert_coef, hor_coef\\n #train = False\\n return nn_obj, conf, vert_coef, hor_coef\",\n \"def unet_network(input_tensor, nb_classes):\\n # contraction 1\\n conv1 = Conv2D(\\n filters=64,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv1')(\\n input_tensor) # (batch_size, ?, ?, 64)\\n conv2 = Conv2D(\\n filters=64,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv2')(\\n conv1) # (batch_size, ?, ?, 64)\\n crop2 = Cropping2D(\\n cropping=((88, 88), (88, 88)),\\n name=\\\"crop2\\\")(\\n conv2) # (batch_size, ?, ?, 64)\\n maxpool2 = MaxPooling2D(\\n pool_size=(3, 3),\\n strides=(2, 2),\\n name=\\\"maxpool2\\\")(\\n conv2) # (batch_size, ?, ?, 64)\\n\\n # contraction 2\\n conv3 = Conv2D(\\n filters=128,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv3')(\\n maxpool2) # (batch_size, ?, ?, 128)\\n conv4 = Conv2D(\\n filters=128,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv4')(\\n conv3) # (batch_size, ?, ?, 128)\\n crop4 = Cropping2D(\\n cropping=((40, 40), (40, 40)),\\n name=\\\"crop4\\\")(\\n conv4) # (batch_size, ?, ?, 128)\\n maxpool4 = MaxPooling2D(\\n pool_size=(3, 3),\\n strides=(2, 2),\\n name=\\\"maxpool4\\\")(\\n conv4) # ((batch_size, ?, ?, 128)\\n\\n # contraction 3\\n conv5 = Conv2D(\\n filters=256,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv5')(\\n maxpool4) # (batch_size, ?, ?, 256)\\n conv6 = Conv2D(\\n filters=256,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv6')(\\n conv5) # (batch_size, ?, ?, 256)\\n crop6 = Cropping2D(\\n cropping=((16, 16), (16, 16)),\\n name=\\\"crop6\\\")(\\n conv6) # (batch_size, ?, ?, 256)\\n maxpool6 = MaxPooling2D(\\n pool_size=(3, 3),\\n strides=(2, 2),\\n name=\\\"maxpool6\\\")(\\n conv6) # (batch_size, ?, ?, 256)\\n\\n # contraction 4\\n conv7 = Conv2D(\\n filters=512,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv7')(\\n maxpool6) # (batch_size, ?, ?, 512)\\n conv8 = Conv2D(\\n filters=512,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv8')(\\n conv7) # (batch_size, ?, ?, 512)\\n crop8 = Cropping2D(\\n cropping=((4, 4), (4, 4)),\\n name=\\\"crop8\\\")(\\n conv8) # (batch_size, ?, ?, 512)\\n maxpool8 = MaxPooling2D(\\n pool_size=(3, 3),\\n strides=(2, 2),\\n name=\\\"maxpool8\\\")(\\n conv8) # (batch_size, ?, ?, 512)\\n\\n # bottom\\n conv9 = Conv2D(\\n filters=1024,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv9')(\\n maxpool8) # (batch_size, ?, ?, 1024)\\n conv10 = Conv2D(\\n filters=1024,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv10')(\\n conv9) # (batch_size, ?, ?, 1024)\\n\\n # expansion 1\\n upconv11 = up_conv_2d(\\n input_tensor=conv10,\\n nb_filters=512,\\n name='upconv11') # (batch_size, ?, ?, 512)\\n concat11 = tf.concat(\\n values=[crop8, upconv11],\\n axis=-1,\\n name='concat11') # (batch_size, ?, ?, 1024)\\n conv12 = Conv2D(\\n filters=512,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv12')(\\n concat11) # (batch_size, ?, ?, 512)\\n conv13 = Conv2D(\\n filters=512,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv13')(\\n conv12) # (batch_size, ?, ?, 512)\\n\\n # expansion 2\\n upconv14 = up_conv_2d(\\n input_tensor=conv13,\\n nb_filters=256,\\n name='upconv14') # (batch_size, ?, ?, 256)\\n concat14 = tf.concat(\\n values=[crop6, upconv14],\\n axis=-1,\\n name='concat14') # (batch_size, ?, ?, 512)\\n conv15 = Conv2D(\\n filters=256,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv15')(\\n concat14) # (batch_size, ?, ?, 256)\\n conv16 = Conv2D(\\n filters=256,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv16')(\\n conv15) # (batch_size, ?, ?, 256)\\n\\n # expansion 3\\n upconv17 = up_conv_2d(\\n input_tensor=conv16,\\n nb_filters=128,\\n name='upconv17') # (batch_size, ?, ?, 128)\\n concat17 = tf.concat(\\n values=[crop4, upconv17],\\n axis=-1,\\n name='concat17') # (batch_size, ?, ?, 256)\\n conv18 = Conv2D(\\n filters=128,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv18')(\\n concat17) # (batch_size, ?, ?, 128)\\n conv19 = Conv2D(\\n filters=128,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv19')(\\n conv18) # (batch_size, ?, ?, 128)\\n\\n # expansion 4\\n upconv20 = up_conv_2d(\\n input_tensor=conv19,\\n nb_filters=64,\\n name='upconv20') # (batch_size, ?, ?, 64)\\n concat20 = tf.concat(\\n values=[crop2, upconv20],\\n axis=-1,\\n name='concat20') # (batch_size, ?, ?, 128)\\n conv21 = Conv2D(\\n filters=64,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv21')(\\n concat20) # (batch_size, ?, ?, 64)\\n conv22 = Conv2D(\\n filters=64,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv22')(\\n conv21) # (batch_size, ?, ?, 64)\\n conv23 = Conv2D(\\n filters=nb_classes,\\n kernel_size=(1, 1),\\n activation='sigmoid',\\n name='conv23')(\\n conv22) # (batch_size, ?, ?, nb_classes)\\n\\n return conv23\",\n \"def train(self):\\r\\n raw_dataset = pd.read_csv(self.datafile, sep = ',', header = 0,\\r\\n na_values = '?', comment = '\\\\t',\\r\\n skipinitialspace = True)\\r\\n\\r\\n dataset = raw_dataset.copy()\\r\\n dataset.tail()\\r\\n\\r\\n # Clear unknown values\\r\\n dataset.isna().sum()\\r\\n dataset = dataset.dropna()\\r\\n\\r\\n # takes a sample of 80% of the data points\\r\\n train_dataset = dataset.sample(frac = 0.8, random_state = 0)\\r\\n test_dataset = dataset.drop(train_dataset.index)\\r\\n\\r\\n # Split features from labels for training and test datasets\\r\\n train_features = train_dataset.copy()\\r\\n test_features = test_dataset.copy()\\r\\n train_labels = train_features.pop('Quality')\\r\\n test_labels = test_features.pop('Quality')\\r\\n\\r\\n # normalize data\\r\\n normalizer = preprocessing.Normalization()\\r\\n normalizer.adapt(np.array(train_features))\\r\\n\\r\\n # builds the model\\r\\n def build_and_compile_model(norm):\\r\\n model = keras.Sequential([\\r\\n norm,\\r\\n layers.Dense(64, activation='relu'),\\r\\n layers.Dense(64, activation='relu'),\\r\\n layers.Dense(1)\\r\\n ])\\r\\n\\r\\n model.compile(loss='mean_absolute_error',\\r\\n optimizer=tf.keras.optimizers.Adam(0.001))\\r\\n return model\\r\\n\\r\\n deep_neural_network_model = build_and_compile_model(normalizer)\\r\\n\\r\\n history = deep_neural_network_model.fit(\\r\\n train_features, train_labels,\\r\\n validation_split=0.2,\\r\\n verbose=0, epochs=100)\\r\\n\\r\\n deep_neural_network_model.save('deep_neural_network_model')\",\n \"def run_net(self,\\n pre_trained_chckpnt_dir ='' #for resuming training, load the model from this directory\\n ):\\n\\n _rd = _read_data(data=self.data)\\n\\n self.alpha_coeff=1\\n\\n #read path of the images for train, test, and validation\\n train_CTs, train_GTVs, train_Torso, train_penalize, train_surface,\\\\\\n validation_CTs, validation_GTVs, validation_Torso, validation_penalize, validation_surface,\\\\\\n test_CTs, test_GTVs, test_Torso, test_penalize,test_surface=_rd.read_data_path(fold=self.fold)\\n self.img_width = self.img_width\\n self.img_height = self.img_height\\n # ======================================\\n #validation instances\\n bunch_of_images_no=20\\n _image_class_vl = image_class(validation_CTs, validation_GTVs, validation_Torso,validation_penalize,validation_surface\\n , bunch_of_images_no=bunch_of_images_no, is_training=0,\\n patch_window=self.patch_window)\\n _patch_extractor_thread_vl = _patch_extractor_thread(_image_class=_image_class_vl,\\n sample_no=self.sample_no, patch_window=self.patch_window,\\n GTV_patchs_size=self.GTV_patchs_size,\\n tumor_percent=self.tumor_percent,\\n img_no=bunch_of_images_no,\\n mutex=settings.mutex,is_training=0,vl_sample_no=self.validation_samples\\n )\\n _fill_thread_vl = fill_thread(validation_CTs,\\n validation_GTVs,\\n validation_Torso,\\n validation_penalize,\\n validation_surface,\\n _image_class_vl,\\n sample_no=self.sample_no,\\n total_sample_no=self.validation_samples,\\n patch_window=self.patch_window,\\n GTV_patchs_size=self.GTV_patchs_size,\\n img_width=self.img_width, img_height=self.img_height,\\n mutex=settings.mutex,\\n tumor_percent=self.tumor_percent,\\n is_training=0,\\n patch_extractor=_patch_extractor_thread_vl,\\n fold=self.fold)\\n\\n\\n _fill_thread_vl.start()\\n _patch_extractor_thread_vl.start()\\n _read_thread_vl = read_thread(_fill_thread_vl, mutex=settings.mutex,\\n validation_sample_no=self.validation_samples, is_training=0)\\n _read_thread_vl.start()\\n # ======================================\\n #training instances\\n bunch_of_images_no = 24\\n _image_class = image_class(train_CTs, train_GTVs, train_Torso,train_penalize,train_surface\\n , bunch_of_images_no=bunch_of_images_no,is_training=1,patch_window=self.patch_window\\n )\\n patch_extractor_thread = _patch_extractor_thread(_image_class=_image_class,\\n sample_no=240, patch_window=self.patch_window,\\n GTV_patchs_size=self.GTV_patchs_size,\\n tumor_percent=self.tumor_percent,\\n img_no=bunch_of_images_no,\\n mutex=settings.mutex,is_training=1)\\n _fill_thread = fill_thread(train_CTs, train_GTVs, train_Torso,train_penalize,train_surface,\\n _image_class,\\n sample_no=self.sample_no,total_sample_no=self.sample_no,\\n patch_window=self.patch_window,\\n GTV_patchs_size=self.GTV_patchs_size,\\n img_width=self.img_width,\\n img_height=self.img_height,mutex=settings.mutex,\\n tumor_percent=self.tumor_percent,\\n is_training=1,\\n patch_extractor=patch_extractor_thread,\\n fold=self.fold)\\n\\n _fill_thread.start()\\n patch_extractor_thread.start()\\n\\n _read_thread = read_thread(_fill_thread,mutex=settings.mutex,is_training=1)\\n _read_thread.start()\\n # ======================================\\n\\n image = tf.placeholder(tf.float32, shape=[None, None, None, None, 1])\\n label = tf.placeholder(tf.float32, shape=[None, None, None, None, 2])\\n penalize = tf.placeholder(tf.float32, shape=[None, None, None, None,1])\\n surf_map = tf.placeholder(tf.float32, shape=[None, None, None, None,1])\\n loss_coef = tf.placeholder(tf.float32, shape=[None, 2]) # shape: batchno * 2 values for each class\\n alpha = tf.placeholder(tf.float32, name='alpha') # background coeff\\n beta = tf.placeholder(tf.float32, name='beta') # tumor coeff\\n\\n ave_vali_acc=tf.placeholder(tf.float32)\\n ave_loss_vali=tf.placeholder(tf.float32)\\n ave_dsc_vali=tf.placeholder(tf.float32)\\n\\n dropout=tf.placeholder(tf.float32,name='dropout')\\n is_training = tf.placeholder(tf.bool, name='is_training')\\n is_training_bn = tf.placeholder(tf.bool, name='is_training_bn')\\n dense_net_dim = tf.placeholder(tf.int32, name='dense_net_dim')\\n\\n _dn = _densenet_unet(self.densnet_unet_config,self.compression_coefficient,self.growth_rate) #create object\\n y=_dn.dens_net(image=image,is_training=is_training,dropout_rate1=0,dropout_rate2=0,dim=dense_net_dim,is_training_bn=is_training_bn)\\n # y = _dn.vgg(image)\\n\\n y_dirX = ((y[:, int(self.GTV_patchs_size / 2), :, :, 0, np.newaxis]))\\n label_dirX = (label[:, int(self.GTV_patchs_size / 2), :, :, 0, np.newaxis])\\n penalize_dirX = (penalize[:,16,:,:,0,np.newaxis])\\n surf_map_dirX = (surf_map[:,16,:,:,0,np.newaxis])\\n image_dirX = ((image[:, int(self.patch_window / 2), :, :, 0, np.newaxis]))\\n\\n show_img=tf.nn.softmax(y)[:, int(self.GTV_patchs_size / 2) , :, :, 0, np.newaxis]\\n tf.summary.image('outprunut',show_img , 3)\\n tf.summary.image('output without softmax',y_dirX ,3)\\n tf.summary.image('groundtruth', label_dirX,3)\\n tf.summary.image('penalize', penalize_dirX,3)\\n tf.summary.image('surf_map', surf_map_dirX,3)\\n tf.summary.image('image',image_dirX ,3)\\n\\n print('*****************************************')\\n print('*****************************************')\\n print('*****************************************')\\n sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))\\n devices = sess.list_devices()\\n print(devices)\\n\\n print(device_lib.list_local_devices())\\n print('*****************************************')\\n print('*****************************************')\\n print('*****************************************')\\n\\n train_writer = tf.summary.FileWriter(self.LOGDIR + '/train' ,graph=tf.get_default_graph())\\n validation_writer = tf.summary.FileWriter(self.LOGDIR + '/validation' , graph=sess.graph)\\n\\n extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\\n saver=tf.train.Saver(tf.global_variables(), max_to_keep=1000)\\n\\n\\n\\n #define the loss function\\n with tf.name_scope('cost'):\\n penalize_weight=0\\n [ penalized_loss,\\n soft_dice_coef,logt,lbl]=self.loss_instance.dice_plus_distance_penalize(logits=y, labels=label,penalize=penalize)\\n surface_loss= self.loss_instance.surface_loss(logits=y, labels=label, surf_map=surf_map)\\n cost = tf.reduce_mean((1.0 - soft_dice_coef[1])+penalize_weight*penalized_loss+surface_loss, name=\\\"cost\\\")\\n\\n #Setup the Tensorboard plots\\n tf.summary.scalar(\\\"cost\\\", cost)\\n f1_measure = self.loss_instance.f1_measure(logits=y, labels=label)\\n tf.summary.scalar(\\\"dice_bakground\\\", f1_measure[0])\\n tf.summary.scalar(\\\"dice_tumor\\\", f1_measure[1])\\n\\n pwc = self.loss_instance.PWC(y, label)\\n tf.summary.scalar(\\\"pwc_bakground\\\", pwc[0])\\n tf.summary.scalar(\\\"pwc_tumor\\\", pwc[1])\\n\\n recall = self.loss_instance.Recall(y, label)\\n tf.summary.scalar(\\\"recall_bakground\\\", recall[0])\\n tf.summary.scalar(\\\"recall_tumor\\\", recall[1])\\n\\n precision = self.loss_instance.Precision(y, label)\\n tf.summary.scalar(\\\"precision_bakground\\\", precision[0])\\n tf.summary.scalar(\\\"precision_tumor\\\", precision[1])\\n\\n fpr = self.loss_instance.FPR(y, label)\\n tf.summary.scalar(\\\"FPR_bakground\\\", fpr[0])\\n tf.summary.scalar(\\\"FPR_tumor\\\", fpr[1])\\n\\n fnr = self.loss_instance.FNR(y, label)\\n tf.summary.scalar(\\\"FNR_bakground\\\", fnr[0])\\n tf.summary.scalar(\\\"FNR_tumor\\\", fnr[1])\\n\\n extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\\n with tf.control_dependencies(extra_update_ops):\\n optimizer_tmp = tf.train.AdamOptimizer(self.learning_rate,epsilon=0.001)\\n optimizer = optimizer_tmp.minimize(cost)\\n\\n with tf.name_scope('validation'):\\n average_validation_accuracy=ave_vali_acc\\n average_validation_loss=ave_loss_vali\\n average_dsc_loss=ave_dsc_vali\\n tf.summary.scalar(\\\"average_validation_accuracy\\\",average_validation_accuracy)\\n tf.summary.scalar(\\\"average_validation_loss\\\",average_validation_loss)\\n tf.summary.scalar(\\\"average_dsc_loss\\\",average_dsc_loss)\\n\\n with tf.name_scope('accuracy'):\\n accuracy=self.loss_instance.accuracy_fn(y, label)\\n\\n tf.summary.scalar(\\\"accuracy\\\", accuracy)\\n\\n sess.run(tf.global_variables_initializer())\\n logging.debug('total number of variables %s' % (\\n np.sum([np.prod(v.get_shape().as_list()) for v in tf.trainable_variables()])))\\n summ=tf.summary.merge_all()\\n\\n point = 0 # starting point, starts from a value > 0 if training is resumed\\n itr1 = 0 # number of iterations\\n if len(pre_trained_chckpnt_dir):\\n ckpt = tf.train.get_checkpoint_state(pre_trained_chckpnt_dir)\\n saver.restore(sess, ckpt.model_checkpoint_path)\\n point=int(ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])\\n itr1=point\\n\\n\\n # patch_radius = 49\\n '''loop for epochs'''\\n\\n for epoch in range(self.total_epochs):\\n while self.no_sample_per_each_itr*int(point/self.no_sample_per_each_itr)<self.sample_no:\\n print('0')\\n print(\\\"epoch #: %d\\\" %(epoch))\\n startTime = time.time()\\n step = 0\\n self.beta_coeff=1+1 * np.exp(-point/2000)\\n # =============start validation================\\n if itr1 % self.display_validation_step ==0:\\n '''Validation: '''\\n loss_validation = 0\\n acc_validation = 0\\n validation_step = 0\\n dsc_validation=0\\n while (validation_step * self.batch_no_validation <settings.validation_totalimg_patch):\\n [validation_CT_image, validation_GTV_image,validation_Penalize_patch,validation_Surface_patch] = _image_class_vl.return_patches_validation( validation_step * self.batch_no_validation, (validation_step + 1) *self.batch_no_validation)\\n if (len(validation_CT_image)<self.batch_no_validation) | (len(validation_GTV_image)<self.batch_no_validation) | (len(validation_Penalize_patch)<self.batch_no_validation) | (len(validation_Surface_patch)<self.batch_no_validation) :\\n _read_thread_vl.resume()\\n time.sleep(0.5)\\n continue\\n\\n validation_CT_image_patchs = validation_CT_image\\n validation_GTV_label = validation_GTV_image\\n tic=time.time()\\n\\n [acc_vali, loss_vali,dsc_vali,surface_loss1] = sess.run([accuracy, cost,f1_measure,surface_loss],\\n feed_dict={image: validation_CT_image_patchs,\\n label: validation_GTV_label,\\n penalize: validation_Penalize_patch,\\n dropout: 1,\\n is_training: False,\\n ave_vali_acc: -1,\\n ave_loss_vali: -1,\\n ave_dsc_vali:-1,\\n dense_net_dim: self.patch_window,\\n is_training_bn:False,\\n alpha:1,\\n beta:1,\\n surf_map:validation_Surface_patch,\\n })\\n elapsed=time.time()-tic\\n\\n acc_validation += acc_vali\\n loss_validation += loss_vali\\n dsc_validation+=dsc_vali[1]\\n validation_step += 1\\n if np.isnan(dsc_validation) or np.isnan(loss_validation) or np.isnan(acc_validation):\\n print('nan problem')\\n process = psutil.Process(os.getpid())\\n\\n print(\\n '%d - > %d: elapsed_time:%d acc_validation: %f, loss_validation: %f, memory_percent: %4s' % (\\n validation_step,validation_step * self.batch_no_validation\\n , elapsed, acc_vali, loss_vali, str(process.memory_percent()),\\n ))\\n\\n settings.queue_isready_vl = False\\n acc_validation = acc_validation / (validation_step)\\n loss_validation = loss_validation / (validation_step)\\n dsc_validation = dsc_validation / (validation_step)\\n if np.isnan(dsc_validation) or np.isnan(loss_validation) or np.isnan(acc_validation):\\n print('nan problem')\\n _fill_thread_vl.kill_thread()\\n print('******Validation, step: %d , accuracy: %.4f, loss: %f*******' % (\\n itr1, acc_validation, loss_validation))\\n\\n [sum_validation] = sess.run([summ],\\n feed_dict={image: validation_CT_image_patchs,\\n label: validation_GTV_label,\\n penalize: validation_Penalize_patch,\\n dropout: 1,\\n is_training: False,\\n ave_vali_acc: acc_validation,\\n ave_loss_vali: loss_validation,\\n ave_dsc_vali:dsc_validation,\\n dense_net_dim: self.patch_window,\\n is_training_bn: False,\\n alpha: 1,\\n beta: 1,\\n surf_map: validation_Surface_patch,\\n\\n })\\n validation_writer.add_summary(sum_validation, point)\\n print('end of validation---------%d' % (point))\\n\\n #loop for training batches\\n while(step*self.batch_no<self.no_sample_per_each_itr):\\n [train_CT_image_patchs, train_GTV_label, train_Penalize_patch,loss_coef_weights,train_Surface_patch] = _image_class.return_patches( self.batch_no)\\n\\n if (len(train_CT_image_patchs)<self.batch_no)|(len(train_GTV_label)<self.batch_no)\\\\\\n |(len(train_Penalize_patch)<self.batch_no)|(len(train_Surface_patch)<self.batch_no):\\n time.sleep(0.5)\\n _read_thread.resume()\\n continue\\n\\n tic=time.time()\\n [acc_train1, loss_train1, optimizing,out,dsc_train11] = sess.run([accuracy, cost, optimizer,y,f1_measure],\\n feed_dict={image: train_CT_image_patchs,\\n label: train_GTV_label,\\n penalize: train_Penalize_patch,\\n # loss_coef: loss_coef_weights,\\n dropout: self.dropout_keep,\\n is_training: True,\\n ave_vali_acc: -1,\\n ave_loss_vali: -1,\\n ave_dsc_vali: -1,\\n dense_net_dim: self.patch_window,\\n is_training_bn: True,\\n alpha: self.alpha_coeff,\\n beta: self.beta_coeff,\\n surf_map: train_Surface_patch,\\n\\n })\\n elapsed=time.time()-tic\\n dsc_train1=dsc_train11[1]\\n\\n self.x_hist=self.x_hist+1\\n # np.hstack((self.x_hist, [np.ceil(\\n\\n [sum_train] = sess.run([summ],\\n feed_dict={image: train_CT_image_patchs,\\n label: train_GTV_label,\\n penalize: train_Penalize_patch,\\n dropout: self.dropout_keep, is_training: True,\\n ave_vali_acc: acc_train1,\\n ave_loss_vali: loss_train1,\\n ave_dsc_vali: dsc_train1,\\n dense_net_dim: self.patch_window,\\n is_training_bn: True,\\n alpha: self.alpha_coeff,\\n beta: self.beta_coeff,\\n surf_map: train_Surface_patch,\\n\\n })\\n train_writer.add_summary(sum_train,point)\\n step = step + 1\\n\\n process = psutil.Process(os.getpid())\\n\\n print(\\n 'point: %d, elapsed_time:%d step*self.batch_no:%f , LR: %.15f, acc_train1:%f, loss_train1:%f,memory_percent: %4s' % (\\n int((point)),elapsed,\\n step * self.batch_no, self.learning_rate, acc_train1, loss_train1,\\n str(process.memory_percent())))\\n\\n\\n point=int((point))\\n if point%100==0:\\n '''saveing model inter epoch'''\\n chckpnt_path = os.path.join(self.chckpnt_dir,\\n ('densenet_unet_inter_epoch%d_point%d.ckpt' % (epoch, point)))\\n saver.save(sess, chckpnt_path, global_step=point)\\n itr1 = itr1 + 1\\n point=point+1\\n endTime = time.time()\\n\\n #==============\\n '''saveing model after each epoch'''\\n chckpnt_path = os.path.join(self.chckpnt_dir, 'densenet_unet.ckpt')\\n saver.save(sess, chckpnt_path, global_step=epoch)\\n print(\\\"End of epoch----> %d, elapsed time: %d\\\" % (epoch, endTime - startTime))\",\n \"def create_img(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled, IMG_OUTPUT_FILEPATH):\\n viz = Visualizer(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled=upsampled)\\n viz.evaluate()\\n if upsampled == True:\\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '_upsampled.png'\\n else:\\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '.png'\\n viz.visualizer.show(outpath=outpath_, clear_figure=True)\",\n \"def train(**kwargs):\\n\\n # Roll out the parameters\\n batch_size = kwargs[\\\"batch_size\\\"]\\n n_batch_per_epoch = kwargs[\\\"n_batch_per_epoch\\\"]\\n nb_epoch = kwargs[\\\"nb_epoch\\\"]\\n model_name = kwargs[\\\"model_name\\\"]\\n generator = kwargs[\\\"generator\\\"]\\n image_dim_ordering = kwargs[\\\"image_dim_ordering\\\"]\\n img_dim = kwargs[\\\"img_dim\\\"]\\n patch_size = kwargs[\\\"patch_size\\\"]\\n bn_mode = kwargs[\\\"bn_mode\\\"]\\n label_smoothing = kwargs[\\\"use_label_smoothing\\\"]\\n label_flipping = kwargs[\\\"label_flipping\\\"]\\n dset = kwargs[\\\"dset\\\"]\\n use_mbd = kwargs[\\\"use_mbd\\\"]\\n\\n epoch_size = n_batch_per_epoch * batch_size\\n\\n # Setup environment (logging directory etc)\\n general_utils.setup_logging(model_name)\\n\\n # Load and rescale data\\n X_full_train, X_sketch_train, X_full_val, X_sketch_val = data_utils.load_data(dset, image_dim_ordering)\\n img_dim = X_full_train.shape[-3:]\\n\\n # Get the number of non overlapping patch and the size of input image to the discriminator\\n nb_patch, img_dim_disc = data_utils.get_nb_patch(img_dim, patch_size, image_dim_ordering)\\n\\n try:\\n\\n # Create optimizers\\n opt_dcgan = Adam(lr=1E-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08)\\n # opt_discriminator = SGD(lr=1E-3, momentum=0.9, nesterov=True)\\n opt_discriminator = Adam(lr=1E-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08)\\n\\n # Load generator model\\n generator_model = models.load(\\\"generator_unet_%s\\\" % generator,\\n img_dim,\\n nb_patch,\\n bn_mode,\\n use_mbd,\\n batch_size)\\n # Load discriminator model\\n discriminator_model = models.load(\\\"DCGAN_discriminator\\\",\\n img_dim_disc,\\n nb_patch,\\n bn_mode,\\n use_mbd,\\n batch_size)\\n\\n generator_model.compile(loss='mae', optimizer=opt_discriminator)\\n discriminator_model.trainable = False\\n\\n DCGAN_model = models.DCGAN(generator_model,\\n discriminator_model,\\n img_dim,\\n patch_size,\\n image_dim_ordering)\\n\\n loss = ['mae', 'binary_crossentropy']\\n loss_weights = [1E2, 1]\\n DCGAN_model.compile(loss=loss, loss_weights=loss_weights, optimizer=opt_dcgan)\\n\\n discriminator_model.trainable = True\\n discriminator_model.compile(loss='binary_crossentropy', optimizer=opt_discriminator)\\n\\n gen_loss = 100\\n disc_loss = 100\\n\\n # Start training\\n print(\\\"Start training\\\")\\n for e in range(nb_epoch):\\n # Initialize progbar and batch counter\\n progbar = generic_utils.Progbar(epoch_size)\\n batch_counter = 1\\n start = time.time()\\n\\n for X_full_batch, X_sketch_batch in data_utils.gen_batch(X_full_train, X_sketch_train, batch_size):\\n\\n # Create a batch to feed the discriminator model\\n X_disc, y_disc = data_utils.get_disc_batch(X_full_batch,\\n X_sketch_batch,\\n generator_model,\\n batch_counter,\\n patch_size,\\n image_dim_ordering,\\n label_smoothing=label_smoothing,\\n label_flipping=label_flipping)\\n\\n # Update the discriminator\\n disc_loss = discriminator_model.train_on_batch(X_disc, y_disc)\\n\\n # Create a batch to feed the generator model\\n X_gen_target, X_gen = next(data_utils.gen_batch(X_full_train, X_sketch_train, batch_size))\\n y_gen = np.zeros((X_gen.shape[0], 2), dtype=np.uint8)\\n y_gen[:, 1] = 1\\n\\n # Freeze the discriminator\\n discriminator_model.trainable = False\\n gen_loss = DCGAN_model.train_on_batch(X_gen, [X_gen_target, y_gen])\\n # Unfreeze the discriminator\\n discriminator_model.trainable = True\\n\\n batch_counter += 1\\n progbar.add(batch_size, values=[(\\\"D logloss\\\", disc_loss),\\n (\\\"G tot\\\", gen_loss[0]),\\n (\\\"G mae\\\", gen_loss[1]),\\n (\\\"G logloss\\\", gen_loss[2])])\\n\\n # Save images for visualization\\n if batch_counter % (n_batch_per_epoch / 2) == 0:\\n # Get new images from validation\\n data_utils.plot_generated_batch(X_full_batch, X_sketch_batch, generator_model,\\n batch_size, image_dim_ordering, \\\"training\\\")\\n X_full_batch, X_sketch_batch = next(data_utils.gen_batch(X_full_val, X_sketch_val, batch_size))\\n data_utils.plot_generated_batch(X_full_batch, X_sketch_batch, generator_model,\\n batch_size, image_dim_ordering, \\\"validation\\\")\\n\\n if batch_counter >= n_batch_per_epoch:\\n break\\n\\n print(\\\"\\\")\\n print('Epoch %s/%s, Time: %s' % (e + 1, nb_epoch, time.time() - start))\\n\\n if e % 5 == 0:\\n gen_weights_path = os.path.join('../../models/%s/gen_weights_epoch%s.h5' % (model_name, e))\\n generator_model.save_weights(gen_weights_path, overwrite=True)\\n\\n disc_weights_path = os.path.join('../../models/%s/disc_weights_epoch%s.h5' % (model_name, e))\\n discriminator_model.save_weights(disc_weights_path, overwrite=True)\\n\\n DCGAN_weights_path = os.path.join('../../models/%s/DCGAN_weights_epoch%s.h5' % (model_name, e))\\n DCGAN_model.save_weights(DCGAN_weights_path, overwrite=True)\\n\\n except KeyboardInterrupt:\\n pass\",\n \"def main():\\n df = prof_conv_bwd_filter()\\n df.to_csv(\\\"prof.cudnnConvBwdFilter.csv\\\")\\n\\n \\\"\\\"\\\"visualization, Roofline model\\\"\\\"\\\"\\n df = pd.read_csv('prof.cudnnConvBwdFilter.csv', header=0, index_col=0)\\n fig = plt.figure(figsize=(10,5))\\n ax = fig.add_subplot(1, 1, 1)\\n plot_rooline (ax, MACHINE_SPEC, PEAK_PERF, BAND_WIDTH)\\n plot_result (ax, df)\\n # fig.subplots_adjust(right=0.8)\\n plt.subplots_adjust(left=0.1, right=0.6)\\n plt.savefig('roofline.png')\\n return\",\n \"def train_network(self):\\n if self.trainData:\\n if self.verbose:\\n print('Started training...')\\n\\n for epoch in range(135):\\n pass\\n # save the model\\n else:\\n if self.verbose:\\n print('No train data available')\",\n \"def __init__(self, in_channels=3, n_classes=21):\\n super(U_Net, self).__init__()\\n\\n self.layer_0 = UNet_Encoder_Particular(in_channels, 64)\\n\\n self.layer_1 = UNet_Encoder(64, 128)\\n self.layer_2 = UNet_Encoder(128, 256)\\n self.layer_3 = UNet_Encoder(256, 512)\\n self.layer_4 = UNet_Encoder(512, 512)\\n\\n self.layer_7 = UNet_Decoder(1024, 256)\\n self.layer_8 = UNet_Decoder(512, 128)\\n self.layer_9 = UNet_Decoder(256, 64)\\n self.layer_10 = UNet_Decoder(128, 64)\\n\\n self.layer_11 = UNet_Decoder_Particular(64, n_classes)\",\n \"def train(self):\\n\\n # Set the pretrain log\\n trlog = {}\\n trlog['args'] = vars(self.args)\\n trlog['train_loss'] = []\\n trlog['val_loss'] = []\\n trlog['train_acc'] = []\\n trlog['val_acc'] = []\\n trlog['train_iou']=[]\\n trlog['val_iou']=[]\\n trlog['max_iou'] = 0.0\\n trlog['max_iou_epoch'] = 0\\n\\n # Set the timer\\n timer = Timer()\\n # Set global count to zero\\n global_count = 0\\n # Set tensorboardX\\n writer = SummaryWriter(comment=self.args.save_path)\\n\\n # Start pretrain\\n for epoch in range(1, self.args.pre_max_epoch + 1):\\n # Update learning rate\\n self.lr_scheduler.step()\\n # Set the model to train mode\\n self.model.train()\\n self.model.mode = 'train'\\n # Set averager classes to record training losses and accuracies\\n train_loss_averager = Averager()\\n train_acc_averager = Averager()\\n train_iou_averager = Averager()\\n\\n # Using tqdm to read samples from train loader\\n tqdm_gen = tqdm.tqdm(self.train_loader)\\n\\n for i, batch in enumerate(tqdm_gen, 1):\\n # Update global count number \\n global_count = global_count + 1\\n if torch.cuda.is_available():\\n data, label = [_.cuda() for _ in batch]\\n else:\\n data = batch[0]\\n label = batch[1]\\n\\n # Output logits for model\\n logits = self.model(data)\\n # Calculate train loss\\n # CD loss is modified in the whole project to incorporate ony Cross Entropy loss. Modify as per requirement.\\n #loss = self.FL(logits, label) + self.CD(logits,label) + self.LS(logits,label)\\n loss = self.CD(logits,label) \\n \\n # Calculate train accuracy\\n self._reset_metrics()\\n seg_metrics = eval_metrics(logits, label, self.args.num_classes)\\n self._update_seg_metrics(*seg_metrics)\\n pixAcc, mIoU, _ = self._get_seg_metrics(self.args.num_classes).values()\\n\\n # Add loss and accuracy for the averagers\\n train_loss_averager.add(loss.item())\\n train_acc_averager.add(pixAcc)\\n train_iou_averager.add(mIoU)\\n\\n # Print loss and accuracy till this step\\n tqdm_gen.set_description('Epoch {}, Loss={:.4f} Acc={:.4f} IOU={:.4f}'.format(epoch, train_loss_averager.item(),train_acc_averager.item()*100.0,train_iou_averager.item()))\\n \\n # Loss backwards and optimizer updates\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # Update the averagers\\n train_loss_averager = train_loss_averager.item()\\n train_acc_averager = train_acc_averager.item()\\n train_iou_averager = train_iou_averager.item()\\n\\n writer.add_scalar('data/train_loss(Pre)', float(train_loss_averager), epoch)\\n writer.add_scalar('data/train_acc(Pre)', float(train_acc_averager)*100.0, epoch) \\n writer.add_scalar('data/train_iou (Pre)', float(train_iou_averager), epoch)\\n \\n print('Epoch {}, Train: Loss={:.4f}, Acc={:.4f}, IoU={:.4f}'.format(epoch, train_loss_averager, train_acc_averager*100.0,train_iou_averager)) \\n \\n # Start validation for this epoch, set model to eval mode\\n self.model.eval()\\n self.model.mode = 'val'\\n\\n # Set averager classes to record validation losses and accuracies\\n val_loss_averager = Averager()\\n val_acc_averager = Averager()\\n val_iou_averager = Averager()\\n\\n # Print previous information \\n if epoch % 1 == 0:\\n print('Best Val Epoch {}, Best Val IoU={:.4f}'.format(trlog['max_iou_epoch'], trlog['max_iou']))\\n\\n # Run validation\\n for i, batch in enumerate(self.val_loader, 1):\\n if torch.cuda.is_available():\\n data, labels,_ = [_.cuda() for _ in batch]\\n else:\\n data = batch[0]\\n label=labels[0]\\n p = self.args.way*self.args.shot\\n data_shot, data_query = data[:p], data[p:]\\n label_shot,label=labels[:p],labels[p:]\\n \\n par=data_shot, label_shot, data_query\\n logits = self.model(par)\\n # Calculate preval loss\\n \\n #loss = self.FL(logits, label) + self.CD(logits,label) + self.LS(logits,label)\\n loss = self.CD(logits,label) \\n \\n # Calculate val accuracy\\n self._reset_metrics()\\n seg_metrics = eval_metrics(logits, label, self.args.way)\\n self._update_seg_metrics(*seg_metrics)\\n pixAcc, mIoU, _ = self._get_seg_metrics(self.args.way).values()\\n\\n val_loss_averager.add(loss.item())\\n val_acc_averager.add(pixAcc)\\n val_iou_averager.add(mIoU) \\n\\n # Update validation averagers\\n val_loss_averager = val_loss_averager.item()\\n val_acc_averager = val_acc_averager.item()\\n val_iou_averager = val_iou_averager.item()\\n \\n writer.add_scalar('data/val_loss(Pre)', float(val_loss_averager), epoch)\\n writer.add_scalar('data/val_acc(Pre)', float(val_acc_averager)*100.0, epoch) \\n writer.add_scalar('data/val_iou (Pre)', float(val_iou_averager), epoch) \\n \\n # Print loss and accuracy for this epoch\\n print('Epoch {}, Val: Loss={:.4f} Acc={:.4f} IoU={:.4f}'.format(epoch, val_loss_averager, val_acc_averager*100.0,val_iou_averager))\\n\\n # Update best saved model\\n if val_iou_averager > trlog['max_iou']:\\n trlog['max_iou'] = val_iou_averager\\n trlog['max_iou_epoch'] = epoch\\n print(\\\"model saved in max_iou\\\")\\n self.save_model('max_iou')\\n\\n # Save model every 10 epochs\\n if epoch % 10 == 0:\\n self.save_model('epoch'+str(epoch))\\n\\n # Update the logs\\n trlog['train_loss'].append(train_loss_averager)\\n trlog['train_acc'].append(train_acc_averager)\\n trlog['val_loss'].append(val_loss_averager)\\n trlog['val_acc'].append(val_acc_averager)\\n trlog['train_iou'].append(train_iou_averager)\\n trlog['val_iou'].append(val_iou_averager)\\n\\n # Save log\\n torch.save(trlog, osp.join(self.args.save_path, 'trlog'))\\n\\n if epoch % 1 == 0:\\n print('Running Time: {}, Estimated Time: {}'.format(timer.measure(), timer.measure(epoch / self.args.max_epoch)))\\n writer.close()\",\n \"def __init__(self):\\n\\n TEST_RATIO = 0.05\\n mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=None)\\n idxs = np.arange(mnist_trainset.train_data.size(0))\\n np.random.shuffle(idxs)\\n\\n #print(torch.min(mnist_trainset.train_labels), torch.max(mnist_trainset.train_labels))\\n #print(mnist_trainset.train_labels.size())\\n \\n # reshape input data to (1, 784) and normalize to range [0., 1.]\\n self.train_data = torch.reshape(\\n mnist_trainset.train_data[idxs].float(), (-1,1,28,28))/255.\\n self.data_size = self.train_data.size(0)\\n self.train_len = self.train_data.size(0)\\n self.train_label = torch.Tensor([1]).float() # since there is only one class - 'real' image\\n\\n print('Train images -- {}'.format(self.train_data.size()))\",\n \"def train_nn(train_nn_results, label, title, yaxis):\\n plt.figure(figsize=(12,5))\\n for i in range(len(label)):\\n plt.plot(train_nn_results[i], label=label[i], alpha=0.75)\\n plt.title(title)\\n plt.xlabel('epoch')\\n plt.ylabel(yaxis)\\n plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')\\n plt.tight_layout()\\n plt.show()\",\n \"def main(tetrode_number=TETRODE_NUMBER,num_hidden_units=500,num_hidden_units_2=300,num_hidden_units_3=200,num_code_units=50):\\n \\n print(\\\"Making the model...\\\")\\n network = model((None,200),200,num_hidden_units,num_hidden_units_2,num_hidden_units_3,num_code_units)\\n print(\\\"Done!\\\")\\n\\n\\n for tetrode_number in [10]:\\n\\n print(\\\"Loading the model parameters from {}\\\".format(MODEL_FILENAME+str(tetrode_number)))\\n f = open(MODEL_FILENAME+str(tetrode_number),'r')\\n all_param_values = pickle.load(f)\\n f.close()\\n # print(all_param_values)\\n lasagne.layers.set_all_param_values(network, all_param_values)\\n\\n print(\\\"Loading the data...\\\")\\n dataset = load_data(tetrode_number)\\n print(\\\"Done!\\\")\\n\\n print(dataset['data'].shape)\\n\\n print(\\\"Setting up the training functions...\\\")\\n training = funcs(dataset,network)\\n print(\\\"Done!\\\")\\n\\n for i in range(NUM_EPOCHS):\\n costs = []\\n\\n for start, end in zip(range(0, dataset['data'].shape[0], BATCH_SIZE), range(BATCH_SIZE, dataset['data'].shape[0], BATCH_SIZE)):\\n cost = training['train'](dataset['data'][start:end],dataset['data'][start:end])\\n costs.append(cost)\\n\\n meanTrainCost = np.mean(np.asarray(costs,dtype=np.float32))\\n # accuracy = training['accuracy'](dataset['X_test'],dataset['y_test'])\\n\\n print(\\\"Epoch: {}, Training cost: {}\\\".format(i+1,meanTrainCost))\\n # NUM_POINTS = 5000\\n codes = training['code'](dataset['data'][0:NUM_POINTS])\\n\\n \\n\\n # y = set(list(d.predict(dataset['data'][0:NUM_POINTS])))\\n\\n # print(y)\\n\\n # activations_1 = training['activations_1'](dataset['data'][0:NUM_POINTS])\\n # activations_2 = training['activations_2'](dataset['data'][0:NUM_POINTS])\\n # codes = training['code'](dataset['data'][0:NUM_POINTS])\\n # # print(codes.shape)\\n # # codes_2d = bh_sne(codes)\\n\\n # for k in range(3):\\n # print(k)\\n\\n # codes_2d = bh_sne(np.asarray(codes[:(k+1)*12000],dtype=np.float64))\\n\\n # # d = DPGMM(n_components=10, covariance_type='full')\\n # d = DPGMM(n_components=15,n_iter=100)\\n\\n # d.fit(codes_2d[:(k+1)*12000])\\n\\n # hdp = d.predict_proba(codes_2d[:(k+1)*12000])\\n\\n # hdp_1d = [np.argmax(z) for z in hdp]\\n\\n # print(set(list(hdp_1d)))\\n\\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=hdp_1d, alpha=0.8,lw=0)\\n # plt.savefig('dbscan_labels/deep/sparse/hdp_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\\n # plt.close()\\n\\n # # m = TSNE(n_components=2, random_state=0)\\n \\n # # codes_2d = m.fit_transform(codes[:NUM_POINTS])\\n # # activations_1_2d = bh_sne(activations_1)\\n # # activations_2_2d = bh_sne(activations_2)\\n\\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=dataset['labels'][0:NUM_POINTS][:(k+1)*12000],alpha=0.8,lw=0)\\n # plt.savefig('dbscan_labels/deep/sparse/tsne_codes_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\\n # plt.close()\\n\\n # # This is where the code for the video will go\\n # ##############################################################################\\n # # Compute DBSCAN\\n # db = None\\n # core_samples_mask = None\\n # labels = None\\n\\n # num_labels = 0\\n # eps=1.0\\n # while(num_labels < 10):\\n # db = DBSCAN(eps=eps, min_samples=10).fit(codes_2d)\\n # core_samples_mask = np.zeros_like(db.labels_, dtype=bool)\\n # core_samples_mask[db.core_sample_indices_] = True\\n # labels = db.labels_\\n # num_labels = np.amax(labels)\\n # eps -= 0.1\\n\\n # print(\\\"Num learned labels: {}\\\".format(num_labels))\\n\\n # plt.title('Estimated number of clusters: {}'.format(np.amax(labels)))\\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=labels[0:NUM_POINTS][:(k+1)*12000],lw=0)\\n # plt.savefig('dbscan_labels/deep/sparse/dbscan_codes_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\\n # plt.close()\\n\\n # # f=open('dbscan_labels/deep/sparse/tetrode_{}.npy'.format(tetrode_number),'w')\\n # # pickle.dump(labels, f)\\n # # f.close()\\n\\n codes_2d = bh_sne(np.asarray(codes,dtype=np.float64),theta=0.4)\\n\\n # d = DPGMM(n_components=10, covariance_type='full')\\n d = DPGMM(n_components=15,n_iter=1000)\\n\\n d.fit(codes_2d)\\n\\n hdp = d.predict_proba(codes_2d)\\n\\n hdp_1d = [np.argmax(z) for z in hdp]\\n\\n print(set(list(hdp_1d)))\\n\\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=hdp_1d, alpha=0.8,lw=0)\\n plt.savefig('dbscan_labels/deep/sparse/hdp_{}.png'.format(tetrode_number), bbox_inches='tight')\\n plt.close()\\n\\n # m = TSNE(n_components=2, random_state=0)\\n \\n # codes_2d = m.fit_transform(codes[:NUM_POINTS])\\n # activations_1_2d = bh_sne(activations_1)\\n # activations_2_2d = bh_sne(activations_2)\\n\\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=dataset['labels'][0:NUM_POINTS],alpha=0.8,lw=0)\\n plt.savefig('dbscan_labels/deep/sparse/tsne_codes_{}.png'.format(tetrode_number), bbox_inches='tight')\\n plt.close()\\n\\n # This is where the code for the video will go\\n ##############################################################################\\n # Compute DBSCAN\\n db = None\\n core_samples_mask = None\\n labels = None\\n\\n num_labels = 0\\n eps=1.0\\n while(num_labels < 10):\\n db = DBSCAN(eps=eps, min_samples=10).fit(codes_2d)\\n core_samples_mask = np.zeros_like(db.labels_, dtype=bool)\\n core_samples_mask[db.core_sample_indices_] = True\\n labels = db.labels_\\n num_labels = np.amax(labels)\\n eps -= 0.1\\n\\n print(\\\"Num learned labels: {}\\\".format(num_labels))\\n\\n plt.title('Estimated number of clusters: {}'.format(np.amax(labels)))\\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=labels[0:NUM_POINTS],lw=0)\\n plt.savefig('dbscan_labels/deep/sparse/dbscan_codes_{}.png'.format(tetrode_number), bbox_inches='tight')\\n plt.close()\\n\\n # f=open('dbscan_labels/deep/sparse/tetrode_{}.npy'.format(tetrode_number),'w')\\n # pickle.dump(labels, f)\\n # f.close()\",\n \"def train_callback(self):\\n self.input_weight_1 = 1.0\\n self.input_weight_2 = 1.0\\n self.bias = 0\\n weights = np.array([self.input_weight_1, self.input_weight_2])\\n outer_loop = False\\n error_array = np.array([5.0, 5.0, 5.0, 5.0])\\n \\n # ==========================\\n # Training starts from here\\n # ==========================\\n for i in range(0, 100):\\n for j in range(0, 4):\\n # =======================\\n # Getting the input point\\n # =======================\\n point = self.data_points[j, :]\\n \\n # =======================\\n # Calculating net value\\n # =======================\\n net_value = np.sum(weights * point) + self.bias # [1x2] * [2x1]\\n \\n # =======================\\n # Calculating error\\n # =======================\\n error = self.targets[j] - self.get_activation(net_value)\\n error_array[j] = error\\n \\n # ============================================\\n # Keeping the error in range from -700 to 700\\n # this is to avoid nan or overflow error\\n # ============================================\\n if error > 1000 or error < -700:\\n error /= 10000\\n\\n # ==========================\\n # Updating Weights and bias\\n # ==========================\\n weights += error * point\\n self.bias += error * 1.0 # While updating bias input is always 1\\n \\n # if weights[0] > 5000 or weights[0] < -5000:\\n # weights[0] /= 10000\\n # if weights[1] > 5000 or weights[1] < -5000:\\n # weights[1] /= 10000\\n # if self.bias > 5000 or self.bias < -5000:\\n # self.bias /= 10000\\n \\n # ==================================\\n # Printing out the updated weights\\n # ==================================\\n # print(weights)\\n \\n if (error_array == np.array([0.0, 0.0, 0.0, 0.0])).all():\\n outer_loop = True\\n break\\n self.x_values = np.linspace(-10, 10, 256)\\n \\n # ========================================================\\n # Getting the y values to plot a linear decision boundary\\n # ========================================================\\n self.y_values = ((- weights[0] * self.x_values) - self.bias) / weights[1] # Equation of a line\\n self.input_weight_1 = weights[0]\\n self.input_weight_2 = weights[1]\\n \\n # ================================\\n # plotting the decision boundary\\n # ================================\\n if i % 20 == 0:\\n self.plot_graph()\\n \\n if outer_loop:\\n break\\n \\n self.plot_graph()\\n self.input_weight_1 = weights[0]\\n self.input_weight_2 = weights[1]\",\n \"def plot_train_output(self, n, show=False, amount=10):\\n\\n fig, axes = plt.subplots(3, 1, sharex = True, figsize = (8, 6))\\n ax = axes[0]\\n\\n # track 'amount' random outputs of the 1000 input simulations\\n random_indices = np.random.randint(0,self.n_s, amount)\\n outputs = np.asarray(n.history['train output'])[:,random_indices,0]\\n end = len(n.history['train output'])\\n epochs = np.arange(end)\\n\\n # plot 'amount' random outputs vs epochs\\n for i in range(amount):\\n ax.plot(epochs,outputs[:,i],alpha=0.5,ls='dashed')\\n\\n # plot the network mean of all the input simulations\\n ax.plot(epochs, np.array(n.history[\\\"μ\\\"])[:,0],ls='solid',label='μ')\\n ax.set_ylabel('Network output')\\n ax.set_title(f'Output of {amount} random input simulations')\\n ax.legend()\\n\\n # plot the network mean of all the input simulations, in a separate plot\\n ax = axes[1]\\n ax.plot(epochs, np.array(n.history[\\\"μ\\\"])[:,0],ls='solid',label='μ')\\n ax.set_title(f'Network mean')\\n ax.set_ylabel('Network output')\\n\\n # plot the numpy mean of this subset\\n ax = axes[2]\\n ax.set_title('numpy mean/std of the random subset of simulations')\\n ax.errorbar(epochs, np.mean(outputs,axis=1), yerr=np.std(outputs,axis=1),label=r'$1\\\\sigma$',zorder=1)\\n ax.plot(epochs, np.mean(outputs,axis=1),label='mean',zorder=2)\\n ax.set_ylabel('Value')\\n ax.legend()\\n \\n # print (np.std(outputs,axis=1))\\n\\n axes[-1].set_xlabel('Epoch')\\n plt.tight_layout()\\n plt.savefig(f'{self.figuredir}output_vs_epochs_{self.modelversion}.png')\\n if show: plt.show()\\n plt.close()\",\n \"def learning_viz(self) :\\n self.train\\n history = self.history\\n plot_loss(history)\",\n \"def train_network(self, batch_size, epochs):\\n\\n if self.eq_train: self.model.fit([self.X_train_high_level, self.X_train_low_level], self.y_train, epochs=epochs, batch_size=batch_size, sample_weight=self.train_weights_eq) \\n else: self.model.fit([self.X_train_high_level, self.X_train_low_level], self.y_train, epochs=epochs, batch_size=batch_size, sample_weight=self.train_weights)\",\n \"def train_nasnetmobile():\\n\\n # load data\\n training_sets = load_augmented_dataset()\\n\\n # build models\\n model_nas = build_nasnet()\\n\\n baseWeights_t = model_nas.get_weights()\\n\\n # NOTE: You can still leave this alone if you've only downloaded the fully augmented set.\\n for training_set in training_sets:\\n print(\\\" Starting training for set {}\\\".format(str(training_set)))\\n model_nas.set_weights(baseWeights_t) # Resets model\\n train_x = np.load(os.path.join(\\\"./model_cache/train_data\\\", training_sets[training_set][0]))\\n train_y = np.load(os.path.join(\\\"./model_cache/train_data\\\", training_sets[training_set][1]))\\n\\n early_stopping_monitor = EarlyStopping(patience=2)\\n history = model_nas.fit(train_x, train_y, batch_size=32, epochs=20, verbose=1, validation_split=0.2,\\n shuffle=True,\\n callbacks=[early_stopping_monitor])\\n\\n mpu.plot_accuracy_loss(history,\\n \\\"./model_cache/train_data/{}_nasnetmobile_plots.png\\\".format(str(training_set)))\\n\\n upload_blob(BUCKET_NAME, \\\"./model_cache/train_data/{}_nasnetmobile_plots.png\\\".format(str(training_set)),\\n \\\"model_charts/{}_nasnetmobile_plots.png\\\".format(str(training_set)))\\n\\n model_nas.save(\\\"./model_cache/train_data/{}_nasnetmobile.h5\\\".format(str(training_set)))\\n\\n upload_blob(BUCKET_NAME, \\\"./model_cache/train_data/{}_nasnetmobile.h5\\\".format(str(training_set)),\\n \\\"saved_models/{}_nasnetmobile.h5\\\".format(str(training_set)))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6543201","0.63936913","0.61371124","0.60957474","0.603511","0.6034276","0.59679383","0.58697367","0.58606166","0.58570796","0.5854856","0.58541954","0.5833947","0.5821031","0.5809367","0.5758914","0.5753244","0.5733578","0.57328314","0.56852037","0.5683603","0.5663585","0.56567657","0.5652878","0.56468385","0.5642941","0.5640119","0.5627415","0.56101155","0.56089175","0.5594756","0.55803263","0.5576574","0.55631864","0.55623186","0.55618745","0.55600727","0.55535495","0.5546279","0.55383855","0.553586","0.55272835","0.55272835","0.55267084","0.5494496","0.5476496","0.54740167","0.5471497","0.5462799","0.54572415","0.5451594","0.5448722","0.54463524","0.54444015","0.5440932","0.5439487","0.543436","0.54285586","0.542779","0.54225314","0.5420671","0.54064965","0.5400777","0.5397819","0.5396225","0.5383825","0.5378193","0.5376632","0.5375978","0.536955","0.5367566","0.5366931","0.536655","0.53656954","0.53654337","0.5363776","0.5362562","0.5361911","0.5361911","0.5361911","0.5361911","0.5361911","0.53605014","0.535764","0.5351735","0.53497857","0.53465384","0.5345106","0.5341465","0.5340236","0.53394747","0.53311545","0.5329245","0.5324684","0.53246343","0.531872","0.5310185","0.53031135","0.5302581","0.5299663","0.5296102"],"string":"[\n \"0.6543201\",\n \"0.63936913\",\n \"0.61371124\",\n \"0.60957474\",\n \"0.603511\",\n \"0.6034276\",\n \"0.59679383\",\n \"0.58697367\",\n \"0.58606166\",\n \"0.58570796\",\n \"0.5854856\",\n \"0.58541954\",\n \"0.5833947\",\n \"0.5821031\",\n \"0.5809367\",\n \"0.5758914\",\n \"0.5753244\",\n \"0.5733578\",\n \"0.57328314\",\n \"0.56852037\",\n \"0.5683603\",\n \"0.5663585\",\n \"0.56567657\",\n \"0.5652878\",\n \"0.56468385\",\n \"0.5642941\",\n \"0.5640119\",\n \"0.5627415\",\n \"0.56101155\",\n \"0.56089175\",\n \"0.5594756\",\n \"0.55803263\",\n \"0.5576574\",\n \"0.55631864\",\n \"0.55623186\",\n \"0.55618745\",\n \"0.55600727\",\n \"0.55535495\",\n \"0.5546279\",\n \"0.55383855\",\n \"0.553586\",\n \"0.55272835\",\n \"0.55272835\",\n \"0.55267084\",\n \"0.5494496\",\n \"0.5476496\",\n \"0.54740167\",\n \"0.5471497\",\n \"0.5462799\",\n \"0.54572415\",\n \"0.5451594\",\n \"0.5448722\",\n \"0.54463524\",\n \"0.54444015\",\n \"0.5440932\",\n \"0.5439487\",\n \"0.543436\",\n \"0.54285586\",\n \"0.542779\",\n \"0.54225314\",\n \"0.5420671\",\n \"0.54064965\",\n \"0.5400777\",\n \"0.5397819\",\n \"0.5396225\",\n \"0.5383825\",\n \"0.5378193\",\n \"0.5376632\",\n \"0.5375978\",\n \"0.536955\",\n \"0.5367566\",\n \"0.5366931\",\n \"0.536655\",\n \"0.53656954\",\n \"0.53654337\",\n \"0.5363776\",\n \"0.5362562\",\n \"0.5361911\",\n \"0.5361911\",\n \"0.5361911\",\n \"0.5361911\",\n \"0.5361911\",\n \"0.53605014\",\n \"0.535764\",\n \"0.5351735\",\n \"0.53497857\",\n \"0.53465384\",\n \"0.5345106\",\n \"0.5341465\",\n \"0.5340236\",\n \"0.53394747\",\n \"0.53311545\",\n \"0.5329245\",\n \"0.5324684\",\n \"0.53246343\",\n \"0.531872\",\n \"0.5310185\",\n \"0.53031135\",\n \"0.5302581\",\n \"0.5299663\",\n \"0.5296102\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84588,"cells":{"query":{"kind":"string","value":"Saves the weights of model to output_path."},"document":{"kind":"string","value":"def save_model_weights(model, output_path):\n output_dir = os.path.dirname(output_path)\n if output_dir and not os.path.exists(output_dir):\n os.makedirs(output_dir)\n \n model.save_weights(output_path)"},"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_model_weights(self, filename):\n self.model.save_weights(filename)","def save_model(self, file_name):\n\t\tself.model.save_weights(file_name)","def save(self, filename):\n self.model.save_weights(filename)","def save_model(self, model_filename):\n self.model.save_weights(model_filename)","def save_weights(self, the_path):\n torch.save(self.model.state_dict(), the_path)","def save(self, weights_file):\r\n \r\n self.model.save_weights(weights_file)","def saveModel(self):\n self._model.save_weights('./my_model')\n return None","def save_model(self, output_path):\n joblib.dump(self.dtr, output_path)","def save_model(self):\n saved_path = self.config.path_tmp / self.model.model_name\n saved_path.mkdir(parents=True, exist_ok=True)\n self.model.save_weights(str(saved_path / 'model.vec'))","def save_weight(model):\n file = h5py.File(WEIGHT_SAVE, 'w')\n weight = model.get_weights()\n for i in range(len(weight)):\n file.create_dataset('weight' + str(i), data=weight[i])\n file.close()","def save_model(self, dir_path):\n np.savez(\n dir_path + os.path.sep + \"weights.npz\", W1=self.W1, W2=self.W2, W3=self.W3\n )\n np.savez(\n dir_path + os.path.sep + \"biases.npz\", b1=self.b1, b2=self.b2, b3=self.b3\n )","def save_model(self):\n save_folder = os.path.join(self.log_path, \"models\", \"weights_{}\".format(self.epoch))\n if not os.path.exists(save_folder):\n os.makedirs(save_folder)\n\n for model_name, model in self.models.items():\n print(\"MODEL NAME = {}\".format(model_name))\n save_path = os.path.join(save_folder, \"{}.pth\".format(model_name))\n to_save = model.state_dict()\n if model_name == 'encoder':\n # save the sizes - these are needed at prediction time\n to_save['height'] = self.height\n to_save['width'] = self.width\n torch.save(to_save, save_path)\n\n save_path = os.path.join(save_folder, \"{}.pth\".format(\"adam\"))\n torch.save(self.model_optimizer.state_dict(), save_path)","def save(self, filename, overwrite=False):\n self.model.save_weights(filename, overwrite=overwrite)","def save_model(self):\n\n print('Save model')\n self.feature_extractor.save_weights(\n self.path_save_model + self.name_model + '.h5')\n\n print('Mean and std')\n np.save(self.path_save_model + 'mean.npy', self.mean)\n np.save(self.path_save_model + 'std.npy', self.std)","def save_model_weights(model, filename, verbose=1, cp_folder=\"\"):\n if verbose:\n print(f\"\\n -> Saving weights to {os.path.join(cp_folder, filename)}\\n\")\n torch.save(model.state_dict(), os.path.join(cp_folder, filename))","def save_model(self):\n save_folder = os.path.join(self.log_path, \"models\", \"weights_{}\".format(self.epoch))\n if not os.path.exists(save_folder):\n os.makedirs(save_folder)\n\n for model_name in [\"encoder\", \"decoder\"]:\n save_path = os.path.join(save_folder, \"{}.pth\".format(model_name))\n if model_name == 'encoder':\n to_save = self.encoder.state_dict()\n # save the sizes - these are needed at prediction time\n to_save['height'] = self.opt.height\n to_save['width'] = self.opt.width\n else:\n to_save = self.decoder.state_dict()\n torch.save(to_save, save_path)\n\n save_path = os.path.join(save_folder, \"{}.pth\".format(\"adam\"))\n torch.save(self.optimizer.state_dict(), save_path)","def save_weights(self, path: str):\n torch.save(self.state_dict(), path)","def save_weights(self, path: str):\n torch.save(self.state_dict(), path)","def save(self, filename):\n # serialize model to JSON\n model_json = self._model.to_json()\n with open('models/' + filename + \".json\", \"w\") as json_file:\n json_file.write(model_json)\n\n # serialize weights to HDF5\n self._model.save_weights('models/' + filename + \".h5\")\n print(\"Saved model to disk\")","def save_model_weight(model, filename):\n weights = model.get_weights()\n with open (filename, 'wb') as obj:\n pkl.dump(weights, obj, pkl.HIGHEST_PROTOCOL)","def save_weights(self, filepath, overwrite=True):\n self.model.save_weights(filepath=filepath, overwrite=overwrite,\n save_format=None)","def save_model(self, output_model: ModelEntity):\n logger.info(\"called save_model\")\n buffer = io.BytesIO()\n hyperparams_str = ids_to_strings(cfg_helper.convert(self._hyperparams, dict, enum_to_str=True))\n labels = {label.name: label.color.rgb_tuple for label in self._labels}\n model_ckpt = torch.load(self._model_ckpt)\n modelinfo = {\n \"model\": model_ckpt,\n \"config\": hyperparams_str,\n \"labels\": labels,\n \"VERSION\": 1,\n }\n\n torch.save(modelinfo, buffer)\n output_model.set_data(\"weights.pth\", buffer.getvalue())\n output_model.set_data(\n \"label_schema.json\",\n label_schema_to_bytes(self._task_environment.label_schema),\n )\n output_model.precision = self._precision","def save_model(self, model):\n # serialize model to JSON\n model_json = model.to_json()\n os.makedirs(os.path.dirname(self.model_json_path), exist_ok=True)\n with open(self.model_json_path, \"w\") as json_file:\n json_file.write(model_json)\n\n # serialize weights to HDF5\n model.save_weights(self.model_weights_path)\n print(\"Saved model to disk\")","def save_weights(self, path):\n Path(path).mkdir(parents=True, exist_ok=True)\n self.model.save_weights(path)","def save_weights(self, location: str):\n\n # import torch\n torch = import_optional_dependency(\"torch\")\n torch.save(self.model.state_dict(), self._set_save_location(location))","def save(self, model_path: str) -> None:\n metadata_string = json.dumps({ \"classes\": self.classes })\n with open(os.path.join(model_path, \"metadata.json\"), \"w\") as metadata_file:\n metadata_file.write(metadata_string)\n with self.graph.as_default():\n with self.session.as_default():\n self.model.save_weights(os.path.join(model_path, \"weights.h5\"))","def save_weights(self, file):\n self.model.save_weights(file)\n return","def save_model_weights(self, fp=None, **kwds):\n n_epoch = self._cur_epoch\n if fp is None:\n fp = self.dir_model / f'weights_epoch{n_epoch}.pt'\n torch.save(self.model.state_dict(), fp, **kwds)","def save_weights(self):\n np.save(\"weights.npy\", self.model.parameters)\n return \"weights.npy\"","def save(self, output_path):\r\n self.graph.cleanup().toposort()\r\n model = gs.export_onnx(self.graph)\r\n output_path = os.path.realpath(output_path)\r\n os.makedirs(os.path.dirname(output_path), exist_ok=True)\r\n onnx.save(model, output_path)\r\n log.info(\"Saved ONNX model to {}\".format(output_path))","def save(self, weight_path, vocab_path, output_path, binary=False):\n w2v_save_model(weight_path.encode(\"ascii\"),\n vocab_path.encode(\"ascii\"), \n output_path.encode(\"ascii\"),\n self.minCount, binary)\n excpt = check_server_exception()\n if excpt[\"status\"]:\n raise RuntimeError(excpt[\"info\"])","def save_weights(self, file_path, format=None):\n _save_weights(self, file_path, format)","def save(self, folder):\n self.generator.save_weights('%s/generator.h5'%folder)\n self.critic.save_weights('%s/critic.h5'%folder)","def save_model(self, path='./model_checkpoint', name='tf_model'):\n json_config = self._model.to_json()\n with open(os.path.join(path, name + '.json'), 'w') as json_file:\n json_file.write(json_config)\n weights_path = os.path.join(path, name + '_weights.h5')\n self._model.save_weights(weights_path)","def save(self, model_out_file):\n\t\tvariables_dict = {v.name: v for v in tf.global_variables()}\n\t\tvalues_dict = self.sess.run(variables_dict)\n\t\tnp.savez(open(model_out_file, 'wb'), **values_dict)","def _save_model_weights(model_weights, model_weights_dir, epoch_idx):\n model_weights_path = os.path.join(model_weights_dir,\n f\"model_epoch_{epoch_idx}.pth\")\n torch.save(model_weights, model_weights_path)","def save(model: nn.Module, path):\n save_model(model, path)","def save(self) -> None:\n self.saver.save_model_and_weights(self.model)\n self.saver.save_data_shuffle_indices(\n self.data.eval_shuffler.ds_inds\n )\n self.saver.save_input_scaler(self.data.x.scaler)","def save_model(self, output_dir):\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n\n logger.info('Saving model')\n dst_config_file = os.path.join(output_dir, self.CONFIG_FILE)\n if self.fullpath_input_configfile != dst_config_file:\n shutil.copy(self.fullpath_input_configfile, dst_config_file)\n\n pickle.dump(self.word_det_rfc,\n open(os.path.join(output_dir, self.WORD_DET_RFC), 'wb'))\n pickle.dump(self.reg_coeffs, open(\n os.path.join(output_dir, self.REGRESSION_PARAMS), 'wb'))","def _save_model(self):\n with open(self.filepath, 'wb') as file:\n pickle.dump(self.cmodel, file)","def save_model(self):\n\n self.check_model()\n\n with open(self.filename, 'wb') as file:\n pickle.dump({'model': self.model, 'vec': self.vectorizer, 'vec_data': self.vectorized_data,\n 'df': self.df_topic_keywords}, file)","def save_model(model, filename=\"model.json\"):\n model_json = model.to_json()\n with open(filename, \"w\") as json_file:\n json_file.write(model_json)\n model.save_weights(\"model.h5\")\n print(\"Saved model to disk\")","def save_model(model, model_filepath):","def save_weights_model(self, list_path):\n [path_encoder, path_decoder, path_discriminator, path_scaler] = list_path\n self.encode_.save_weights(path_encoder)\n self.decode_.save_weights(path_decoder)\n self.b.save_weights(path_discriminator)\n joblib.dump(self.scaler, path_scaler + 'scaler.pkl')","def save_model(model, model_path) -> None:\n try:\n createFolder(model_path)\n exportJSON(model.to_json(), model_path+'/model.json')\n model.save_weights(model_path+'/model_weights.h5')\n except Exception as error:\n print(f\"Error: save_model(model, {model_path}) -> {error}\")","def export_model(self, output_model_dir):\n logger.info(\"Exporting model to directory : {}\".format(output_model_dir))\n self.model.export(output_model_dir=output_model_dir)","def save_model(self):\n filename=self.name + '_words'\n file_write(filename, self.words)\n\n filename2=self.name+'_word_lengths'\n file_write(filename2, self.word_lengths)\n\n filename3=self.name+'_stems'\n file_write(filename3, self.stems)\n\n filename4=self.sentence_lengths+'_sentence_lengths'\n file_write(filename4, self.sentence_lengths)\n\n filename5= self.endings+'_endings'\n file_write(filename5, self.endings)","def save(self, name):\n if self.model is None:\n raise Exception(\"Build the model first!\")\n\n if os.path.isdir(self.config[\"model\"][\"checkpoint_path\"]) is False:\n os.makedirs(self.config[\"model\"][\"checkpoint_path\"])\n\n print(\"Saving model...\")\n self.model.save_weights(self.config[\"model\"][\"checkpoint_path\"] + name)\n print(\"Model saved!\")","def save(self, name):\n if self.model is None:\n raise Exception(\"Build the model first!\")\n\n if os.path.isdir(self.config[\"model\"][\"checkpoint_path\"]) is False:\n os.makedirs(self.config[\"model\"][\"checkpoint_path\"])\n\n print(\"Saving model...\")\n self.model.save_weights(self.config[\"model\"][\"checkpoint_path\"] + name)\n print(\"Model saved!\")","def save_model(self,\n file_path: str = \"models/world_model.h5\"\n ):\n self.model.save(file_path)","def save(self, filename):\n hebbian_weights = open(filename, \"w\")\n for i in xrange(self.hidden):\n hebbian_weights.write(\"\\t\".join(self.vis_layer[i].get_weights()) + '\\n')\n for i in xrange(self.layers):\n for j in xrange(self.hidden):\n hebbian_weights.write(\"\\t\".join(self.hidden_layers[i][j].get_weights()) + '\\n')\n hebbian_weights.write(\"\\t\".join(self.output_neuron.get_weights()) + '\\n')\n hebbian_weights.close()","def save_model(model, output):\n\n # model.save(os.path.join(output))\n tf.saved_model.save(model, os.path.join(output, \"1\"))\n\n # tf.saved_model.save(model, os.path.join(output, \"1\"))\n print(\"Model successfully saved at: {}\".format(output))","def save(self, prefix):\n model_file = prefix + \".json\"\n weight_file = prefix + \".h5\"\n json.dump(self.model.to_json(), open(model_file, \"w\"))\n self.model.save_weights(weight_file)\n return self","def save_model(self, model, model_filepath):\n joblib.dump(model, model_filepath)","def save_model(self, fpath):\n self._make_model_folder(fpath)\n self.model.save(os.path.join(fpath, U.MODEL_NAME), save_format=\"h5\")\n return","def save_model(self):\n print(\"\\nModels are integrated to be multi scale.\\nSaving to disk.\")\n self.column_names = [ \"x_\" + str(x) for x in range(self.embedding.shape[1])]\n self.embedding = pd.DataFrame(self.embedding, columns = self.column_names)\n self.embedding.to_csv(self.args.output, index = None)","def save_model(self, model_learnable: ModelLearnable, fl_ctx: FLContext):\n if model_learnable:\n if fl_ctx.get_prop(AppConstants.CURRENT_ROUND) == fl_ctx.get_prop(AppConstants.NUM_ROUNDS) - 1:\n self.logger.info(f\"Saving received model to {os.path.abspath(self.save_path)}\")\n # save 'weights' which contains model parameters\n model = model_learnable[ModelLearnableKey.WEIGHTS]\n dump(model, self.save_path, compress=1)","def save_model(self):\n # words dictionary\n filename = self.name + \"_words\"\n f = open(filename, 'w')\n f.write(str(self.words))\n f.close()\n\n # word_lengths dictionary\n filename = self.name + \"_word_lengths\"\n f = open(filename, 'w')\n f.write(str(self.word_lengths))\n f.close()\n\n # stems dictionary\n filename = self.name + \"_stems\"\n f = open(filename, 'w')\n f.write(str(self.stems))\n f.close()\n\n # sentence_lengths dictionary\n filename = self.name + \"_sentence_lengths\"\n f = open(filename, 'w')\n f.write(str(self.sentence_lengths))\n f.close()\n\n # ten most common words\n filename = self.name + \"_common_word\"\n f = open(filename, 'w')\n f.write(str(self.common_word))\n f.close()","def save(self, fpath):\n logging.info(\"Saving agent with filepath={}\".format(fpath))\n self.agent.save_weights(fpath, overwrite=True)","def save(self):\n print(\"==> Saving model to\", self.model_dir)\n self.model.save(self.model_dir)","def save_model(self):\n self.pred_net.save((self.save_path / \"iqn_pred_net\").absolute().as_posix())\n self.target_net.save((self.save_path / \"iqn_target_net\").absolute().as_posix())","def save(self, save_path):\n # params\n model_params = {\n \"batch_size\": self.batch_size,\n \"lr\": self.lr,\n \"epsilon\": self.epsilon,\n \"gamma\": self.gamma,\n \"epsilon_min\": self.epsilon_min,\n \"epsilon_decay\": self.epsilon_decay,\n \"memory\": self.memory,\n \"observation_space\": self.observation_space,\n \"action_space\": self.action_space,\n \"_seed\": self._seed,\n }\n\n serialized_params = data_to_json(model_params)\n self.policy.save(save_path + \".h5\")\n\n # Check postfix if save_path is a string\n if isinstance(save_path, str):\n _, ext = os.path.splitext(save_path)\n if ext == \"\":\n save_path += \".zip\"\n\n # Create a zip-archive and write our params\n # there. This works when save_path\n # is either str or a file-like\n with zipfile.ZipFile(save_path, \"w\") as file_:\n # Do not try to save \"None\" elements\n file_.writestr(\"parameters\", serialized_params)","def save_model(self, model_path: str):","def save_weights(model, weights_dir, epoch):\n weights_fname = 'weights-%s.pth' % (epoch)\n weights_fpath = os.path.join(weights_dir, weights_fname)\n torch.save({'state_dict': model.state_dict()}, weights_fpath)\n return weights_fpath","def save_graph(self):\n with tf.Session(graph=self.graph) as sess:\n saver = tf.train.Saver()\n sess.run(tf.global_variables_initializer())\n\n save_path = saver.save(sess, os.path.join(MODELS_PATH, \"model\"))\n print(\"Model saved in path: %s\" % save_path)\n\n with open(os.path.join(MODELS_PATH, \".model.inputs\"), \"w\") as file:\n for v in self.inputs.values():\n file.write(v.name + \"\\n\")\n with open(os.path.join(MODELS_PATH, \".model.output\"), \"w\") as file:\n file.write(self.output.name)","def save_model(self, model_file):\n net_params = self.get_policy_param() # get model params\n torch.save(net_params, model_file)","def saveModel(self):\n with open(self.modelSaveFile, 'wb') as f:\n pickle.dump(self.values, f, pickle.HIGHEST_PROTOCOL)\n pickle.dump(self.policy, f, pickle.HIGHEST_PROTOCOL)","def save_model(exe, graph, dirname):\n assert graph is not None and dirname is not None\n graph = GraphWrapper(graph) if isinstance(graph,\n paddle.static.Program) else graph\n\n paddle.static.save(program=graph.program, model_path=dirname)\n weights_file = dirname\n _logger.info(\"Save model weights into {}\".format(weights_file))\n shapes = {}\n for var in graph.program.list_vars():\n if var.persistable and str(var.type) != 'VarType.READER':\n shapes[var.name] = var.shape\n SHAPES_FILE = os.path.join(dirname, _SHAPES_FILE)\n if not os.path.exists(dirname):\n os.makedirs(dirname)\n with open(SHAPES_FILE, \"w\") as f:\n json.dump(shapes, f)\n _logger.info(\"Save shapes of weights into {}\".format(SHAPES_FILE))\n\n groups = {}\n for op in graph.ops():\n if 'conv2d' in op.type():\n filter_name = op.inputs('Filter')[0].name()\n groups[filter_name] = op.attr('groups')\n\n GROUPS_FILE = os.path.join(dirname, _GROUPS_FILE)\n with open(GROUPS_FILE, \"w\") as f:\n json.dump(groups, f)\n _logger.info(\"Save groups of cnov2d into {}\".format(GROUPS_FILE))","def save(self, path=None):\n if path is None:\n path = os.path.join(logger.get_dir(), \"model.pkl\")\n\n with tempfile.TemporaryDirectory() as td:\n save_state(os.path.join(td, \"model\"))\n arc_name = os.path.join(td, \"packed.zip\")\n with zipfile.ZipFile(arc_name, 'w') as zipf:\n for root, dirs, files in os.walk(td):\n for fname in files:\n file_path = os.path.join(root, fname)\n if file_path != arc_name:\n zipf.write(file_path, os.path.relpath(file_path, td))\n with open(arc_name, \"rb\") as f:\n model_data = f.read()\n with open(path, \"wb\") as f:\n cloudpickle.dump((model_data, self._act_params), f)","def saveModel(self, modelFilepath):\n\n if self.memory is None:\n raise Exception('Memory not constructed - cannot save model')\n \n saveDict = {\n 'memorySize' : self.memorySize,\n 'windowSize' : self.windowSize,\n 'optimizer' : self.optimizer,\n 'inputDimension' : self.inputDimension,\n 'encoderStateSize' : self.encoderStateSize,\n 'lstmStateSize' : self.lstmStateSize,\n 'memory' : self.memory,\n 'q' : self.q,\n 'gruEncoder' : self.gruEncoder.get_weights(),\n 'lstm' : self.lstm.get_weights(),\n 'W' : self.W.read_value(),\n 'A' : self.memOut.A.read_value(),\n 'b' : self.b.read_value()\n }\n\n fl = open(modelFilepath, 'wb')\n pickle.dump(saveDict, fl)\n fl.close()","def save_weights(self, save_dir: Path, is_best: bool = False) -> None:\n if is_best:\n save_path = save_dir.expanduser() / self.BEST_SAVE_NAME\n else:\n save_path = save_dir.expanduser() / self.SAVE_NAME\n torch.save(self.model.state_dict(), save_path)","def save_model(learn, name):\n# callback_fns = learn.callback_fns # preserve wandb callback and others\n# callbacks = learn.callbacks\n \n# learn.callback_fns = [] # clean callbacks\n# learn.callbacks = []\n \n learn.save(PATH_TO_MODELS / name) # save only weights, adds .pth automatically\n learn.export(PATH_TO_MODELS / f\"{name}.pkl\") # serialize entire model, need to add .pkl","def save_model(self):\n\n # =============================================================\n # Default : pickle the trained model. Change this (and the load\n # function, below) only if the library you used does not support\n # pickling.\n # self.Model_made.save(\"Model_made.h5\")\n # self.Model_claim.save(\"Model_claim.h5\")\n # Model_made = self.Model_made\n # Model_claim = self.Model_claim\n # self.Model_made = None\n # self.Model_claim = None\n with open('pricing_model.p', 'wb') as target:\n pickle.dump(self, target)\n\n # self.Model_made = Model_made\n # self.Model_claim = Model_claim\n\n # zipObj = ZipFile(\"model.zip\",\"w\")\n # zipObj.write(\"Model_made.h5\")\n # zipObj.write(\"Model_claim.h5\")\n # zipObj.write(\"pricing_model.p\")\n # zipObj.close()","def save_model(self):\n torch.save(self.get_params(), 'code/lr-model.pt')","def save(self, path):\n with tempfile.TemporaryDirectory() as td:\n U.save_state(os.path.join(td, \"model\"))\n arc_name = os.path.join(td, \"packed.zip\")\n with zipfile.ZipFile(arc_name, 'w') as zipf:\n for root, dirs, files in os.walk(td):\n for fname in files:\n file_path = os.path.join(root, fname)\n if file_path != arc_name:\n zipf.write(file_path, os.path.relpath(file_path, td))\n with open(arc_name, \"rb\") as f:\n model_data = f.read()\n with open(path, \"wb\") as f:\n dill.dump((model_data, self._act_params), f)","def save_model(self, path):\n try:\n # os.makedirs(osp.dirname(path), exist_ok=1)\n joblib.dump(self.model, path)\n except Exception as e:\n print(e)\n print(\"Couldn't save scikit learn model on path {}!\".format(path))","def save_model(self, path=\"/model\"):\n state = {\n 'epoch': self.epoch_counter,\n 'state_dict': self.net.state_dict(),\n 'optimizer': self.optimizer.state_dict()\n }\n torch.save(state, path)","def save_model(self):\n joblib.dump(self.pipeline, \"model.joblib\")","def _save(self, tmp_checkpoint_dir):\n checkpoint_path = os.path.join(tmp_checkpoint_dir, \"model_weights\")\n self.model.save_weights(checkpoint_path, save_format=\"tf\")\n return tmp_checkpoint_dir","def write_keras_model_to_file(keras_model, file_path):\n keras_model.save(file_path)","def save_model(model):\n model.to_disk(\"../model/custom_ner_model\")","def save_model(self, path):\n save_path = self._saver.save(self._sess, path + '/model.ckp')\n\n attrs_to_save = {\n '_m': self._m,\n '_n': self._n,\n '_neighbourhood': self._neighbourhood,\n # '_topography': self._topography,\n '_num_iterations': self._num_iterations,\n '_Wts': self._Wts,\n '_locations': self._locations,\n '_centroid_grid': self._centroid_grid,\n '_learned': self._learned,\n 'abnormal_dist': self.abnormal_dist\n }\n\n output = open(path + '/som.pkl', 'wb')\n pickle.dump(attrs_to_save, output)\n output.close()\n print(\"Model saved in path: %s\" % save_path)\n\n pd.DataFrame(self._centroid_grid).to_csv(path + '/grid.csv', header=False, index=False)\n print('Grid saved to ' + path + ' for easy reading')","def save_model(model, model_filepath):\n joblib.dump(model, model_filepath)","def save_model(model, model_filepath):\n joblib.dump(model, model_filepath)","def save_model(model, model_filepath):\n joblib.dump(model, model_filepath)","def save_model(self):\n pickle.dump(self, open(\"Logistic_Regression_Model.pkl\", \"wb\"))","def save_model_wandb(save_path: str):\n wandb.save(os.path.abspath(save_path))","def save_weights_file(self, file_path, file_name):\n\n # Join the path with the file name and append the extension (h5)\n path = join(file_path, \"{}.h5\".format(file_name))\n\n # Store the weights\n self._cnn_model.save_weights(path)","def save_model(model, model_filepath): \n pickle.dump(model, open(model_filepath, 'wb'))","def save(path_to_model):\n pass","def save(self, filename):\n model_dict = {'model_state_dict': self.state_dict(),\n 'init_args': {\"vocab_size\": self.vocab_size,\n \"embeddings_size\": self.embeddings_size,\n \"hidden_size\": self.hidden_size,\n \"mlp_hidden_size\": self.mlp_hidden_size,\n \"dropout\": self.dropout}}\n torch.save(model_dict, filename)","def save_model(self, filename='model.pt'):\n checkpoint = {\n 'input_size': self.linear_layers[0].in_features,\n 'output_size': self.linear_layers[-1].out_features,\n 'hidden_layers': [layer.out_features for layer in self.linear_layers[:-1]],\n 'state_dict': self.state_dict()}\n torch.save(checkpoint, filename)","def save(self):\n\n self.saver.save(self.sess, self.path + '/tensorflow-model', global_step=self.counter.count)","def save_model(self):\n filename = self.name + '_words'\n f = open(filename, 'w') \n f.write(str(self.words)) \n f.close()\n \n filename2 = self.name + '_word_lengths'\n f = open(filename2, 'w') \n f.write(str(self.word_lengths)) \n f.close()\n \n filename3 = self.name + '_stems'\n f = open(filename3, 'w') \n f.write(str(self.stems)) \n f.close()\n \n filename4 = self.name + '_sentence_lengths'\n f = open(filename4, 'w') \n f.write(str(self.sentence_lengths)) \n f.close()\n \n filename5 = self.name + '_punctuation'\n f = open(filename5, 'w') \n f.write(str(self.punctuation)) \n f.close()","def save(self, path):\n print('Saving model... %s' % path)\n torch.save(self, path)","def save(self, path):\n print('Saving model... %s' % path)\n torch.save(self, path)","def save(self, path):\n print('Saving model... %s' % path)\n torch.save(self, path)","def save(self, path):\n print('Saving model... %s' % path)\n torch.save(self, path)","def save(self, path):\n print('Saving model... %s' % path)\n torch.save(self, path)","def save(self, path):\n np.savez_compressed(path, **self.model_dict)"],"string":"[\n \"def save_model_weights(self, filename):\\n self.model.save_weights(filename)\",\n \"def save_model(self, file_name):\\n\\t\\tself.model.save_weights(file_name)\",\n \"def save(self, filename):\\n self.model.save_weights(filename)\",\n \"def save_model(self, model_filename):\\n self.model.save_weights(model_filename)\",\n \"def save_weights(self, the_path):\\n torch.save(self.model.state_dict(), the_path)\",\n \"def save(self, weights_file):\\r\\n \\r\\n self.model.save_weights(weights_file)\",\n \"def saveModel(self):\\n self._model.save_weights('./my_model')\\n return None\",\n \"def save_model(self, output_path):\\n joblib.dump(self.dtr, output_path)\",\n \"def save_model(self):\\n saved_path = self.config.path_tmp / self.model.model_name\\n saved_path.mkdir(parents=True, exist_ok=True)\\n self.model.save_weights(str(saved_path / 'model.vec'))\",\n \"def save_weight(model):\\n file = h5py.File(WEIGHT_SAVE, 'w')\\n weight = model.get_weights()\\n for i in range(len(weight)):\\n file.create_dataset('weight' + str(i), data=weight[i])\\n file.close()\",\n \"def save_model(self, dir_path):\\n np.savez(\\n dir_path + os.path.sep + \\\"weights.npz\\\", W1=self.W1, W2=self.W2, W3=self.W3\\n )\\n np.savez(\\n dir_path + os.path.sep + \\\"biases.npz\\\", b1=self.b1, b2=self.b2, b3=self.b3\\n )\",\n \"def save_model(self):\\n save_folder = os.path.join(self.log_path, \\\"models\\\", \\\"weights_{}\\\".format(self.epoch))\\n if not os.path.exists(save_folder):\\n os.makedirs(save_folder)\\n\\n for model_name, model in self.models.items():\\n print(\\\"MODEL NAME = {}\\\".format(model_name))\\n save_path = os.path.join(save_folder, \\\"{}.pth\\\".format(model_name))\\n to_save = model.state_dict()\\n if model_name == 'encoder':\\n # save the sizes - these are needed at prediction time\\n to_save['height'] = self.height\\n to_save['width'] = self.width\\n torch.save(to_save, save_path)\\n\\n save_path = os.path.join(save_folder, \\\"{}.pth\\\".format(\\\"adam\\\"))\\n torch.save(self.model_optimizer.state_dict(), save_path)\",\n \"def save(self, filename, overwrite=False):\\n self.model.save_weights(filename, overwrite=overwrite)\",\n \"def save_model(self):\\n\\n print('Save model')\\n self.feature_extractor.save_weights(\\n self.path_save_model + self.name_model + '.h5')\\n\\n print('Mean and std')\\n np.save(self.path_save_model + 'mean.npy', self.mean)\\n np.save(self.path_save_model + 'std.npy', self.std)\",\n \"def save_model_weights(model, filename, verbose=1, cp_folder=\\\"\\\"):\\n if verbose:\\n print(f\\\"\\\\n -> Saving weights to {os.path.join(cp_folder, filename)}\\\\n\\\")\\n torch.save(model.state_dict(), os.path.join(cp_folder, filename))\",\n \"def save_model(self):\\n save_folder = os.path.join(self.log_path, \\\"models\\\", \\\"weights_{}\\\".format(self.epoch))\\n if not os.path.exists(save_folder):\\n os.makedirs(save_folder)\\n\\n for model_name in [\\\"encoder\\\", \\\"decoder\\\"]:\\n save_path = os.path.join(save_folder, \\\"{}.pth\\\".format(model_name))\\n if model_name == 'encoder':\\n to_save = self.encoder.state_dict()\\n # save the sizes - these are needed at prediction time\\n to_save['height'] = self.opt.height\\n to_save['width'] = self.opt.width\\n else:\\n to_save = self.decoder.state_dict()\\n torch.save(to_save, save_path)\\n\\n save_path = os.path.join(save_folder, \\\"{}.pth\\\".format(\\\"adam\\\"))\\n torch.save(self.optimizer.state_dict(), save_path)\",\n \"def save_weights(self, path: str):\\n torch.save(self.state_dict(), path)\",\n \"def save_weights(self, path: str):\\n torch.save(self.state_dict(), path)\",\n \"def save(self, filename):\\n # serialize model to JSON\\n model_json = self._model.to_json()\\n with open('models/' + filename + \\\".json\\\", \\\"w\\\") as json_file:\\n json_file.write(model_json)\\n\\n # serialize weights to HDF5\\n self._model.save_weights('models/' + filename + \\\".h5\\\")\\n print(\\\"Saved model to disk\\\")\",\n \"def save_model_weight(model, filename):\\n weights = model.get_weights()\\n with open (filename, 'wb') as obj:\\n pkl.dump(weights, obj, pkl.HIGHEST_PROTOCOL)\",\n \"def save_weights(self, filepath, overwrite=True):\\n self.model.save_weights(filepath=filepath, overwrite=overwrite,\\n save_format=None)\",\n \"def save_model(self, output_model: ModelEntity):\\n logger.info(\\\"called save_model\\\")\\n buffer = io.BytesIO()\\n hyperparams_str = ids_to_strings(cfg_helper.convert(self._hyperparams, dict, enum_to_str=True))\\n labels = {label.name: label.color.rgb_tuple for label in self._labels}\\n model_ckpt = torch.load(self._model_ckpt)\\n modelinfo = {\\n \\\"model\\\": model_ckpt,\\n \\\"config\\\": hyperparams_str,\\n \\\"labels\\\": labels,\\n \\\"VERSION\\\": 1,\\n }\\n\\n torch.save(modelinfo, buffer)\\n output_model.set_data(\\\"weights.pth\\\", buffer.getvalue())\\n output_model.set_data(\\n \\\"label_schema.json\\\",\\n label_schema_to_bytes(self._task_environment.label_schema),\\n )\\n output_model.precision = self._precision\",\n \"def save_model(self, model):\\n # serialize model to JSON\\n model_json = model.to_json()\\n os.makedirs(os.path.dirname(self.model_json_path), exist_ok=True)\\n with open(self.model_json_path, \\\"w\\\") as json_file:\\n json_file.write(model_json)\\n\\n # serialize weights to HDF5\\n model.save_weights(self.model_weights_path)\\n print(\\\"Saved model to disk\\\")\",\n \"def save_weights(self, path):\\n Path(path).mkdir(parents=True, exist_ok=True)\\n self.model.save_weights(path)\",\n \"def save_weights(self, location: str):\\n\\n # import torch\\n torch = import_optional_dependency(\\\"torch\\\")\\n torch.save(self.model.state_dict(), self._set_save_location(location))\",\n \"def save(self, model_path: str) -> None:\\n metadata_string = json.dumps({ \\\"classes\\\": self.classes })\\n with open(os.path.join(model_path, \\\"metadata.json\\\"), \\\"w\\\") as metadata_file:\\n metadata_file.write(metadata_string)\\n with self.graph.as_default():\\n with self.session.as_default():\\n self.model.save_weights(os.path.join(model_path, \\\"weights.h5\\\"))\",\n \"def save_weights(self, file):\\n self.model.save_weights(file)\\n return\",\n \"def save_model_weights(self, fp=None, **kwds):\\n n_epoch = self._cur_epoch\\n if fp is None:\\n fp = self.dir_model / f'weights_epoch{n_epoch}.pt'\\n torch.save(self.model.state_dict(), fp, **kwds)\",\n \"def save_weights(self):\\n np.save(\\\"weights.npy\\\", self.model.parameters)\\n return \\\"weights.npy\\\"\",\n \"def save(self, output_path):\\r\\n self.graph.cleanup().toposort()\\r\\n model = gs.export_onnx(self.graph)\\r\\n output_path = os.path.realpath(output_path)\\r\\n os.makedirs(os.path.dirname(output_path), exist_ok=True)\\r\\n onnx.save(model, output_path)\\r\\n log.info(\\\"Saved ONNX model to {}\\\".format(output_path))\",\n \"def save(self, weight_path, vocab_path, output_path, binary=False):\\n w2v_save_model(weight_path.encode(\\\"ascii\\\"),\\n vocab_path.encode(\\\"ascii\\\"), \\n output_path.encode(\\\"ascii\\\"),\\n self.minCount, binary)\\n excpt = check_server_exception()\\n if excpt[\\\"status\\\"]:\\n raise RuntimeError(excpt[\\\"info\\\"])\",\n \"def save_weights(self, file_path, format=None):\\n _save_weights(self, file_path, format)\",\n \"def save(self, folder):\\n self.generator.save_weights('%s/generator.h5'%folder)\\n self.critic.save_weights('%s/critic.h5'%folder)\",\n \"def save_model(self, path='./model_checkpoint', name='tf_model'):\\n json_config = self._model.to_json()\\n with open(os.path.join(path, name + '.json'), 'w') as json_file:\\n json_file.write(json_config)\\n weights_path = os.path.join(path, name + '_weights.h5')\\n self._model.save_weights(weights_path)\",\n \"def save(self, model_out_file):\\n\\t\\tvariables_dict = {v.name: v for v in tf.global_variables()}\\n\\t\\tvalues_dict = self.sess.run(variables_dict)\\n\\t\\tnp.savez(open(model_out_file, 'wb'), **values_dict)\",\n \"def _save_model_weights(model_weights, model_weights_dir, epoch_idx):\\n model_weights_path = os.path.join(model_weights_dir,\\n f\\\"model_epoch_{epoch_idx}.pth\\\")\\n torch.save(model_weights, model_weights_path)\",\n \"def save(model: nn.Module, path):\\n save_model(model, path)\",\n \"def save(self) -> None:\\n self.saver.save_model_and_weights(self.model)\\n self.saver.save_data_shuffle_indices(\\n self.data.eval_shuffler.ds_inds\\n )\\n self.saver.save_input_scaler(self.data.x.scaler)\",\n \"def save_model(self, output_dir):\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n\\n logger.info('Saving model')\\n dst_config_file = os.path.join(output_dir, self.CONFIG_FILE)\\n if self.fullpath_input_configfile != dst_config_file:\\n shutil.copy(self.fullpath_input_configfile, dst_config_file)\\n\\n pickle.dump(self.word_det_rfc,\\n open(os.path.join(output_dir, self.WORD_DET_RFC), 'wb'))\\n pickle.dump(self.reg_coeffs, open(\\n os.path.join(output_dir, self.REGRESSION_PARAMS), 'wb'))\",\n \"def _save_model(self):\\n with open(self.filepath, 'wb') as file:\\n pickle.dump(self.cmodel, file)\",\n \"def save_model(self):\\n\\n self.check_model()\\n\\n with open(self.filename, 'wb') as file:\\n pickle.dump({'model': self.model, 'vec': self.vectorizer, 'vec_data': self.vectorized_data,\\n 'df': self.df_topic_keywords}, file)\",\n \"def save_model(model, filename=\\\"model.json\\\"):\\n model_json = model.to_json()\\n with open(filename, \\\"w\\\") as json_file:\\n json_file.write(model_json)\\n model.save_weights(\\\"model.h5\\\")\\n print(\\\"Saved model to disk\\\")\",\n \"def save_model(model, model_filepath):\",\n \"def save_weights_model(self, list_path):\\n [path_encoder, path_decoder, path_discriminator, path_scaler] = list_path\\n self.encode_.save_weights(path_encoder)\\n self.decode_.save_weights(path_decoder)\\n self.b.save_weights(path_discriminator)\\n joblib.dump(self.scaler, path_scaler + 'scaler.pkl')\",\n \"def save_model(model, model_path) -> None:\\n try:\\n createFolder(model_path)\\n exportJSON(model.to_json(), model_path+'/model.json')\\n model.save_weights(model_path+'/model_weights.h5')\\n except Exception as error:\\n print(f\\\"Error: save_model(model, {model_path}) -> {error}\\\")\",\n \"def export_model(self, output_model_dir):\\n logger.info(\\\"Exporting model to directory : {}\\\".format(output_model_dir))\\n self.model.export(output_model_dir=output_model_dir)\",\n \"def save_model(self):\\n filename=self.name + '_words'\\n file_write(filename, self.words)\\n\\n filename2=self.name+'_word_lengths'\\n file_write(filename2, self.word_lengths)\\n\\n filename3=self.name+'_stems'\\n file_write(filename3, self.stems)\\n\\n filename4=self.sentence_lengths+'_sentence_lengths'\\n file_write(filename4, self.sentence_lengths)\\n\\n filename5= self.endings+'_endings'\\n file_write(filename5, self.endings)\",\n \"def save(self, name):\\n if self.model is None:\\n raise Exception(\\\"Build the model first!\\\")\\n\\n if os.path.isdir(self.config[\\\"model\\\"][\\\"checkpoint_path\\\"]) is False:\\n os.makedirs(self.config[\\\"model\\\"][\\\"checkpoint_path\\\"])\\n\\n print(\\\"Saving model...\\\")\\n self.model.save_weights(self.config[\\\"model\\\"][\\\"checkpoint_path\\\"] + name)\\n print(\\\"Model saved!\\\")\",\n \"def save(self, name):\\n if self.model is None:\\n raise Exception(\\\"Build the model first!\\\")\\n\\n if os.path.isdir(self.config[\\\"model\\\"][\\\"checkpoint_path\\\"]) is False:\\n os.makedirs(self.config[\\\"model\\\"][\\\"checkpoint_path\\\"])\\n\\n print(\\\"Saving model...\\\")\\n self.model.save_weights(self.config[\\\"model\\\"][\\\"checkpoint_path\\\"] + name)\\n print(\\\"Model saved!\\\")\",\n \"def save_model(self,\\n file_path: str = \\\"models/world_model.h5\\\"\\n ):\\n self.model.save(file_path)\",\n \"def save(self, filename):\\n hebbian_weights = open(filename, \\\"w\\\")\\n for i in xrange(self.hidden):\\n hebbian_weights.write(\\\"\\\\t\\\".join(self.vis_layer[i].get_weights()) + '\\\\n')\\n for i in xrange(self.layers):\\n for j in xrange(self.hidden):\\n hebbian_weights.write(\\\"\\\\t\\\".join(self.hidden_layers[i][j].get_weights()) + '\\\\n')\\n hebbian_weights.write(\\\"\\\\t\\\".join(self.output_neuron.get_weights()) + '\\\\n')\\n hebbian_weights.close()\",\n \"def save_model(model, output):\\n\\n # model.save(os.path.join(output))\\n tf.saved_model.save(model, os.path.join(output, \\\"1\\\"))\\n\\n # tf.saved_model.save(model, os.path.join(output, \\\"1\\\"))\\n print(\\\"Model successfully saved at: {}\\\".format(output))\",\n \"def save(self, prefix):\\n model_file = prefix + \\\".json\\\"\\n weight_file = prefix + \\\".h5\\\"\\n json.dump(self.model.to_json(), open(model_file, \\\"w\\\"))\\n self.model.save_weights(weight_file)\\n return self\",\n \"def save_model(self, model, model_filepath):\\n joblib.dump(model, model_filepath)\",\n \"def save_model(self, fpath):\\n self._make_model_folder(fpath)\\n self.model.save(os.path.join(fpath, U.MODEL_NAME), save_format=\\\"h5\\\")\\n return\",\n \"def save_model(self):\\n print(\\\"\\\\nModels are integrated to be multi scale.\\\\nSaving to disk.\\\")\\n self.column_names = [ \\\"x_\\\" + str(x) for x in range(self.embedding.shape[1])]\\n self.embedding = pd.DataFrame(self.embedding, columns = self.column_names)\\n self.embedding.to_csv(self.args.output, index = None)\",\n \"def save_model(self, model_learnable: ModelLearnable, fl_ctx: FLContext):\\n if model_learnable:\\n if fl_ctx.get_prop(AppConstants.CURRENT_ROUND) == fl_ctx.get_prop(AppConstants.NUM_ROUNDS) - 1:\\n self.logger.info(f\\\"Saving received model to {os.path.abspath(self.save_path)}\\\")\\n # save 'weights' which contains model parameters\\n model = model_learnable[ModelLearnableKey.WEIGHTS]\\n dump(model, self.save_path, compress=1)\",\n \"def save_model(self):\\n # words dictionary\\n filename = self.name + \\\"_words\\\"\\n f = open(filename, 'w')\\n f.write(str(self.words))\\n f.close()\\n\\n # word_lengths dictionary\\n filename = self.name + \\\"_word_lengths\\\"\\n f = open(filename, 'w')\\n f.write(str(self.word_lengths))\\n f.close()\\n\\n # stems dictionary\\n filename = self.name + \\\"_stems\\\"\\n f = open(filename, 'w')\\n f.write(str(self.stems))\\n f.close()\\n\\n # sentence_lengths dictionary\\n filename = self.name + \\\"_sentence_lengths\\\"\\n f = open(filename, 'w')\\n f.write(str(self.sentence_lengths))\\n f.close()\\n\\n # ten most common words\\n filename = self.name + \\\"_common_word\\\"\\n f = open(filename, 'w')\\n f.write(str(self.common_word))\\n f.close()\",\n \"def save(self, fpath):\\n logging.info(\\\"Saving agent with filepath={}\\\".format(fpath))\\n self.agent.save_weights(fpath, overwrite=True)\",\n \"def save(self):\\n print(\\\"==> Saving model to\\\", self.model_dir)\\n self.model.save(self.model_dir)\",\n \"def save_model(self):\\n self.pred_net.save((self.save_path / \\\"iqn_pred_net\\\").absolute().as_posix())\\n self.target_net.save((self.save_path / \\\"iqn_target_net\\\").absolute().as_posix())\",\n \"def save(self, save_path):\\n # params\\n model_params = {\\n \\\"batch_size\\\": self.batch_size,\\n \\\"lr\\\": self.lr,\\n \\\"epsilon\\\": self.epsilon,\\n \\\"gamma\\\": self.gamma,\\n \\\"epsilon_min\\\": self.epsilon_min,\\n \\\"epsilon_decay\\\": self.epsilon_decay,\\n \\\"memory\\\": self.memory,\\n \\\"observation_space\\\": self.observation_space,\\n \\\"action_space\\\": self.action_space,\\n \\\"_seed\\\": self._seed,\\n }\\n\\n serialized_params = data_to_json(model_params)\\n self.policy.save(save_path + \\\".h5\\\")\\n\\n # Check postfix if save_path is a string\\n if isinstance(save_path, str):\\n _, ext = os.path.splitext(save_path)\\n if ext == \\\"\\\":\\n save_path += \\\".zip\\\"\\n\\n # Create a zip-archive and write our params\\n # there. This works when save_path\\n # is either str or a file-like\\n with zipfile.ZipFile(save_path, \\\"w\\\") as file_:\\n # Do not try to save \\\"None\\\" elements\\n file_.writestr(\\\"parameters\\\", serialized_params)\",\n \"def save_model(self, model_path: str):\",\n \"def save_weights(model, weights_dir, epoch):\\n weights_fname = 'weights-%s.pth' % (epoch)\\n weights_fpath = os.path.join(weights_dir, weights_fname)\\n torch.save({'state_dict': model.state_dict()}, weights_fpath)\\n return weights_fpath\",\n \"def save_graph(self):\\n with tf.Session(graph=self.graph) as sess:\\n saver = tf.train.Saver()\\n sess.run(tf.global_variables_initializer())\\n\\n save_path = saver.save(sess, os.path.join(MODELS_PATH, \\\"model\\\"))\\n print(\\\"Model saved in path: %s\\\" % save_path)\\n\\n with open(os.path.join(MODELS_PATH, \\\".model.inputs\\\"), \\\"w\\\") as file:\\n for v in self.inputs.values():\\n file.write(v.name + \\\"\\\\n\\\")\\n with open(os.path.join(MODELS_PATH, \\\".model.output\\\"), \\\"w\\\") as file:\\n file.write(self.output.name)\",\n \"def save_model(self, model_file):\\n net_params = self.get_policy_param() # get model params\\n torch.save(net_params, model_file)\",\n \"def saveModel(self):\\n with open(self.modelSaveFile, 'wb') as f:\\n pickle.dump(self.values, f, pickle.HIGHEST_PROTOCOL)\\n pickle.dump(self.policy, f, pickle.HIGHEST_PROTOCOL)\",\n \"def save_model(exe, graph, dirname):\\n assert graph is not None and dirname is not None\\n graph = GraphWrapper(graph) if isinstance(graph,\\n paddle.static.Program) else graph\\n\\n paddle.static.save(program=graph.program, model_path=dirname)\\n weights_file = dirname\\n _logger.info(\\\"Save model weights into {}\\\".format(weights_file))\\n shapes = {}\\n for var in graph.program.list_vars():\\n if var.persistable and str(var.type) != 'VarType.READER':\\n shapes[var.name] = var.shape\\n SHAPES_FILE = os.path.join(dirname, _SHAPES_FILE)\\n if not os.path.exists(dirname):\\n os.makedirs(dirname)\\n with open(SHAPES_FILE, \\\"w\\\") as f:\\n json.dump(shapes, f)\\n _logger.info(\\\"Save shapes of weights into {}\\\".format(SHAPES_FILE))\\n\\n groups = {}\\n for op in graph.ops():\\n if 'conv2d' in op.type():\\n filter_name = op.inputs('Filter')[0].name()\\n groups[filter_name] = op.attr('groups')\\n\\n GROUPS_FILE = os.path.join(dirname, _GROUPS_FILE)\\n with open(GROUPS_FILE, \\\"w\\\") as f:\\n json.dump(groups, f)\\n _logger.info(\\\"Save groups of cnov2d into {}\\\".format(GROUPS_FILE))\",\n \"def save(self, path=None):\\n if path is None:\\n path = os.path.join(logger.get_dir(), \\\"model.pkl\\\")\\n\\n with tempfile.TemporaryDirectory() as td:\\n save_state(os.path.join(td, \\\"model\\\"))\\n arc_name = os.path.join(td, \\\"packed.zip\\\")\\n with zipfile.ZipFile(arc_name, 'w') as zipf:\\n for root, dirs, files in os.walk(td):\\n for fname in files:\\n file_path = os.path.join(root, fname)\\n if file_path != arc_name:\\n zipf.write(file_path, os.path.relpath(file_path, td))\\n with open(arc_name, \\\"rb\\\") as f:\\n model_data = f.read()\\n with open(path, \\\"wb\\\") as f:\\n cloudpickle.dump((model_data, self._act_params), f)\",\n \"def saveModel(self, modelFilepath):\\n\\n if self.memory is None:\\n raise Exception('Memory not constructed - cannot save model')\\n \\n saveDict = {\\n 'memorySize' : self.memorySize,\\n 'windowSize' : self.windowSize,\\n 'optimizer' : self.optimizer,\\n 'inputDimension' : self.inputDimension,\\n 'encoderStateSize' : self.encoderStateSize,\\n 'lstmStateSize' : self.lstmStateSize,\\n 'memory' : self.memory,\\n 'q' : self.q,\\n 'gruEncoder' : self.gruEncoder.get_weights(),\\n 'lstm' : self.lstm.get_weights(),\\n 'W' : self.W.read_value(),\\n 'A' : self.memOut.A.read_value(),\\n 'b' : self.b.read_value()\\n }\\n\\n fl = open(modelFilepath, 'wb')\\n pickle.dump(saveDict, fl)\\n fl.close()\",\n \"def save_weights(self, save_dir: Path, is_best: bool = False) -> None:\\n if is_best:\\n save_path = save_dir.expanduser() / self.BEST_SAVE_NAME\\n else:\\n save_path = save_dir.expanduser() / self.SAVE_NAME\\n torch.save(self.model.state_dict(), save_path)\",\n \"def save_model(learn, name):\\n# callback_fns = learn.callback_fns # preserve wandb callback and others\\n# callbacks = learn.callbacks\\n \\n# learn.callback_fns = [] # clean callbacks\\n# learn.callbacks = []\\n \\n learn.save(PATH_TO_MODELS / name) # save only weights, adds .pth automatically\\n learn.export(PATH_TO_MODELS / f\\\"{name}.pkl\\\") # serialize entire model, need to add .pkl\",\n \"def save_model(self):\\n\\n # =============================================================\\n # Default : pickle the trained model. Change this (and the load\\n # function, below) only if the library you used does not support\\n # pickling.\\n # self.Model_made.save(\\\"Model_made.h5\\\")\\n # self.Model_claim.save(\\\"Model_claim.h5\\\")\\n # Model_made = self.Model_made\\n # Model_claim = self.Model_claim\\n # self.Model_made = None\\n # self.Model_claim = None\\n with open('pricing_model.p', 'wb') as target:\\n pickle.dump(self, target)\\n\\n # self.Model_made = Model_made\\n # self.Model_claim = Model_claim\\n\\n # zipObj = ZipFile(\\\"model.zip\\\",\\\"w\\\")\\n # zipObj.write(\\\"Model_made.h5\\\")\\n # zipObj.write(\\\"Model_claim.h5\\\")\\n # zipObj.write(\\\"pricing_model.p\\\")\\n # zipObj.close()\",\n \"def save_model(self):\\n torch.save(self.get_params(), 'code/lr-model.pt')\",\n \"def save(self, path):\\n with tempfile.TemporaryDirectory() as td:\\n U.save_state(os.path.join(td, \\\"model\\\"))\\n arc_name = os.path.join(td, \\\"packed.zip\\\")\\n with zipfile.ZipFile(arc_name, 'w') as zipf:\\n for root, dirs, files in os.walk(td):\\n for fname in files:\\n file_path = os.path.join(root, fname)\\n if file_path != arc_name:\\n zipf.write(file_path, os.path.relpath(file_path, td))\\n with open(arc_name, \\\"rb\\\") as f:\\n model_data = f.read()\\n with open(path, \\\"wb\\\") as f:\\n dill.dump((model_data, self._act_params), f)\",\n \"def save_model(self, path):\\n try:\\n # os.makedirs(osp.dirname(path), exist_ok=1)\\n joblib.dump(self.model, path)\\n except Exception as e:\\n print(e)\\n print(\\\"Couldn't save scikit learn model on path {}!\\\".format(path))\",\n \"def save_model(self, path=\\\"/model\\\"):\\n state = {\\n 'epoch': self.epoch_counter,\\n 'state_dict': self.net.state_dict(),\\n 'optimizer': self.optimizer.state_dict()\\n }\\n torch.save(state, path)\",\n \"def save_model(self):\\n joblib.dump(self.pipeline, \\\"model.joblib\\\")\",\n \"def _save(self, tmp_checkpoint_dir):\\n checkpoint_path = os.path.join(tmp_checkpoint_dir, \\\"model_weights\\\")\\n self.model.save_weights(checkpoint_path, save_format=\\\"tf\\\")\\n return tmp_checkpoint_dir\",\n \"def write_keras_model_to_file(keras_model, file_path):\\n keras_model.save(file_path)\",\n \"def save_model(model):\\n model.to_disk(\\\"../model/custom_ner_model\\\")\",\n \"def save_model(self, path):\\n save_path = self._saver.save(self._sess, path + '/model.ckp')\\n\\n attrs_to_save = {\\n '_m': self._m,\\n '_n': self._n,\\n '_neighbourhood': self._neighbourhood,\\n # '_topography': self._topography,\\n '_num_iterations': self._num_iterations,\\n '_Wts': self._Wts,\\n '_locations': self._locations,\\n '_centroid_grid': self._centroid_grid,\\n '_learned': self._learned,\\n 'abnormal_dist': self.abnormal_dist\\n }\\n\\n output = open(path + '/som.pkl', 'wb')\\n pickle.dump(attrs_to_save, output)\\n output.close()\\n print(\\\"Model saved in path: %s\\\" % save_path)\\n\\n pd.DataFrame(self._centroid_grid).to_csv(path + '/grid.csv', header=False, index=False)\\n print('Grid saved to ' + path + ' for easy reading')\",\n \"def save_model(model, model_filepath):\\n joblib.dump(model, model_filepath)\",\n \"def save_model(model, model_filepath):\\n joblib.dump(model, model_filepath)\",\n \"def save_model(model, model_filepath):\\n joblib.dump(model, model_filepath)\",\n \"def save_model(self):\\n pickle.dump(self, open(\\\"Logistic_Regression_Model.pkl\\\", \\\"wb\\\"))\",\n \"def save_model_wandb(save_path: str):\\n wandb.save(os.path.abspath(save_path))\",\n \"def save_weights_file(self, file_path, file_name):\\n\\n # Join the path with the file name and append the extension (h5)\\n path = join(file_path, \\\"{}.h5\\\".format(file_name))\\n\\n # Store the weights\\n self._cnn_model.save_weights(path)\",\n \"def save_model(model, model_filepath): \\n pickle.dump(model, open(model_filepath, 'wb'))\",\n \"def save(path_to_model):\\n pass\",\n \"def save(self, filename):\\n model_dict = {'model_state_dict': self.state_dict(),\\n 'init_args': {\\\"vocab_size\\\": self.vocab_size,\\n \\\"embeddings_size\\\": self.embeddings_size,\\n \\\"hidden_size\\\": self.hidden_size,\\n \\\"mlp_hidden_size\\\": self.mlp_hidden_size,\\n \\\"dropout\\\": self.dropout}}\\n torch.save(model_dict, filename)\",\n \"def save_model(self, filename='model.pt'):\\n checkpoint = {\\n 'input_size': self.linear_layers[0].in_features,\\n 'output_size': self.linear_layers[-1].out_features,\\n 'hidden_layers': [layer.out_features for layer in self.linear_layers[:-1]],\\n 'state_dict': self.state_dict()}\\n torch.save(checkpoint, filename)\",\n \"def save(self):\\n\\n self.saver.save(self.sess, self.path + '/tensorflow-model', global_step=self.counter.count)\",\n \"def save_model(self):\\n filename = self.name + '_words'\\n f = open(filename, 'w') \\n f.write(str(self.words)) \\n f.close()\\n \\n filename2 = self.name + '_word_lengths'\\n f = open(filename2, 'w') \\n f.write(str(self.word_lengths)) \\n f.close()\\n \\n filename3 = self.name + '_stems'\\n f = open(filename3, 'w') \\n f.write(str(self.stems)) \\n f.close()\\n \\n filename4 = self.name + '_sentence_lengths'\\n f = open(filename4, 'w') \\n f.write(str(self.sentence_lengths)) \\n f.close()\\n \\n filename5 = self.name + '_punctuation'\\n f = open(filename5, 'w') \\n f.write(str(self.punctuation)) \\n f.close()\",\n \"def save(self, path):\\n print('Saving model... %s' % path)\\n torch.save(self, path)\",\n \"def save(self, path):\\n print('Saving model... %s' % path)\\n torch.save(self, path)\",\n \"def save(self, path):\\n print('Saving model... %s' % path)\\n torch.save(self, path)\",\n \"def save(self, path):\\n print('Saving model... %s' % path)\\n torch.save(self, path)\",\n \"def save(self, path):\\n print('Saving model... %s' % path)\\n torch.save(self, path)\",\n \"def save(self, path):\\n np.savez_compressed(path, **self.model_dict)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80955356","0.7926381","0.7886226","0.7832939","0.7832589","0.77854276","0.77565","0.7726169","0.77205503","0.77095634","0.7655661","0.7647746","0.76366","0.75701165","0.75657123","0.75270814","0.7525037","0.7525037","0.74478704","0.7430976","0.74265957","0.740892","0.7395449","0.73944044","0.73902494","0.73519987","0.7350844","0.7345354","0.73346287","0.7331106","0.7276732","0.7187931","0.7174534","0.7168121","0.71639544","0.7130689","0.7084393","0.7058415","0.7007356","0.697156","0.6968595","0.6965361","0.695412","0.6949271","0.69485366","0.6917888","0.6873875","0.6868829","0.6868829","0.6865974","0.6858605","0.68560266","0.685552","0.6855449","0.68479997","0.6841188","0.6839336","0.68263066","0.68172055","0.6800541","0.6793095","0.67875874","0.67792445","0.677807","0.67698944","0.6762306","0.6760939","0.67584884","0.6757941","0.6754816","0.67539454","0.6747233","0.6745033","0.6743922","0.6743664","0.67393094","0.67391396","0.67298824","0.6718523","0.6714361","0.67140716","0.6712045","0.6706945","0.6706945","0.6706945","0.6703099","0.669564","0.66818565","0.66792214","0.6674208","0.66727275","0.6669809","0.66694945","0.6662699","0.66601294","0.66601294","0.66601294","0.66601294","0.66601294","0.6654733"],"string":"[\n \"0.80955356\",\n \"0.7926381\",\n \"0.7886226\",\n \"0.7832939\",\n \"0.7832589\",\n \"0.77854276\",\n \"0.77565\",\n \"0.7726169\",\n \"0.77205503\",\n \"0.77095634\",\n \"0.7655661\",\n \"0.7647746\",\n \"0.76366\",\n \"0.75701165\",\n \"0.75657123\",\n \"0.75270814\",\n \"0.7525037\",\n \"0.7525037\",\n \"0.74478704\",\n \"0.7430976\",\n \"0.74265957\",\n \"0.740892\",\n \"0.7395449\",\n \"0.73944044\",\n \"0.73902494\",\n \"0.73519987\",\n \"0.7350844\",\n \"0.7345354\",\n \"0.73346287\",\n \"0.7331106\",\n \"0.7276732\",\n \"0.7187931\",\n \"0.7174534\",\n \"0.7168121\",\n \"0.71639544\",\n \"0.7130689\",\n \"0.7084393\",\n \"0.7058415\",\n \"0.7007356\",\n \"0.697156\",\n \"0.6968595\",\n \"0.6965361\",\n \"0.695412\",\n \"0.6949271\",\n \"0.69485366\",\n \"0.6917888\",\n \"0.6873875\",\n \"0.6868829\",\n \"0.6868829\",\n \"0.6865974\",\n \"0.6858605\",\n \"0.68560266\",\n \"0.685552\",\n \"0.6855449\",\n \"0.68479997\",\n \"0.6841188\",\n \"0.6839336\",\n \"0.68263066\",\n \"0.68172055\",\n \"0.6800541\",\n \"0.6793095\",\n \"0.67875874\",\n \"0.67792445\",\n \"0.677807\",\n \"0.67698944\",\n \"0.6762306\",\n \"0.6760939\",\n \"0.67584884\",\n \"0.6757941\",\n \"0.6754816\",\n \"0.67539454\",\n \"0.6747233\",\n \"0.6745033\",\n \"0.6743922\",\n \"0.6743664\",\n \"0.67393094\",\n \"0.67391396\",\n \"0.67298824\",\n \"0.6718523\",\n \"0.6714361\",\n \"0.67140716\",\n \"0.6712045\",\n \"0.6706945\",\n \"0.6706945\",\n \"0.6706945\",\n \"0.6703099\",\n \"0.669564\",\n \"0.66818565\",\n \"0.66792214\",\n \"0.6674208\",\n \"0.66727275\",\n \"0.6669809\",\n \"0.66694945\",\n \"0.6662699\",\n \"0.66601294\",\n \"0.66601294\",\n \"0.66601294\",\n \"0.66601294\",\n \"0.66601294\",\n \"0.6654733\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8475825"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84589,"cells":{"query":{"kind":"string","value":"Generates a set of examples from the trained model."},"document":{"kind":"string","value":"def plot_examples(model, clean_test, noisy_test, num_examples=15, \n randomize=False, output_path=None):\n \n if num_examples <= 0:\n raise ValueError('must generate a positive number of examples')\n \n if randomize:\n indices = np.random.choice(clean_test.shape[0], num_examples)\n else:\n indices = list(range(num_examples))\n \n cleans = tf.reshape(clean_test[indices], data_shape)\n noisys = tf.reshape(noisy_test[indices], data_shape)\n predictions = model.predict(noisy_test[indices])\n inferences = infer(noisys, model, spacing=4)\n\n titles = ['ground truth', 'augmented with gaussian noise',\n 'neural network output', 'J-invariant reconstruction']\n show_grid([cleans, noisys, predictions, inferences], titles=titles,\n output_path=output_path)"},"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_train_examples(self, data_path):\r\n return self.create_examples(self.read_data(data_path), 'train')","def get_train_examples(self):\n raise NotImplementedError()","def build_examples():\n build_models([\n \"VGG_16\",\n \"VGG_19\",\n \"RESNET_50\",\n \"MOBILENET\",\n #\"INCEPTION_V3\",\n #\"INCEPTION_RESNET\",\n #\"DENSENET_121\",\n #\"DENSENET_169\",\n #\"DENSENET_201\"])\n ])","def train_and_eval_examples(self) -> types.Channel:\n\n return self._example_gen.outputs.examples","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n\t\traise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_train_examples(self, data_dir):\n raise NotImplementedError()","def get_test_examples(self, data_path):\r\n return self.create_examples(self.read_data(data_path), 'test')","def get_train_examples(self, input_file):\r\n raise NotImplementedError()","def _create_examples(self, data, set_type):\n examples = []\n for (i, elem) in enumerate(data):\n guid = \"%s-%s\" % (set_type, i)\n text = elem[0]\n label = elem[1]\n examples.append(\n InputExample(guid=guid, text=text, label=label))\n return examples","def model_samples(self) -> List[Model]:\n return self._model_samples","def train(self, iteration, train_examples, model_path=None):\n return self.process_trained_model(\n self.train_with_examples(iteration, train_examples, model_path),\n iteration,\n train_examples,\n model_path,\n )","def _create_examples(self, data_dir, set_type):\n\t\texamples = []\n\t\tinput_file_data = os.path.join(data_dir, \"data.tsv\")\n\t\twith open(input_file_data, \"r\", encoding=\"utf-8-sig\") as f:\n\t\t\tfor i, inp in enumerate(f):\n\t\t\t\tinps = inp.split('\\t') \n\t\t\t\tguid = \"%s-%s\" % (set_type, i)\n\t\t\t\ttext_inp = inps[1].strip()\n\t\t\t\ttext_out = inps[2].strip()\n\t\t\t\texamples.append(InputExample(guid=guid, text_inp=text_inp, text_out=text_out))\n\t\t\t\t\n\t\t\t# Sort these out before returning\n\t\t\texamples = sorted(examples, key=sort_inp_len)\n\t\t\treturn examples","def get_train_full_examples(self, data_dir):\n raise NotImplementedError()","def _create_examples(self, df, mode):\n idx_tr, idx_te = next(ShuffleSplit(test_size=0.3, random_state=1234).split(df.title, df.totalViews))\n\n examples = []\n\n iterind = idx_tr if mode == \"train\" else idx_te\n\n for i in iterind:\n examples.append(\n InputExample(guid=i, text_a=df.title.values[i], label=df.totalViews.values[i]))\n\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n # labels = []\n for (i, line) in enumerate(lines):\n # ignore first header line\n if i == 0:\n continue\n if i <= 3:\n print(\"i={}, line={}\".format(i, line))\n guid = \"%s-%s\" % (set_type, i)\n if set_type == \"test\":\n text_a = tokenization.convert_to_unicode(line[0])\n label = \"0\"\n else:\n text_a = tokenization.convert_to_unicode(line[0])\n label = tokenization.convert_to_unicode(line[1])\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n # labels.append(label)\n # if set_type == \"train\":\n # self.class_weight_ = self.get_class_weight(labels, \"balanced\")\n # else:\n # self.class_weight_ = self.get_class_weight(labels, None)\n # print(\"set_type={}, class_weight_={}\".format(set_type, self.class_weight_))\n return examples","def examples(self):\n return self._examples","def get_test_examples(self, data_dir):\n \n raise NotImplementedError()","def _generate_examples(self, filepath):\n # Simultaneously iterating through the different data sets in the hdf5\n # file is >100x slower and the data set is small (26.7MB). Hence, we first\n # load everything into memory before yielding the samples.\n with tfds.core.lazy_imports.h5py.File(filepath, \"r\") as h5dataset:\n image_array = np.array(h5dataset[\"imgs\"])\n class_array = np.array(h5dataset[\"latents\"][\"classes\"])\n values_array = np.array(h5dataset[\"latents\"][\"values\"])\n\n for i, (image, classes, values) in enumerate(moves.zip(\n image_array, class_array, values_array)):\n record = dict(\n image=np.expand_dims(image, -1),\n label_shape=classes[1],\n label_scale=classes[2],\n label_orientation=classes[3],\n label_x_position=classes[4],\n label_y_position=classes[5],\n value_shape=values[1],\n value_scale=values[2],\n value_orientation=values[3],\n value_x_position=values[4],\n value_y_position=values[5])\n if self.version > \"2.0.0\":\n record[\"id\"] = \"{:06d}\".format(i)\n yield i, record","def generate_examples_serial(self):\n # Now we have a Gensim Dictionary to work with\n self._build_dictionary()\n # Remove any tokens with a frequency less than 10\n self.dictionary.filter_extremes(no_below=10, no_above=0.75)\n\n self.examples = []\n for file in tqdm(self.load_files(), desc=\"Generating Examples (serial)\"):\n file = self.dictionary.doc2idx(file)\n self.examples.extend(self._generate_examples_from_file(file))","def get_test_examples(self, data_dir):\n raise NotImplementedError()","def get_test_examples(self, data_dir):\n raise NotImplementedError()","def get_test_examples(self, data_dir):\n raise NotImplementedError()","def get_test_examples(self, data_dir):\n raise NotImplementedError()","def get_test_examples(self, data_dir):\n raise NotImplementedError()","def _generate_examples(self, data_dir_path):\n\n for class_name in tf.io.gfile.listdir(data_dir_path):\n class_dir_path = os.path.join(data_dir_path, class_name)\n for image_name in tf.io.gfile.listdir(class_dir_path):\n image = os.path.join(class_dir_path, image_name)\n yield image, {\n \"image\": image,\n \"label\": class_name,\n }","def _generate_examples(self, filepath):\n\n key = 1\n with tf.io.gfile.GFile(filepath, \"r\") as f:\n tokens = []\n tags = []\n langs = []\n for line in f:\n line = line.rstrip()\n # pylint: disable=g-explicit-bool-comparison\n if line.startswith(\"-DOCSTART-\") or line == \"\":\n if tokens:\n spans = get_spans(tokens, tags)\n yield key, {\n \"tokens\": tokens,\n \"tags\": tags,\n \"langs\": langs,\n \"spans\": spans\n }\n key += 1\n tokens = []\n tags = []\n langs = []\n else:\n # wikiann data is tab separated\n fields = line.split(\"\\t\")\n # strip out language prefix\n langs.append(fields[0].split(\":\")[0])\n tokens.append(\":\".join(fields[0].split(\":\")[1:]))\n if len(fields) > 1:\n tags.append(fields[-1])\n else:\n # examples have no label in test set\n tags.append(\"O\")\n if tokens:\n spans = get_spans(tokens, tags)\n yield key, {\n \"tokens\": tokens,\n \"tags\": tags,\n \"langs\": langs,\n \"spans\": spans\n }","def get_examples(self, env):\n return self.fam.c_get_examples(self, env)","def test_predict_from_examples():\n examples = []\n for i in range(len(DATA)):\n (value, attribute_map) = DATA[i]\n print 'tuple created : \\n1:' + str(value) + \"\\n2:\" + str(attribute_map)\n ex = VowpalExample(i, value)\n #Extracting the features from all of the namespaces in the map. \n for (featureNamespace, features) in attribute_map.items():\n #Each \"section\" is \n ex.add_section(featureNamespace, features)\n examples.append(ex)\n train = examples[:-2]\n test = examples[-2:]\n vw = Vowpal(PATH_VW, './vw.%s', {'--passes' : '10' })\n preds = vw.predict_from_examples(train, test)\n for (id, value) in preds:\n print 'prediction for %s is %s' % (id, value)","def examples(self):\n for obj_ind in range(len(self.objects)):\n yield self.get_object_intent_by_index(obj_ind)","def test_generate_all_training(self):\n facade = ChatetteFacade.get_or_create()\n\n input_dir_path = \"tests/system-testing/inputs/generate-all/\"\n input_filenames = [\n \"simplest.chatette\", \"only-words.chatette\",\n \"words-and-groups.chatette\", \"alias.chatette\", \"include.chatette\",\n \"slot.chatette\", \"slotrolegroup.chatette\"\n ]\n for filename in input_filenames:\n file_path = os.path.join(input_dir_path, filename)\n facade.run(file_path)\n if not TestSystem.check_no_duplicates(facade.train_examples):\n pytest.fail(\n \"Some examples were generated several times \" +\n \"when dealing with file '\" + filename + \"'.\\nGenerated: \" + \\\n str(facade.train_examples)\n )\n legal_examples = TestSystem.get_legal_examples(file_path)\n for ex in facade.train_examples:\n formatted_ex = {\"intent\": ex.intent_name, \"text\": ex.text}\n if formatted_ex not in legal_examples:\n pytest.fail(\n str(formatted_ex) + \" is not a legal example for '\" + \\\n file_path + \"'\"\n )\n if len(legal_examples) != len(facade.train_examples):\n training_texts = [ex.text for ex in facade.train_examples]\n for legal_ex in legal_examples:\n if legal_ex[\"text\"] not in training_texts:\n pytest.fail(\n \"Example '\" + legal_ex[\"text\"] + \\\n \"' was not generated.\"\n )\n pytest.fail(\n \"An unknown example was not generated (\" + \\\n str(len(facade.train_examples)) + \\\n \" generated instead of \" + str(len(legal_examples)) + \\\n \").\\nGenerated: \" + str(facade.train_examples)\n )\n legal_syn = TestSystem.get_legal_synonyms(file_path)\n if legal_syn is not None:\n synonyms = AST.get_or_create().get_entities_synonyms()\n for key in synonyms:\n if key not in legal_syn:\n pytest.fail(\n \"'\" + key + \"' shouldn't have any synonyms.\"\n )\n for syn in synonyms[key]:\n if syn not in legal_syn[key]:\n pytest.fail(\n \"'\" + syn + \"' shouldn't be a synonym of '\" + \\\n key + \"'\"\n )","def _generate_examples(\n self, mode: str) -> Generator[ProcessedExample, None, None]:\n if mode not in self._json_dict:\n self._json_dict[mode] = collections.defaultdict(list)\n generator = self.builder_config.example_generator(mode)\n for example in generator:\n img_id, processed_example = self._convert_raw_example(\n self._json_dict[mode], example)\n yield img_id, processed_example","def get_test_examples(self, data_dir):\n raise NotImplementedError()","def get_test_examples(self, data_dir):\n raise NotImplementedError()","def convert_examples_to_features(self):\n features = []\n for ex_index, example in enumerate(self.examples):\n taskname = example.taskname\n taskname_ids = self.tokenizer.text_to_ids(taskname)\n processor = example.processor\n if ex_index % 10000 == 0:\n logging.info(f\"Writing example {ex_index} of {len(self.examples)}\")\n enc_query = processor.get_ptune_query(\n example.content,\n self.pseudo_token_id,\n self.max_seq_length - self.max_seq_length_decoder + 1,\n self.templates,\n self.tokenizer,\n )\n features.append([enc_query, taskname_ids])\n return features","def instantiate_examples(self, examples : [dict]) -> [dict]:\n raise NotImplementedError()","def generate_store_model_samples(current_sample_list, cass_ip, cass_port):\n cluster = Cluster([cass_ip], int(cass_port))\n session = cluster.connect()\n # NOTE: None of these schema represent the best practice in Casandra schema design,\n # they are merely for simple examples:\n session.execute(\"CREATE KEYSPACE IF NOT EXISTS ml_db WITH \"\n \"REPLICATION = {'class' : 'SimpleStrategy', 'replication_factor' : 1}\")\n session.set_keyspace('ml_db')\n session.execute(\"CREATE TABLE IF NOT EXISTS all_raw_data\"\n \"(time timeuuid PRIMARY KEY, samples text)\")\n session.execute(\"CREATE TABLE IF NOT EXISTS models\"\n \"(time timeuuid, model_id int, model text, PRIMARY KEY(model_id, time))\")\n\n rows = session.execute('SELECT samples FROM all_raw_data')\n all_data = [json.loads(row.samples) for row in rows]\n\n # Insert the new samples into the database, while appending the samples on the currently loaded list:\n prepared = session.prepare(\"\"\"INSERT INTO all_raw_data(time, samples) VALUES (now(), ?)\"\"\")\n for sample in current_sample_list:\n session.execute(prepared.bind((json.dumps(sample),)))\n all_data.append(sample)\n\n # Train the model:\n X = []\n y = []\n for sample in all_data:\n X.append([sample[1]])\n y.append(sample[0])\n\n model = Pipeline([('poly', PolynomialFeatures(degree=2)),\n ('linear', LinearRegression(fit_intercept=False))])\n\n model.fit(X, y)\n\n print(all_data)\n print(X)\n print(y)\n print(model.predict([[35]]))\n # print(pickle.dumps(model, 1))\n\n prepared = session.prepare(\"\"\"INSERT INTO models(time, model_id, model) VALUES (now(), 1, ?)\"\"\")\n session.execute(prepared.bind((pickle.dumps(model, 0),)))\n\n cluster.shutdown()","def test_intent_classifier_get_training_samples(self):\n pass","def _create_examples(self, lines, set_type):\n examples = []\n \n for (i, line) in enumerate(lines):\n sentence_number = 0\n premise_text = line[\"premise\"]\n modified_premise_text = re.sub(self.stage_name_pattern,\"\",premise_text)\n modified_premise_text = re.sub(self.w_patterns,\"\",modified_premise_text)\n hypothesis_text = line[\"hypothesis\"]\n hypothesis_text = re.sub(self.w_patterns,\"\",hypothesis_text)\n a_label = int(line[\"label\"])\n\n sentences = modified_premise_text.split('.')\n\n for j, sentence in enumerate(sentences):\n guid = \"\" + str(sentence_number) + \"\\t\" + str(i) + \"\\t\" + str(len(sentences)) + \"\\t\" + str(a_label)\n text_a = sentence\n text_b = hypothesis_text\n label = a_label\n sentence_number += 1\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n #print(\"16th sentence::\",sentences[16])\n\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, ids) in enumerate(lines):\n text_a = lines[ids]['sentence']\n examples.append(\n InputExample(text_a=text_a) )\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(tqdm(lines)):\n if i == 0:\n continue\n gold_label_id = self.label2id(line[0])\n several_labels = [self.label2id(line[-5]), self.label2id(line[-4]), self.label2id(line[-3]),\n self.label2id(line[-2]), self.label2id(line[-1])]\n\n pair_id = line[-6]\n premise = line[5]\n hypothesis = line[6]\n premise_bp = line[1]\n hypothesis_bp = line[2]\n premise_p = line[3]\n hypothesis_p = line[4]\n # premise_length = len(premise)\n # hypothesis_length = len(hypothesis)\n guid = \"%s-%s\" % (set_type, i)\n\n ex = dict()\n for k in self.data_keys:\n ex[k] = eval(k)\n examples.append(ex)\n logger.info(\" {} examples\".format(len(examples)))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n # Only the test set has a header\n if set_type == \"test\" and i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n if set_type == \"test\":\n text_a = tokenization.convert_to_unicode(line[1])\n label = \"0\"\n else:\n text_a = tokenization.convert_to_unicode(line[3])\n label = tokenization.convert_to_unicode(line[1])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (_, data) in enumerate(lines):\n passage = data[\"passage\"]\n ents_pos = [(pos[\"start\"], pos[\"end\"])\n for pos in passage[\"entities\"]]\n ents = [passage[\"text\"][start:end+1] for start, end in ents_pos]\n for qa in data[\"qas\"]:\n qa_id = f\"{set_type}-{data['idx']}-{qa['idx']}\"\n answers = set([ans[\"text\"] for ans in qa[\"answers\"]])\n for ent_idx, ent in enumerate(ents):\n is_answer = ent in answers\n guid = f\"{qa_id}-{ent_idx}\"\n examples.append(\n InputExample(\n guid=guid,\n text_a=passage[\"text\"],\n # Insert entity in query\n text_b=qa[\"query\"].replace(\"@placeholder\", ent),\n label=\"1\" if is_answer else \"0\",\n )\n )\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n # Only the test set has a header\n if set_type == \"test\" and i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n if set_type == \"test\":\n text_a = tokenization.convert_to_unicode(line[1])\n label = \"0\"\n else:\n text_a = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[0])\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n if i <= 3:\n print(\"i={}, line={}\".format(i, line))\n guid = \"%s-%s\" % (set_type, i)\n if set_type == \"test\":\n text_a = tokenization.convert_to_unicode(line[1])\n label = \"0\"\n else:\n text_a = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[0])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def get_examples():\n symbols = get_symbols()\n symbol_start_indices, total_examples = _index_symbols(symbols)\n selection_order = np.arange(total_examples)\n np.random.shuffle(selection_order)\n for sample_index in selection_order:\n # use a binary search to determine which symbol to use given the sample_index\n start_index_index = bisect.bisect_left(symbol_start_indices, sample_index + 1) - 1\n start_index = symbol_start_indices[start_index_index]\n offset = sample_index - start_index\n symbol = symbols[start_index_index]\n time_series_data = get_time_series_data(symbol)\n next_day = time_series_data[offset]\n previous_days = time_series_data[offset + 1: offset + 1 + EXAMPLE_SIZE]\n previous_days.reverse()\n metadata = get_metadata_for_symbol(symbol)\n yield previous_days, next_day, metadata","def _create_examples(self, lines, set_type):\n test_mode = set_type == \"test\"\n if test_mode:\n lines = lines[1:]\n text_index = 1 if test_mode else 3\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[text_index]\n label = None if test_mode else line[1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, tokenization.convert_to_unicode(line[0]))\n text_a = tokenization.convert_to_unicode(line[8])\n text_b = tokenization.convert_to_unicode(line[9])\n label = tokenization.convert_to_unicode(line[-1])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _evaluate_examples(self):\n\n getLogger(\"problog_lfi\").debug(\"Evaluating examples:\")\n if self._log:\n evaluator = ExampleEvaluatorLog(self._weights)\n else:\n evaluator = ExampleEvaluator(self._weights)\n\n results = []\n for i, example in enumerate(self._compiled_examples):\n try:\n result = evaluator(example)\n results.append(result)\n getLogger(\"problog_lfi\").debug(\n \"Example \"\n + str(i + 1)\n + \":\\tFrequency = \"\n + str(result[0][0])\n + \"\\tp_evidence = \"\n + str(result[0][1])\n + \"\\tp_queries = \"\n + str(result[0][2])\n )\n except InconsistentEvidenceError:\n # print(\"Ignoring example {}/{}\".format(i + 1, len(self._compiled_examples)))\n getLogger(\"problog_lfi\").warning(\n \"Ignoring example {}/{}\".format(i + 1, len(self._compiled_examples))\n )\n\n return list(chain.from_iterable(results))","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[1])\n text_b = tokenization.convert_to_unicode(line[2])\n label = tokenization.convert_to_unicode(line[3])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[0])\n text_b = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[2])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = line[0]\n text_a = line[1] + \" . \" + line[2]\n text_b = line[-1]\n label = 0\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[3])\n label = tokenization.convert_to_unicode(line[1])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[2])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[2])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[3])\n text_b = tokenization.convert_to_unicode(line[4])\n if set_type == \"test\":\n label = \"0\"\n else:\n label = tokenization.convert_to_unicode(line[0])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def test_text_classifier_get_training_samples(self):\n pass","def train(self):\n for doc, label in zip(self.train_docs(), self.train_labels()):\n yield doc, label","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[3])\n text_b = tokenization.convert_to_unicode(line[4])\n label = tokenization.convert_to_unicode(line[0])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, ids) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, ids )\n text_a = lines[ids]['term']\n text_b = lines[ids]['sentence']\n label = lines[ids]['polarity']\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[8]\r\n text_b = line[9]\r\n if set_type != 'test':\r\n label = line[-1]\r\n else:\r\n label = self.get_labels()[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[1]\r\n text_b = line[2]\r\n if set_type != 'test':\r\n label = line[-1]\r\n else:\r\n label = self.get_labels()[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def test_model_sample(net, data_loader):\n net.eval()\n array = []\n with torch.no_grad():\n for data in data_loader:\n X = data['X']\n output = net(X)\n output = ToPILImage()(output)\n array.append(output)\n return array","def _create_examples(self, lines, set_type):\n examples = []\n for (_, data) in enumerate(lines):\n examples.append(\n InputExample(\n guid=f\"{set_type}-{data['idx']}\",\n text_a=data[\"premise\"],\n text_b=data[\"hypothesis\"],\n label=str(data[\"label\"]),\n )\n )\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n # ignore first header line\n if i == 0:\n continue\n if i <= 3:\n print(\"i={}, line={}\".format(i, line))\n guid = \"%s-%s\" % (set_type, i)\n if set_type == \"test\":\n text_a = tokenization.convert_to_unicode(line[0])\n label = \"3.0\"\n else:\n text_a = tokenization.convert_to_unicode(line[0])\n label = tokenization.convert_to_unicode(line[1])\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for i, line in lines.iterrows():\n guid = \"%s-%s\" % (set_type, i)\n text_a = line['sentence1']\n text_b = line['sentence2']\n label = line['label']\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n if set_type != 'test':\r\n guid = \"%s-%s\" % (set_type, i)\r\n text_a = line[0]\r\n label = line[1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\r\n else:\r\n guid = \"%s-%s\" % (set_type, i)\r\n text_a = line[1]\r\n label = self.get_labels()[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\r\n\r\n return examples","def test_generator_produces_examples(self):\n\n for is_training in [True, False]:\n with TemporaryDirectory() as tmp_dir:\n mock_raw_data(tmp_dir, raw_dim=256, num_images=100)\n for example in allen_brain._generator(tmp_dir, is_training):\n for key in [\"image/encoded\", \"image/format\",\n \"image/height\", \"image/width\"]:\n self.assertTrue(key in example.keys())","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0]) if set_type != \"test\" else line[0]\n text_a = line[1]\n text_b = line[2]\n label = line[-1] if set_type != \"test\" else \"entailment\"\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def get_examples(self, data_dir, file_key=\"train\"):\n raise NotImplementedError()","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, tokenization.convert_to_unicode(line[0]))\n text_a = tokenization.convert_to_unicode(line[8])\n text_b = tokenization.convert_to_unicode(line[9])\n if set_type == \"test\":\n label = \"contradiction\"\n else:\n label = tokenization.convert_to_unicode(line[-1])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[7]\n text_b = line[8]\n label = None if set_type == \"test\" else line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _generate_examples(self, folders, split):\n raise NotImplementedError(\"TODO\")","def convert_examples_to_features(self):\n features = []\n max_label_len = 0\n # find ou the max label length\n labels_list = []\n for ex_index, example in enumerate(self.examples):\n processor = example.processor\n label_ids = self.tokenizer.text_to_ids(processor.label2string(example.label)) + [self.tokenizer.eos_id]\n max_label_len = max(len(label_ids), max_label_len)\n labels_list.append(label_ids)\n if self.max_seq_length_decoder is None:\n self.max_seq_length_decoder = max_label_len\n else:\n self.max_seq_length_decoder = max(\n self.max_seq_length_decoder, max_label_len\n ) # take the max of the two to be conservative\n for ex_index, example in enumerate(self.examples):\n taskname = example.taskname\n taskname_ids = self.tokenizer.text_to_ids(taskname)\n processor = example.processor\n if ex_index % 10000 == 0:\n logging.info(f\"Writing example {ex_index} of {len(self.examples)}\")\n label_ids = labels_list[ex_index]\n enc_query = processor.get_ptune_query(\n example.content,\n self.pseudo_token_id,\n self.max_seq_length - self.max_seq_length_decoder + 1,\n self.templates,\n self.tokenizer,\n )\n input_ids = enc_query + label_ids[:-1]\n labels = [SMALL_NUM for i in range(len(enc_query) - 1)] + label_ids\n features.append([input_ids, labels, enc_query, taskname_ids])\n return features","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0]) if set_type != \"test\" else line[0]\n try:\n text_a = line[3] if set_type != \"test\" else line[1]\n text_b = line[4] if set_type != \"test\" else line[2]\n label = line[5] if set_type != \"test\" else \"0\"\n except IndexError:\n continue\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n if set_type != 'test':\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n try:\r\n text_a = line[3]\r\n text_b = line[4]\r\n label = line[5]\r\n except IndexError:\r\n continue\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n else:\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n try:\r\n text_a = line[1]\r\n text_b = line[2]\r\n label = self.get_labels()[0]\r\n except IndexError:\r\n continue\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n\r\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[1]\r\n text_b = line[2]\r\n if set_type != 'test_matched':\r\n label = line[-1]\r\n else:\r\n label = self.get_labels()[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def create_InputExamples(self, data, labels):\n examples = []\n for (i, u_tips) in enumerate(data):\n for text in u_tips:\n examples.append(\n run_classifier.InputExample(\n guid=None,\n text_a=text,\n text_b=None,\n label=np.argmax(labels[i])\n )\n )\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (_, data) in enumerate(lines):\n passage = data[\"passage\"][\"text\"]\n for Q in data[\"passage\"][\"questions\"]:\n question = Q[\"question\"]\n for A in Q[\"answers\"]:\n guid = f\"{set_type}-{data['idx']-Q['idx']-A['idx']}\"\n examples.append(\n InputExample(\n guid=guid,\n text_a=passage,\n text_b=question + \" \" + A[\"text\"],\n label=str(A[\"label\"]),\n )\n )\n return examples"],"string":"[\n \"def get_train_examples(self, data_path):\\r\\n return self.create_examples(self.read_data(data_path), 'train')\",\n \"def get_train_examples(self):\\n raise NotImplementedError()\",\n \"def build_examples():\\n build_models([\\n \\\"VGG_16\\\",\\n \\\"VGG_19\\\",\\n \\\"RESNET_50\\\",\\n \\\"MOBILENET\\\",\\n #\\\"INCEPTION_V3\\\",\\n #\\\"INCEPTION_RESNET\\\",\\n #\\\"DENSENET_121\\\",\\n #\\\"DENSENET_169\\\",\\n #\\\"DENSENET_201\\\"])\\n ])\",\n \"def train_and_eval_examples(self) -> types.Channel:\\n\\n return self._example_gen.outputs.examples\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n\\t\\traise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_test_examples(self, data_path):\\r\\n return self.create_examples(self.read_data(data_path), 'test')\",\n \"def get_train_examples(self, input_file):\\r\\n raise NotImplementedError()\",\n \"def _create_examples(self, data, set_type):\\n examples = []\\n for (i, elem) in enumerate(data):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text = elem[0]\\n label = elem[1]\\n examples.append(\\n InputExample(guid=guid, text=text, label=label))\\n return examples\",\n \"def model_samples(self) -> List[Model]:\\n return self._model_samples\",\n \"def train(self, iteration, train_examples, model_path=None):\\n return self.process_trained_model(\\n self.train_with_examples(iteration, train_examples, model_path),\\n iteration,\\n train_examples,\\n model_path,\\n )\",\n \"def _create_examples(self, data_dir, set_type):\\n\\t\\texamples = []\\n\\t\\tinput_file_data = os.path.join(data_dir, \\\"data.tsv\\\")\\n\\t\\twith open(input_file_data, \\\"r\\\", encoding=\\\"utf-8-sig\\\") as f:\\n\\t\\t\\tfor i, inp in enumerate(f):\\n\\t\\t\\t\\tinps = inp.split('\\\\t') \\n\\t\\t\\t\\tguid = \\\"%s-%s\\\" % (set_type, i)\\n\\t\\t\\t\\ttext_inp = inps[1].strip()\\n\\t\\t\\t\\ttext_out = inps[2].strip()\\n\\t\\t\\t\\texamples.append(InputExample(guid=guid, text_inp=text_inp, text_out=text_out))\\n\\t\\t\\t\\t\\n\\t\\t\\t# Sort these out before returning\\n\\t\\t\\texamples = sorted(examples, key=sort_inp_len)\\n\\t\\t\\treturn examples\",\n \"def get_train_full_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def _create_examples(self, df, mode):\\n idx_tr, idx_te = next(ShuffleSplit(test_size=0.3, random_state=1234).split(df.title, df.totalViews))\\n\\n examples = []\\n\\n iterind = idx_tr if mode == \\\"train\\\" else idx_te\\n\\n for i in iterind:\\n examples.append(\\n InputExample(guid=i, text_a=df.title.values[i], label=df.totalViews.values[i]))\\n\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n # labels = []\\n for (i, line) in enumerate(lines):\\n # ignore first header line\\n if i == 0:\\n continue\\n if i <= 3:\\n print(\\\"i={}, line={}\\\".format(i, line))\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n if set_type == \\\"test\\\":\\n text_a = tokenization.convert_to_unicode(line[0])\\n label = \\\"0\\\"\\n else:\\n text_a = tokenization.convert_to_unicode(line[0])\\n label = tokenization.convert_to_unicode(line[1])\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n # labels.append(label)\\n # if set_type == \\\"train\\\":\\n # self.class_weight_ = self.get_class_weight(labels, \\\"balanced\\\")\\n # else:\\n # self.class_weight_ = self.get_class_weight(labels, None)\\n # print(\\\"set_type={}, class_weight_={}\\\".format(set_type, self.class_weight_))\\n return examples\",\n \"def examples(self):\\n return self._examples\",\n \"def get_test_examples(self, data_dir):\\n \\n raise NotImplementedError()\",\n \"def _generate_examples(self, filepath):\\n # Simultaneously iterating through the different data sets in the hdf5\\n # file is >100x slower and the data set is small (26.7MB). Hence, we first\\n # load everything into memory before yielding the samples.\\n with tfds.core.lazy_imports.h5py.File(filepath, \\\"r\\\") as h5dataset:\\n image_array = np.array(h5dataset[\\\"imgs\\\"])\\n class_array = np.array(h5dataset[\\\"latents\\\"][\\\"classes\\\"])\\n values_array = np.array(h5dataset[\\\"latents\\\"][\\\"values\\\"])\\n\\n for i, (image, classes, values) in enumerate(moves.zip(\\n image_array, class_array, values_array)):\\n record = dict(\\n image=np.expand_dims(image, -1),\\n label_shape=classes[1],\\n label_scale=classes[2],\\n label_orientation=classes[3],\\n label_x_position=classes[4],\\n label_y_position=classes[5],\\n value_shape=values[1],\\n value_scale=values[2],\\n value_orientation=values[3],\\n value_x_position=values[4],\\n value_y_position=values[5])\\n if self.version > \\\"2.0.0\\\":\\n record[\\\"id\\\"] = \\\"{:06d}\\\".format(i)\\n yield i, record\",\n \"def generate_examples_serial(self):\\n # Now we have a Gensim Dictionary to work with\\n self._build_dictionary()\\n # Remove any tokens with a frequency less than 10\\n self.dictionary.filter_extremes(no_below=10, no_above=0.75)\\n\\n self.examples = []\\n for file in tqdm(self.load_files(), desc=\\\"Generating Examples (serial)\\\"):\\n file = self.dictionary.doc2idx(file)\\n self.examples.extend(self._generate_examples_from_file(file))\",\n \"def get_test_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_test_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_test_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_test_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_test_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def _generate_examples(self, data_dir_path):\\n\\n for class_name in tf.io.gfile.listdir(data_dir_path):\\n class_dir_path = os.path.join(data_dir_path, class_name)\\n for image_name in tf.io.gfile.listdir(class_dir_path):\\n image = os.path.join(class_dir_path, image_name)\\n yield image, {\\n \\\"image\\\": image,\\n \\\"label\\\": class_name,\\n }\",\n \"def _generate_examples(self, filepath):\\n\\n key = 1\\n with tf.io.gfile.GFile(filepath, \\\"r\\\") as f:\\n tokens = []\\n tags = []\\n langs = []\\n for line in f:\\n line = line.rstrip()\\n # pylint: disable=g-explicit-bool-comparison\\n if line.startswith(\\\"-DOCSTART-\\\") or line == \\\"\\\":\\n if tokens:\\n spans = get_spans(tokens, tags)\\n yield key, {\\n \\\"tokens\\\": tokens,\\n \\\"tags\\\": tags,\\n \\\"langs\\\": langs,\\n \\\"spans\\\": spans\\n }\\n key += 1\\n tokens = []\\n tags = []\\n langs = []\\n else:\\n # wikiann data is tab separated\\n fields = line.split(\\\"\\\\t\\\")\\n # strip out language prefix\\n langs.append(fields[0].split(\\\":\\\")[0])\\n tokens.append(\\\":\\\".join(fields[0].split(\\\":\\\")[1:]))\\n if len(fields) > 1:\\n tags.append(fields[-1])\\n else:\\n # examples have no label in test set\\n tags.append(\\\"O\\\")\\n if tokens:\\n spans = get_spans(tokens, tags)\\n yield key, {\\n \\\"tokens\\\": tokens,\\n \\\"tags\\\": tags,\\n \\\"langs\\\": langs,\\n \\\"spans\\\": spans\\n }\",\n \"def get_examples(self, env):\\n return self.fam.c_get_examples(self, env)\",\n \"def test_predict_from_examples():\\n examples = []\\n for i in range(len(DATA)):\\n (value, attribute_map) = DATA[i]\\n print 'tuple created : \\\\n1:' + str(value) + \\\"\\\\n2:\\\" + str(attribute_map)\\n ex = VowpalExample(i, value)\\n #Extracting the features from all of the namespaces in the map. \\n for (featureNamespace, features) in attribute_map.items():\\n #Each \\\"section\\\" is \\n ex.add_section(featureNamespace, features)\\n examples.append(ex)\\n train = examples[:-2]\\n test = examples[-2:]\\n vw = Vowpal(PATH_VW, './vw.%s', {'--passes' : '10' })\\n preds = vw.predict_from_examples(train, test)\\n for (id, value) in preds:\\n print 'prediction for %s is %s' % (id, value)\",\n \"def examples(self):\\n for obj_ind in range(len(self.objects)):\\n yield self.get_object_intent_by_index(obj_ind)\",\n \"def test_generate_all_training(self):\\n facade = ChatetteFacade.get_or_create()\\n\\n input_dir_path = \\\"tests/system-testing/inputs/generate-all/\\\"\\n input_filenames = [\\n \\\"simplest.chatette\\\", \\\"only-words.chatette\\\",\\n \\\"words-and-groups.chatette\\\", \\\"alias.chatette\\\", \\\"include.chatette\\\",\\n \\\"slot.chatette\\\", \\\"slotrolegroup.chatette\\\"\\n ]\\n for filename in input_filenames:\\n file_path = os.path.join(input_dir_path, filename)\\n facade.run(file_path)\\n if not TestSystem.check_no_duplicates(facade.train_examples):\\n pytest.fail(\\n \\\"Some examples were generated several times \\\" +\\n \\\"when dealing with file '\\\" + filename + \\\"'.\\\\nGenerated: \\\" + \\\\\\n str(facade.train_examples)\\n )\\n legal_examples = TestSystem.get_legal_examples(file_path)\\n for ex in facade.train_examples:\\n formatted_ex = {\\\"intent\\\": ex.intent_name, \\\"text\\\": ex.text}\\n if formatted_ex not in legal_examples:\\n pytest.fail(\\n str(formatted_ex) + \\\" is not a legal example for '\\\" + \\\\\\n file_path + \\\"'\\\"\\n )\\n if len(legal_examples) != len(facade.train_examples):\\n training_texts = [ex.text for ex in facade.train_examples]\\n for legal_ex in legal_examples:\\n if legal_ex[\\\"text\\\"] not in training_texts:\\n pytest.fail(\\n \\\"Example '\\\" + legal_ex[\\\"text\\\"] + \\\\\\n \\\"' was not generated.\\\"\\n )\\n pytest.fail(\\n \\\"An unknown example was not generated (\\\" + \\\\\\n str(len(facade.train_examples)) + \\\\\\n \\\" generated instead of \\\" + str(len(legal_examples)) + \\\\\\n \\\").\\\\nGenerated: \\\" + str(facade.train_examples)\\n )\\n legal_syn = TestSystem.get_legal_synonyms(file_path)\\n if legal_syn is not None:\\n synonyms = AST.get_or_create().get_entities_synonyms()\\n for key in synonyms:\\n if key not in legal_syn:\\n pytest.fail(\\n \\\"'\\\" + key + \\\"' shouldn't have any synonyms.\\\"\\n )\\n for syn in synonyms[key]:\\n if syn not in legal_syn[key]:\\n pytest.fail(\\n \\\"'\\\" + syn + \\\"' shouldn't be a synonym of '\\\" + \\\\\\n key + \\\"'\\\"\\n )\",\n \"def _generate_examples(\\n self, mode: str) -> Generator[ProcessedExample, None, None]:\\n if mode not in self._json_dict:\\n self._json_dict[mode] = collections.defaultdict(list)\\n generator = self.builder_config.example_generator(mode)\\n for example in generator:\\n img_id, processed_example = self._convert_raw_example(\\n self._json_dict[mode], example)\\n yield img_id, processed_example\",\n \"def get_test_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_test_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def convert_examples_to_features(self):\\n features = []\\n for ex_index, example in enumerate(self.examples):\\n taskname = example.taskname\\n taskname_ids = self.tokenizer.text_to_ids(taskname)\\n processor = example.processor\\n if ex_index % 10000 == 0:\\n logging.info(f\\\"Writing example {ex_index} of {len(self.examples)}\\\")\\n enc_query = processor.get_ptune_query(\\n example.content,\\n self.pseudo_token_id,\\n self.max_seq_length - self.max_seq_length_decoder + 1,\\n self.templates,\\n self.tokenizer,\\n )\\n features.append([enc_query, taskname_ids])\\n return features\",\n \"def instantiate_examples(self, examples : [dict]) -> [dict]:\\n raise NotImplementedError()\",\n \"def generate_store_model_samples(current_sample_list, cass_ip, cass_port):\\n cluster = Cluster([cass_ip], int(cass_port))\\n session = cluster.connect()\\n # NOTE: None of these schema represent the best practice in Casandra schema design,\\n # they are merely for simple examples:\\n session.execute(\\\"CREATE KEYSPACE IF NOT EXISTS ml_db WITH \\\"\\n \\\"REPLICATION = {'class' : 'SimpleStrategy', 'replication_factor' : 1}\\\")\\n session.set_keyspace('ml_db')\\n session.execute(\\\"CREATE TABLE IF NOT EXISTS all_raw_data\\\"\\n \\\"(time timeuuid PRIMARY KEY, samples text)\\\")\\n session.execute(\\\"CREATE TABLE IF NOT EXISTS models\\\"\\n \\\"(time timeuuid, model_id int, model text, PRIMARY KEY(model_id, time))\\\")\\n\\n rows = session.execute('SELECT samples FROM all_raw_data')\\n all_data = [json.loads(row.samples) for row in rows]\\n\\n # Insert the new samples into the database, while appending the samples on the currently loaded list:\\n prepared = session.prepare(\\\"\\\"\\\"INSERT INTO all_raw_data(time, samples) VALUES (now(), ?)\\\"\\\"\\\")\\n for sample in current_sample_list:\\n session.execute(prepared.bind((json.dumps(sample),)))\\n all_data.append(sample)\\n\\n # Train the model:\\n X = []\\n y = []\\n for sample in all_data:\\n X.append([sample[1]])\\n y.append(sample[0])\\n\\n model = Pipeline([('poly', PolynomialFeatures(degree=2)),\\n ('linear', LinearRegression(fit_intercept=False))])\\n\\n model.fit(X, y)\\n\\n print(all_data)\\n print(X)\\n print(y)\\n print(model.predict([[35]]))\\n # print(pickle.dumps(model, 1))\\n\\n prepared = session.prepare(\\\"\\\"\\\"INSERT INTO models(time, model_id, model) VALUES (now(), 1, ?)\\\"\\\"\\\")\\n session.execute(prepared.bind((pickle.dumps(model, 0),)))\\n\\n cluster.shutdown()\",\n \"def test_intent_classifier_get_training_samples(self):\\n pass\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n \\n for (i, line) in enumerate(lines):\\n sentence_number = 0\\n premise_text = line[\\\"premise\\\"]\\n modified_premise_text = re.sub(self.stage_name_pattern,\\\"\\\",premise_text)\\n modified_premise_text = re.sub(self.w_patterns,\\\"\\\",modified_premise_text)\\n hypothesis_text = line[\\\"hypothesis\\\"]\\n hypothesis_text = re.sub(self.w_patterns,\\\"\\\",hypothesis_text)\\n a_label = int(line[\\\"label\\\"])\\n\\n sentences = modified_premise_text.split('.')\\n\\n for j, sentence in enumerate(sentences):\\n guid = \\\"\\\" + str(sentence_number) + \\\"\\\\t\\\" + str(i) + \\\"\\\\t\\\" + str(len(sentences)) + \\\"\\\\t\\\" + str(a_label)\\n text_a = sentence\\n text_b = hypothesis_text\\n label = a_label\\n sentence_number += 1\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n #print(\\\"16th sentence::\\\",sentences[16])\\n\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, ids) in enumerate(lines):\\n text_a = lines[ids]['sentence']\\n examples.append(\\n InputExample(text_a=text_a) )\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(tqdm(lines)):\\n if i == 0:\\n continue\\n gold_label_id = self.label2id(line[0])\\n several_labels = [self.label2id(line[-5]), self.label2id(line[-4]), self.label2id(line[-3]),\\n self.label2id(line[-2]), self.label2id(line[-1])]\\n\\n pair_id = line[-6]\\n premise = line[5]\\n hypothesis = line[6]\\n premise_bp = line[1]\\n hypothesis_bp = line[2]\\n premise_p = line[3]\\n hypothesis_p = line[4]\\n # premise_length = len(premise)\\n # hypothesis_length = len(hypothesis)\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n\\n ex = dict()\\n for k in self.data_keys:\\n ex[k] = eval(k)\\n examples.append(ex)\\n logger.info(\\\" {} examples\\\".format(len(examples)))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n # Only the test set has a header\\n if set_type == \\\"test\\\" and i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n if set_type == \\\"test\\\":\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = \\\"0\\\"\\n else:\\n text_a = tokenization.convert_to_unicode(line[3])\\n label = tokenization.convert_to_unicode(line[1])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (_, data) in enumerate(lines):\\n passage = data[\\\"passage\\\"]\\n ents_pos = [(pos[\\\"start\\\"], pos[\\\"end\\\"])\\n for pos in passage[\\\"entities\\\"]]\\n ents = [passage[\\\"text\\\"][start:end+1] for start, end in ents_pos]\\n for qa in data[\\\"qas\\\"]:\\n qa_id = f\\\"{set_type}-{data['idx']}-{qa['idx']}\\\"\\n answers = set([ans[\\\"text\\\"] for ans in qa[\\\"answers\\\"]])\\n for ent_idx, ent in enumerate(ents):\\n is_answer = ent in answers\\n guid = f\\\"{qa_id}-{ent_idx}\\\"\\n examples.append(\\n InputExample(\\n guid=guid,\\n text_a=passage[\\\"text\\\"],\\n # Insert entity in query\\n text_b=qa[\\\"query\\\"].replace(\\\"@placeholder\\\", ent),\\n label=\\\"1\\\" if is_answer else \\\"0\\\",\\n )\\n )\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n # Only the test set has a header\\n if set_type == \\\"test\\\" and i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n if set_type == \\\"test\\\":\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = \\\"0\\\"\\n else:\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[0])\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n if i <= 3:\\n print(\\\"i={}, line={}\\\".format(i, line))\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n if set_type == \\\"test\\\":\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = \\\"0\\\"\\n else:\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[0])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def get_examples():\\n symbols = get_symbols()\\n symbol_start_indices, total_examples = _index_symbols(symbols)\\n selection_order = np.arange(total_examples)\\n np.random.shuffle(selection_order)\\n for sample_index in selection_order:\\n # use a binary search to determine which symbol to use given the sample_index\\n start_index_index = bisect.bisect_left(symbol_start_indices, sample_index + 1) - 1\\n start_index = symbol_start_indices[start_index_index]\\n offset = sample_index - start_index\\n symbol = symbols[start_index_index]\\n time_series_data = get_time_series_data(symbol)\\n next_day = time_series_data[offset]\\n previous_days = time_series_data[offset + 1: offset + 1 + EXAMPLE_SIZE]\\n previous_days.reverse()\\n metadata = get_metadata_for_symbol(symbol)\\n yield previous_days, next_day, metadata\",\n \"def _create_examples(self, lines, set_type):\\n test_mode = set_type == \\\"test\\\"\\n if test_mode:\\n lines = lines[1:]\\n text_index = 1 if test_mode else 3\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[text_index]\\n label = None if test_mode else line[1]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, tokenization.convert_to_unicode(line[0]))\\n text_a = tokenization.convert_to_unicode(line[8])\\n text_b = tokenization.convert_to_unicode(line[9])\\n label = tokenization.convert_to_unicode(line[-1])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _evaluate_examples(self):\\n\\n getLogger(\\\"problog_lfi\\\").debug(\\\"Evaluating examples:\\\")\\n if self._log:\\n evaluator = ExampleEvaluatorLog(self._weights)\\n else:\\n evaluator = ExampleEvaluator(self._weights)\\n\\n results = []\\n for i, example in enumerate(self._compiled_examples):\\n try:\\n result = evaluator(example)\\n results.append(result)\\n getLogger(\\\"problog_lfi\\\").debug(\\n \\\"Example \\\"\\n + str(i + 1)\\n + \\\":\\\\tFrequency = \\\"\\n + str(result[0][0])\\n + \\\"\\\\tp_evidence = \\\"\\n + str(result[0][1])\\n + \\\"\\\\tp_queries = \\\"\\n + str(result[0][2])\\n )\\n except InconsistentEvidenceError:\\n # print(\\\"Ignoring example {}/{}\\\".format(i + 1, len(self._compiled_examples)))\\n getLogger(\\\"problog_lfi\\\").warning(\\n \\\"Ignoring example {}/{}\\\".format(i + 1, len(self._compiled_examples))\\n )\\n\\n return list(chain.from_iterable(results))\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[1])\\n text_b = tokenization.convert_to_unicode(line[2])\\n label = tokenization.convert_to_unicode(line[3])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[0])\\n text_b = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[2])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = line[0]\\n text_a = line[1] + \\\" . \\\" + line[2]\\n text_b = line[-1]\\n label = 0\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[3])\\n label = tokenization.convert_to_unicode(line[1])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[2])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[2])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[3])\\n text_b = tokenization.convert_to_unicode(line[4])\\n if set_type == \\\"test\\\":\\n label = \\\"0\\\"\\n else:\\n label = tokenization.convert_to_unicode(line[0])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def test_text_classifier_get_training_samples(self):\\n pass\",\n \"def train(self):\\n for doc, label in zip(self.train_docs(), self.train_labels()):\\n yield doc, label\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[3])\\n text_b = tokenization.convert_to_unicode(line[4])\\n label = tokenization.convert_to_unicode(line[0])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, ids) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, ids )\\n text_a = lines[ids]['term']\\n text_b = lines[ids]['sentence']\\n label = lines[ids]['polarity']\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[8]\\r\\n text_b = line[9]\\r\\n if set_type != 'test':\\r\\n label = line[-1]\\r\\n else:\\r\\n label = self.get_labels()[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[1]\\r\\n text_b = line[2]\\r\\n if set_type != 'test':\\r\\n label = line[-1]\\r\\n else:\\r\\n label = self.get_labels()[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def test_model_sample(net, data_loader):\\n net.eval()\\n array = []\\n with torch.no_grad():\\n for data in data_loader:\\n X = data['X']\\n output = net(X)\\n output = ToPILImage()(output)\\n array.append(output)\\n return array\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (_, data) in enumerate(lines):\\n examples.append(\\n InputExample(\\n guid=f\\\"{set_type}-{data['idx']}\\\",\\n text_a=data[\\\"premise\\\"],\\n text_b=data[\\\"hypothesis\\\"],\\n label=str(data[\\\"label\\\"]),\\n )\\n )\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n # ignore first header line\\n if i == 0:\\n continue\\n if i <= 3:\\n print(\\\"i={}, line={}\\\".format(i, line))\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n if set_type == \\\"test\\\":\\n text_a = tokenization.convert_to_unicode(line[0])\\n label = \\\"3.0\\\"\\n else:\\n text_a = tokenization.convert_to_unicode(line[0])\\n label = tokenization.convert_to_unicode(line[1])\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for i, line in lines.iterrows():\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line['sentence1']\\n text_b = line['sentence2']\\n label = line['label']\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n if set_type != 'test':\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n text_a = line[0]\\r\\n label = line[1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\r\\n else:\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n text_a = line[1]\\r\\n label = self.get_labels()[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\r\\n\\r\\n return examples\",\n \"def test_generator_produces_examples(self):\\n\\n for is_training in [True, False]:\\n with TemporaryDirectory() as tmp_dir:\\n mock_raw_data(tmp_dir, raw_dim=256, num_images=100)\\n for example in allen_brain._generator(tmp_dir, is_training):\\n for key in [\\\"image/encoded\\\", \\\"image/format\\\",\\n \\\"image/height\\\", \\\"image/width\\\"]:\\n self.assertTrue(key in example.keys())\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0]) if set_type != \\\"test\\\" else line[0]\\n text_a = line[1]\\n text_b = line[2]\\n label = line[-1] if set_type != \\\"test\\\" else \\\"entailment\\\"\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def get_examples(self, data_dir, file_key=\\\"train\\\"):\\n raise NotImplementedError()\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, tokenization.convert_to_unicode(line[0]))\\n text_a = tokenization.convert_to_unicode(line[8])\\n text_b = tokenization.convert_to_unicode(line[9])\\n if set_type == \\\"test\\\":\\n label = \\\"contradiction\\\"\\n else:\\n label = tokenization.convert_to_unicode(line[-1])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[7]\\n text_b = line[8]\\n label = None if set_type == \\\"test\\\" else line[-1]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _generate_examples(self, folders, split):\\n raise NotImplementedError(\\\"TODO\\\")\",\n \"def convert_examples_to_features(self):\\n features = []\\n max_label_len = 0\\n # find ou the max label length\\n labels_list = []\\n for ex_index, example in enumerate(self.examples):\\n processor = example.processor\\n label_ids = self.tokenizer.text_to_ids(processor.label2string(example.label)) + [self.tokenizer.eos_id]\\n max_label_len = max(len(label_ids), max_label_len)\\n labels_list.append(label_ids)\\n if self.max_seq_length_decoder is None:\\n self.max_seq_length_decoder = max_label_len\\n else:\\n self.max_seq_length_decoder = max(\\n self.max_seq_length_decoder, max_label_len\\n ) # take the max of the two to be conservative\\n for ex_index, example in enumerate(self.examples):\\n taskname = example.taskname\\n taskname_ids = self.tokenizer.text_to_ids(taskname)\\n processor = example.processor\\n if ex_index % 10000 == 0:\\n logging.info(f\\\"Writing example {ex_index} of {len(self.examples)}\\\")\\n label_ids = labels_list[ex_index]\\n enc_query = processor.get_ptune_query(\\n example.content,\\n self.pseudo_token_id,\\n self.max_seq_length - self.max_seq_length_decoder + 1,\\n self.templates,\\n self.tokenizer,\\n )\\n input_ids = enc_query + label_ids[:-1]\\n labels = [SMALL_NUM for i in range(len(enc_query) - 1)] + label_ids\\n features.append([input_ids, labels, enc_query, taskname_ids])\\n return features\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0]) if set_type != \\\"test\\\" else line[0]\\n try:\\n text_a = line[3] if set_type != \\\"test\\\" else line[1]\\n text_b = line[4] if set_type != \\\"test\\\" else line[2]\\n label = line[5] if set_type != \\\"test\\\" else \\\"0\\\"\\n except IndexError:\\n continue\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n if set_type != 'test':\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n try:\\r\\n text_a = line[3]\\r\\n text_b = line[4]\\r\\n label = line[5]\\r\\n except IndexError:\\r\\n continue\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n else:\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n try:\\r\\n text_a = line[1]\\r\\n text_b = line[2]\\r\\n label = self.get_labels()[0]\\r\\n except IndexError:\\r\\n continue\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[1]\\r\\n text_b = line[2]\\r\\n if set_type != 'test_matched':\\r\\n label = line[-1]\\r\\n else:\\r\\n label = self.get_labels()[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def create_InputExamples(self, data, labels):\\n examples = []\\n for (i, u_tips) in enumerate(data):\\n for text in u_tips:\\n examples.append(\\n run_classifier.InputExample(\\n guid=None,\\n text_a=text,\\n text_b=None,\\n label=np.argmax(labels[i])\\n )\\n )\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (_, data) in enumerate(lines):\\n passage = data[\\\"passage\\\"][\\\"text\\\"]\\n for Q in data[\\\"passage\\\"][\\\"questions\\\"]:\\n question = Q[\\\"question\\\"]\\n for A in Q[\\\"answers\\\"]:\\n guid = f\\\"{set_type}-{data['idx']-Q['idx']-A['idx']}\\\"\\n examples.append(\\n InputExample(\\n guid=guid,\\n text_a=passage,\\n text_b=question + \\\" \\\" + A[\\\"text\\\"],\\n label=str(A[\\\"label\\\"]),\\n )\\n )\\n return examples\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6898566","0.68552566","0.68252814","0.65360844","0.6499116","0.64343864","0.64343864","0.64343864","0.64343864","0.64343864","0.64343864","0.64343864","0.64186585","0.64186585","0.64146006","0.64114195","0.64114195","0.64114195","0.64114195","0.64114195","0.64114195","0.64114195","0.64114195","0.64114195","0.64114195","0.64114195","0.64114195","0.64114195","0.64114195","0.6383931","0.63712245","0.63337463","0.63030386","0.62751347","0.626642","0.62613404","0.625266","0.6222024","0.6185342","0.618528","0.6173145","0.61653394","0.61574036","0.61574036","0.61574036","0.61574036","0.61574036","0.61565614","0.6140688","0.6138876","0.61252356","0.60854506","0.6082987","0.6078059","0.60748994","0.60748994","0.60729194","0.6044134","0.60435563","0.6022533","0.6018039","0.6013565","0.6011493","0.59839743","0.5962305","0.5957545","0.5956302","0.5947735","0.59393084","0.5936937","0.59362376","0.5935735","0.5935562","0.59333503","0.5930507","0.59299177","0.59299177","0.5921345","0.59158176","0.5915536","0.5911403","0.5895727","0.5890892","0.58895975","0.58887327","0.5887726","0.58727163","0.58726674","0.5869936","0.5864484","0.58628917","0.58583623","0.5855021","0.5849157","0.58486104","0.5841369","0.58372366","0.5837076","0.5836891","0.58337635","0.58312964"],"string":"[\n \"0.6898566\",\n \"0.68552566\",\n \"0.68252814\",\n \"0.65360844\",\n \"0.6499116\",\n \"0.64343864\",\n \"0.64343864\",\n \"0.64343864\",\n \"0.64343864\",\n \"0.64343864\",\n \"0.64343864\",\n \"0.64343864\",\n \"0.64186585\",\n \"0.64186585\",\n \"0.64146006\",\n \"0.64114195\",\n \"0.64114195\",\n \"0.64114195\",\n \"0.64114195\",\n \"0.64114195\",\n \"0.64114195\",\n \"0.64114195\",\n \"0.64114195\",\n \"0.64114195\",\n \"0.64114195\",\n \"0.64114195\",\n \"0.64114195\",\n \"0.64114195\",\n \"0.64114195\",\n \"0.6383931\",\n \"0.63712245\",\n \"0.63337463\",\n \"0.63030386\",\n \"0.62751347\",\n \"0.626642\",\n \"0.62613404\",\n \"0.625266\",\n \"0.6222024\",\n \"0.6185342\",\n \"0.618528\",\n \"0.6173145\",\n \"0.61653394\",\n \"0.61574036\",\n \"0.61574036\",\n \"0.61574036\",\n \"0.61574036\",\n \"0.61574036\",\n \"0.61565614\",\n \"0.6140688\",\n \"0.6138876\",\n \"0.61252356\",\n \"0.60854506\",\n \"0.6082987\",\n \"0.6078059\",\n \"0.60748994\",\n \"0.60748994\",\n \"0.60729194\",\n \"0.6044134\",\n \"0.60435563\",\n \"0.6022533\",\n \"0.6018039\",\n \"0.6013565\",\n \"0.6011493\",\n \"0.59839743\",\n \"0.5962305\",\n \"0.5957545\",\n \"0.5956302\",\n \"0.5947735\",\n \"0.59393084\",\n \"0.5936937\",\n \"0.59362376\",\n \"0.5935735\",\n \"0.5935562\",\n \"0.59333503\",\n \"0.5930507\",\n \"0.59299177\",\n \"0.59299177\",\n \"0.5921345\",\n \"0.59158176\",\n \"0.5915536\",\n \"0.5911403\",\n \"0.5895727\",\n \"0.5890892\",\n \"0.58895975\",\n \"0.58887327\",\n \"0.5887726\",\n \"0.58727163\",\n \"0.58726674\",\n \"0.5869936\",\n \"0.5864484\",\n \"0.58628917\",\n \"0.58583623\",\n \"0.5855021\",\n \"0.5849157\",\n \"0.58486104\",\n \"0.5841369\",\n \"0.58372366\",\n \"0.5837076\",\n \"0.5836891\",\n \"0.58337635\",\n \"0.58312964\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84590,"cells":{"query":{"kind":"string","value":"Initialize the GenericProcessing class."},"document":{"kind":"string","value":"def __init__(self):\n self.bpf_lcut = 10\n self.bpf_hcut = 425\n self.lpf_lcut = 5\n self.lp_butter_order = 4\n self.bp_butter_order = 2\n self.data_rate = None\n self.process_time = []"},"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 _initialize(self):\n pass","def _initialize(self):\n pass","def _initialize(self):\n pass","def initialize(cls):","def __init__(self, *args, **kwargs):\n # count the cores available on the local machine\n self.tasks = mp.cpu_count()\n super(ParallelPreprocessor, self).__init__(*args, **kwargs)","def _init(self):\n pass","def _init(self):\n raise NotImplementedError","def __init__(self):\n super(PreProcess, self).__init__()","def initialize(self, *args, **kwargs):\n pass","def __init__(self):\n self.tape_tag = None\n self.independentVariableShapeList = []\n self.dependentVariableShapeList = []","def __init__(self, attributes=None):\n super().__init__(attributes)\n \n # processing parameters\n self.set = _Settings()\n\n # results storage\n self.measure_time = None # store here in case we average FIDs, filled by chain!\n self.frequency_shift = None\n self.phase_0 = None\n self.data = None\n \n if attributes is not None:\n self.inflate(attributes)\n\n self.chain = None","def init(self):\n raise NotImplementedError","def init(self):\n raise NotImplementedError","def initialize(self) -> None:\n pass","def __init__(self):\n \n self.load_PSF_data()","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n\t\tpass","def init(self) -> None:\n ...","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def initialize(self):\n raise NotImplementedError","def initialize(self):\n raise NotImplementedError","def initialize(self):\n raise NotImplementedError","def initialize(self):\r\n pass","def initialize(self):\r\n pass","def __init__(self):\r\n config = ConfigProvider().getProcessingConfig()\r\n self.xGround = config.get(\"xGround\")\r\n self.yGround = config.get(\"yGround\")","def __init__(self, pipeline, **kwargs):\n self.pipeline = pipeline\n\n self.batch_size = pipeline.batch_size\n self.X_train = None\n self.y_train = None\n self.X_valid = None\n self.y_valid = None\n\n # Child classes should have init signature:\n # (self, batch_size, **kwargs), should call this __init__ and then\n # define self.X_train, self.y_train, self.X_valid, and self.y_valid","def __init__(self, config):\n Submodule.__init__(self, \"command_ingest\", config)\n self.general_queue = queue()\n\n self.processes = {\n \"dispatch\": ThreadHandler(\n target=partial(self.dispatch),\n name=\"command_ingest_dispatch\",\n parent_logger=self.logger,\n )\n }","def __init__(self,config,typ='train'):\n\n self._config = config\n self.type = typ\n self.reader = JsonlReader(self._config.annotations.as_dict()[typ])\n self.annotations = self.reader.read()\n self.transform = get_image_processor(self._config.image_processor)","def do_init(self):\n\n pass","def __init__(self):\n _snap.TFile_swiginit(self, _snap.new_TFile())","def __init__(self):\n\n self.read_input_file()\n self.read_simulation_files()","def init(self):\n self._frame_idx = 0\n if self.initialization is not None:\n del self.initialization\n self.initialization = None\n\n if self.config.initialization is not None:\n self.initialization = INITIALIZATION.load(self.config.initialization, **self.__kwargs)\n self.initialization.init()\n\n if self.preprocessing is not None:\n del self.preprocessing\n self.preprocessing = None\n\n if self.config.preprocessing is not None:\n self.preprocessing = Preprocessing(self.config.preprocessing, **self.__kwargs)\n\n if self.odometry is None:\n assert self.config.odometry is not None\n self.odometry = ODOMETRY.load(self.config.odometry, **self.__kwargs)\n\n assert self.odometry is not None\n self.odometry.init()\n if self.loop_closure is None and self.config.loop_closure is not None:\n self.loop_closure = LOOP_CLOSURE.load(self.config.loop_closure, **self.__kwargs)\n if self.loop_closure is not None:\n self.loop_closure.init()\n if self.config.backend is not None:\n self.backend = BACKEND.load(self.config.backend, **self.__kwargs)\n if self.backend is not None:\n self.backend.init()\n else:\n logging.warning(\"[SLAMAlgorithm]Defined a Loop Closure Algorithm Without a Backend\")","def __init__(self, data_streamer, sonifier, mapping):\n self._data_streamer = data_streamer\n self._mapping = mapping\n self._init_sonifier(sonifier)\n self._parameter_names = self._mapping.keys()\n self._value_queues = dict()\n for parameter in self._parameter_names:\n self._value_queues[parameter] = LifoQueue()\n self._run = True","def __init__(self, processing_hub, parent=None):\n super(ProcessingWorker, self).__init__(parent)\n\n self.parent = parent\n\n # Processing hub object\n self.processing_hub = processing_hub\n\n # Flag to indicate processing mode\n self.processing_mode = processing_hub.control.processing_mode\n\n # Initialise progress bar with enabled loggers\n loggers = self.processing_hub.control.loggers\n enabled_logger_ids = [logger.logger_id for logger in loggers if logger.enabled]\n self.pb = ProcessingProgressBar(enabled_logger_ids)\n self.pb.show()\n self._connect_signals()","def __init__(self):\n\t\tScriptedLoadableModuleLogic.__init__(self)\n\n\t\tself._parameterNode = None\n\t\tself.postopProgrammingInstance = None\n\t\tself.FrameAutoDetect = False","def initialize(self):\n self.initialize_edges()\n self.initialize_prob()\n self.initialize_total_input_dict()\n\n self.initialize_fpmusigv_dict()","def init(self) -> None:","def __init__(self, binning: int = 2, **kwargs: Any):\n ImageProcessor.__init__(self, **kwargs)\n\n # store\n self.binning = binning","def _init(self, options):\n self._initRuntime(options)\n self._loadConfig() # needs runtime\n self._initGeneral() # needs _config\n self._initGroups() # needs _config and general","def __init__(self):\n manager = Manager()\n # As the snippet is executing in multiprocessing.Process, a shared\n # dict should be used to ensure the change is propagated.\n self.local = manager.dict()\n\n # the object in shared dict should also be shared\n for k, v in self.presets.items():\n if isinstance(v, list):\n self.local[k] = manager.list(v)\n elif isinstance(v, dict):\n self.local[k] = manager.dict(v)\n elif isinstance(v, set):\n self.local[k] = manager.set(v)\n else:\n self.local[k] = v","def setup_class(cls):\n\n # set the base directory\n cls.basedir = os.path.join(os.path.split(os.path.realpath(__file__))[0], \"base\")\n\n cls.ninj = 50 # number of simulated signals\n cls.maxamp = 5e-23 # maximum amplitude\n cls.freqrange = (10.0, 100.0) # frequency range\n\n # default prior dictionary\n cls.priors = {}\n cls.priors[\"h0\"] = bilby.core.prior.Uniform(\n name=\"h0\", minimum=0.0, maximum=1e-22\n )","def __init__(self, root, transform=None, pre_transform=None, pre_filter=None, re_process_init=True):\n self.re_process_init = re_process_init\n\n super(DatasetGEO, self).__init__(root, transform, pre_transform, pre_filter=pre_filter)\n\n if re_process_init:\n self.re_process()\n else:\n pass","def initialize(self, *args, **kwargs):","def init(self, *args, **kwds):\n pass","def initialise(self):","def __init__(self) -> None:\n self.registration_method = None\n self.fixed_image = None\n self.moving_image = None\n self.transform = None","def __init__(self, the_input_shape, num_classes):\n self.the_input_shape = the_input_shape\n self.num_classes = num_classes","def __init__(self):\r\n self.label = \"ProcessGeogridFile\"\r\n self.description = \"This tool takes an input WRF Geogrid file in NetCDF format\" + \\\r\n \" and uses the HGT_M grid and an input high-resolution elevation grid\" + \\\r\n \"to produce a high-resolution hydrologically processed output.\"\r\n #self.canRunInBackground = False\r\n self.canRunInBackground = True\r\n self.category = \"Processing\"","def __init__(self, task_queue, results_queue, individuals):\n Process.__init__(self)\n \n self.proc_name = self.name\n \n logger.info(\"Setting up variant_annotator: {0}\".format(\n self.proc_name))\n \n logger.debug(\"Setting up task queue\")\n self.task_queue = task_queue\n \n logger.debug(\"Setting up results queue\")\n self.results_queue = results_queue\n\n logger.debug(\"Setting up individuals\")\n self.individuals = individuals\n \n if len(self.individuals) == 1:\n self.models = ['AR_comp', 'AR_comp_dn', 'AD', 'AD_dn']\n else:\n self.models = ['AR_comp', 'AR_comp_dn']","def __init__(self, pipeline):\n self._jobs = []\n self._active_jobs = []\n\n self._threads = []\n self._thread_index = {}\n self._thread_id = 1\n\n\n self.local_backend = Local()\n self.backend = None\n\n self.pipeline = pipeline","def __init__(self, log_settings, log_queue, loop = None):\n\t\tself.loop = loop if loop is not None else asyncio.get_event_loop()\n\t\tself.log_settings = log_settings\n\t\tself.log_queue = log_queue\n\t\tself.logger = None\n\t\tself.extensions_tasks = {}\n\t\tself.extension_task_id = 0\n\t\tself.result_history = {}\n\t\tself.proxy_file_handler = None\n\t\tself.name = 'LogProcessor'","def initialize(self, **kwargs: Any) -> None:\n pass","def initialize(self) -> None:\n self._step = self._start_step\n self._tebd_propagator = compute_tebd_propagator(\n system_chain=self._system_chain,\n time_step=self._parameters.dt/2.0,\n epsrel=self._parameters.epsrel,\n order=self._parameters.order)\n self._results = {}\n self._t_mps = PtTebdBackend(\n gammas=self._initial_augmented_mps.gammas,\n lambdas=self._initial_augmented_mps.lambdas,\n epsrel=self._parameters.epsrel,\n config=self._backend_config)\n self._init_results()\n self._apply_controls(step=self.step, post=False)\n self._append_results()","def __init__(\n self,\n system: BaseSystem,\n bath: Bath,\n process_tensor: BaseProcessTensor,\n initial_state: Optional[ndarray] = None,\n system_correlations: Optional[ndarray] = None,\n name: Optional[Text] = None,\n description: Optional[Text] = None) -> None:\n self._system = system\n self._bath = bath\n\n initial_tensor = process_tensor.get_initial_tensor()\n assert (initial_state is None) ^ (initial_tensor is None), \\\n \"Initial state must be either (exclusively) encoded in the \" \\\n + \"process tensor or given as an argument.\"\n\n self._process_tensor = process_tensor\n self._initial_state = initial_state\n\n if system_correlations is None:\n self._system_correlations = np.array([[]], dtype=NpDtype)\n else:\n self._system_correlations = system_correlations\n self._temp = bath.correlations.temperature\n self._bath_correlations = {}\n super().__init__(name, description)","def __init__(self, p):\n self.InitBase()","def initialize(self):\n pass # pragma: no cover","def __init__(self, loader, *args, **kw):\n self._loader = loader","def initialise(self, **kwargs):\n pass","def _on_pipeline_init(self) -> None:\n pass","def initialize(self, **kwargs):","def _initialize(self) -> None:\n p = self.params\n # We make self.input public so that users can access its methods like\n # IdsToStrings if needed.\n with py_utils.infeed_context_scope(\n infeed_host_index=p.infeed_host_index,\n num_infeed_hosts=p.num_infeed_hosts):\n self.input = p.input.Instantiate()\n\n if hasattr(self.input, 'datasource') and isinstance(\n self.input.datasource, datasource.TFDatasetSource):\n # For the special case when the input is implemented by a tf.data.Dataset,\n # use it directly. Otherwise roundtrip adaptions may result in returning\n # duplciate batches.\n self._get_next_fn = self.input.datasource.GetNext\n else:\n self._get_next_fn = tf.function(self._get_batch)\n self._num_batches_produced = 0","def __init__(self, *args, **kwargs):\n # Training/prediction data volume\n self.train_volume: np.ndarray = None\n # Training label volume\n self.train_label_volume: Optional[np.ndarray] = None\n # Per-voxel training error weighting volume\n self.train_weight_volume: Optional[np.ndarray] = None\n # Validation data volume\n self.eval_volume: Optional[np.ndarray] = None\n # Validation label volume\n self.eval_label_volume: Optional[np.ndarray] = None\n\n # Number of label classes\n self.n_classes: int = None\n\n # RandomState used to control random number generation\n self.random_state = np.random.RandomState()\n\n # Image augmentation instance_settings for use during training\n self.augmentation_settings: Dict[str, Any] = None\n\n # Load data if arguments are supplied\n if len(args) > 0 or len(kwargs) > 0:\n self.load(*args, **kwargs)\n\n pass","def __init__ ( self ) :\n\n self.m_src = self.configSrc ('source', ':Cspad.')\n self.m_key_in = self.configStr ('key_in', 'peaks_nda')\n self.m_print_bits = self.configInt ('print_bits', 1)\n\n self.counter = 0\n self.count_msg = 0\n\n if self.m_print_bits & 1 : self.print_input_pars()\n\n self.list_of_dtypes = [\n psana.ndarray_float32_2,\n psana.ndarray_float64_2\n ]","def __init__(self):\n super(MultiProcessEngine, self).__init__()\n self._debug_output = False\n self._name = 'Main'\n self._last_worker_number = 0\n self._log_filename = None\n self._pid = os.getpid()\n self._process_information = process_info.ProcessInfo(self._pid)\n self._process_information_per_pid = {}\n self._processes_per_pid = {}\n self._quiet_mode = False\n self._rpc_clients_per_pid = {}\n self._rpc_errors_per_pid = {}\n self._status_update_active = False\n self._status_update_thread = None\n self._storage_writer = None\n self._worker_memory_limit = definitions.DEFAULT_WORKER_MEMORY_LIMIT","def initialize(self, args):\n # You must parse model_config. JSON string is not parsed here\n self.model_config = json.loads(args['model_config'])\n print(\"model_config:\", self.model_config)\n\n self.input_names = []\n for input_config in self.model_config[\"input\"]:\n self.input_names.append(input_config[\"name\"])\n print(\"postprocess input names:\", self.input_names)\n\n self.output_names = []\n self.output_dtype = []\n for output_config in self.model_config[\"output\"]:\n self.output_names.append(output_config[\"name\"])\n dtype = pb_utils.triton_string_to_numpy(output_config[\"data_type\"])\n self.output_dtype.append(dtype)\n print(\"postprocess output names:\", self.output_names)\n self.postprocessor = fd.vision.ocr.DBDetectorPostprocessor()\n self.cls_preprocessor = fd.vision.ocr.ClassifierPreprocessor()\n self.rec_preprocessor = fd.vision.ocr.RecognizerPreprocessor()\n self.cls_threshold = 0.9","def __init__(self, loader, *args, **kw):\r\n self._loader = loader","def __init__(self) -> None:\n # TODO: Provide the complete constructor for this object","def __init__(self, datapath, fileType='TargetLynx', sop='Generic', **kwargs):\n\n super().__init__(sop=sop, **kwargs)\n self.filePath, fileName = os.path.split(datapath)\n self.fileName, fileExtension = os.path.splitext(fileName)\n\n self.name = self.fileName\n\n # Load files and match data, calibration report and SOP, then Apply the limits of quantification\n if fileType == 'TargetLynx':\n # Read files, filter calibration samples, filter IS, applyLLOQ, clean object\n self._loadTargetLynxDataset(datapath, **kwargs)\n # Finalise object\n self.VariableType = VariableType.Discrete\n self.AnalyticalPlatform = AnalyticalPlatform.MS\n self.initialiseMasks()\n elif fileType == 'Bruker Quantification':\n # Read files, clean object\n self._loadBrukerXMLDataset(datapath, **kwargs)\n # Finalise object\n self.VariableType = VariableType.Discrete\n self.AnalyticalPlatform = AnalyticalPlatform.NMR\n self.initialiseMasks()\n elif fileType == 'empty':\n # Build empty object for testing\n pass\n else:\n raise NotImplementedError\n\n # Check the final object is valid and log\n if fileType != 'empty':\n validDataset = self.validateObject(verbose=False, raiseError=False, raiseWarning=False)\n if not validDataset['BasicTargetedDataset']:\n raise ValueError('Import Error: The imported dataset does not satisfy to the Basic TargetedDataset definition')\n self.Attributes['Log'].append([datetime.now(),\n '%s instance initiated, with %d samples, %d features, from %s'\n % (self.__class__.__name__, self.noSamples, self.noFeatures, datapath)])\n # Check later\n if 'Metadata Available' not in self.sampleMetadata:\n self.sampleMetadata['Metadata Available'] = False","def initialize(self, context):\n raise NotImplementedError","def __init__(self, config, loop):\n self.config = config\n self.loop = loop","def __init__(self, rdc):\n EphemeralProcessing.__init__(self, rdc)\n # Create the storage interface to store the exported resources\n self.storage_interface = rdc.create_storage_interface()","def _initialize(self, **kwargs):\n return None","def init(self, **kwargs):\n self._d = {}\n self._th = None\n self._run = True\n self.load()","def __init__(self, config, set_name, preprocess_image):\n\t\t\tself.data_dir = config['data_dir']\n\t\t\tself.set_name = set_name\n\t\t\tself.coco = COCO(os.path.join(self.data_dir, 'annotations', 'instances_' + set_name + '.json'))\n\t\t\tself.image_ids = self.coco.getImgIds()\n\t\t\tself.mask = config['mask']\n\n\t\t\tself.load_classes()\n\n\t\t\tsuper(CocoGenerator, self).__from_config__(config, preprocess_image=preprocess_image)","def __init__(self):\r\n\r\n self.Helpers = Helpers(\"Movidius\")\r\n self.confs = self.Helpers.confs\r\n\r\n self.classes = []\r\n self.ncsGraph = None\r\n self.ncsDevice = None\r\n self.reqsize = None\r\n\r\n self.mean = 128\r\n self.std = 1 / 128\r\n\r\n #mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2)\r\n\r\n self.Helpers.logger.info(\"Movidius class initialization complete.\")","def init(self, parameters):\n pass","def Initialise(self):\n self.__m_Platform.Initialise()\n self.__m_Pump.Initialise( False )","def __init__(self, task_manager, num_samples, num_shards, kernel, scale,\n bucket, directory):\n # Task parameters\n self.task_manager = task_manager\n self.num_samples = num_samples\n self.num_shards = num_shards\n\n # Patches paramters\n self.kernel = kernel\n self.scale = scale\n\n # Storage location\n self.bucket = bucket\n self.directory = directory","def __init__(self, **kwargs):\n cls = self.__class__\n\n # Initialize all configurables and input arguments\n for arg in cls.configurables():\n try: # Read from class constructor\n setattr(self, arg, kwargs[arg])\n except KeyError:\n try: # Set from default value defined in class\n default_value = getattr(self, arg).kwargs[\"default\"]\n setattr(self, arg, default_value)\n except KeyError: # if nothing is provided, fallbakcs to None\n setattr(self, arg, None)\n\n self.input_arguments = None\n if cls.input_configurables():\n self.input_arguments = [\n getattr(self, arg) for arg in cls.input_configurables()\n ]\n\n self.json_config = cfg.JsonConfig(self.config)\n self.output_objects = []\n self.file = None","def __init__(self,\n features: List[Text] = None,\n labels: List[Text] = None,\n overwrite: Dict[Text, Any] = None,\n **unused_kwargs):\n super(StandardPreprocesser, self).__init__(features=features,\n labels=labels,\n overwrite=overwrite,\n **unused_kwargs)\n\n # List of features and labels\n self.features = features or []\n self.labels = labels or []\n\n self.t_dict = parse_methods(overwrite or {},\n 'transform',\n TransformMethods)\n\n self.t_d_dict = parse_methods(DEFAULT_DICT,\n 'transform',\n TransformMethods)\n\n self.f_dict = parse_methods(overwrite or {},\n 'filling',\n NonSeqFillingMethods)\n\n self.f_d_dict = parse_methods(DEFAULT_DICT,\n 'filling',\n NonSeqFillingMethods)","def initialize(self, **kwargs):\n raise NotImplementedError()","def __init__(self, **kwargs):\n # Handle whatever kwargs we want here\n self.io_mapping = kwargs.get(\"io_mapping\", [])\n\n self.create_inputs = kwargs.get(\"create_inputs\", [])\n self.min_completion_fraction = kwargs.get(\"min_completion_fraction\", 1.0)\n\n # Now pass all of them to the parent class\n super(self.__class__, self).__init__(**kwargs)","def __init__(self):\n # Effective batch size\n self.BATCH_SIZE = self.IMAGES_PER_GPU * self.GPU_COUNT\n\n # Input image size\n if self.IMAGE_RESIZE_MODE == \"crop\":\n self.IMAGE_SHAPE = np.array([self.IMAGE_MIN_DIM, self.IMAGE_MIN_DIM,\n self.IMAGE_CHANNEL_COUNT])\n else:\n self.IMAGE_SHAPE = np.array([self.IMAGE_MAX_DIM, self.IMAGE_MAX_DIM,\n self.IMAGE_CHANNEL_COUNT])\n\n # Image meta data length\n # See compose_image_meta() for details\n self.IMAGE_META_SIZE = 1 + 3 + 3 + 4 + 1 + self.NUM_CLASSES","def __init__(self, *args):\n _snap.TFIn_swiginit(self, _snap.new_TFIn(*args))","def initialize(self):\n logger.debug(\"Begin Generation\")\n self.events.begin_generation()","def __init__(self):\r\n\r\n #480p 2.39:1 720x302\r\n #2048x2048 is more than 7.3GB of vRAM for the Master DISC model\r\n\r\n #Loading the preprocessed data\r\n preprocessVars = Preprocess()\r\n\r\n #The training and display of the trained models\r\n self.modelTrain = train.Train(preprocessVars)\r\n self.disp = display.Display(preprocessVars)","def __init__():","def __init__(self, preprocess=None, required=False):\n\n super().__init__(preprocess, required)\n self._type = str\n self._value = []","def __init__(self, filename: str):\n self.tif_file = None\n self.byteOrder = 'big'\n self.magic = None\n self.ifds = []\n\n if filename is not None:\n self.tif_file = TiffFileHandler(filename)\n self.load_tiff()","def _init(self):"],"string":"[\n \"def _initialize(self):\\n pass\",\n \"def _initialize(self):\\n pass\",\n \"def _initialize(self):\\n pass\",\n \"def initialize(cls):\",\n \"def __init__(self, *args, **kwargs):\\n # count the cores available on the local machine\\n self.tasks = mp.cpu_count()\\n super(ParallelPreprocessor, self).__init__(*args, **kwargs)\",\n \"def _init(self):\\n pass\",\n \"def _init(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n super(PreProcess, self).__init__()\",\n \"def initialize(self, *args, **kwargs):\\n pass\",\n \"def __init__(self):\\n self.tape_tag = None\\n self.independentVariableShapeList = []\\n self.dependentVariableShapeList = []\",\n \"def __init__(self, attributes=None):\\n super().__init__(attributes)\\n \\n # processing parameters\\n self.set = _Settings()\\n\\n # results storage\\n self.measure_time = None # store here in case we average FIDs, filled by chain!\\n self.frequency_shift = None\\n self.phase_0 = None\\n self.data = None\\n \\n if attributes is not None:\\n self.inflate(attributes)\\n\\n self.chain = None\",\n \"def init(self):\\n raise NotImplementedError\",\n \"def init(self):\\n raise NotImplementedError\",\n \"def initialize(self) -> None:\\n pass\",\n \"def __init__(self):\\n \\n self.load_PSF_data()\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n\\t\\tpass\",\n \"def init(self) -> None:\\n ...\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def initialize(self):\\r\\n pass\",\n \"def initialize(self):\\r\\n pass\",\n \"def __init__(self):\\r\\n config = ConfigProvider().getProcessingConfig()\\r\\n self.xGround = config.get(\\\"xGround\\\")\\r\\n self.yGround = config.get(\\\"yGround\\\")\",\n \"def __init__(self, pipeline, **kwargs):\\n self.pipeline = pipeline\\n\\n self.batch_size = pipeline.batch_size\\n self.X_train = None\\n self.y_train = None\\n self.X_valid = None\\n self.y_valid = None\\n\\n # Child classes should have init signature:\\n # (self, batch_size, **kwargs), should call this __init__ and then\\n # define self.X_train, self.y_train, self.X_valid, and self.y_valid\",\n \"def __init__(self, config):\\n Submodule.__init__(self, \\\"command_ingest\\\", config)\\n self.general_queue = queue()\\n\\n self.processes = {\\n \\\"dispatch\\\": ThreadHandler(\\n target=partial(self.dispatch),\\n name=\\\"command_ingest_dispatch\\\",\\n parent_logger=self.logger,\\n )\\n }\",\n \"def __init__(self,config,typ='train'):\\n\\n self._config = config\\n self.type = typ\\n self.reader = JsonlReader(self._config.annotations.as_dict()[typ])\\n self.annotations = self.reader.read()\\n self.transform = get_image_processor(self._config.image_processor)\",\n \"def do_init(self):\\n\\n pass\",\n \"def __init__(self):\\n _snap.TFile_swiginit(self, _snap.new_TFile())\",\n \"def __init__(self):\\n\\n self.read_input_file()\\n self.read_simulation_files()\",\n \"def init(self):\\n self._frame_idx = 0\\n if self.initialization is not None:\\n del self.initialization\\n self.initialization = None\\n\\n if self.config.initialization is not None:\\n self.initialization = INITIALIZATION.load(self.config.initialization, **self.__kwargs)\\n self.initialization.init()\\n\\n if self.preprocessing is not None:\\n del self.preprocessing\\n self.preprocessing = None\\n\\n if self.config.preprocessing is not None:\\n self.preprocessing = Preprocessing(self.config.preprocessing, **self.__kwargs)\\n\\n if self.odometry is None:\\n assert self.config.odometry is not None\\n self.odometry = ODOMETRY.load(self.config.odometry, **self.__kwargs)\\n\\n assert self.odometry is not None\\n self.odometry.init()\\n if self.loop_closure is None and self.config.loop_closure is not None:\\n self.loop_closure = LOOP_CLOSURE.load(self.config.loop_closure, **self.__kwargs)\\n if self.loop_closure is not None:\\n self.loop_closure.init()\\n if self.config.backend is not None:\\n self.backend = BACKEND.load(self.config.backend, **self.__kwargs)\\n if self.backend is not None:\\n self.backend.init()\\n else:\\n logging.warning(\\\"[SLAMAlgorithm]Defined a Loop Closure Algorithm Without a Backend\\\")\",\n \"def __init__(self, data_streamer, sonifier, mapping):\\n self._data_streamer = data_streamer\\n self._mapping = mapping\\n self._init_sonifier(sonifier)\\n self._parameter_names = self._mapping.keys()\\n self._value_queues = dict()\\n for parameter in self._parameter_names:\\n self._value_queues[parameter] = LifoQueue()\\n self._run = True\",\n \"def __init__(self, processing_hub, parent=None):\\n super(ProcessingWorker, self).__init__(parent)\\n\\n self.parent = parent\\n\\n # Processing hub object\\n self.processing_hub = processing_hub\\n\\n # Flag to indicate processing mode\\n self.processing_mode = processing_hub.control.processing_mode\\n\\n # Initialise progress bar with enabled loggers\\n loggers = self.processing_hub.control.loggers\\n enabled_logger_ids = [logger.logger_id for logger in loggers if logger.enabled]\\n self.pb = ProcessingProgressBar(enabled_logger_ids)\\n self.pb.show()\\n self._connect_signals()\",\n \"def __init__(self):\\n\\t\\tScriptedLoadableModuleLogic.__init__(self)\\n\\n\\t\\tself._parameterNode = None\\n\\t\\tself.postopProgrammingInstance = None\\n\\t\\tself.FrameAutoDetect = False\",\n \"def initialize(self):\\n self.initialize_edges()\\n self.initialize_prob()\\n self.initialize_total_input_dict()\\n\\n self.initialize_fpmusigv_dict()\",\n \"def init(self) -> None:\",\n \"def __init__(self, binning: int = 2, **kwargs: Any):\\n ImageProcessor.__init__(self, **kwargs)\\n\\n # store\\n self.binning = binning\",\n \"def _init(self, options):\\n self._initRuntime(options)\\n self._loadConfig() # needs runtime\\n self._initGeneral() # needs _config\\n self._initGroups() # needs _config and general\",\n \"def __init__(self):\\n manager = Manager()\\n # As the snippet is executing in multiprocessing.Process, a shared\\n # dict should be used to ensure the change is propagated.\\n self.local = manager.dict()\\n\\n # the object in shared dict should also be shared\\n for k, v in self.presets.items():\\n if isinstance(v, list):\\n self.local[k] = manager.list(v)\\n elif isinstance(v, dict):\\n self.local[k] = manager.dict(v)\\n elif isinstance(v, set):\\n self.local[k] = manager.set(v)\\n else:\\n self.local[k] = v\",\n \"def setup_class(cls):\\n\\n # set the base directory\\n cls.basedir = os.path.join(os.path.split(os.path.realpath(__file__))[0], \\\"base\\\")\\n\\n cls.ninj = 50 # number of simulated signals\\n cls.maxamp = 5e-23 # maximum amplitude\\n cls.freqrange = (10.0, 100.0) # frequency range\\n\\n # default prior dictionary\\n cls.priors = {}\\n cls.priors[\\\"h0\\\"] = bilby.core.prior.Uniform(\\n name=\\\"h0\\\", minimum=0.0, maximum=1e-22\\n )\",\n \"def __init__(self, root, transform=None, pre_transform=None, pre_filter=None, re_process_init=True):\\n self.re_process_init = re_process_init\\n\\n super(DatasetGEO, self).__init__(root, transform, pre_transform, pre_filter=pre_filter)\\n\\n if re_process_init:\\n self.re_process()\\n else:\\n pass\",\n \"def initialize(self, *args, **kwargs):\",\n \"def init(self, *args, **kwds):\\n pass\",\n \"def initialise(self):\",\n \"def __init__(self) -> None:\\n self.registration_method = None\\n self.fixed_image = None\\n self.moving_image = None\\n self.transform = None\",\n \"def __init__(self, the_input_shape, num_classes):\\n self.the_input_shape = the_input_shape\\n self.num_classes = num_classes\",\n \"def __init__(self):\\r\\n self.label = \\\"ProcessGeogridFile\\\"\\r\\n self.description = \\\"This tool takes an input WRF Geogrid file in NetCDF format\\\" + \\\\\\r\\n \\\" and uses the HGT_M grid and an input high-resolution elevation grid\\\" + \\\\\\r\\n \\\"to produce a high-resolution hydrologically processed output.\\\"\\r\\n #self.canRunInBackground = False\\r\\n self.canRunInBackground = True\\r\\n self.category = \\\"Processing\\\"\",\n \"def __init__(self, task_queue, results_queue, individuals):\\n Process.__init__(self)\\n \\n self.proc_name = self.name\\n \\n logger.info(\\\"Setting up variant_annotator: {0}\\\".format(\\n self.proc_name))\\n \\n logger.debug(\\\"Setting up task queue\\\")\\n self.task_queue = task_queue\\n \\n logger.debug(\\\"Setting up results queue\\\")\\n self.results_queue = results_queue\\n\\n logger.debug(\\\"Setting up individuals\\\")\\n self.individuals = individuals\\n \\n if len(self.individuals) == 1:\\n self.models = ['AR_comp', 'AR_comp_dn', 'AD', 'AD_dn']\\n else:\\n self.models = ['AR_comp', 'AR_comp_dn']\",\n \"def __init__(self, pipeline):\\n self._jobs = []\\n self._active_jobs = []\\n\\n self._threads = []\\n self._thread_index = {}\\n self._thread_id = 1\\n\\n\\n self.local_backend = Local()\\n self.backend = None\\n\\n self.pipeline = pipeline\",\n \"def __init__(self, log_settings, log_queue, loop = None):\\n\\t\\tself.loop = loop if loop is not None else asyncio.get_event_loop()\\n\\t\\tself.log_settings = log_settings\\n\\t\\tself.log_queue = log_queue\\n\\t\\tself.logger = None\\n\\t\\tself.extensions_tasks = {}\\n\\t\\tself.extension_task_id = 0\\n\\t\\tself.result_history = {}\\n\\t\\tself.proxy_file_handler = None\\n\\t\\tself.name = 'LogProcessor'\",\n \"def initialize(self, **kwargs: Any) -> None:\\n pass\",\n \"def initialize(self) -> None:\\n self._step = self._start_step\\n self._tebd_propagator = compute_tebd_propagator(\\n system_chain=self._system_chain,\\n time_step=self._parameters.dt/2.0,\\n epsrel=self._parameters.epsrel,\\n order=self._parameters.order)\\n self._results = {}\\n self._t_mps = PtTebdBackend(\\n gammas=self._initial_augmented_mps.gammas,\\n lambdas=self._initial_augmented_mps.lambdas,\\n epsrel=self._parameters.epsrel,\\n config=self._backend_config)\\n self._init_results()\\n self._apply_controls(step=self.step, post=False)\\n self._append_results()\",\n \"def __init__(\\n self,\\n system: BaseSystem,\\n bath: Bath,\\n process_tensor: BaseProcessTensor,\\n initial_state: Optional[ndarray] = None,\\n system_correlations: Optional[ndarray] = None,\\n name: Optional[Text] = None,\\n description: Optional[Text] = None) -> None:\\n self._system = system\\n self._bath = bath\\n\\n initial_tensor = process_tensor.get_initial_tensor()\\n assert (initial_state is None) ^ (initial_tensor is None), \\\\\\n \\\"Initial state must be either (exclusively) encoded in the \\\" \\\\\\n + \\\"process tensor or given as an argument.\\\"\\n\\n self._process_tensor = process_tensor\\n self._initial_state = initial_state\\n\\n if system_correlations is None:\\n self._system_correlations = np.array([[]], dtype=NpDtype)\\n else:\\n self._system_correlations = system_correlations\\n self._temp = bath.correlations.temperature\\n self._bath_correlations = {}\\n super().__init__(name, description)\",\n \"def __init__(self, p):\\n self.InitBase()\",\n \"def initialize(self):\\n pass # pragma: no cover\",\n \"def __init__(self, loader, *args, **kw):\\n self._loader = loader\",\n \"def initialise(self, **kwargs):\\n pass\",\n \"def _on_pipeline_init(self) -> None:\\n pass\",\n \"def initialize(self, **kwargs):\",\n \"def _initialize(self) -> None:\\n p = self.params\\n # We make self.input public so that users can access its methods like\\n # IdsToStrings if needed.\\n with py_utils.infeed_context_scope(\\n infeed_host_index=p.infeed_host_index,\\n num_infeed_hosts=p.num_infeed_hosts):\\n self.input = p.input.Instantiate()\\n\\n if hasattr(self.input, 'datasource') and isinstance(\\n self.input.datasource, datasource.TFDatasetSource):\\n # For the special case when the input is implemented by a tf.data.Dataset,\\n # use it directly. Otherwise roundtrip adaptions may result in returning\\n # duplciate batches.\\n self._get_next_fn = self.input.datasource.GetNext\\n else:\\n self._get_next_fn = tf.function(self._get_batch)\\n self._num_batches_produced = 0\",\n \"def __init__(self, *args, **kwargs):\\n # Training/prediction data volume\\n self.train_volume: np.ndarray = None\\n # Training label volume\\n self.train_label_volume: Optional[np.ndarray] = None\\n # Per-voxel training error weighting volume\\n self.train_weight_volume: Optional[np.ndarray] = None\\n # Validation data volume\\n self.eval_volume: Optional[np.ndarray] = None\\n # Validation label volume\\n self.eval_label_volume: Optional[np.ndarray] = None\\n\\n # Number of label classes\\n self.n_classes: int = None\\n\\n # RandomState used to control random number generation\\n self.random_state = np.random.RandomState()\\n\\n # Image augmentation instance_settings for use during training\\n self.augmentation_settings: Dict[str, Any] = None\\n\\n # Load data if arguments are supplied\\n if len(args) > 0 or len(kwargs) > 0:\\n self.load(*args, **kwargs)\\n\\n pass\",\n \"def __init__ ( self ) :\\n\\n self.m_src = self.configSrc ('source', ':Cspad.')\\n self.m_key_in = self.configStr ('key_in', 'peaks_nda')\\n self.m_print_bits = self.configInt ('print_bits', 1)\\n\\n self.counter = 0\\n self.count_msg = 0\\n\\n if self.m_print_bits & 1 : self.print_input_pars()\\n\\n self.list_of_dtypes = [\\n psana.ndarray_float32_2,\\n psana.ndarray_float64_2\\n ]\",\n \"def __init__(self):\\n super(MultiProcessEngine, self).__init__()\\n self._debug_output = False\\n self._name = 'Main'\\n self._last_worker_number = 0\\n self._log_filename = None\\n self._pid = os.getpid()\\n self._process_information = process_info.ProcessInfo(self._pid)\\n self._process_information_per_pid = {}\\n self._processes_per_pid = {}\\n self._quiet_mode = False\\n self._rpc_clients_per_pid = {}\\n self._rpc_errors_per_pid = {}\\n self._status_update_active = False\\n self._status_update_thread = None\\n self._storage_writer = None\\n self._worker_memory_limit = definitions.DEFAULT_WORKER_MEMORY_LIMIT\",\n \"def initialize(self, args):\\n # You must parse model_config. JSON string is not parsed here\\n self.model_config = json.loads(args['model_config'])\\n print(\\\"model_config:\\\", self.model_config)\\n\\n self.input_names = []\\n for input_config in self.model_config[\\\"input\\\"]:\\n self.input_names.append(input_config[\\\"name\\\"])\\n print(\\\"postprocess input names:\\\", self.input_names)\\n\\n self.output_names = []\\n self.output_dtype = []\\n for output_config in self.model_config[\\\"output\\\"]:\\n self.output_names.append(output_config[\\\"name\\\"])\\n dtype = pb_utils.triton_string_to_numpy(output_config[\\\"data_type\\\"])\\n self.output_dtype.append(dtype)\\n print(\\\"postprocess output names:\\\", self.output_names)\\n self.postprocessor = fd.vision.ocr.DBDetectorPostprocessor()\\n self.cls_preprocessor = fd.vision.ocr.ClassifierPreprocessor()\\n self.rec_preprocessor = fd.vision.ocr.RecognizerPreprocessor()\\n self.cls_threshold = 0.9\",\n \"def __init__(self, loader, *args, **kw):\\r\\n self._loader = loader\",\n \"def __init__(self) -> None:\\n # TODO: Provide the complete constructor for this object\",\n \"def __init__(self, datapath, fileType='TargetLynx', sop='Generic', **kwargs):\\n\\n super().__init__(sop=sop, **kwargs)\\n self.filePath, fileName = os.path.split(datapath)\\n self.fileName, fileExtension = os.path.splitext(fileName)\\n\\n self.name = self.fileName\\n\\n # Load files and match data, calibration report and SOP, then Apply the limits of quantification\\n if fileType == 'TargetLynx':\\n # Read files, filter calibration samples, filter IS, applyLLOQ, clean object\\n self._loadTargetLynxDataset(datapath, **kwargs)\\n # Finalise object\\n self.VariableType = VariableType.Discrete\\n self.AnalyticalPlatform = AnalyticalPlatform.MS\\n self.initialiseMasks()\\n elif fileType == 'Bruker Quantification':\\n # Read files, clean object\\n self._loadBrukerXMLDataset(datapath, **kwargs)\\n # Finalise object\\n self.VariableType = VariableType.Discrete\\n self.AnalyticalPlatform = AnalyticalPlatform.NMR\\n self.initialiseMasks()\\n elif fileType == 'empty':\\n # Build empty object for testing\\n pass\\n else:\\n raise NotImplementedError\\n\\n # Check the final object is valid and log\\n if fileType != 'empty':\\n validDataset = self.validateObject(verbose=False, raiseError=False, raiseWarning=False)\\n if not validDataset['BasicTargetedDataset']:\\n raise ValueError('Import Error: The imported dataset does not satisfy to the Basic TargetedDataset definition')\\n self.Attributes['Log'].append([datetime.now(),\\n '%s instance initiated, with %d samples, %d features, from %s'\\n % (self.__class__.__name__, self.noSamples, self.noFeatures, datapath)])\\n # Check later\\n if 'Metadata Available' not in self.sampleMetadata:\\n self.sampleMetadata['Metadata Available'] = False\",\n \"def initialize(self, context):\\n raise NotImplementedError\",\n \"def __init__(self, config, loop):\\n self.config = config\\n self.loop = loop\",\n \"def __init__(self, rdc):\\n EphemeralProcessing.__init__(self, rdc)\\n # Create the storage interface to store the exported resources\\n self.storage_interface = rdc.create_storage_interface()\",\n \"def _initialize(self, **kwargs):\\n return None\",\n \"def init(self, **kwargs):\\n self._d = {}\\n self._th = None\\n self._run = True\\n self.load()\",\n \"def __init__(self, config, set_name, preprocess_image):\\n\\t\\t\\tself.data_dir = config['data_dir']\\n\\t\\t\\tself.set_name = set_name\\n\\t\\t\\tself.coco = COCO(os.path.join(self.data_dir, 'annotations', 'instances_' + set_name + '.json'))\\n\\t\\t\\tself.image_ids = self.coco.getImgIds()\\n\\t\\t\\tself.mask = config['mask']\\n\\n\\t\\t\\tself.load_classes()\\n\\n\\t\\t\\tsuper(CocoGenerator, self).__from_config__(config, preprocess_image=preprocess_image)\",\n \"def __init__(self):\\r\\n\\r\\n self.Helpers = Helpers(\\\"Movidius\\\")\\r\\n self.confs = self.Helpers.confs\\r\\n\\r\\n self.classes = []\\r\\n self.ncsGraph = None\\r\\n self.ncsDevice = None\\r\\n self.reqsize = None\\r\\n\\r\\n self.mean = 128\\r\\n self.std = 1 / 128\\r\\n\\r\\n #mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2)\\r\\n\\r\\n self.Helpers.logger.info(\\\"Movidius class initialization complete.\\\")\",\n \"def init(self, parameters):\\n pass\",\n \"def Initialise(self):\\n self.__m_Platform.Initialise()\\n self.__m_Pump.Initialise( False )\",\n \"def __init__(self, task_manager, num_samples, num_shards, kernel, scale,\\n bucket, directory):\\n # Task parameters\\n self.task_manager = task_manager\\n self.num_samples = num_samples\\n self.num_shards = num_shards\\n\\n # Patches paramters\\n self.kernel = kernel\\n self.scale = scale\\n\\n # Storage location\\n self.bucket = bucket\\n self.directory = directory\",\n \"def __init__(self, **kwargs):\\n cls = self.__class__\\n\\n # Initialize all configurables and input arguments\\n for arg in cls.configurables():\\n try: # Read from class constructor\\n setattr(self, arg, kwargs[arg])\\n except KeyError:\\n try: # Set from default value defined in class\\n default_value = getattr(self, arg).kwargs[\\\"default\\\"]\\n setattr(self, arg, default_value)\\n except KeyError: # if nothing is provided, fallbakcs to None\\n setattr(self, arg, None)\\n\\n self.input_arguments = None\\n if cls.input_configurables():\\n self.input_arguments = [\\n getattr(self, arg) for arg in cls.input_configurables()\\n ]\\n\\n self.json_config = cfg.JsonConfig(self.config)\\n self.output_objects = []\\n self.file = None\",\n \"def __init__(self,\\n features: List[Text] = None,\\n labels: List[Text] = None,\\n overwrite: Dict[Text, Any] = None,\\n **unused_kwargs):\\n super(StandardPreprocesser, self).__init__(features=features,\\n labels=labels,\\n overwrite=overwrite,\\n **unused_kwargs)\\n\\n # List of features and labels\\n self.features = features or []\\n self.labels = labels or []\\n\\n self.t_dict = parse_methods(overwrite or {},\\n 'transform',\\n TransformMethods)\\n\\n self.t_d_dict = parse_methods(DEFAULT_DICT,\\n 'transform',\\n TransformMethods)\\n\\n self.f_dict = parse_methods(overwrite or {},\\n 'filling',\\n NonSeqFillingMethods)\\n\\n self.f_d_dict = parse_methods(DEFAULT_DICT,\\n 'filling',\\n NonSeqFillingMethods)\",\n \"def initialize(self, **kwargs):\\n raise NotImplementedError()\",\n \"def __init__(self, **kwargs):\\n # Handle whatever kwargs we want here\\n self.io_mapping = kwargs.get(\\\"io_mapping\\\", [])\\n\\n self.create_inputs = kwargs.get(\\\"create_inputs\\\", [])\\n self.min_completion_fraction = kwargs.get(\\\"min_completion_fraction\\\", 1.0)\\n\\n # Now pass all of them to the parent class\\n super(self.__class__, self).__init__(**kwargs)\",\n \"def __init__(self):\\n # Effective batch size\\n self.BATCH_SIZE = self.IMAGES_PER_GPU * self.GPU_COUNT\\n\\n # Input image size\\n if self.IMAGE_RESIZE_MODE == \\\"crop\\\":\\n self.IMAGE_SHAPE = np.array([self.IMAGE_MIN_DIM, self.IMAGE_MIN_DIM,\\n self.IMAGE_CHANNEL_COUNT])\\n else:\\n self.IMAGE_SHAPE = np.array([self.IMAGE_MAX_DIM, self.IMAGE_MAX_DIM,\\n self.IMAGE_CHANNEL_COUNT])\\n\\n # Image meta data length\\n # See compose_image_meta() for details\\n self.IMAGE_META_SIZE = 1 + 3 + 3 + 4 + 1 + self.NUM_CLASSES\",\n \"def __init__(self, *args):\\n _snap.TFIn_swiginit(self, _snap.new_TFIn(*args))\",\n \"def initialize(self):\\n logger.debug(\\\"Begin Generation\\\")\\n self.events.begin_generation()\",\n \"def __init__(self):\\r\\n\\r\\n #480p 2.39:1 720x302\\r\\n #2048x2048 is more than 7.3GB of vRAM for the Master DISC model\\r\\n\\r\\n #Loading the preprocessed data\\r\\n preprocessVars = Preprocess()\\r\\n\\r\\n #The training and display of the trained models\\r\\n self.modelTrain = train.Train(preprocessVars)\\r\\n self.disp = display.Display(preprocessVars)\",\n \"def __init__():\",\n \"def __init__(self, preprocess=None, required=False):\\n\\n super().__init__(preprocess, required)\\n self._type = str\\n self._value = []\",\n \"def __init__(self, filename: str):\\n self.tif_file = None\\n self.byteOrder = 'big'\\n self.magic = None\\n self.ifds = []\\n\\n if filename is not None:\\n self.tif_file = TiffFileHandler(filename)\\n self.load_tiff()\",\n \"def _init(self):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6463012","0.6463012","0.6463012","0.6433146","0.6373256","0.6362228","0.63576984","0.6353064","0.6337008","0.6281862","0.6280358","0.6260662","0.6260662","0.62492085","0.6231807","0.6200611","0.6200611","0.6200611","0.6200611","0.6200611","0.6199629","0.61927366","0.6188616","0.6188616","0.6188616","0.6188616","0.6188616","0.6188616","0.6188616","0.6188616","0.6184222","0.6184222","0.6184222","0.61700284","0.61700284","0.6169445","0.6164659","0.6154438","0.6152564","0.61450166","0.612603","0.6120382","0.61015886","0.61000276","0.6099866","0.6098514","0.6093423","0.6081582","0.60792905","0.6071711","0.6071459","0.60643643","0.60403186","0.6038243","0.6037052","0.60327184","0.60255647","0.60154307","0.6014881","0.6012838","0.6010042","0.6004097","0.60004413","0.5999509","0.59990644","0.5996031","0.5988437","0.59845066","0.59805703","0.5975491","0.59737545","0.59713316","0.59688663","0.596669","0.59609526","0.59573317","0.59536815","0.595052","0.594957","0.594905","0.5948993","0.59455186","0.59429735","0.5939619","0.59341997","0.5931213","0.59280616","0.59265715","0.59244066","0.59192663","0.5918169","0.5914869","0.5913634","0.5913352","0.5912023","0.5907787","0.59076136","0.5906863","0.5896918","0.58942926","0.5893166"],"string":"[\n \"0.6463012\",\n \"0.6463012\",\n \"0.6463012\",\n \"0.6433146\",\n \"0.6373256\",\n \"0.6362228\",\n \"0.63576984\",\n \"0.6353064\",\n \"0.6337008\",\n \"0.6281862\",\n \"0.6280358\",\n \"0.6260662\",\n \"0.6260662\",\n \"0.62492085\",\n \"0.6231807\",\n \"0.6200611\",\n \"0.6200611\",\n \"0.6200611\",\n \"0.6200611\",\n \"0.6200611\",\n \"0.6199629\",\n \"0.61927366\",\n \"0.6188616\",\n \"0.6188616\",\n \"0.6188616\",\n \"0.6188616\",\n \"0.6188616\",\n \"0.6188616\",\n \"0.6188616\",\n \"0.6188616\",\n \"0.6184222\",\n \"0.6184222\",\n \"0.6184222\",\n \"0.61700284\",\n \"0.61700284\",\n \"0.6169445\",\n \"0.6164659\",\n \"0.6154438\",\n \"0.6152564\",\n \"0.61450166\",\n \"0.612603\",\n \"0.6120382\",\n \"0.61015886\",\n \"0.61000276\",\n \"0.6099866\",\n \"0.6098514\",\n \"0.6093423\",\n \"0.6081582\",\n \"0.60792905\",\n \"0.6071711\",\n \"0.6071459\",\n \"0.60643643\",\n \"0.60403186\",\n \"0.6038243\",\n \"0.6037052\",\n \"0.60327184\",\n \"0.60255647\",\n \"0.60154307\",\n \"0.6014881\",\n \"0.6012838\",\n \"0.6010042\",\n \"0.6004097\",\n \"0.60004413\",\n \"0.5999509\",\n \"0.59990644\",\n \"0.5996031\",\n \"0.5988437\",\n \"0.59845066\",\n \"0.59805703\",\n \"0.5975491\",\n \"0.59737545\",\n \"0.59713316\",\n \"0.59688663\",\n \"0.596669\",\n \"0.59609526\",\n \"0.59573317\",\n \"0.59536815\",\n \"0.595052\",\n \"0.594957\",\n \"0.594905\",\n \"0.5948993\",\n \"0.59455186\",\n \"0.59429735\",\n \"0.5939619\",\n \"0.59341997\",\n \"0.5931213\",\n \"0.59280616\",\n \"0.59265715\",\n \"0.59244066\",\n \"0.59192663\",\n \"0.5918169\",\n \"0.5914869\",\n \"0.5913634\",\n \"0.5913352\",\n \"0.5912023\",\n \"0.5907787\",\n \"0.59076136\",\n \"0.5906863\",\n \"0.5896918\",\n \"0.58942926\",\n \"0.5893166\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84591,"cells":{"query":{"kind":"string","value":"Create a butter bandpass filter."},"document":{"kind":"string","value":"def _butter_bandpass(lowcut: float, highcut: float, fs: float, order: int = 5) -> tuple:\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n b, a = butter(order, [low, high], btype=\"band\")\n return b, a"},"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 butter_filter(datalist):\n fs = 200.00\n fHigh = 50.00\n fLow = 5.00\n N=4\n [b,a]=sg.butter(N,[fLow/fs, fHigh/fs], btype='band')\n global filtered\n #IIR filter\n return sg.filtfilt(b,a,datalist)","def butter_bandpass_filter(data, lowcut, highcut, fs, order=5, axis=0): \n omega = 0.5 * fs\n low = lowcut / omega\n high = highcut / omega\n b, a = signal.butter(order, [low, high], btype='band')\n y = signal.lfilter(b, a, data, axis=0)\n return y","def ButterworthFilter(\n self,\n name: str,\n cutoffFrequency: float,\n order: int = 2,\n operation: SymbolicConstant = NONE,\n halt: Boolean = OFF,\n limit: float = None,\n invariant: SymbolicConstant = NONE,\n ) -> ButterworthFilter:\n self.filters[name] = butterworthFilter = ButterworthFilter(\n name, cutoffFrequency, order, operation, halt, limit, invariant\n )\n return butterworthFilter","def butter_bandpass_filter(data, lowcut, highcut, fs, order=1):\n b, a = butter_bandpass(lowcut, highcut, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def butter_filter(self, data, low_pass, high_pass, fs, order=10):\n\n nyq = fs/2\n low = low_pass/nyq\n high = high_pass/nyq\n\n b, a = signal.butter(order, [low, high], btype='band')\n filt_data = np.abs(signal.hilbert(signal.filtfilt(b, a, data, axis=1), axis=1))\n return filt_data","def butterworth_bandpass_filter( values, lowFreq, highFreq, sampleFreq, order=5):\n nyq = 0.5 * sampleFreq\n low = lowFreq / nyq\n high = highFreq /nyq\n b,a = butter( order, [low,high], btype='band' )\n return y = lfilter(b, a, data)","def butter_bandpass_filter(data, lowcut, highcut, fs, order=2):\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n \n # butter() and lfilter() are from scipy.signal\n \n b, a = butter(order, [low, high], btype='band')\n y = lfilter(b, a, data)\n return y","def butter_bandpass_filter(\n data: numpy.ndarray,\n lowcut: float,\n highcut: float,\n samplerate: float,\n order: int = 2,\n):\n nyq = 0.5 * samplerate\n lowf = lowcut / nyq\n highf = highcut / nyq\n # generic names for coefficients in filters\n # pylint: disable=invalid-name\n a, b = butter(order, [lowf, highf], btype=\"band\")\n if len(data) < BUTTER_MIN_LENGTH:\n return None\n return filtfilt(a, b, data)","def make_butter_sp(self, wn, order):\n nyquist = self.s_freq/2\n wn_arr=np.asarray(wn)\n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\n \n self.sp_sos = butter(order, wn_arr, btype='bandpass', output='sos')\n print(f\"Zero phase butterworth filter successfully created: order = {order}x{order} bandpass = {wn}\")","def _butter_bandpass_filter(self, data: np.ndarray, lowcut: float, highcut: float, fs: float, order: int = 5):\n b, a = self._butter_bandpass(lowcut, highcut, fs, order=order)\n y = lfilter(b, a, data)\n return y","def make_butter_so(self, wn, order):\n \n nyquist = self.s_freq/2\n wn_arr = np.asarray(wn)\n \n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\n \n self.so_sos = butter(order, wn_arr, btype='bandpass', output='sos')\n print(f\"Zero phase butterworth filter successfully created: order = {order}x{order}, bandpass = {wn}\")","def butterworth_filter(signal, Fs, highpassfreq=None, lowpassfreq=None, order=4, filtfunc='filtfilt'):\n Fn = Fs / 2.\n \n # set the function for filtering\n if filtfunc is 'lfilter':\n ffunc = spsig.lfilter\n elif filtfunc is 'filtfilt':\n ffunc = spsig.filtfilt\n else:\n raise ValueError(\"filtfunc must to be either 'filtfilt' or 'lfilter'\")\n \n # set parameters\n if lowpassfreq and highpassfreq:\n if highpassfreq < lowpassfreq:\n Wn = (highpassfreq / Fn, lowpassfreq / Fn)\n btype = 'bandpass'\n else:\n Wn = (lowpassfreq / Fn, highpassfreq / Fn)\n btype = 'bandstop'\n elif lowpassfreq:\n Wn = lowpassfreq / Fn\n btype = 'lowpass'\n elif highpassfreq:\n Wn = highpassfreq / Fn\n btype = 'highpass'\n else:\n raise ValueError(\"Specify highpassfreq and/or lowpathfreq\")\n \n # filter design\n b, a = spsig.butter(order, Wn, btype=btype)\n \n return ffunc(b, a, signal)","def butter_bp_coe(lowcut, highcut, fs, order=1):\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n b, a = butter(order, [low, high], btype='band')\n return b, a","def butterworth_bandpass(lowcut, highcut, fs, order=5):\n nyq = 0.5 * fs # nyquist sampling rate\n low = lowcut / nyq # normalize frequency\n high = highcut / nyq # normalize frequency\n b, a = butter(order, [low, high], btype='band')\n return b, a","def butter_bandstop_filter(data, lowcut, highcut, fs, order):\n\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n\n i, u = sg.butter(order, (low, high), btype='bandstop')\n y = sg.filtfilt(i, u, data)\n return y","def Butterworth_Filter(x,order,Low_High,Wn):\r\n\r\n\r\n # Create an order butterworth filter:\r\n\r\n b, a = signal.butter(order,Wn,Low_High);\r\n\r\n # Apply the filter to x. Use lfilter_zi to choose the initial condition of the filter:\r\n\r\n zi = signal.lfilter_zi(b, a);\r\n z, _ = signal.lfilter(b, a, x, zi=zi*x[0]);\r\n\r\n # Apply the filter again, to have a result filtered at an order the same as filtfilt:\r\n\r\n z2, _ = signal.lfilter(b, a, z, zi=zi*z[0])\r\n\r\n # Use filtfilt to apply the filter:\r\n\r\n y = signal.filtfilt(b, a, x);\r\n\r\n return y;","def butterworth_filter(freq):\n\tf_raw = 1/(0.00000002*100*33)\n\tb = np.array([[-32092,15750],[-31238,14895]])*2.0**(-14)\n\tomega = 2*np.pi*freq/f_raw\n\te1, e2 = np.exp(-1j*omega), np.exp(-2j*omega)\n\ttmp = (1+2*e1+e2)**2/(1+b[0,0]*e1+b[0,1]*e2)/(1+b[1,0]*e1+b[1,1]*e2)\n\treturn tmp * (1+sum(b[0]))*(1+sum(b[1]))/16","def butterworth(dx, order, cutoff, /, btype='low'):\n # Initial stuff\n # * Need to run *forward and backward* to prevent time-shifting.\n # * The 'analog' means units of cutoffs are rad/s.\n # * Unlike Lanczos filter, the *length* of this should be\n # determined always as function of timestep, because really high\n # order filters can get pretty wonky.\n # * Cutoff is point at which gain reduces to 1/sqrt(2) of the\n # initial frequency. If doing bandpass, can\n # N = (width/dx)//1 # convert to timestep units\n # N = (N//2)*2 + 1 # odd numbered\n N = order # or order\n analog = False # lfilter seems to need digital\n if analog:\n cutoff = 2 * np.pi / (cutoff / dx) # from wavelengths to rad/steps\n else:\n cutoff = 1.0 / cutoff # to Hz, or cycles/unit\n cutoff = cutoff * (2 * dx) # to cycles / (2 timesteps)\n if cutoff > 1:\n raise ValueError(\n 'Cuttoff frequency must be in [0, 1]. Remember you pass a cutoff '\n '*wavelength* to this function, not a frequency.'\n )\n\n # Apply filter\n print(f'Order-{order} Butterworth filter')\n b, a = signal.butter(N - 1, cutoff, btype=btype, analog=analog, output='ba')\n return b, a","def design_filter(interpolation, decimation, fractional_bw):\n\n if fractional_bw >= 0.5 or fractional_bw <= 0:\n raise ValueError('Invalid fractional bandwidth, must be in (0, 0.5)')\n\n if decimation < 1 or interpolation < 1:\n raise ValueError('Invalid interpolation or decimation rate. Must be a non-zero positive integer.')\n\n beta = 7.0\n halfband = 0.5\n rate = float(interpolation)/float(decimation)\n if(rate >= 1.0):\n trans_width = halfband - fractional_bw\n mid_transition_band = halfband - trans_width/2.0\n else:\n trans_width = rate*(halfband - fractional_bw)\n mid_transition_band = rate*halfband - trans_width/2.0\n\n taps = filter.firdes.low_pass(interpolation, # gain\n interpolation, # Fs\n mid_transition_band, # trans mid point\n trans_width, # transition width\n filter.firdes.WIN_KAISER,\n beta) # beta\n\n return taps","def butter_filter(image, n, f0):\n [ny, nx] = image.shape\n dx = 2.0/nx\n dy = 2.0/nx\n dfx = 0.5\n dfy = 0.5\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\n FX, FY = np.meshgrid(fx, fy)\n shift = np.exp(-2*np.pi*1j*(FX+FY))\n sin_pad = np.sin(image)\n cos_pad = np.cos(image)\n ft_sin = shift * np.fft.fftshift(np.fft.fft2(sin_pad))\n ft_cos = shift * np.fft.fftshift(np.fft.fft2(cos_pad))\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\n sin_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_sin)) / shift)\n cos_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_cos)) / shift)\n phase_filt = np.arctan2(sin_filt, cos_filt)\n return phase_filt","def make_butter_spso(self, spso_wn_pass, spso_wn_stop, spso_order):\n nyquist = self.s_freq/2\n wn_pass_arr = np.asarray(spso_wn_pass)\n wn_stop_arr = np.asarray(spso_wn_stop)\n \n # must remake filter for each pt bc of differences in s_freq\n if np.any(wn_pass_arr <=0) or np.any(wn_pass_arr >=1):\n wn_pass_arr = wn_pass_arr/nyquist \n \n if np.any(wn_stop_arr <=0) or np.any(wn_stop_arr >=1):\n wn_stop_arr = wn_stop_arr/nyquist\n\n self.spso_sos_bandstop = butter(spso_order, wn_stop_arr, btype='bandstop', output='sos')\n self.spso_sos_bandpass = butter(spso_order, wn_pass_arr, btype='bandpass', output='sos')\n print(f\"Zero phase butterworth filter successfully created: order = {spso_order}x{spso_order} bandpass = {spso_wn_pass}\")\n print(f\"Zero phase butterworth filter successfully created: order = {spso_order}x{spso_order} bandstop = {spso_wn_stop}\")","def butter_bp(n, wlo, whi):\n zeros = []\n poles = _butter_analog_poles(n)\n k = 1\n fs = 2\n\n warpedlo = 2 * fs * mp.tan(mp.pi * wlo / fs)\n warpedhi = 2 * fs * mp.tan(mp.pi * whi / fs)\n bw = warpedhi - warpedlo\n wo = mp.sqrt(warpedlo * warpedhi)\n z, p, k = _zpklp2bp(zeros, poles, k, wo=wo, bw=bw)\n z, p, k = _zpkbilinear(z, p, k, fs=fs)\n return z, p, k","def butter_highpass_filter(data, cutoff, fs, order=1):\n b, a = butter_highpass(cutoff, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def bpfilter(\n data: numpy.ndarray, short_min: float = 2, long_min: float = 12\n) -> Optional[numpy.ndarray]:\n return butter_bandpass_filter(\n data, 1 / (long_min * 60), 1 / (short_min * 60), 1 / DATA_RATE\n )","def bandpass_filter(s, sample_rate, low_freq, high_freq, filter_order=5, rescale=False):\n #create a butterworth filter\n nyq = sample_rate / 2.0\n f = np.array([low_freq, high_freq]) / nyq\n b,a = filter_design.butter(filter_order, f, btype='bandpass')\n\n #filter the signal\n filtered_s = filtfilt(b, a, s)\n\n if rescale:\n #rescale filtered signal\n filtered_s /= filtered_s.max()\n filtered_s *= s.max()\n\n return filtered_s","def bandpass(filename,f1,f2,Q,wout=True,plot=True):\n start=time.time()\n n, data, data_dB,sr,ch=inputwav(filename)\n b, a = butter(Q,Wn=(f1/sr,f2/sr),btype='bandpass')\n data_filtered=lfilter(b,a,data,axis=0)\n print('Applying FFT...')\n if wout==True:\n print('Exporting...')\n sf.write(filename[0:len(filename)-4]+'_BP.wav',data_filtered,sr,'PCM_16')\n if plot==True:\n print('Plotting...')\n py.close()\n w, h = freqz(b,a,worN=16384)\n fig, (ax1, ax2) = py.subplots(nrows=2)\n ax1.semilogx(0.5*sr*w/np.pi,abs(h),'k-')\n ax1.set_xlabel('Frequency (Hz)')\n ax1.set_ylabel('Rel. Amplitude')\n ax1.grid()\n ax1.set_ylim(0,1.1)\n ax1.set_xlim(1,20000)\n ax2.plot(data,'k-',label='Raw data')\n ax2.plot(data_filtered,'m-',lw=1,label='Filtered data')\n ax2.set_xlim(0,10000)\n ax2.set_ylim(-1,1)\n ax2.set_ylabel('Amplitude (Norm Bits)')\n ax2.set_xlabel('Samples')\n ax2.legend(loc=2,frameon=False,ncol=2)\n py.subplots_adjust(hspace=0.35) \n print('Done!')\n end=time.time()\n elapsed=int(1000*(end-start))\n print('...............................')\n print('Completed in '+str(elapsed)+' milliseconds.')\n return data_filtered","def _butter_pass(cutoff, fs, order=5, btype='high'):\r\n nyq = 0.5*fs\r\n normal_cutoff = cutoff/nyq\r\n# print \"normalized cutoff: \", normal_cutoff\r\n if normal_cutoff >= 1.:\r\n normal_cutoff = 1.\r\n b, a = signal.butter(order, normal_cutoff, btype=btype, analog=False)\r\n return b, a","def bessel_wave(freq, alpha, beta):\n return FMFilter(SineWave(freq), SineWave(alpha), beta)","def butterworth_filter(dft4img, stopband2=10, order=3, showdft=False):\n h, w = dft4img.shape[0], dft4img.shape[1]\n P = h / 2\n Q = w / 2\n dst = np.zeros((h, w, 3), np.float64)\n for i in range(h):\n for j in range(w):\n r2 = float((i - P) ** 2 + (j - Q) ** 2)\n if r2 == 0:\n r2 = 1.0\n dst[i, j] = 1 / (1 + (r2 / stopband2) ** order)\n dst = np.float64(dst)\n if showdft:\n cv2.imshow(\"butterworth\", cv2.magnitude(dst[:, :, 0], dst[:, :, 1]))\n return dst","def bandpass_filterbank(bands, fs=1.0, order=8, output=\"sos\"):\n\n filters = []\n nyquist = fs / 2.0\n\n for band in bands:\n # remove bands above nyquist frequency\n if band[0] >= nyquist:\n raise ValueError(\"Bands should be below Nyquist frequency\")\n\n # Truncate the highest band to Nyquist frequency\n norm_band = np.minimum(0.99, np.array(band) / nyquist)\n\n # Compute coefficients\n coeffs = butter(order / 2, norm_band, \"bandpass\", output=output)\n filters.append(coeffs)\n\n return filters","def filt_bp(sig: np.ndarray, Ss: int, Cfs0: int, Cfs1: None,\n order=5) -> np.ndarray:\n nyq = 0.5 * Ss\n normal_cutoff1 = Cfs0 / nyq\n normal_cutoff2 = Cfs1 / nyq\n b, a = butter(order, (normal_cutoff1, normal_cutoff2),\n btype='band',\n analog=False)\n return lfilter(b, a, sig)","def _signal_filter_butterworth(signal, sampling_rate=1000, lowcut=None, highcut=None, order=2):\n if lowcut is not None and highcut is not None:\n sos = scipy.signal.butter(order, [lowcut, highcut], btype=\"bandpass\", output='sos', fs=sampling_rate)\n elif lowcut is not None:\n sos = scipy.signal.butter(order, [lowcut], btype=\"highpass\", output='sos', fs=sampling_rate)\n elif highcut is not None:\n sos = scipy.signal.butter(order, [highcut], btype=\"lowpass\", output='sos', fs=sampling_rate)\n\n filtered = scipy.signal.sosfiltfilt(sos, signal)\n return filtered","def _make_filters(self):\n\n \"\"\"\n filter_bank = bandpass_filterbank(\n self.bands, fs=self.fs, order=order, output=output\n )\n\n return [lambda sig: sosfiltfilt(bpf, sig) for bpf in filter_bank]\n \"\"\"\n\n # This seems to work only for Octave bands out of the box\n centers = self.centers\n n = len(self.centers)\n\n new_bands = [[centers[0] / 2, centers[1]]]\n for i in range(1, n - 1):\n new_bands.append([centers[i - 1], centers[i + 1]])\n new_bands.append([centers[-2], self.fs / 2])\n\n n_freq = self.n_fft // 2 + 1\n freq_resp = np.zeros((n_freq, n))\n freq = np.arange(n_freq) / self.n_fft * self.fs\n\n for b, (band, center) in enumerate(zip(new_bands, centers)):\n lo = np.logical_and(band[0] <= freq, freq < center)\n freq_resp[lo, b] = 0.5 * (1 + np.cos(2 * np.pi * freq[lo] / center))\n\n if b != n - 1:\n hi = np.logical_and(center <= freq, freq < band[1])\n freq_resp[hi, b] = 0.5 * (1 - np.cos(2 * np.pi * freq[hi] / band[1]))\n else:\n hi = center <= freq\n freq_resp[hi, b] = 1.0\n\n filters = np.fft.fftshift(\n np.fft.irfft(freq_resp, n=self.n_fft, axis=0),\n axes=[0],\n )\n\n # remove the first sample to make them odd-length symmetric filters\n self.filters = filters[1:, :]","def butter_filter_unwrapped(image, n, f0, pad = False):\n if pad == True:\n res = [2**kji for kji in range(15)]\n N_int_x = image.shape[1]\n N_int_y = image.shape[0]\n nx_pad = np.where(res > np.tile(N_int_x, len(res)))\n nx_pad = res[nx_pad[0][0]]\n ny_pad = np.where(res > np.tile(N_int_y, len(res)))\n ny_pad = res[ny_pad[0][0]]\n dif_x = (nx_pad - N_int_x)/2\n dif_y = (ny_pad - N_int_y)/2\n orig_shape = image.shape\n image = np.lib.pad(image, ((dif_y, dif_y), (dif_x, dif_x)), 'reflect')\n \n [ny, nx] = image.shape\n dx = 2.0/nx\n dy = 2.0/ny\n dfx = 0.5\n dfy = 0.5\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\n FX, FY = np.meshgrid(fx, fy)\n shift = np.exp(-2*np.pi*1j*(FX+FY))\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\n ft_img = shift * np.fft.fftshift(np.fft.fft2(image))\n \n buttered = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_img))/ shift)\n if pad == True:\n assert(buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x].shape == orig_shape)\n return buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x]\n else:\n assert(buttered.shape == image.shape)\n return buttered","def lowpass_butter(fs, L, order, data, axis=-1, btype='low'):\n from scipy.signal import butter, sosfiltfilt\n\n nyq = 0.5 * fs # Nyquist frequency\n low = L / nyq\n sos = butter(order, low, btype=btype, output='sos') # Coefficients for Butterworth filter\n filtered = sosfiltfilt(sos, data, axis=axis)\n\n return filtered","def __band_filter(data: dict, lowFreq: Union[int, float], highFreq: Union[int, float], timestep: int=0,\n samplingFreq: int=240, order: int=5, eegSensor: int=0, filterType: str='bandpass',\n lengthOfTestSeconds: Union[int, float]=32, example: int=0) -> dict:\n #Test\n # Filter.__band_filter_test(data=data, low=lowFreq, high=highFreq, samplingFreq=samplingFreq, order=order,\n # eegSensor=eegSensor, filterType=filterType, lengthOfTestSeconds=lengthOfTestSeconds)\n #Code\n nyq = 0.5 * samplingFreq\n low = lowFreq / nyq\n high = highFreq / nyq\n b, a = signal.butter(order, [low, high], btype=filterType)\n y = signal.lfilter(b, a, data['Signal'])\n ##Graph - This belongs somewhere else probably.\n # t = np.linspace(0, len(data), len(data), endpoint=False)\n # plt.plot(t, y, label='Sensor #' + str(eegSensor) + ' (' + str(lowFreq) + '-' + str(highFreq) + ') Hz')\n # plt.grid(True)\n # plt.axis('tight')\n # plt.xticks(range(10), range(lengthOfTestSeconds)) ##32 seconds per test?\n # plt.xlabel(\"Time in Seconds\")\n # plt.legend(loc='upper left')\n # plt.show()\n output = {}\n timestep = []\n for index, eegChannel in enumerate(y[0]):#the extra [0] is becuase signal.lfilter() puts it in a 1D array. Grrr\n timestep.append(eegChannel)\n output['Signal'] = timestep\n Visualization.channelGraph(y[0][0])\n return output #output is 2D 64xTimeSamples","def _build_wavelet_bank(self):\n self._build_filters()\n wavelet_bank = torch.stack(self._filters)\n wavelet_bank = wavelet_bank.view(\n wavelet_bank.shape[0], 1, 1, wavelet_bank.shape[1]\n )\n wavelet_bank = torch.cat([wavelet_bank] * self.channels, 2)\n return wavelet_bank","def butter_lowpass_filter(data: np.ndarray, cutoff: float, fs: float, order: int) -> np.ndarray:\n nyq = 0.5 * fs\n normal_cutoff = cutoff / nyq\n # Get the filter coefficients\n b, a = signal.butter(order, normal_cutoff, btype='low', analog=False)\n y = signal.filtfilt(b, a, data)\n return y","def bandpass_filter_raw_plot(data, fs, f1, f2):\n b, a = sp.butter(N=2, Wn=np.array([f1, f2]) / fs * 2, btype='bandpass') # build a bandpass butterworth filter of order 4, with cut-off frequencies 1 and 45\n w, h = sp.freqz(b, a) # compute the frequency response of the filter\n f = w / np.pi * fs / 2\n plt.figure()\n plt.plot(f, 10 * np.log10(abs(h)))\n plt.xlabel('frequency (Hz)')\n plt.ylabel('Magnitude (dB)')\n plt.title('frequency response of butterworth bandpass [1, 45]Hz')\n plt.grid()\n\n data1 = sp.filtfilt(b, a, data)\n return data1","def butterworthsmoothing(df, column_names: list = None, Wn = 0.015):\n\n if column_names is None:\n return df\n else:\n # First, design the Buterworth filter\n N = 2 # Filter order\n Wn = Wn # Cutoff frequency\n B, A = signal.butter(N, Wn, output='ba')\n for i in column_names:\n df[i] = signal.filtfilt(B, A, df[i])\n df.dropna(axis=0, how='any', inplace=True)\n return df","def __init__(self, init=None, filter_table=None, filter_name=None,\n wavecent=None, fwhm=None, **kwargs):\n super(MiriBandPassFilter, self).__init__(init=init,\n filter_table=filter_table,\n filter_name=filter_name,\n filter_type='BandPass',\n **kwargs)\n\n # Define the central wavelength and fwhm, if defined.\n if wavecent:\n self.meta.instrument.filter_wavecent = wavecent\n if fwhm:\n self.meta.instrument.filter_fwhm = fwhm","def band_pass_eeg(eeg, freq_range, order=4):\n return ButterworthFilter(eeg, freq_range, filt_type='pass', order=order).filter()","def filters(array, sample_frequency):\n strain = TimeSeries(array, sample_rate=int(sample_frequency))\n white_data = strain.whiten(fftlength=4, fduration=4)\n bp_data = white_data.bandpass(50, 250)\n return bp_data.value","def butter_lowpass_filter(data, cutoff, fs, order=1):\n b, a = butter_lowpass(cutoff, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def butter_hpf(highcut, fs, order):\n nyq = 0.5 * fs\n high = highcut / nyq\n b, a = signal.butter(order, high, btype='highpass')\n w, h = signal.freqz(b, a, worN=1000)\n# plt.figure()\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\n return b, a","def filtroBilateral(frame):\n fb = cv2.bilateralFilter(frame, 0, 32, 2)\n return fb","def bandpassFilter (self, lowerFreq, upperFreq):\n self.bandpassLimits = (lowerFreq, upperFreq)\n # stuff to do","def butter2d_lp(shape, f, n):\n \n rows, cols = shape \n x = np.linspace(-0.5, 0.5, cols)\n y = np.linspace(-0.5, 0.5, rows)\n radius = np.sqrt((x**2)[np.newaxis] + (y**2)[:, np.newaxis]) \n filt = 1 / (1.0 + (radius / f)**(2*n))\n \n return (filt)","def bandpass(self, gulp=512, **kwargs):\n bpass_ar = np.zeros(self.header.nchans, dtype=\"float64\")\n num_samples = 0\n for nsamps, _ii, data in self.readPlan(gulp, **kwargs):\n lib.getBpass(data, bpass_ar, self.header.nchans, nsamps)\n num_samples += nsamps\n bpass_ar /= num_samples\n return TimeSeries(bpass_ar, self.header.newHeader({\"nchans\": 1}))","def make_filter_banks(power_frames, sampling_rate, NFFT, num_filt = 40):\n low_freq_mel = 0\n high_freq_mel = Hz_to_Mel(sampling_rate/2) # Convert Hz to Mel\n #mel_points = np.arange(low_freq_mel, high_freq_mel, (high_freq_mel - low_freq_mel)/(num_filt + 2)) # Equally spaced in Mel scale\n mel_points = np.linspace(low_freq_mel, high_freq_mel, num_filt + 2) # Equally spaced in Mel scale\n #hz_points = Mel_to_Hz(mel_points) # Convert Mel to Hz\n bins = np.floor((NFFT + 1) * Mel_to_Hz(mel_points) / sampling_rate)\n \n #bank = np.empty((num_filt, int(np.floor(NFFT / 2 + 1))))\n bank = np.zeros((num_filt, int(np.floor(NFFT / 2 + 1))))\n for m in range(1, num_filt + 1):\n f_s = bins[m - 1 : m + 2]\n f_prev = int(f_s[0]) # left\n f = int(f_s[1]) # center\n f_next = int(f_s[2]) # right\n\n np.put(bank[m - 1], list(range(f_prev)), 0) # k < f_prev\n\n for k in range(f_prev, f):\n np.put(bank, ((m - 1)*int(np.floor(NFFT / 2 + 1))) + k, (k - f_prev) / (f - f_prev)) \n \n for k in range(f, f_next):\n np.put(bank, ((m - 1)*int(np.floor(NFFT / 2 + 1))) + k, (f_next - k) / (f_next - f))\n\n np.put(bank[m - 1], list(range(f_next, len(bank))), 0) # k > f_next\n\n filter_banks = np.where(np.dot(power_frames, bank.T) == 0, np.finfo(float).eps, np.dot(power_frames, bank.T))\n #filter_banks = np.where(filter_banks == 0, np.finfo(float).eps, filter_banks) # Numerical Stability\n filter_banks = 20 * np.log10(filter_banks) # dB\n\n return filter_banks","def butter_lpf(fc, fs, order):\n nyq = 0.5 * fs\n high = fc / nyq\n b, a = signal.butter(order, high, btype='lowpass', analog=False)\n w, h = signal.freqz(b, a, worN=1000)\n# plt.figure()\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\n return b, a","def _butter_lowpass(lowcut, fs, order=4) -> tuple:\n nyq = 0.5 * fs\n low = lowcut / nyq\n b, a = butter(order, [low], btype=\"low\")\n return b, a","def bandpass_filter(data, lowcut, highcut, fs=2000, numtaps=255):\n nyq = fs / 2\n\n # design filter\n fe1 = lowcut / nyq\n fe2 = highcut / nyq\n b = firwin(numtaps, (fe1, fe2), pass_zero=False)\n\n filtered = lfilter(b, 1, data)\n\n return filtered","def get_butterworth_high_pass_filter(shape, cutoff, order):\n \n # Hint: May be one can use the low pass filter function to get a high pass mask\n print(\"butterworth_high_pass_filter = \")\n print(\"cutoff: \",cutoff)\n print(\"order: \",order)\n filter = get_butterworth_low_pass_filter(shape, cutoff, order)\n\n for i in range(shape[0]):\n for j in range(shape[1]):\n filter[i, j] = 1 - filter[i, j]\n\n # return filter\n return process_filter(image, filter)","def _get_fir_filter(passband, fs, order=183, weights=[5.75, 1., 5.75], mask=[0, 1, 0]):\n # return remez(order, passband, mask, weights, Hz=fs), 1.\n return remez(order, passband, mask, Hz=fs), 1.","def butter_lowpass_filter(self, data: np.ndarray, lowcut: float, fs: float, order: int = 4) -> np.ndarray:\n b, a = self._butter_lowpass(lowcut, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def get_butterworth_low_pass_filter(shape, cutoff, order):\n \n \n print(\"butterworth_low_pass_filter = \")\n print(\"cutoff: \",cutoff)\n print(\"order: \",order)\n filter = np.zeros(shape)\n for i in range(shape[0]):\n for j in range(shape[1]):\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\n filter[i, j] = 1 / (1 + (D / cutoff) ** (2 * order))\n # print(\"\\n\\n\\n\\n\")\n # print(filter)\n # return filter\n return process_filter(image, filter)","def get_butterworth_high_pass_filter(self, shape, cutoff, order):\r\n\r\n #Hint: May be one can use the low pass filter function to get a high pass mask\r\n # 1 - butter low pass\r\n mask = 1 - self.get_butterworth_low_pass_filter(shape, cutoff, order)\r\n\r\n return mask","def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=(500, 10000)):\n if freq_cutoffs[0] <= 0:\n raise ValueError('Low frequency cutoff {} is invalid, '\n 'must be greater than zero.'\n .format(freq_cutoffs[0]))\n\n Nyquist_rate = samp_freq / 2\n if freq_cutoffs[1] >= Nyquist_rate:\n raise ValueError('High frequency cutoff {} is invalid, '\n 'must be less than Nyquist rate, {}.'\n .format(freq_cutoffs[1], Nyquist_rate))\n\n if rawsong.shape[-1] < 387:\n numtaps = 64\n elif rawsong.shape[-1] < 771:\n numtaps = 128\n elif rawsong.shape[-1] < 1539:\n numtaps = 256\n else:\n numtaps = 512\n\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\n freq_cutoffs[1] / Nyquist_rate])\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\n # window to design filter, but default for matlab's fir1\n # is actually Hamming\n # note that first parameter for scipy.signal.firwin is filter *length*\n # whereas argument to matlab's fir1 is filter *order*\n # for linear FIR, filter length is filter order + 1\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\n a = np.zeros((numtaps+1,))\n a[0] = 1 # make an \"all-zero filter\"\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\n return filtsong","def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=None):\n\n Nyquist_rate = samp_freq / 2\n if freq_cutoffs is None:\n freq_cutoffs = [500, 10000]\n if rawsong.shape[-1] < 387:\n numtaps = 64\n elif rawsong.shape[-1] < 771:\n numtaps = 128\n elif rawsong.shape[-1] < 1539:\n numtaps = 256\n else:\n numtaps = 512\n\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\n freq_cutoffs[1] / Nyquist_rate])\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\n # window to design filter, but default for matlab's fir1\n # is actually Hamming\n # note that first parameter for scipy.signal.firwin is filter *length*\n # whereas argument to matlab's fir1 is filter *order*\n # for linear FIR, filter length is filter order + 1\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\n a = np.zeros((numtaps+1,))\n a[0] = 1 # make an \"all-zero filter\"\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\n return filtsong","def bandpass_filter_audio(audio, f_low=400, f_high=450):\n filtered_audio = core.sinc_filter(audio, f_low, window_size=256, high_pass=True)\n filtered_audio = core.sinc_filter(filtered_audio, f_high, window_size=256, high_pass=False)\n return tf.squeeze(filtered_audio)","def copy(self):\n new_filter = BloomFilter(self.capacity, self.error_rate)\n new_filter.filter = self.filter.copy()\n return new_filter","def make_block(self, block_ix, downsample, ker_size, block_len):\n stride = int(downsample) + 1\n n_in_filters = self.filters[block_ix]\n n_filters = self.filters[block_ix+1]\n mult_fact = 1 if block_ix == 0 else 6\n\n block = [MBConv(n_in_filters, n_filters, ker_size, stride, mult_fact)]\n block += [MBConv(n_filters, n_filters, ker_size, 1, mult_fact) for _ in range(block_len-1)]\n return block","def iirfilter(x, N=4, pass_freq=0.7 / 12.):\n b, a = signal.butter(N, pass_freq, \"low\", analog=False)\n return signal.filtfilt(b, a, x)","def dwt(image_array, quantization_Array):\n # Create the high pass and low pass filters\n # both filters are non-causal\n # symmetric\n # [-2, -1, 0, 1, 2]\n LPF = [-0.125, 0.25, 0.75, 0.25, -0.125]\n LPF_center = 2\n\n # [ -2,-1, 0]\n HPF = [-0.5, 1, -0.5]\n HPF_center = 2\n\n nrow, ncol = image_array.shape\n\n # create an array that will contain the 4 different subbands of the image\n LL = np.zeros((nrow, ncol))\n LH = np.zeros((nrow, ncol))\n HL = np.zeros((nrow, ncol))\n HH = np.zeros((nrow, ncol))\n filtered_image = [LL, LH, HL, HH]\n\n # filtering the rows using a low pass and high pass filters\n LowPass_rows = np.zeros((nrow, ncol))\n HighPass_rows = np.zeros((nrow, ncol))\n for i in range(0, nrow):\n LowPass_rows[i, :] = lfilter(LPF, image_array[i, :], LPF_center)\n HighPass_rows[i, :] = lfilter(HPF, image_array[i, :], HPF_center)\n\n # down sample rows.\n # which means we will have half the number of columns\n for i in range(0, len(filtered_image)):\n filtered_image[i] = filtered_image[i][:, ::2]\n\n # apply filters accross columns\n for i in range(0, ncol):\n LL[:, i] = lfilter(LPF, LowPass_rows[:, i], LPF_center)\n LH[:, i] = lfilter(HPF, LowPass_rows[:, i], HPF_center)\n HL[:, i] = lfilter(LPF, HighPass_rows[:, i], LPF_center)\n HH[:, i] = lfilter(HPF, HighPass_rows[:, i], HPF_center)\n\n # down sample columns and quantize\n for i in range(0, len(filtered_image)):\n filtered_image[i] = filtered_image[i][::2, :]\n filtered_image[i] = np.round(\n filtered_image[i]/quantization_Array[i]).astype(int)\n\n return filtered_image","def A_weighting(fs):\n b, a = A_weighting_analog()\n\n # Use the bilinear transformation to get the digital filter.\n return bilinear(b, a, fs)","def conv_block(input, nb_filter, dropout_rate=None, weight_decay=1E-4):\n\n x = Activation('relu')(input)\n x = Convolution2D(nb_filter, (3, 3), kernel_initializer=\"he_uniform\", padding=\"same\", use_bias=False,\n kernel_regularizer=l2(weight_decay))(x)\n if dropout_rate is not None:\n x = Dropout(dropout_rate)(x)\n\n return x","def bias(self, bias_value):\n if bias_value == 0:\n return\n new_channel = sppasChannel()\n new_channel.set_sampwidth(self._sampwidth)\n new_channel.set_framerate(self._framerate)\n a = sppasAudioFrames(self._channel.get_frames(self._channel.get_nframes()), self._channel.get_sampwidth(), 1)\n new_channel.set_frames(a.bias(bias_value))\n\n self._channel = new_channel","def estimate_bandpass(data):\n \n est = filter(data, params.st_bp_window_f, axis=0)\n est = filter(est, params.st_bp_window_t, axis=1)\n \n return est","def broadbandfilter(self):\n _, = self.broadbandfilters\n return _","def apply_band_pass(ftd, freq, omega, bp_wid=1):\n # Find number of frequencies\n nf = len(freq)\n # Find index for band pass, only consider indices of positive freqs\n idx_om = hf.find_nearest_index(freq[0:nf//2], omega)\n # Filter out frequencies left of band pass\n ftd[:,0:idx_om-1-bp_wid] = 0.0\n # Filter out frequencies left of omega\n ftd[:,idx_om+1+bp_wid:-1] = 0.0\n # Correct for lost amplitude\n ftd[:,idx_om-bp_wid:idx_om+bp_wid] = ftd[:,idx_om-bp_wid:idx_om+bp_wid] * 2.0\n return ftd","def butterworth(path_to_data, dtype, n_channels, data_order,\n low_frequency, high_factor, order, sampling_frequency,\n max_memory, output_path, output_dtype, standarize=False,\n output_filename='filtered.bin', if_file_exists='skip',\n processes='max'):\n processes = multiprocess.cpu_count() if processes == 'max' else processes\n\n # init batch processor\n bp = BatchProcessor(path_to_data, dtype, n_channels, data_order,\n max_memory, buffer_size=200)\n\n if standarize:\n bp_ = BatchProcessor(path_to_data, dtype, n_channels, data_order,\n max_memory, buffer_size=0)\n\n filtering = partial(_butterworth, low_frequency=low_frequency,\n high_factor=high_factor,\n order=order,\n sampling_frequency=sampling_frequency)\n\n # if standarize, estimate sd from first batch and use\n # _butterworth_scale function, pass filtering to estimate sd from the\n # filtered data\n sd = standard_deviation(bp_, sampling_frequency,\n preprocess_fn=filtering)\n fn = partial(_butterworth_scale, denominator=sd)\n # add name to the partial object, since it is not added...\n fn.__name__ = _butterworth_scale.__name__\n else:\n # otherwise use _butterworth function\n fn = _butterworth\n\n _output_path = os.path.join(output_path, output_filename)\n\n (path,\n params) = bp.multi_channel_apply(fn, mode='disk',\n cleanup_function=fix_indexes,\n output_path=_output_path,\n if_file_exists=if_file_exists,\n cast_dtype=output_dtype,\n low_frequency=low_frequency,\n high_factor=high_factor,\n order=order,\n sampling_frequency=sampling_frequency,\n processes=processes)\n\n return path, params","def make_bwfull(w,minZ,maxZ,ires=1,fixw=False,m=mz0):\n cmds = []\n # coefficients for the amplitudes\n cmds.append(\"A[1,0,1000000]\")\n cmds.append(\"B[1,0,1000000]\")\n cmds.append(\"C[10000.0,0,1000000]\")\n # amplitudes\n cmds.append('m[%s,%s,%s]'%(m,minZ,maxZ))\n cmds.append('g[2.49,0,10]')\n denom = '((x^2-m^2)^2+x^4*g^2/m^2)'\n cmds.append(\"expr::z_rbw('x^2/%s',x,m,g)\"%denom)\n cmds.append(\"expr::z_int('(x^2-m^2)/%s',x,m,g)\"%denom)\n cmds.append(\"expr::z_rad('1/(x^2)',x)\")\n # resolution model\n cmds += resolutions[ires]()\n [w.factory(cmd) for cmd in cmds]\n # any parameter adjustments\n if True:\n w.var('r_m').setConstant(kTRUE) if w.var('r_m') else None\n w.var('rt_m').setConstant(kTRUE) if w.var('rt_m') else None\n w.var('g').setConstant(kTRUE) if w.var('g') and fixw else None\n # sum-of-amplitudes pdf\n lshape = RooRealSumPdf('lshape','lshape',RooArgList(w.function('z_rad'),w.function('z_int'),w.function('z_rbw')),RooArgList(w.var('A'),w.var('B'),w.var('C')))\n getattr(w,'import')(lshape)\n # convolution\n pdf = w.pdf('lshape')\n if w.pdf('res'):\n w.var('x').setBins(10000,'cache')\n cmd = 'FCONV::sum(x,lshape,res)'\n w.factory(cmd)\n pdf = w.pdf('sum')\n return pdf, kFALSE","def makebdf(startTime, endTime, metadata, data, bdfdir='.'):\n\n from sdmpy import bdf\n from rfpipe.metadata import Metadata\n\n assert type(metadata) == Metadata, (\"metadata must be \"\n \"of type rfpipe.metadata.Metadata\")\n\n assert data.ndim == 6, (\"data must have 6 dimensions: \"\n \"nint, nbl, nspw, numBin, nchan, npol.\")\n\n nint, nbl, nspw, numBin, nchan, npol = data.shape\n\n IFidspwnum = [spw.split('-') for (spw, freq) in metadata.spworder]\n spws = [bdf.BDFSpectralWindow(None, numBin=numBin, numSpectralPoint=nchan,\n sw=int(swnum)+1, # casting from 0->1 based\n swbb='{0}_8BIT'.format(IFid),\n npol=npol) for (IFid, swnum) in IFidspwnum]\n # TODO: confirm that sw is 1 based for a proper SDM\n # TODO: confirm that metadata spworder is 0 based\n\n assert nspw == len(spws), ('Expected one spw in metadata.spworder per spw '\n 'in data array.')\n assert os.path.isdir(bdfdir), 'bdfdir does not exist'\n\n uid = ('uid:///evla/realfastbdf/{0}'\n .format(int(time.Time(startTime, format='mjd').unix*1e3)))\n logger.info(\"Creating BDFWriter for {0}\".format(uid))\n w = bdf.BDFWriter(bdfdir, start_mjd=startTime, uid=uid,\n num_antenna=metadata.nants_orig, spws=spws, scan_idx=1,\n corr_mode='c')\n\n logger.info(\"Writing data to bdf\")\n dat = {}\n w.write_header()\n for i in range(nint):\n dat['crossData'] = data[i]\n ts = startTime + i*metadata.inttime/86400.\n w.write_integration(mjd=ts, interval=metadata.inttime, data=dat)\n w.close()","def filt(self,cutoff_dt, btype='low',order=3,axis=-1):\r\n \r\n if self.isequal==False and self.VERBOSE:\r\n print 'Warning - time series is unequally spaced. Use self.interp to interpolate onto an equal grid'\r\n \r\n if not btype == 'band':\r\n Wn = self.dt/cutoff_dt\r\n else:\r\n Wn = [self.dt/co for co in cutoff_dt]\r\n \r\n (b, a) = signal.butter(order, Wn, btype=btype, analog=0, output='ba')\r\n \r\n return signal.filtfilt(b, a, self.y, axis=axis)","def fastbias(self, fo, fbDac, data, slow):\n if fbDac not in [0, 1]:\n raise RuntimeError('fbDac must be 0 or 1')\n if slow not in [0, 1]:\n raise RuntimeError('slow must be 0 or 1')\n a = {0: 0x100000, 1: 0x200000}[fo]\n b = (data & 0xffff) << 3\n c = fbDac << 19\n d = slow << 2\n self.append(a + b + c + d)\n return self","def tophat_bandpass(ctr, width, name=None):\n\n nintervals = 100 # intervals between wmin and wmax\n interval = width / nintervals # interval of each sample\n wmin = ctr - width / 2. - interval / 2.\n wmax = ctr + width / 2. + interval / 2.\n wave = np.linspace(wmin, wmax, nintervals + 1)\n trans = np.ones_like(wave)\n trans[[0, -1]] = 0.\n return Bandpass(wave, trans, wave_unit=u.micron, name=name)","def gaussianFilter(gain,BT,spSym,nTaps):\n\n a = np.sqrt(np.log(2)/2)/BT\n t = np.linspace(-.5*nTaps,.5*nTaps-1,nTaps)/spSym\n\n ft = np.sqrt(np.pi)/a *np.exp(-(np.pi**2*(t)**2)/a**2)\n ft /= np.sum(ft) * gain # normalize filter\n\n return ft","def bessel_bandpass_filter(data, lowcut, highcut, fs, order=2):\n\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n\n # bessel() and lfilter() are from scipy.signal\n\n b, a = bessel(order, [low, high], btype='band')\n y = lfilter(b, a, data)\n return y","def band_filter(self, bands) -> 'ImageCollection':\n\n process_id = 'filter_bands'\n args = {\n 'imagery': self.graph,\n 'bands': bands\n }\n return self.graph_add_process(process_id, args)","def lowpass_filter(data, Wn=0.014, N=2):\n data = np.array(data)\n data = data.astype(np.float)\n # N = 5 # Filter order\n # Wn = 0.02 # Cutoff frequency\n B, A = signal.butter(N, Wn, output='ba')\n\n # Second, apply the filter\n tempf = signal.filtfilt(B,A, data)\n # print(tempf)\n return tempf","def make_band(f0, band_type, num):\n \n if band_type == '1Hz-spaced':\n hwidth = num//2\n step = 1\n f = np.arange(f0-hwidth, f0+hwidth+step, step)\n \n else:\n lwr = -(num-1)//2 # lower range bound for frequency calculation\n upr = (num+1)//2 # upper range bound for frequency calculation\n f = np.array(list(f0*2**(k/(12*num)) for k in range(lwr,upr)))\n \n return f","def band(self, name, bands, new_name=None, label=None, text_key=None):\n if not self._is_numeric(name):\n msg = \"Can only band numeric typed data! {} is {}.\"\n msg = msg.format(name, self._get_type(name))\n raise TypeError(msg)\n if not text_key: text_key = self.text_key\n if not new_name: new_name = '{}_banded'.format(name)\n if not label: label = self.text(name, False, text_key)\n franges = []\n for idx, band in enumerate(bands, start=1):\n lab = None\n if isinstance(band, dict):\n lab = list(band.keys())[0]\n band = list(band.values())[0]\n if isinstance(band, tuple):\n if band[0] < 0:\n raise ValueError('Cannot band with lower bound < 0.')\n elif band[1] < 0:\n raise ValueError('Cannot band with upper bound < 0.')\n r = '{}-{}'.format(band[0], band[1])\n franges.append([idx, lab or r, {name: frange(r)}])\n else:\n r = str(band)\n franges.append([idx, lab or r, {name: [band]}])\n\n self.derive(new_name, 'single', label, franges,\n text_key=text_key)\n\n return None","def generate_blackbody(temp, wmin=40., wmax=300.):\n c = 2.99792e14 # um/s\n Jy2W = 1e-26 # Convert Jy to W/m2/Hz\n dw = 0.005\n nw = int((wmax - wmin) / dw) + 1\n wstar = np.arange(nw) * dw + wmin\n fstar = np.pi * thermast.planck_function(wstar, temp) \\\n * wstar ** 2 / (Jy2W * c)\n return wstar, fstar","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 )","def bandpass_filter(files, lowpass_freq=0.1, highpass_freq=0.01, tr=2):\n import os\n\n import nibabel as nb\n import numpy as np\n from nipype.utils.filemanip import (\n filename_to_list,\n list_to_filename,\n split_filename\n )\n\n fs = 1./tr\n\n out_files = []\n for filename in filename_to_list(files):\n path, name, ext = split_filename(filename)\n out_file = os.path.join(os.getcwd(), name + '_bandpassed' + ext)\n\n img = nb.load(filename)\n timepoints = img.shape[-1]\n F = np.zeros((timepoints))\n\n lowidx = int(timepoints / 2) + 1\n if lowpass_freq > 0:\n lowidx = np.round(float(lowpass_freq) / fs * timepoints)\n\n highidx = 0\n if highpass_freq > 0:\n highidx = np.round(float(highpass_freq) / fs * timepoints)\n F[int(highidx):int(lowidx)] = 1\n F = ((F + F[::-1]) > 0).astype(int)\n data = img.get_data()\n if np.all(F == 1):\n filtered_data = data\n else:\n filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F))\n img_out = nb.Nifti1Image(filtered_data, img.affine, img.header)\n img_out.to_filename(out_file)\n out_files.append(out_file)\n\n return list_to_filename(out_files)","def Deband(clip: vs.VideoNode, radius: int = 17, threshold: float = 4,\n iterations: int = 1, grain: float = 4, chroma: bool = True)-> vs.VideoNode:\n if get_depth(clip) != 16:\n clip = depth(clip, 16)\n if chroma is True:\n clip = join([core.placebo.Deband(x, 1, iterations, threshold, radius, grain)\n for x in split(clip)])\n else:\n clip = core.placebo.Deband(clip, 1, iterations, threshold, radius, grain)\n return clip","def xor_folding(self):\n lbs = round(self.bit_size / 2)\n cap = round(self.capacity / 2)\n\n fold_pos = round( len(self.filter) / 2 )\n\n a = self.filter[0:fold_pos]\n b = self.filter[fold_pos:]\n # print('======>',self.bit_size,'#',len(a),len(b))\n\n r = BloomFilter(cap=cap, fpr=self.false_positive_rate, bfpower=self.potencia, bs=lbs)\n r.filter = a.__ixor__(b)\n return r","def to_bw(self) -> 'BaseImage':\n\n def bw(r: int, g: int, b: int, a: int) -> Tuple4IntType:\n \"\"\"\n To black-white function.\n \"\"\"\n c = int((r + g + b) / 3)\n return c, c, c, a\n\n return self.apply_image_function(image_function=bw)","def butterfly(self):\n\n self.log.info(\"Begin Butterfly\")\n\n dst = os.path.join(self.cfg['start_dir'], 'Butterfly', 'src')\n try:\n os.chdir(dst)\n except OSError, err:\n self.log.error(\"Butterfly: failed to change to dst dir %s\" % (dst, err))\n\n cmd = \"ant\"\n run_cmd(cmd)\n\n self.log.info(\"End Butterfly\")","def test_filt_abmag(self):\n sun = Sun.from_builtin('E490_2014')\n V = get_bandpass('johnson v')\n wave, fluxd = sun.filt(V, unit=u.ABmag)\n assert np.isclose(fluxd.value, -26.77, atol=0.007)","def generate_brown_noise(duration: float, f_sample: float) -> np.ndarray:\r\n # calculate the number of time points and the time difference between them\r\n length = duration * f_sample\r\n delta_t = 1 / f_sample\r\n # get the angular frequency axis in [omega]\r\n # calculate the frequency coefficients based on the noise color\r\n # brown/red noise has power spectral density of 1/(f**2) -> the amplitude has 1/f\r\n f_k = sc.fft.fftfreq(length, d=delta_t) / (2 * np.pi)\r\n C_k = np.ndarray(length)\r\n C_k[1:] = 1 / np.abs(f_k[1:])\r\n # no dc\r\n C_k[0] = 0\r\n # generate the signal from the frequency coefficients\r\n return generate_signal_from_spectrum(C_k)","def get_bw(self):\n return np.array([b2 - b1 for b1, b2 in self.bands])","def iir(self):\r\n\r\n #Passband and stop-band are expressed as fraction of the Nyquist\r\n #frequency:\r\n if self.ub is not None:\r\n ub_frac = self.ub / (self.sampling_rate / 2.)\r\n else:\r\n ub_frac = 1.0\r\n\r\n lb_frac = self.lb / (self.sampling_rate / 2.)\r\n\r\n # For the band-pass:\r\n if lb_frac > 0 and ub_frac < 1:\r\n\r\n wp = [lb_frac, ub_frac]\r\n\r\n ws = [np.max([lb_frac - 0.1, 0]),\r\n np.min([ub_frac + 0.1, 1.0])]\r\n\r\n # For the lowpass:\r\n elif lb_frac == 0:\r\n wp = ub_frac\r\n ws = np.min([ub_frac + 0.1, 0.9])\r\n\r\n # For the highpass:\r\n elif ub_frac == 1:\r\n wp = lb_frac\r\n ws = np.max([lb_frac - 0.1, 0.1])\r\n\r\n b, a = signal.iirdesign(wp, ws, self._gpass, self._gstop,\r\n ftype=self._ftype)\r\n\r\n return self.filtfilt(b, a)","def imgBC(img, mask=None, scale=1.0, numBins=64, returnBias=False):\n spacing = np.array(img.GetSpacing())/scale\n img_ds = imgResample(img, spacing=spacing)\n\n # Calculate bias\n if mask is None:\n mask_ds = sitk.Image(img_ds.GetSize(), sitk.sitkUInt8)+1\n mask_ds.CopyInformation(img_ds)\n else:\n mask_ds = imgResample(mask, spacing=spacing, useNearest=True)\n mask_ds = mask_ds > 0\n\n splineOrder = 2\n img_ds_bc = sitk.N4BiasFieldCorrection(sitk.Cast(img_ds, sitk.sitkFloat32), mask_ds, numberOfHistogramBins=numBins, splineOrder=splineOrder, numberOfControlPoints=[splineOrder+1]*4)\n #bias_ds = img_ds_bc - sitk.Cast(img_ds,img_ds_bc.GetPixelID())\n\n bias_ds = imgFinite(img_ds_bc / img_ds)\n bias_ds = sitk.Mask(bias_ds, mask_ds) + sitk.Cast(1-mask_ds, sitk.sitkFloat32) # Fill background with 1s\n\n # Upsample bias \n bias = imgResample(bias_ds, spacing=img.GetSpacing(), size=img.GetSize())\n bias = sitk.Cast(bias, img.GetPixelID())\n\n # Apply bias to original image and threshold to eliminate negitive values\n try:\n upper = np.iinfo(sitkToNpDataTypes[img.GetPixelID()]).max\n except:\n upper = np.finfo(sitkToNpDataTypes[img.GetPixelID()]).max *0.99\n\n #img_bc = sitk.Threshold(img + sitk.Cast(bias, img.GetPixelID()),\n # lower=0,\n # upper=upper)\n\n img_bc = sitk.Threshold(img * bias, lower=0, upper=upper)\n\n if returnBias:\n return (img_bc, bias)\n else:\n return img_bc","def filter(sig, sampling_rate, lc, hc, order=2):\n\n # Construct butterworth band-pass filter\n b1, a1 = butter(order, [2.0 * lc / sampling_rate,\n 2.0 * hc / sampling_rate], btype=\"band\")\n nchan, nsamp = sig.shape\n fsig = np.copy(sig)\n\n # Apply cosine taper then apply band-pass filter in both directions\n for ch in range(0, nchan):\n fsig[ch, :] = fsig[ch, :] - fsig[ch, 0]\n tap = cosine_taper(len(fsig[ch, :]), 0.1)\n fsig[ch, :] = fsig[ch, :] * tap\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, ::-1])[::-1]\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, :])\n\n return fsig","def __init__(self, fs=250, smoothing_win=20):\n self.fs = fs\n self.threshold = .35 # Generally between 0.3125 and 0.475\n self.ns200ms = int(self.fs * .2)\n self.r_peaks_buffer = [(0., 0.)]\n self.noise_peaks_buffer = [(0., 0., 0.)]\n self.prev_samples = np.zeros(smoothing_win)\n self.prev_diff_samples = np.zeros(smoothing_win)\n self.prev_times = np.zeros(smoothing_win)\n self.prev_max_slope = 0\n\n self.bp_filter = ExGFilter(cutoff_freq=(1, 30), filter_type='bandpass', s_rate=fs, n_chan=1, order=3)\n self.hamming_window = signal.windows.hamming(smoothing_win, sym=True)\n self.hamming_window /= self.hamming_window.sum()","def transition_block(input, nb_filter, dropout_rate=None, weight_decay=1E-4):\n\n concat_axis = 1 if K.image_dim_ordering() == \"th\" else -1\n\n x = Convolution2D(nb_filter, (1, 1), kernel_initializer=\"he_uniform\", padding=\"same\", use_bias=False,\n kernel_regularizer=l2(weight_decay))(input)\n if dropout_rate is not None:\n x = Dropout(dropout_rate)(x)\n x = AveragePooling2D((2, 2), strides=(2, 2))(x)\n\n x = BatchNormalization(axis=concat_axis, gamma_regularizer=l2(weight_decay),\n beta_regularizer=l2(weight_decay))(x)\n\n return x","def __init__(self, bandit):\n self.bandit = bandit","def generate_filter(length, fs, f_low=None, f_high=None, mode='box', is_plot=False):\n\n freqs = np.fft.fftfreq(int(length), d=(1. / float(fs)))\n\n filter_array = np.ones(length)\n\n if f_low is None and f_high is None:\n print('no filtering required!')\n elif f_low is None and f_high is not None:\n print('low-pass fileter')\n if f_high <= 0:\n raise(ValueError, 'Higher cutoff frquency should be positive!')\n filter_array[freqs >= f_high] = 0.\n filter_array[freqs <= -f_high] = 0.\n elif f_low is not None and f_high is None:\n print('high-pass fileter')\n if f_low < 0:\n raise (ValueError, 'Lower cutoff frquency should be non-negative!')\n filter_array[np.logical_and((freqs >= -f_low), (freqs <= f_low))] = 0.\n else:\n print('band-pass filter')\n if f_high <= 0:\n raise (ValueError, 'Higher cutoff frquency should be positive!')\n if f_low < 0:\n raise (ValueError, 'Lower cutoff frquency should be non-negative!')\n filter_array[freqs >= f_high] = 0.\n filter_array[freqs <= -f_high] = 0.\n filter_array[np.logical_and((freqs >= -f_low), (freqs <= f_low))] = 0.\n\n if mode == '1/f':\n filter_array[1:] = filter_array[1:] / abs(freqs[1:])\n filter_array[0] = 0\n filter_array = bas.array_nor(filter_array)\n elif mode == 'box':\n filter_array[0] = 0\n else:\n raise(NameError, 'Variable \"mode\" should be either \"1/f\" or \"box\"!')\n\n if is_plot:\n plot_array = zip(freqs, filter_array)\n plot_array.sort(key=lambda x: x[0])\n plot_array = zip(*plot_array)\n\n _ = plt.figure(figsize=(10, 3))\n plt.plot(plot_array[0], plot_array[1])\n plt.xlabel('frequency (Hz)')\n plt.ylim([-0.1, 1.1])\n plt.show()\n\n return freqs, filter_array"],"string":"[\n \"def butter_filter(datalist):\\n fs = 200.00\\n fHigh = 50.00\\n fLow = 5.00\\n N=4\\n [b,a]=sg.butter(N,[fLow/fs, fHigh/fs], btype='band')\\n global filtered\\n #IIR filter\\n return sg.filtfilt(b,a,datalist)\",\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=5, axis=0): \\n omega = 0.5 * fs\\n low = lowcut / omega\\n high = highcut / omega\\n b, a = signal.butter(order, [low, high], btype='band')\\n y = signal.lfilter(b, a, data, axis=0)\\n return y\",\n \"def ButterworthFilter(\\n self,\\n name: str,\\n cutoffFrequency: float,\\n order: int = 2,\\n operation: SymbolicConstant = NONE,\\n halt: Boolean = OFF,\\n limit: float = None,\\n invariant: SymbolicConstant = NONE,\\n ) -> ButterworthFilter:\\n self.filters[name] = butterworthFilter = ButterworthFilter(\\n name, cutoffFrequency, order, operation, halt, limit, invariant\\n )\\n return butterworthFilter\",\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=1):\\n b, a = butter_bandpass(lowcut, highcut, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def butter_filter(self, data, low_pass, high_pass, fs, order=10):\\n\\n nyq = fs/2\\n low = low_pass/nyq\\n high = high_pass/nyq\\n\\n b, a = signal.butter(order, [low, high], btype='band')\\n filt_data = np.abs(signal.hilbert(signal.filtfilt(b, a, data, axis=1), axis=1))\\n return filt_data\",\n \"def butterworth_bandpass_filter( values, lowFreq, highFreq, sampleFreq, order=5):\\n nyq = 0.5 * sampleFreq\\n low = lowFreq / nyq\\n high = highFreq /nyq\\n b,a = butter( order, [low,high], btype='band' )\\n return y = lfilter(b, a, data)\",\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=2):\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n \\n # butter() and lfilter() are from scipy.signal\\n \\n b, a = butter(order, [low, high], btype='band')\\n y = lfilter(b, a, data)\\n return y\",\n \"def butter_bandpass_filter(\\n data: numpy.ndarray,\\n lowcut: float,\\n highcut: float,\\n samplerate: float,\\n order: int = 2,\\n):\\n nyq = 0.5 * samplerate\\n lowf = lowcut / nyq\\n highf = highcut / nyq\\n # generic names for coefficients in filters\\n # pylint: disable=invalid-name\\n a, b = butter(order, [lowf, highf], btype=\\\"band\\\")\\n if len(data) < BUTTER_MIN_LENGTH:\\n return None\\n return filtfilt(a, b, data)\",\n \"def make_butter_sp(self, wn, order):\\n nyquist = self.s_freq/2\\n wn_arr=np.asarray(wn)\\n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\\n \\n self.sp_sos = butter(order, wn_arr, btype='bandpass', output='sos')\\n print(f\\\"Zero phase butterworth filter successfully created: order = {order}x{order} bandpass = {wn}\\\")\",\n \"def _butter_bandpass_filter(self, data: np.ndarray, lowcut: float, highcut: float, fs: float, order: int = 5):\\n b, a = self._butter_bandpass(lowcut, highcut, fs, order=order)\\n y = lfilter(b, a, data)\\n return y\",\n \"def make_butter_so(self, wn, order):\\n \\n nyquist = self.s_freq/2\\n wn_arr = np.asarray(wn)\\n \\n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\\n \\n self.so_sos = butter(order, wn_arr, btype='bandpass', output='sos')\\n print(f\\\"Zero phase butterworth filter successfully created: order = {order}x{order}, bandpass = {wn}\\\")\",\n \"def butterworth_filter(signal, Fs, highpassfreq=None, lowpassfreq=None, order=4, filtfunc='filtfilt'):\\n Fn = Fs / 2.\\n \\n # set the function for filtering\\n if filtfunc is 'lfilter':\\n ffunc = spsig.lfilter\\n elif filtfunc is 'filtfilt':\\n ffunc = spsig.filtfilt\\n else:\\n raise ValueError(\\\"filtfunc must to be either 'filtfilt' or 'lfilter'\\\")\\n \\n # set parameters\\n if lowpassfreq and highpassfreq:\\n if highpassfreq < lowpassfreq:\\n Wn = (highpassfreq / Fn, lowpassfreq / Fn)\\n btype = 'bandpass'\\n else:\\n Wn = (lowpassfreq / Fn, highpassfreq / Fn)\\n btype = 'bandstop'\\n elif lowpassfreq:\\n Wn = lowpassfreq / Fn\\n btype = 'lowpass'\\n elif highpassfreq:\\n Wn = highpassfreq / Fn\\n btype = 'highpass'\\n else:\\n raise ValueError(\\\"Specify highpassfreq and/or lowpathfreq\\\")\\n \\n # filter design\\n b, a = spsig.butter(order, Wn, btype=btype)\\n \\n return ffunc(b, a, signal)\",\n \"def butter_bp_coe(lowcut, highcut, fs, order=1):\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n b, a = butter(order, [low, high], btype='band')\\n return b, a\",\n \"def butterworth_bandpass(lowcut, highcut, fs, order=5):\\n nyq = 0.5 * fs # nyquist sampling rate\\n low = lowcut / nyq # normalize frequency\\n high = highcut / nyq # normalize frequency\\n b, a = butter(order, [low, high], btype='band')\\n return b, a\",\n \"def butter_bandstop_filter(data, lowcut, highcut, fs, order):\\n\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n\\n i, u = sg.butter(order, (low, high), btype='bandstop')\\n y = sg.filtfilt(i, u, data)\\n return y\",\n \"def Butterworth_Filter(x,order,Low_High,Wn):\\r\\n\\r\\n\\r\\n # Create an order butterworth filter:\\r\\n\\r\\n b, a = signal.butter(order,Wn,Low_High);\\r\\n\\r\\n # Apply the filter to x. Use lfilter_zi to choose the initial condition of the filter:\\r\\n\\r\\n zi = signal.lfilter_zi(b, a);\\r\\n z, _ = signal.lfilter(b, a, x, zi=zi*x[0]);\\r\\n\\r\\n # Apply the filter again, to have a result filtered at an order the same as filtfilt:\\r\\n\\r\\n z2, _ = signal.lfilter(b, a, z, zi=zi*z[0])\\r\\n\\r\\n # Use filtfilt to apply the filter:\\r\\n\\r\\n y = signal.filtfilt(b, a, x);\\r\\n\\r\\n return y;\",\n \"def butterworth_filter(freq):\\n\\tf_raw = 1/(0.00000002*100*33)\\n\\tb = np.array([[-32092,15750],[-31238,14895]])*2.0**(-14)\\n\\tomega = 2*np.pi*freq/f_raw\\n\\te1, e2 = np.exp(-1j*omega), np.exp(-2j*omega)\\n\\ttmp = (1+2*e1+e2)**2/(1+b[0,0]*e1+b[0,1]*e2)/(1+b[1,0]*e1+b[1,1]*e2)\\n\\treturn tmp * (1+sum(b[0]))*(1+sum(b[1]))/16\",\n \"def butterworth(dx, order, cutoff, /, btype='low'):\\n # Initial stuff\\n # * Need to run *forward and backward* to prevent time-shifting.\\n # * The 'analog' means units of cutoffs are rad/s.\\n # * Unlike Lanczos filter, the *length* of this should be\\n # determined always as function of timestep, because really high\\n # order filters can get pretty wonky.\\n # * Cutoff is point at which gain reduces to 1/sqrt(2) of the\\n # initial frequency. If doing bandpass, can\\n # N = (width/dx)//1 # convert to timestep units\\n # N = (N//2)*2 + 1 # odd numbered\\n N = order # or order\\n analog = False # lfilter seems to need digital\\n if analog:\\n cutoff = 2 * np.pi / (cutoff / dx) # from wavelengths to rad/steps\\n else:\\n cutoff = 1.0 / cutoff # to Hz, or cycles/unit\\n cutoff = cutoff * (2 * dx) # to cycles / (2 timesteps)\\n if cutoff > 1:\\n raise ValueError(\\n 'Cuttoff frequency must be in [0, 1]. Remember you pass a cutoff '\\n '*wavelength* to this function, not a frequency.'\\n )\\n\\n # Apply filter\\n print(f'Order-{order} Butterworth filter')\\n b, a = signal.butter(N - 1, cutoff, btype=btype, analog=analog, output='ba')\\n return b, a\",\n \"def design_filter(interpolation, decimation, fractional_bw):\\n\\n if fractional_bw >= 0.5 or fractional_bw <= 0:\\n raise ValueError('Invalid fractional bandwidth, must be in (0, 0.5)')\\n\\n if decimation < 1 or interpolation < 1:\\n raise ValueError('Invalid interpolation or decimation rate. Must be a non-zero positive integer.')\\n\\n beta = 7.0\\n halfband = 0.5\\n rate = float(interpolation)/float(decimation)\\n if(rate >= 1.0):\\n trans_width = halfband - fractional_bw\\n mid_transition_band = halfband - trans_width/2.0\\n else:\\n trans_width = rate*(halfband - fractional_bw)\\n mid_transition_band = rate*halfband - trans_width/2.0\\n\\n taps = filter.firdes.low_pass(interpolation, # gain\\n interpolation, # Fs\\n mid_transition_band, # trans mid point\\n trans_width, # transition width\\n filter.firdes.WIN_KAISER,\\n beta) # beta\\n\\n return taps\",\n \"def butter_filter(image, n, f0):\\n [ny, nx] = image.shape\\n dx = 2.0/nx\\n dy = 2.0/nx\\n dfx = 0.5\\n dfy = 0.5\\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\\n FX, FY = np.meshgrid(fx, fy)\\n shift = np.exp(-2*np.pi*1j*(FX+FY))\\n sin_pad = np.sin(image)\\n cos_pad = np.cos(image)\\n ft_sin = shift * np.fft.fftshift(np.fft.fft2(sin_pad))\\n ft_cos = shift * np.fft.fftshift(np.fft.fft2(cos_pad))\\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\\n sin_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_sin)) / shift)\\n cos_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_cos)) / shift)\\n phase_filt = np.arctan2(sin_filt, cos_filt)\\n return phase_filt\",\n \"def make_butter_spso(self, spso_wn_pass, spso_wn_stop, spso_order):\\n nyquist = self.s_freq/2\\n wn_pass_arr = np.asarray(spso_wn_pass)\\n wn_stop_arr = np.asarray(spso_wn_stop)\\n \\n # must remake filter for each pt bc of differences in s_freq\\n if np.any(wn_pass_arr <=0) or np.any(wn_pass_arr >=1):\\n wn_pass_arr = wn_pass_arr/nyquist \\n \\n if np.any(wn_stop_arr <=0) or np.any(wn_stop_arr >=1):\\n wn_stop_arr = wn_stop_arr/nyquist\\n\\n self.spso_sos_bandstop = butter(spso_order, wn_stop_arr, btype='bandstop', output='sos')\\n self.spso_sos_bandpass = butter(spso_order, wn_pass_arr, btype='bandpass', output='sos')\\n print(f\\\"Zero phase butterworth filter successfully created: order = {spso_order}x{spso_order} bandpass = {spso_wn_pass}\\\")\\n print(f\\\"Zero phase butterworth filter successfully created: order = {spso_order}x{spso_order} bandstop = {spso_wn_stop}\\\")\",\n \"def butter_bp(n, wlo, whi):\\n zeros = []\\n poles = _butter_analog_poles(n)\\n k = 1\\n fs = 2\\n\\n warpedlo = 2 * fs * mp.tan(mp.pi * wlo / fs)\\n warpedhi = 2 * fs * mp.tan(mp.pi * whi / fs)\\n bw = warpedhi - warpedlo\\n wo = mp.sqrt(warpedlo * warpedhi)\\n z, p, k = _zpklp2bp(zeros, poles, k, wo=wo, bw=bw)\\n z, p, k = _zpkbilinear(z, p, k, fs=fs)\\n return z, p, k\",\n \"def butter_highpass_filter(data, cutoff, fs, order=1):\\n b, a = butter_highpass(cutoff, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def bpfilter(\\n data: numpy.ndarray, short_min: float = 2, long_min: float = 12\\n) -> Optional[numpy.ndarray]:\\n return butter_bandpass_filter(\\n data, 1 / (long_min * 60), 1 / (short_min * 60), 1 / DATA_RATE\\n )\",\n \"def bandpass_filter(s, sample_rate, low_freq, high_freq, filter_order=5, rescale=False):\\n #create a butterworth filter\\n nyq = sample_rate / 2.0\\n f = np.array([low_freq, high_freq]) / nyq\\n b,a = filter_design.butter(filter_order, f, btype='bandpass')\\n\\n #filter the signal\\n filtered_s = filtfilt(b, a, s)\\n\\n if rescale:\\n #rescale filtered signal\\n filtered_s /= filtered_s.max()\\n filtered_s *= s.max()\\n\\n return filtered_s\",\n \"def bandpass(filename,f1,f2,Q,wout=True,plot=True):\\n start=time.time()\\n n, data, data_dB,sr,ch=inputwav(filename)\\n b, a = butter(Q,Wn=(f1/sr,f2/sr),btype='bandpass')\\n data_filtered=lfilter(b,a,data,axis=0)\\n print('Applying FFT...')\\n if wout==True:\\n print('Exporting...')\\n sf.write(filename[0:len(filename)-4]+'_BP.wav',data_filtered,sr,'PCM_16')\\n if plot==True:\\n print('Plotting...')\\n py.close()\\n w, h = freqz(b,a,worN=16384)\\n fig, (ax1, ax2) = py.subplots(nrows=2)\\n ax1.semilogx(0.5*sr*w/np.pi,abs(h),'k-')\\n ax1.set_xlabel('Frequency (Hz)')\\n ax1.set_ylabel('Rel. Amplitude')\\n ax1.grid()\\n ax1.set_ylim(0,1.1)\\n ax1.set_xlim(1,20000)\\n ax2.plot(data,'k-',label='Raw data')\\n ax2.plot(data_filtered,'m-',lw=1,label='Filtered data')\\n ax2.set_xlim(0,10000)\\n ax2.set_ylim(-1,1)\\n ax2.set_ylabel('Amplitude (Norm Bits)')\\n ax2.set_xlabel('Samples')\\n ax2.legend(loc=2,frameon=False,ncol=2)\\n py.subplots_adjust(hspace=0.35) \\n print('Done!')\\n end=time.time()\\n elapsed=int(1000*(end-start))\\n print('...............................')\\n print('Completed in '+str(elapsed)+' milliseconds.')\\n return data_filtered\",\n \"def _butter_pass(cutoff, fs, order=5, btype='high'):\\r\\n nyq = 0.5*fs\\r\\n normal_cutoff = cutoff/nyq\\r\\n# print \\\"normalized cutoff: \\\", normal_cutoff\\r\\n if normal_cutoff >= 1.:\\r\\n normal_cutoff = 1.\\r\\n b, a = signal.butter(order, normal_cutoff, btype=btype, analog=False)\\r\\n return b, a\",\n \"def bessel_wave(freq, alpha, beta):\\n return FMFilter(SineWave(freq), SineWave(alpha), beta)\",\n \"def butterworth_filter(dft4img, stopband2=10, order=3, showdft=False):\\n h, w = dft4img.shape[0], dft4img.shape[1]\\n P = h / 2\\n Q = w / 2\\n dst = np.zeros((h, w, 3), np.float64)\\n for i in range(h):\\n for j in range(w):\\n r2 = float((i - P) ** 2 + (j - Q) ** 2)\\n if r2 == 0:\\n r2 = 1.0\\n dst[i, j] = 1 / (1 + (r2 / stopband2) ** order)\\n dst = np.float64(dst)\\n if showdft:\\n cv2.imshow(\\\"butterworth\\\", cv2.magnitude(dst[:, :, 0], dst[:, :, 1]))\\n return dst\",\n \"def bandpass_filterbank(bands, fs=1.0, order=8, output=\\\"sos\\\"):\\n\\n filters = []\\n nyquist = fs / 2.0\\n\\n for band in bands:\\n # remove bands above nyquist frequency\\n if band[0] >= nyquist:\\n raise ValueError(\\\"Bands should be below Nyquist frequency\\\")\\n\\n # Truncate the highest band to Nyquist frequency\\n norm_band = np.minimum(0.99, np.array(band) / nyquist)\\n\\n # Compute coefficients\\n coeffs = butter(order / 2, norm_band, \\\"bandpass\\\", output=output)\\n filters.append(coeffs)\\n\\n return filters\",\n \"def filt_bp(sig: np.ndarray, Ss: int, Cfs0: int, Cfs1: None,\\n order=5) -> np.ndarray:\\n nyq = 0.5 * Ss\\n normal_cutoff1 = Cfs0 / nyq\\n normal_cutoff2 = Cfs1 / nyq\\n b, a = butter(order, (normal_cutoff1, normal_cutoff2),\\n btype='band',\\n analog=False)\\n return lfilter(b, a, sig)\",\n \"def _signal_filter_butterworth(signal, sampling_rate=1000, lowcut=None, highcut=None, order=2):\\n if lowcut is not None and highcut is not None:\\n sos = scipy.signal.butter(order, [lowcut, highcut], btype=\\\"bandpass\\\", output='sos', fs=sampling_rate)\\n elif lowcut is not None:\\n sos = scipy.signal.butter(order, [lowcut], btype=\\\"highpass\\\", output='sos', fs=sampling_rate)\\n elif highcut is not None:\\n sos = scipy.signal.butter(order, [highcut], btype=\\\"lowpass\\\", output='sos', fs=sampling_rate)\\n\\n filtered = scipy.signal.sosfiltfilt(sos, signal)\\n return filtered\",\n \"def _make_filters(self):\\n\\n \\\"\\\"\\\"\\n filter_bank = bandpass_filterbank(\\n self.bands, fs=self.fs, order=order, output=output\\n )\\n\\n return [lambda sig: sosfiltfilt(bpf, sig) for bpf in filter_bank]\\n \\\"\\\"\\\"\\n\\n # This seems to work only for Octave bands out of the box\\n centers = self.centers\\n n = len(self.centers)\\n\\n new_bands = [[centers[0] / 2, centers[1]]]\\n for i in range(1, n - 1):\\n new_bands.append([centers[i - 1], centers[i + 1]])\\n new_bands.append([centers[-2], self.fs / 2])\\n\\n n_freq = self.n_fft // 2 + 1\\n freq_resp = np.zeros((n_freq, n))\\n freq = np.arange(n_freq) / self.n_fft * self.fs\\n\\n for b, (band, center) in enumerate(zip(new_bands, centers)):\\n lo = np.logical_and(band[0] <= freq, freq < center)\\n freq_resp[lo, b] = 0.5 * (1 + np.cos(2 * np.pi * freq[lo] / center))\\n\\n if b != n - 1:\\n hi = np.logical_and(center <= freq, freq < band[1])\\n freq_resp[hi, b] = 0.5 * (1 - np.cos(2 * np.pi * freq[hi] / band[1]))\\n else:\\n hi = center <= freq\\n freq_resp[hi, b] = 1.0\\n\\n filters = np.fft.fftshift(\\n np.fft.irfft(freq_resp, n=self.n_fft, axis=0),\\n axes=[0],\\n )\\n\\n # remove the first sample to make them odd-length symmetric filters\\n self.filters = filters[1:, :]\",\n \"def butter_filter_unwrapped(image, n, f0, pad = False):\\n if pad == True:\\n res = [2**kji for kji in range(15)]\\n N_int_x = image.shape[1]\\n N_int_y = image.shape[0]\\n nx_pad = np.where(res > np.tile(N_int_x, len(res)))\\n nx_pad = res[nx_pad[0][0]]\\n ny_pad = np.where(res > np.tile(N_int_y, len(res)))\\n ny_pad = res[ny_pad[0][0]]\\n dif_x = (nx_pad - N_int_x)/2\\n dif_y = (ny_pad - N_int_y)/2\\n orig_shape = image.shape\\n image = np.lib.pad(image, ((dif_y, dif_y), (dif_x, dif_x)), 'reflect')\\n \\n [ny, nx] = image.shape\\n dx = 2.0/nx\\n dy = 2.0/ny\\n dfx = 0.5\\n dfy = 0.5\\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\\n FX, FY = np.meshgrid(fx, fy)\\n shift = np.exp(-2*np.pi*1j*(FX+FY))\\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\\n ft_img = shift * np.fft.fftshift(np.fft.fft2(image))\\n \\n buttered = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_img))/ shift)\\n if pad == True:\\n assert(buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x].shape == orig_shape)\\n return buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x]\\n else:\\n assert(buttered.shape == image.shape)\\n return buttered\",\n \"def lowpass_butter(fs, L, order, data, axis=-1, btype='low'):\\n from scipy.signal import butter, sosfiltfilt\\n\\n nyq = 0.5 * fs # Nyquist frequency\\n low = L / nyq\\n sos = butter(order, low, btype=btype, output='sos') # Coefficients for Butterworth filter\\n filtered = sosfiltfilt(sos, data, axis=axis)\\n\\n return filtered\",\n \"def __band_filter(data: dict, lowFreq: Union[int, float], highFreq: Union[int, float], timestep: int=0,\\n samplingFreq: int=240, order: int=5, eegSensor: int=0, filterType: str='bandpass',\\n lengthOfTestSeconds: Union[int, float]=32, example: int=0) -> dict:\\n #Test\\n # Filter.__band_filter_test(data=data, low=lowFreq, high=highFreq, samplingFreq=samplingFreq, order=order,\\n # eegSensor=eegSensor, filterType=filterType, lengthOfTestSeconds=lengthOfTestSeconds)\\n #Code\\n nyq = 0.5 * samplingFreq\\n low = lowFreq / nyq\\n high = highFreq / nyq\\n b, a = signal.butter(order, [low, high], btype=filterType)\\n y = signal.lfilter(b, a, data['Signal'])\\n ##Graph - This belongs somewhere else probably.\\n # t = np.linspace(0, len(data), len(data), endpoint=False)\\n # plt.plot(t, y, label='Sensor #' + str(eegSensor) + ' (' + str(lowFreq) + '-' + str(highFreq) + ') Hz')\\n # plt.grid(True)\\n # plt.axis('tight')\\n # plt.xticks(range(10), range(lengthOfTestSeconds)) ##32 seconds per test?\\n # plt.xlabel(\\\"Time in Seconds\\\")\\n # plt.legend(loc='upper left')\\n # plt.show()\\n output = {}\\n timestep = []\\n for index, eegChannel in enumerate(y[0]):#the extra [0] is becuase signal.lfilter() puts it in a 1D array. Grrr\\n timestep.append(eegChannel)\\n output['Signal'] = timestep\\n Visualization.channelGraph(y[0][0])\\n return output #output is 2D 64xTimeSamples\",\n \"def _build_wavelet_bank(self):\\n self._build_filters()\\n wavelet_bank = torch.stack(self._filters)\\n wavelet_bank = wavelet_bank.view(\\n wavelet_bank.shape[0], 1, 1, wavelet_bank.shape[1]\\n )\\n wavelet_bank = torch.cat([wavelet_bank] * self.channels, 2)\\n return wavelet_bank\",\n \"def butter_lowpass_filter(data: np.ndarray, cutoff: float, fs: float, order: int) -> np.ndarray:\\n nyq = 0.5 * fs\\n normal_cutoff = cutoff / nyq\\n # Get the filter coefficients\\n b, a = signal.butter(order, normal_cutoff, btype='low', analog=False)\\n y = signal.filtfilt(b, a, data)\\n return y\",\n \"def bandpass_filter_raw_plot(data, fs, f1, f2):\\n b, a = sp.butter(N=2, Wn=np.array([f1, f2]) / fs * 2, btype='bandpass') # build a bandpass butterworth filter of order 4, with cut-off frequencies 1 and 45\\n w, h = sp.freqz(b, a) # compute the frequency response of the filter\\n f = w / np.pi * fs / 2\\n plt.figure()\\n plt.plot(f, 10 * np.log10(abs(h)))\\n plt.xlabel('frequency (Hz)')\\n plt.ylabel('Magnitude (dB)')\\n plt.title('frequency response of butterworth bandpass [1, 45]Hz')\\n plt.grid()\\n\\n data1 = sp.filtfilt(b, a, data)\\n return data1\",\n \"def butterworthsmoothing(df, column_names: list = None, Wn = 0.015):\\n\\n if column_names is None:\\n return df\\n else:\\n # First, design the Buterworth filter\\n N = 2 # Filter order\\n Wn = Wn # Cutoff frequency\\n B, A = signal.butter(N, Wn, output='ba')\\n for i in column_names:\\n df[i] = signal.filtfilt(B, A, df[i])\\n df.dropna(axis=0, how='any', inplace=True)\\n return df\",\n \"def __init__(self, init=None, filter_table=None, filter_name=None,\\n wavecent=None, fwhm=None, **kwargs):\\n super(MiriBandPassFilter, self).__init__(init=init,\\n filter_table=filter_table,\\n filter_name=filter_name,\\n filter_type='BandPass',\\n **kwargs)\\n\\n # Define the central wavelength and fwhm, if defined.\\n if wavecent:\\n self.meta.instrument.filter_wavecent = wavecent\\n if fwhm:\\n self.meta.instrument.filter_fwhm = fwhm\",\n \"def band_pass_eeg(eeg, freq_range, order=4):\\n return ButterworthFilter(eeg, freq_range, filt_type='pass', order=order).filter()\",\n \"def filters(array, sample_frequency):\\n strain = TimeSeries(array, sample_rate=int(sample_frequency))\\n white_data = strain.whiten(fftlength=4, fduration=4)\\n bp_data = white_data.bandpass(50, 250)\\n return bp_data.value\",\n \"def butter_lowpass_filter(data, cutoff, fs, order=1):\\n b, a = butter_lowpass(cutoff, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def butter_hpf(highcut, fs, order):\\n nyq = 0.5 * fs\\n high = highcut / nyq\\n b, a = signal.butter(order, high, btype='highpass')\\n w, h = signal.freqz(b, a, worN=1000)\\n# plt.figure()\\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\\n return b, a\",\n \"def filtroBilateral(frame):\\n fb = cv2.bilateralFilter(frame, 0, 32, 2)\\n return fb\",\n \"def bandpassFilter (self, lowerFreq, upperFreq):\\n self.bandpassLimits = (lowerFreq, upperFreq)\\n # stuff to do\",\n \"def butter2d_lp(shape, f, n):\\n \\n rows, cols = shape \\n x = np.linspace(-0.5, 0.5, cols)\\n y = np.linspace(-0.5, 0.5, rows)\\n radius = np.sqrt((x**2)[np.newaxis] + (y**2)[:, np.newaxis]) \\n filt = 1 / (1.0 + (radius / f)**(2*n))\\n \\n return (filt)\",\n \"def bandpass(self, gulp=512, **kwargs):\\n bpass_ar = np.zeros(self.header.nchans, dtype=\\\"float64\\\")\\n num_samples = 0\\n for nsamps, _ii, data in self.readPlan(gulp, **kwargs):\\n lib.getBpass(data, bpass_ar, self.header.nchans, nsamps)\\n num_samples += nsamps\\n bpass_ar /= num_samples\\n return TimeSeries(bpass_ar, self.header.newHeader({\\\"nchans\\\": 1}))\",\n \"def make_filter_banks(power_frames, sampling_rate, NFFT, num_filt = 40):\\n low_freq_mel = 0\\n high_freq_mel = Hz_to_Mel(sampling_rate/2) # Convert Hz to Mel\\n #mel_points = np.arange(low_freq_mel, high_freq_mel, (high_freq_mel - low_freq_mel)/(num_filt + 2)) # Equally spaced in Mel scale\\n mel_points = np.linspace(low_freq_mel, high_freq_mel, num_filt + 2) # Equally spaced in Mel scale\\n #hz_points = Mel_to_Hz(mel_points) # Convert Mel to Hz\\n bins = np.floor((NFFT + 1) * Mel_to_Hz(mel_points) / sampling_rate)\\n \\n #bank = np.empty((num_filt, int(np.floor(NFFT / 2 + 1))))\\n bank = np.zeros((num_filt, int(np.floor(NFFT / 2 + 1))))\\n for m in range(1, num_filt + 1):\\n f_s = bins[m - 1 : m + 2]\\n f_prev = int(f_s[0]) # left\\n f = int(f_s[1]) # center\\n f_next = int(f_s[2]) # right\\n\\n np.put(bank[m - 1], list(range(f_prev)), 0) # k < f_prev\\n\\n for k in range(f_prev, f):\\n np.put(bank, ((m - 1)*int(np.floor(NFFT / 2 + 1))) + k, (k - f_prev) / (f - f_prev)) \\n \\n for k in range(f, f_next):\\n np.put(bank, ((m - 1)*int(np.floor(NFFT / 2 + 1))) + k, (f_next - k) / (f_next - f))\\n\\n np.put(bank[m - 1], list(range(f_next, len(bank))), 0) # k > f_next\\n\\n filter_banks = np.where(np.dot(power_frames, bank.T) == 0, np.finfo(float).eps, np.dot(power_frames, bank.T))\\n #filter_banks = np.where(filter_banks == 0, np.finfo(float).eps, filter_banks) # Numerical Stability\\n filter_banks = 20 * np.log10(filter_banks) # dB\\n\\n return filter_banks\",\n \"def butter_lpf(fc, fs, order):\\n nyq = 0.5 * fs\\n high = fc / nyq\\n b, a = signal.butter(order, high, btype='lowpass', analog=False)\\n w, h = signal.freqz(b, a, worN=1000)\\n# plt.figure()\\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\\n return b, a\",\n \"def _butter_lowpass(lowcut, fs, order=4) -> tuple:\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n b, a = butter(order, [low], btype=\\\"low\\\")\\n return b, a\",\n \"def bandpass_filter(data, lowcut, highcut, fs=2000, numtaps=255):\\n nyq = fs / 2\\n\\n # design filter\\n fe1 = lowcut / nyq\\n fe2 = highcut / nyq\\n b = firwin(numtaps, (fe1, fe2), pass_zero=False)\\n\\n filtered = lfilter(b, 1, data)\\n\\n return filtered\",\n \"def get_butterworth_high_pass_filter(shape, cutoff, order):\\n \\n # Hint: May be one can use the low pass filter function to get a high pass mask\\n print(\\\"butterworth_high_pass_filter = \\\")\\n print(\\\"cutoff: \\\",cutoff)\\n print(\\\"order: \\\",order)\\n filter = get_butterworth_low_pass_filter(shape, cutoff, order)\\n\\n for i in range(shape[0]):\\n for j in range(shape[1]):\\n filter[i, j] = 1 - filter[i, j]\\n\\n # return filter\\n return process_filter(image, filter)\",\n \"def _get_fir_filter(passband, fs, order=183, weights=[5.75, 1., 5.75], mask=[0, 1, 0]):\\n # return remez(order, passband, mask, weights, Hz=fs), 1.\\n return remez(order, passband, mask, Hz=fs), 1.\",\n \"def butter_lowpass_filter(self, data: np.ndarray, lowcut: float, fs: float, order: int = 4) -> np.ndarray:\\n b, a = self._butter_lowpass(lowcut, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def get_butterworth_low_pass_filter(shape, cutoff, order):\\n \\n \\n print(\\\"butterworth_low_pass_filter = \\\")\\n print(\\\"cutoff: \\\",cutoff)\\n print(\\\"order: \\\",order)\\n filter = np.zeros(shape)\\n for i in range(shape[0]):\\n for j in range(shape[1]):\\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\\n filter[i, j] = 1 / (1 + (D / cutoff) ** (2 * order))\\n # print(\\\"\\\\n\\\\n\\\\n\\\\n\\\")\\n # print(filter)\\n # return filter\\n return process_filter(image, filter)\",\n \"def get_butterworth_high_pass_filter(self, shape, cutoff, order):\\r\\n\\r\\n #Hint: May be one can use the low pass filter function to get a high pass mask\\r\\n # 1 - butter low pass\\r\\n mask = 1 - self.get_butterworth_low_pass_filter(shape, cutoff, order)\\r\\n\\r\\n return mask\",\n \"def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=(500, 10000)):\\n if freq_cutoffs[0] <= 0:\\n raise ValueError('Low frequency cutoff {} is invalid, '\\n 'must be greater than zero.'\\n .format(freq_cutoffs[0]))\\n\\n Nyquist_rate = samp_freq / 2\\n if freq_cutoffs[1] >= Nyquist_rate:\\n raise ValueError('High frequency cutoff {} is invalid, '\\n 'must be less than Nyquist rate, {}.'\\n .format(freq_cutoffs[1], Nyquist_rate))\\n\\n if rawsong.shape[-1] < 387:\\n numtaps = 64\\n elif rawsong.shape[-1] < 771:\\n numtaps = 128\\n elif rawsong.shape[-1] < 1539:\\n numtaps = 256\\n else:\\n numtaps = 512\\n\\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\\n freq_cutoffs[1] / Nyquist_rate])\\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\\n # window to design filter, but default for matlab's fir1\\n # is actually Hamming\\n # note that first parameter for scipy.signal.firwin is filter *length*\\n # whereas argument to matlab's fir1 is filter *order*\\n # for linear FIR, filter length is filter order + 1\\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\\n a = np.zeros((numtaps+1,))\\n a[0] = 1 # make an \\\"all-zero filter\\\"\\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\\n return filtsong\",\n \"def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=None):\\n\\n Nyquist_rate = samp_freq / 2\\n if freq_cutoffs is None:\\n freq_cutoffs = [500, 10000]\\n if rawsong.shape[-1] < 387:\\n numtaps = 64\\n elif rawsong.shape[-1] < 771:\\n numtaps = 128\\n elif rawsong.shape[-1] < 1539:\\n numtaps = 256\\n else:\\n numtaps = 512\\n\\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\\n freq_cutoffs[1] / Nyquist_rate])\\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\\n # window to design filter, but default for matlab's fir1\\n # is actually Hamming\\n # note that first parameter for scipy.signal.firwin is filter *length*\\n # whereas argument to matlab's fir1 is filter *order*\\n # for linear FIR, filter length is filter order + 1\\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\\n a = np.zeros((numtaps+1,))\\n a[0] = 1 # make an \\\"all-zero filter\\\"\\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\\n return filtsong\",\n \"def bandpass_filter_audio(audio, f_low=400, f_high=450):\\n filtered_audio = core.sinc_filter(audio, f_low, window_size=256, high_pass=True)\\n filtered_audio = core.sinc_filter(filtered_audio, f_high, window_size=256, high_pass=False)\\n return tf.squeeze(filtered_audio)\",\n \"def copy(self):\\n new_filter = BloomFilter(self.capacity, self.error_rate)\\n new_filter.filter = self.filter.copy()\\n return new_filter\",\n \"def make_block(self, block_ix, downsample, ker_size, block_len):\\n stride = int(downsample) + 1\\n n_in_filters = self.filters[block_ix]\\n n_filters = self.filters[block_ix+1]\\n mult_fact = 1 if block_ix == 0 else 6\\n\\n block = [MBConv(n_in_filters, n_filters, ker_size, stride, mult_fact)]\\n block += [MBConv(n_filters, n_filters, ker_size, 1, mult_fact) for _ in range(block_len-1)]\\n return block\",\n \"def iirfilter(x, N=4, pass_freq=0.7 / 12.):\\n b, a = signal.butter(N, pass_freq, \\\"low\\\", analog=False)\\n return signal.filtfilt(b, a, x)\",\n \"def dwt(image_array, quantization_Array):\\n # Create the high pass and low pass filters\\n # both filters are non-causal\\n # symmetric\\n # [-2, -1, 0, 1, 2]\\n LPF = [-0.125, 0.25, 0.75, 0.25, -0.125]\\n LPF_center = 2\\n\\n # [ -2,-1, 0]\\n HPF = [-0.5, 1, -0.5]\\n HPF_center = 2\\n\\n nrow, ncol = image_array.shape\\n\\n # create an array that will contain the 4 different subbands of the image\\n LL = np.zeros((nrow, ncol))\\n LH = np.zeros((nrow, ncol))\\n HL = np.zeros((nrow, ncol))\\n HH = np.zeros((nrow, ncol))\\n filtered_image = [LL, LH, HL, HH]\\n\\n # filtering the rows using a low pass and high pass filters\\n LowPass_rows = np.zeros((nrow, ncol))\\n HighPass_rows = np.zeros((nrow, ncol))\\n for i in range(0, nrow):\\n LowPass_rows[i, :] = lfilter(LPF, image_array[i, :], LPF_center)\\n HighPass_rows[i, :] = lfilter(HPF, image_array[i, :], HPF_center)\\n\\n # down sample rows.\\n # which means we will have half the number of columns\\n for i in range(0, len(filtered_image)):\\n filtered_image[i] = filtered_image[i][:, ::2]\\n\\n # apply filters accross columns\\n for i in range(0, ncol):\\n LL[:, i] = lfilter(LPF, LowPass_rows[:, i], LPF_center)\\n LH[:, i] = lfilter(HPF, LowPass_rows[:, i], HPF_center)\\n HL[:, i] = lfilter(LPF, HighPass_rows[:, i], LPF_center)\\n HH[:, i] = lfilter(HPF, HighPass_rows[:, i], HPF_center)\\n\\n # down sample columns and quantize\\n for i in range(0, len(filtered_image)):\\n filtered_image[i] = filtered_image[i][::2, :]\\n filtered_image[i] = np.round(\\n filtered_image[i]/quantization_Array[i]).astype(int)\\n\\n return filtered_image\",\n \"def A_weighting(fs):\\n b, a = A_weighting_analog()\\n\\n # Use the bilinear transformation to get the digital filter.\\n return bilinear(b, a, fs)\",\n \"def conv_block(input, nb_filter, dropout_rate=None, weight_decay=1E-4):\\n\\n x = Activation('relu')(input)\\n x = Convolution2D(nb_filter, (3, 3), kernel_initializer=\\\"he_uniform\\\", padding=\\\"same\\\", use_bias=False,\\n kernel_regularizer=l2(weight_decay))(x)\\n if dropout_rate is not None:\\n x = Dropout(dropout_rate)(x)\\n\\n return x\",\n \"def bias(self, bias_value):\\n if bias_value == 0:\\n return\\n new_channel = sppasChannel()\\n new_channel.set_sampwidth(self._sampwidth)\\n new_channel.set_framerate(self._framerate)\\n a = sppasAudioFrames(self._channel.get_frames(self._channel.get_nframes()), self._channel.get_sampwidth(), 1)\\n new_channel.set_frames(a.bias(bias_value))\\n\\n self._channel = new_channel\",\n \"def estimate_bandpass(data):\\n \\n est = filter(data, params.st_bp_window_f, axis=0)\\n est = filter(est, params.st_bp_window_t, axis=1)\\n \\n return est\",\n \"def broadbandfilter(self):\\n _, = self.broadbandfilters\\n return _\",\n \"def apply_band_pass(ftd, freq, omega, bp_wid=1):\\n # Find number of frequencies\\n nf = len(freq)\\n # Find index for band pass, only consider indices of positive freqs\\n idx_om = hf.find_nearest_index(freq[0:nf//2], omega)\\n # Filter out frequencies left of band pass\\n ftd[:,0:idx_om-1-bp_wid] = 0.0\\n # Filter out frequencies left of omega\\n ftd[:,idx_om+1+bp_wid:-1] = 0.0\\n # Correct for lost amplitude\\n ftd[:,idx_om-bp_wid:idx_om+bp_wid] = ftd[:,idx_om-bp_wid:idx_om+bp_wid] * 2.0\\n return ftd\",\n \"def butterworth(path_to_data, dtype, n_channels, data_order,\\n low_frequency, high_factor, order, sampling_frequency,\\n max_memory, output_path, output_dtype, standarize=False,\\n output_filename='filtered.bin', if_file_exists='skip',\\n processes='max'):\\n processes = multiprocess.cpu_count() if processes == 'max' else processes\\n\\n # init batch processor\\n bp = BatchProcessor(path_to_data, dtype, n_channels, data_order,\\n max_memory, buffer_size=200)\\n\\n if standarize:\\n bp_ = BatchProcessor(path_to_data, dtype, n_channels, data_order,\\n max_memory, buffer_size=0)\\n\\n filtering = partial(_butterworth, low_frequency=low_frequency,\\n high_factor=high_factor,\\n order=order,\\n sampling_frequency=sampling_frequency)\\n\\n # if standarize, estimate sd from first batch and use\\n # _butterworth_scale function, pass filtering to estimate sd from the\\n # filtered data\\n sd = standard_deviation(bp_, sampling_frequency,\\n preprocess_fn=filtering)\\n fn = partial(_butterworth_scale, denominator=sd)\\n # add name to the partial object, since it is not added...\\n fn.__name__ = _butterworth_scale.__name__\\n else:\\n # otherwise use _butterworth function\\n fn = _butterworth\\n\\n _output_path = os.path.join(output_path, output_filename)\\n\\n (path,\\n params) = bp.multi_channel_apply(fn, mode='disk',\\n cleanup_function=fix_indexes,\\n output_path=_output_path,\\n if_file_exists=if_file_exists,\\n cast_dtype=output_dtype,\\n low_frequency=low_frequency,\\n high_factor=high_factor,\\n order=order,\\n sampling_frequency=sampling_frequency,\\n processes=processes)\\n\\n return path, params\",\n \"def make_bwfull(w,minZ,maxZ,ires=1,fixw=False,m=mz0):\\n cmds = []\\n # coefficients for the amplitudes\\n cmds.append(\\\"A[1,0,1000000]\\\")\\n cmds.append(\\\"B[1,0,1000000]\\\")\\n cmds.append(\\\"C[10000.0,0,1000000]\\\")\\n # amplitudes\\n cmds.append('m[%s,%s,%s]'%(m,minZ,maxZ))\\n cmds.append('g[2.49,0,10]')\\n denom = '((x^2-m^2)^2+x^4*g^2/m^2)'\\n cmds.append(\\\"expr::z_rbw('x^2/%s',x,m,g)\\\"%denom)\\n cmds.append(\\\"expr::z_int('(x^2-m^2)/%s',x,m,g)\\\"%denom)\\n cmds.append(\\\"expr::z_rad('1/(x^2)',x)\\\")\\n # resolution model\\n cmds += resolutions[ires]()\\n [w.factory(cmd) for cmd in cmds]\\n # any parameter adjustments\\n if True:\\n w.var('r_m').setConstant(kTRUE) if w.var('r_m') else None\\n w.var('rt_m').setConstant(kTRUE) if w.var('rt_m') else None\\n w.var('g').setConstant(kTRUE) if w.var('g') and fixw else None\\n # sum-of-amplitudes pdf\\n lshape = RooRealSumPdf('lshape','lshape',RooArgList(w.function('z_rad'),w.function('z_int'),w.function('z_rbw')),RooArgList(w.var('A'),w.var('B'),w.var('C')))\\n getattr(w,'import')(lshape)\\n # convolution\\n pdf = w.pdf('lshape')\\n if w.pdf('res'):\\n w.var('x').setBins(10000,'cache')\\n cmd = 'FCONV::sum(x,lshape,res)'\\n w.factory(cmd)\\n pdf = w.pdf('sum')\\n return pdf, kFALSE\",\n \"def makebdf(startTime, endTime, metadata, data, bdfdir='.'):\\n\\n from sdmpy import bdf\\n from rfpipe.metadata import Metadata\\n\\n assert type(metadata) == Metadata, (\\\"metadata must be \\\"\\n \\\"of type rfpipe.metadata.Metadata\\\")\\n\\n assert data.ndim == 6, (\\\"data must have 6 dimensions: \\\"\\n \\\"nint, nbl, nspw, numBin, nchan, npol.\\\")\\n\\n nint, nbl, nspw, numBin, nchan, npol = data.shape\\n\\n IFidspwnum = [spw.split('-') for (spw, freq) in metadata.spworder]\\n spws = [bdf.BDFSpectralWindow(None, numBin=numBin, numSpectralPoint=nchan,\\n sw=int(swnum)+1, # casting from 0->1 based\\n swbb='{0}_8BIT'.format(IFid),\\n npol=npol) for (IFid, swnum) in IFidspwnum]\\n # TODO: confirm that sw is 1 based for a proper SDM\\n # TODO: confirm that metadata spworder is 0 based\\n\\n assert nspw == len(spws), ('Expected one spw in metadata.spworder per spw '\\n 'in data array.')\\n assert os.path.isdir(bdfdir), 'bdfdir does not exist'\\n\\n uid = ('uid:///evla/realfastbdf/{0}'\\n .format(int(time.Time(startTime, format='mjd').unix*1e3)))\\n logger.info(\\\"Creating BDFWriter for {0}\\\".format(uid))\\n w = bdf.BDFWriter(bdfdir, start_mjd=startTime, uid=uid,\\n num_antenna=metadata.nants_orig, spws=spws, scan_idx=1,\\n corr_mode='c')\\n\\n logger.info(\\\"Writing data to bdf\\\")\\n dat = {}\\n w.write_header()\\n for i in range(nint):\\n dat['crossData'] = data[i]\\n ts = startTime + i*metadata.inttime/86400.\\n w.write_integration(mjd=ts, interval=metadata.inttime, data=dat)\\n w.close()\",\n \"def filt(self,cutoff_dt, btype='low',order=3,axis=-1):\\r\\n \\r\\n if self.isequal==False and self.VERBOSE:\\r\\n print 'Warning - time series is unequally spaced. Use self.interp to interpolate onto an equal grid'\\r\\n \\r\\n if not btype == 'band':\\r\\n Wn = self.dt/cutoff_dt\\r\\n else:\\r\\n Wn = [self.dt/co for co in cutoff_dt]\\r\\n \\r\\n (b, a) = signal.butter(order, Wn, btype=btype, analog=0, output='ba')\\r\\n \\r\\n return signal.filtfilt(b, a, self.y, axis=axis)\",\n \"def fastbias(self, fo, fbDac, data, slow):\\n if fbDac not in [0, 1]:\\n raise RuntimeError('fbDac must be 0 or 1')\\n if slow not in [0, 1]:\\n raise RuntimeError('slow must be 0 or 1')\\n a = {0: 0x100000, 1: 0x200000}[fo]\\n b = (data & 0xffff) << 3\\n c = fbDac << 19\\n d = slow << 2\\n self.append(a + b + c + d)\\n return self\",\n \"def tophat_bandpass(ctr, width, name=None):\\n\\n nintervals = 100 # intervals between wmin and wmax\\n interval = width / nintervals # interval of each sample\\n wmin = ctr - width / 2. - interval / 2.\\n wmax = ctr + width / 2. + interval / 2.\\n wave = np.linspace(wmin, wmax, nintervals + 1)\\n trans = np.ones_like(wave)\\n trans[[0, -1]] = 0.\\n return Bandpass(wave, trans, wave_unit=u.micron, name=name)\",\n \"def gaussianFilter(gain,BT,spSym,nTaps):\\n\\n a = np.sqrt(np.log(2)/2)/BT\\n t = np.linspace(-.5*nTaps,.5*nTaps-1,nTaps)/spSym\\n\\n ft = np.sqrt(np.pi)/a *np.exp(-(np.pi**2*(t)**2)/a**2)\\n ft /= np.sum(ft) * gain # normalize filter\\n\\n return ft\",\n \"def bessel_bandpass_filter(data, lowcut, highcut, fs, order=2):\\n\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n\\n # bessel() and lfilter() are from scipy.signal\\n\\n b, a = bessel(order, [low, high], btype='band')\\n y = lfilter(b, a, data)\\n return y\",\n \"def band_filter(self, bands) -> 'ImageCollection':\\n\\n process_id = 'filter_bands'\\n args = {\\n 'imagery': self.graph,\\n 'bands': bands\\n }\\n return self.graph_add_process(process_id, args)\",\n \"def lowpass_filter(data, Wn=0.014, N=2):\\n data = np.array(data)\\n data = data.astype(np.float)\\n # N = 5 # Filter order\\n # Wn = 0.02 # Cutoff frequency\\n B, A = signal.butter(N, Wn, output='ba')\\n\\n # Second, apply the filter\\n tempf = signal.filtfilt(B,A, data)\\n # print(tempf)\\n return tempf\",\n \"def make_band(f0, band_type, num):\\n \\n if band_type == '1Hz-spaced':\\n hwidth = num//2\\n step = 1\\n f = np.arange(f0-hwidth, f0+hwidth+step, step)\\n \\n else:\\n lwr = -(num-1)//2 # lower range bound for frequency calculation\\n upr = (num+1)//2 # upper range bound for frequency calculation\\n f = np.array(list(f0*2**(k/(12*num)) for k in range(lwr,upr)))\\n \\n return f\",\n \"def band(self, name, bands, new_name=None, label=None, text_key=None):\\n if not self._is_numeric(name):\\n msg = \\\"Can only band numeric typed data! {} is {}.\\\"\\n msg = msg.format(name, self._get_type(name))\\n raise TypeError(msg)\\n if not text_key: text_key = self.text_key\\n if not new_name: new_name = '{}_banded'.format(name)\\n if not label: label = self.text(name, False, text_key)\\n franges = []\\n for idx, band in enumerate(bands, start=1):\\n lab = None\\n if isinstance(band, dict):\\n lab = list(band.keys())[0]\\n band = list(band.values())[0]\\n if isinstance(band, tuple):\\n if band[0] < 0:\\n raise ValueError('Cannot band with lower bound < 0.')\\n elif band[1] < 0:\\n raise ValueError('Cannot band with upper bound < 0.')\\n r = '{}-{}'.format(band[0], band[1])\\n franges.append([idx, lab or r, {name: frange(r)}])\\n else:\\n r = str(band)\\n franges.append([idx, lab or r, {name: [band]}])\\n\\n self.derive(new_name, 'single', label, franges,\\n text_key=text_key)\\n\\n return None\",\n \"def generate_blackbody(temp, wmin=40., wmax=300.):\\n c = 2.99792e14 # um/s\\n Jy2W = 1e-26 # Convert Jy to W/m2/Hz\\n dw = 0.005\\n nw = int((wmax - wmin) / dw) + 1\\n wstar = np.arange(nw) * dw + wmin\\n fstar = np.pi * thermast.planck_function(wstar, temp) \\\\\\n * wstar ** 2 / (Jy2W * c)\\n return wstar, fstar\",\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 bandpass_filter(files, lowpass_freq=0.1, highpass_freq=0.01, tr=2):\\n import os\\n\\n import nibabel as nb\\n import numpy as np\\n from nipype.utils.filemanip import (\\n filename_to_list,\\n list_to_filename,\\n split_filename\\n )\\n\\n fs = 1./tr\\n\\n out_files = []\\n for filename in filename_to_list(files):\\n path, name, ext = split_filename(filename)\\n out_file = os.path.join(os.getcwd(), name + '_bandpassed' + ext)\\n\\n img = nb.load(filename)\\n timepoints = img.shape[-1]\\n F = np.zeros((timepoints))\\n\\n lowidx = int(timepoints / 2) + 1\\n if lowpass_freq > 0:\\n lowidx = np.round(float(lowpass_freq) / fs * timepoints)\\n\\n highidx = 0\\n if highpass_freq > 0:\\n highidx = np.round(float(highpass_freq) / fs * timepoints)\\n F[int(highidx):int(lowidx)] = 1\\n F = ((F + F[::-1]) > 0).astype(int)\\n data = img.get_data()\\n if np.all(F == 1):\\n filtered_data = data\\n else:\\n filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F))\\n img_out = nb.Nifti1Image(filtered_data, img.affine, img.header)\\n img_out.to_filename(out_file)\\n out_files.append(out_file)\\n\\n return list_to_filename(out_files)\",\n \"def Deband(clip: vs.VideoNode, radius: int = 17, threshold: float = 4,\\n iterations: int = 1, grain: float = 4, chroma: bool = True)-> vs.VideoNode:\\n if get_depth(clip) != 16:\\n clip = depth(clip, 16)\\n if chroma is True:\\n clip = join([core.placebo.Deband(x, 1, iterations, threshold, radius, grain)\\n for x in split(clip)])\\n else:\\n clip = core.placebo.Deband(clip, 1, iterations, threshold, radius, grain)\\n return clip\",\n \"def xor_folding(self):\\n lbs = round(self.bit_size / 2)\\n cap = round(self.capacity / 2)\\n\\n fold_pos = round( len(self.filter) / 2 )\\n\\n a = self.filter[0:fold_pos]\\n b = self.filter[fold_pos:]\\n # print('======>',self.bit_size,'#',len(a),len(b))\\n\\n r = BloomFilter(cap=cap, fpr=self.false_positive_rate, bfpower=self.potencia, bs=lbs)\\n r.filter = a.__ixor__(b)\\n return r\",\n \"def to_bw(self) -> 'BaseImage':\\n\\n def bw(r: int, g: int, b: int, a: int) -> Tuple4IntType:\\n \\\"\\\"\\\"\\n To black-white function.\\n \\\"\\\"\\\"\\n c = int((r + g + b) / 3)\\n return c, c, c, a\\n\\n return self.apply_image_function(image_function=bw)\",\n \"def butterfly(self):\\n\\n self.log.info(\\\"Begin Butterfly\\\")\\n\\n dst = os.path.join(self.cfg['start_dir'], 'Butterfly', 'src')\\n try:\\n os.chdir(dst)\\n except OSError, err:\\n self.log.error(\\\"Butterfly: failed to change to dst dir %s\\\" % (dst, err))\\n\\n cmd = \\\"ant\\\"\\n run_cmd(cmd)\\n\\n self.log.info(\\\"End Butterfly\\\")\",\n \"def test_filt_abmag(self):\\n sun = Sun.from_builtin('E490_2014')\\n V = get_bandpass('johnson v')\\n wave, fluxd = sun.filt(V, unit=u.ABmag)\\n assert np.isclose(fluxd.value, -26.77, atol=0.007)\",\n \"def generate_brown_noise(duration: float, f_sample: float) -> np.ndarray:\\r\\n # calculate the number of time points and the time difference between them\\r\\n length = duration * f_sample\\r\\n delta_t = 1 / f_sample\\r\\n # get the angular frequency axis in [omega]\\r\\n # calculate the frequency coefficients based on the noise color\\r\\n # brown/red noise has power spectral density of 1/(f**2) -> the amplitude has 1/f\\r\\n f_k = sc.fft.fftfreq(length, d=delta_t) / (2 * np.pi)\\r\\n C_k = np.ndarray(length)\\r\\n C_k[1:] = 1 / np.abs(f_k[1:])\\r\\n # no dc\\r\\n C_k[0] = 0\\r\\n # generate the signal from the frequency coefficients\\r\\n return generate_signal_from_spectrum(C_k)\",\n \"def get_bw(self):\\n return np.array([b2 - b1 for b1, b2 in self.bands])\",\n \"def iir(self):\\r\\n\\r\\n #Passband and stop-band are expressed as fraction of the Nyquist\\r\\n #frequency:\\r\\n if self.ub is not None:\\r\\n ub_frac = self.ub / (self.sampling_rate / 2.)\\r\\n else:\\r\\n ub_frac = 1.0\\r\\n\\r\\n lb_frac = self.lb / (self.sampling_rate / 2.)\\r\\n\\r\\n # For the band-pass:\\r\\n if lb_frac > 0 and ub_frac < 1:\\r\\n\\r\\n wp = [lb_frac, ub_frac]\\r\\n\\r\\n ws = [np.max([lb_frac - 0.1, 0]),\\r\\n np.min([ub_frac + 0.1, 1.0])]\\r\\n\\r\\n # For the lowpass:\\r\\n elif lb_frac == 0:\\r\\n wp = ub_frac\\r\\n ws = np.min([ub_frac + 0.1, 0.9])\\r\\n\\r\\n # For the highpass:\\r\\n elif ub_frac == 1:\\r\\n wp = lb_frac\\r\\n ws = np.max([lb_frac - 0.1, 0.1])\\r\\n\\r\\n b, a = signal.iirdesign(wp, ws, self._gpass, self._gstop,\\r\\n ftype=self._ftype)\\r\\n\\r\\n return self.filtfilt(b, a)\",\n \"def imgBC(img, mask=None, scale=1.0, numBins=64, returnBias=False):\\n spacing = np.array(img.GetSpacing())/scale\\n img_ds = imgResample(img, spacing=spacing)\\n\\n # Calculate bias\\n if mask is None:\\n mask_ds = sitk.Image(img_ds.GetSize(), sitk.sitkUInt8)+1\\n mask_ds.CopyInformation(img_ds)\\n else:\\n mask_ds = imgResample(mask, spacing=spacing, useNearest=True)\\n mask_ds = mask_ds > 0\\n\\n splineOrder = 2\\n img_ds_bc = sitk.N4BiasFieldCorrection(sitk.Cast(img_ds, sitk.sitkFloat32), mask_ds, numberOfHistogramBins=numBins, splineOrder=splineOrder, numberOfControlPoints=[splineOrder+1]*4)\\n #bias_ds = img_ds_bc - sitk.Cast(img_ds,img_ds_bc.GetPixelID())\\n\\n bias_ds = imgFinite(img_ds_bc / img_ds)\\n bias_ds = sitk.Mask(bias_ds, mask_ds) + sitk.Cast(1-mask_ds, sitk.sitkFloat32) # Fill background with 1s\\n\\n # Upsample bias \\n bias = imgResample(bias_ds, spacing=img.GetSpacing(), size=img.GetSize())\\n bias = sitk.Cast(bias, img.GetPixelID())\\n\\n # Apply bias to original image and threshold to eliminate negitive values\\n try:\\n upper = np.iinfo(sitkToNpDataTypes[img.GetPixelID()]).max\\n except:\\n upper = np.finfo(sitkToNpDataTypes[img.GetPixelID()]).max *0.99\\n\\n #img_bc = sitk.Threshold(img + sitk.Cast(bias, img.GetPixelID()),\\n # lower=0,\\n # upper=upper)\\n\\n img_bc = sitk.Threshold(img * bias, lower=0, upper=upper)\\n\\n if returnBias:\\n return (img_bc, bias)\\n else:\\n return img_bc\",\n \"def filter(sig, sampling_rate, lc, hc, order=2):\\n\\n # Construct butterworth band-pass filter\\n b1, a1 = butter(order, [2.0 * lc / sampling_rate,\\n 2.0 * hc / sampling_rate], btype=\\\"band\\\")\\n nchan, nsamp = sig.shape\\n fsig = np.copy(sig)\\n\\n # Apply cosine taper then apply band-pass filter in both directions\\n for ch in range(0, nchan):\\n fsig[ch, :] = fsig[ch, :] - fsig[ch, 0]\\n tap = cosine_taper(len(fsig[ch, :]), 0.1)\\n fsig[ch, :] = fsig[ch, :] * tap\\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, ::-1])[::-1]\\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, :])\\n\\n return fsig\",\n \"def __init__(self, fs=250, smoothing_win=20):\\n self.fs = fs\\n self.threshold = .35 # Generally between 0.3125 and 0.475\\n self.ns200ms = int(self.fs * .2)\\n self.r_peaks_buffer = [(0., 0.)]\\n self.noise_peaks_buffer = [(0., 0., 0.)]\\n self.prev_samples = np.zeros(smoothing_win)\\n self.prev_diff_samples = np.zeros(smoothing_win)\\n self.prev_times = np.zeros(smoothing_win)\\n self.prev_max_slope = 0\\n\\n self.bp_filter = ExGFilter(cutoff_freq=(1, 30), filter_type='bandpass', s_rate=fs, n_chan=1, order=3)\\n self.hamming_window = signal.windows.hamming(smoothing_win, sym=True)\\n self.hamming_window /= self.hamming_window.sum()\",\n \"def transition_block(input, nb_filter, dropout_rate=None, weight_decay=1E-4):\\n\\n concat_axis = 1 if K.image_dim_ordering() == \\\"th\\\" else -1\\n\\n x = Convolution2D(nb_filter, (1, 1), kernel_initializer=\\\"he_uniform\\\", padding=\\\"same\\\", use_bias=False,\\n kernel_regularizer=l2(weight_decay))(input)\\n if dropout_rate is not None:\\n x = Dropout(dropout_rate)(x)\\n x = AveragePooling2D((2, 2), strides=(2, 2))(x)\\n\\n x = BatchNormalization(axis=concat_axis, gamma_regularizer=l2(weight_decay),\\n beta_regularizer=l2(weight_decay))(x)\\n\\n return x\",\n \"def __init__(self, bandit):\\n self.bandit = bandit\",\n \"def generate_filter(length, fs, f_low=None, f_high=None, mode='box', is_plot=False):\\n\\n freqs = np.fft.fftfreq(int(length), d=(1. / float(fs)))\\n\\n filter_array = np.ones(length)\\n\\n if f_low is None and f_high is None:\\n print('no filtering required!')\\n elif f_low is None and f_high is not None:\\n print('low-pass fileter')\\n if f_high <= 0:\\n raise(ValueError, 'Higher cutoff frquency should be positive!')\\n filter_array[freqs >= f_high] = 0.\\n filter_array[freqs <= -f_high] = 0.\\n elif f_low is not None and f_high is None:\\n print('high-pass fileter')\\n if f_low < 0:\\n raise (ValueError, 'Lower cutoff frquency should be non-negative!')\\n filter_array[np.logical_and((freqs >= -f_low), (freqs <= f_low))] = 0.\\n else:\\n print('band-pass filter')\\n if f_high <= 0:\\n raise (ValueError, 'Higher cutoff frquency should be positive!')\\n if f_low < 0:\\n raise (ValueError, 'Lower cutoff frquency should be non-negative!')\\n filter_array[freqs >= f_high] = 0.\\n filter_array[freqs <= -f_high] = 0.\\n filter_array[np.logical_and((freqs >= -f_low), (freqs <= f_low))] = 0.\\n\\n if mode == '1/f':\\n filter_array[1:] = filter_array[1:] / abs(freqs[1:])\\n filter_array[0] = 0\\n filter_array = bas.array_nor(filter_array)\\n elif mode == 'box':\\n filter_array[0] = 0\\n else:\\n raise(NameError, 'Variable \\\"mode\\\" should be either \\\"1/f\\\" or \\\"box\\\"!')\\n\\n if is_plot:\\n plot_array = zip(freqs, filter_array)\\n plot_array.sort(key=lambda x: x[0])\\n plot_array = zip(*plot_array)\\n\\n _ = plt.figure(figsize=(10, 3))\\n plt.plot(plot_array[0], plot_array[1])\\n plt.xlabel('frequency (Hz)')\\n plt.ylim([-0.1, 1.1])\\n plt.show()\\n\\n return freqs, filter_array\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7451614","0.71119744","0.70526403","0.70473236","0.701966","0.6992632","0.6988554","0.6983021","0.6854008","0.67565495","0.6697159","0.6620907","0.65991974","0.6589245","0.6563564","0.6532885","0.63735956","0.6355377","0.6267423","0.6253552","0.6224801","0.6153323","0.6152556","0.611852","0.60932535","0.6036671","0.6026395","0.6010355","0.59347004","0.5929893","0.5897635","0.5869904","0.5852535","0.5806595","0.57880026","0.57854694","0.5755794","0.5744816","0.57261664","0.57017034","0.56946015","0.5690301","0.568234","0.566972","0.56639946","0.5648285","0.5628327","0.56052107","0.5604266","0.5599119","0.55864227","0.5572791","0.55656546","0.55387884","0.5508066","0.55044705","0.5489028","0.5486521","0.5473075","0.54518175","0.5430075","0.54167724","0.5415897","0.52871436","0.5285825","0.5250509","0.5243527","0.5230084","0.5211506","0.5197435","0.5193971","0.51698166","0.5152808","0.5138399","0.5138368","0.51045805","0.5102745","0.5093648","0.5090856","0.5089842","0.50782084","0.50641584","0.50639933","0.5043716","0.5042924","0.5039645","0.5023637","0.50147504","0.5008587","0.50082475","0.5000885","0.49972364","0.49926007","0.49867737","0.49852145","0.49813643","0.49745557","0.49730647","0.4972951","0.49638617"],"string":"[\n \"0.7451614\",\n \"0.71119744\",\n \"0.70526403\",\n \"0.70473236\",\n \"0.701966\",\n \"0.6992632\",\n \"0.6988554\",\n \"0.6983021\",\n \"0.6854008\",\n \"0.67565495\",\n \"0.6697159\",\n \"0.6620907\",\n \"0.65991974\",\n \"0.6589245\",\n \"0.6563564\",\n \"0.6532885\",\n \"0.63735956\",\n \"0.6355377\",\n \"0.6267423\",\n \"0.6253552\",\n \"0.6224801\",\n \"0.6153323\",\n \"0.6152556\",\n \"0.611852\",\n \"0.60932535\",\n \"0.6036671\",\n \"0.6026395\",\n \"0.6010355\",\n \"0.59347004\",\n \"0.5929893\",\n \"0.5897635\",\n \"0.5869904\",\n \"0.5852535\",\n \"0.5806595\",\n \"0.57880026\",\n \"0.57854694\",\n \"0.5755794\",\n \"0.5744816\",\n \"0.57261664\",\n \"0.57017034\",\n \"0.56946015\",\n \"0.5690301\",\n \"0.568234\",\n \"0.566972\",\n \"0.56639946\",\n \"0.5648285\",\n \"0.5628327\",\n \"0.56052107\",\n \"0.5604266\",\n \"0.5599119\",\n \"0.55864227\",\n \"0.5572791\",\n \"0.55656546\",\n \"0.55387884\",\n \"0.5508066\",\n \"0.55044705\",\n \"0.5489028\",\n \"0.5486521\",\n \"0.5473075\",\n \"0.54518175\",\n \"0.5430075\",\n \"0.54167724\",\n \"0.5415897\",\n \"0.52871436\",\n \"0.5285825\",\n \"0.5250509\",\n \"0.5243527\",\n \"0.5230084\",\n \"0.5211506\",\n \"0.5197435\",\n \"0.5193971\",\n \"0.51698166\",\n \"0.5152808\",\n \"0.5138399\",\n \"0.5138368\",\n \"0.51045805\",\n \"0.5102745\",\n \"0.5093648\",\n \"0.5090856\",\n \"0.5089842\",\n \"0.50782084\",\n \"0.50641584\",\n \"0.50639933\",\n \"0.5043716\",\n \"0.5042924\",\n \"0.5039645\",\n \"0.5023637\",\n \"0.50147504\",\n \"0.5008587\",\n \"0.50082475\",\n \"0.5000885\",\n \"0.49972364\",\n \"0.49926007\",\n \"0.49867737\",\n \"0.49852145\",\n \"0.49813643\",\n \"0.49745557\",\n \"0.49730647\",\n \"0.4972951\",\n \"0.49638617\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6940084"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":84592,"cells":{"query":{"kind":"string","value":"Create a butter lowpass filter."},"document":{"kind":"string","value":"def _butter_lowpass(lowcut, fs, order=4) -> tuple:\n nyq = 0.5 * fs\n low = lowcut / nyq\n b, a = butter(order, [low], btype=\"low\")\n return b, a"},"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 butter_lowpass_filter(data, cutoff, fs, order=1):\n b, a = butter_lowpass(cutoff, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def butter_lowpass_filter(self, data: np.ndarray, lowcut: float, fs: float, order: int = 4) -> np.ndarray:\n b, a = self._butter_lowpass(lowcut, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def butter_filter(datalist):\n fs = 200.00\n fHigh = 50.00\n fLow = 5.00\n N=4\n [b,a]=sg.butter(N,[fLow/fs, fHigh/fs], btype='band')\n global filtered\n #IIR filter\n return sg.filtfilt(b,a,datalist)","def butter_filter(self, data, low_pass, high_pass, fs, order=10):\n\n nyq = fs/2\n low = low_pass/nyq\n high = high_pass/nyq\n\n b, a = signal.butter(order, [low, high], btype='band')\n filt_data = np.abs(signal.hilbert(signal.filtfilt(b, a, data, axis=1), axis=1))\n return filt_data","def butter_bandpass_filter(data, lowcut, highcut, fs, order=1):\n b, a = butter_bandpass(lowcut, highcut, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def _butter_bandpass_filter(self, data: np.ndarray, lowcut: float, highcut: float, fs: float, order: int = 5):\n b, a = self._butter_bandpass(lowcut, highcut, fs, order=order)\n y = lfilter(b, a, data)\n return y","def butter_lowpass_filter(data: np.ndarray, cutoff: float, fs: float, order: int) -> np.ndarray:\n nyq = 0.5 * fs\n normal_cutoff = cutoff / nyq\n # Get the filter coefficients\n b, a = signal.butter(order, normal_cutoff, btype='low', analog=False)\n y = signal.filtfilt(b, a, data)\n return y","def butter_bandpass_filter(data, lowcut, highcut, fs, order=5, axis=0): \n omega = 0.5 * fs\n low = lowcut / omega\n high = highcut / omega\n b, a = signal.butter(order, [low, high], btype='band')\n y = signal.lfilter(b, a, data, axis=0)\n return y","def ButterworthFilter(\n self,\n name: str,\n cutoffFrequency: float,\n order: int = 2,\n operation: SymbolicConstant = NONE,\n halt: Boolean = OFF,\n limit: float = None,\n invariant: SymbolicConstant = NONE,\n ) -> ButterworthFilter:\n self.filters[name] = butterworthFilter = ButterworthFilter(\n name, cutoffFrequency, order, operation, halt, limit, invariant\n )\n return butterworthFilter","def butterworth_bandpass_filter( values, lowFreq, highFreq, sampleFreq, order=5):\n nyq = 0.5 * sampleFreq\n low = lowFreq / nyq\n high = highFreq /nyq\n b,a = butter( order, [low,high], btype='band' )\n return y = lfilter(b, a, data)","def butter_highpass_filter(data, cutoff, fs, order=1):\n b, a = butter_highpass(cutoff, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def butter_bandpass_filter(data, lowcut, highcut, fs, order=2):\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n \n # butter() and lfilter() are from scipy.signal\n \n b, a = butter(order, [low, high], btype='band')\n y = lfilter(b, a, data)\n return y","def butter_bandpass_filter(\n data: numpy.ndarray,\n lowcut: float,\n highcut: float,\n samplerate: float,\n order: int = 2,\n):\n nyq = 0.5 * samplerate\n lowf = lowcut / nyq\n highf = highcut / nyq\n # generic names for coefficients in filters\n # pylint: disable=invalid-name\n a, b = butter(order, [lowf, highf], btype=\"band\")\n if len(data) < BUTTER_MIN_LENGTH:\n return None\n return filtfilt(a, b, data)","def butterworth_filter(signal, Fs, highpassfreq=None, lowpassfreq=None, order=4, filtfunc='filtfilt'):\n Fn = Fs / 2.\n \n # set the function for filtering\n if filtfunc is 'lfilter':\n ffunc = spsig.lfilter\n elif filtfunc is 'filtfilt':\n ffunc = spsig.filtfilt\n else:\n raise ValueError(\"filtfunc must to be either 'filtfilt' or 'lfilter'\")\n \n # set parameters\n if lowpassfreq and highpassfreq:\n if highpassfreq < lowpassfreq:\n Wn = (highpassfreq / Fn, lowpassfreq / Fn)\n btype = 'bandpass'\n else:\n Wn = (lowpassfreq / Fn, highpassfreq / Fn)\n btype = 'bandstop'\n elif lowpassfreq:\n Wn = lowpassfreq / Fn\n btype = 'lowpass'\n elif highpassfreq:\n Wn = highpassfreq / Fn\n btype = 'highpass'\n else:\n raise ValueError(\"Specify highpassfreq and/or lowpathfreq\")\n \n # filter design\n b, a = spsig.butter(order, Wn, btype=btype)\n \n return ffunc(b, a, signal)","def lowpass_butter(fs, L, order, data, axis=-1, btype='low'):\n from scipy.signal import butter, sosfiltfilt\n\n nyq = 0.5 * fs # Nyquist frequency\n low = L / nyq\n sos = butter(order, low, btype=btype, output='sos') # Coefficients for Butterworth filter\n filtered = sosfiltfilt(sos, data, axis=axis)\n\n return filtered","def get_butterworth_low_pass_filter(shape, cutoff, order):\n \n \n print(\"butterworth_low_pass_filter = \")\n print(\"cutoff: \",cutoff)\n print(\"order: \",order)\n filter = np.zeros(shape)\n for i in range(shape[0]):\n for j in range(shape[1]):\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\n filter[i, j] = 1 / (1 + (D / cutoff) ** (2 * order))\n # print(\"\\n\\n\\n\\n\")\n # print(filter)\n # return filter\n return process_filter(image, filter)","def Butterworth_Filter(x,order,Low_High,Wn):\r\n\r\n\r\n # Create an order butterworth filter:\r\n\r\n b, a = signal.butter(order,Wn,Low_High);\r\n\r\n # Apply the filter to x. Use lfilter_zi to choose the initial condition of the filter:\r\n\r\n zi = signal.lfilter_zi(b, a);\r\n z, _ = signal.lfilter(b, a, x, zi=zi*x[0]);\r\n\r\n # Apply the filter again, to have a result filtered at an order the same as filtfilt:\r\n\r\n z2, _ = signal.lfilter(b, a, z, zi=zi*z[0])\r\n\r\n # Use filtfilt to apply the filter:\r\n\r\n y = signal.filtfilt(b, a, x);\r\n\r\n return y;","def filter_low_pass(x, filt_data, cutoff, fs, order=1, rows=[0,-1]):\n\n from scipy.signal import butter, filtfilt\n import numpy as np\n import matplotlib.pyplot as plt \n\n def butter_lowpass(cutoff, fs, order=5):\n nyq = 0.5 * fs\n normal_cutoff = cutoff / nyq\n b, a = butter(order, normal_cutoff, btype='low', analog=False)\n return b, a \n\n b, a = butter_lowpass(cutoff, fs, order=order)\n \n slice_exp = filt_data[rows[0]:rows[1]]\n lp_slice_exp = filtfilt(b, a, slice_exp)\n lp = np.append(filt_data[:rows[0]],lp_slice_exp)\n lp = np.append(lp,filt_data[rows[1]:])\n\n f, ax = plt.subplots(1,1,figsize=(8,8))\n ax.plot(x,filt_data,'k',label='original data')\n ax.plot(x,lp,'r',label='filtered data')\n ax.legend(loc='best')\n\n return lp","def lowpass_filter(data, Wn=0.014, N=2):\n data = np.array(data)\n data = data.astype(np.float)\n # N = 5 # Filter order\n # Wn = 0.02 # Cutoff frequency\n B, A = signal.butter(N, Wn, output='ba')\n\n # Second, apply the filter\n tempf = signal.filtfilt(B,A, data)\n # print(tempf)\n return tempf","def butterworth_filter(freq):\n\tf_raw = 1/(0.00000002*100*33)\n\tb = np.array([[-32092,15750],[-31238,14895]])*2.0**(-14)\n\tomega = 2*np.pi*freq/f_raw\n\te1, e2 = np.exp(-1j*omega), np.exp(-2j*omega)\n\ttmp = (1+2*e1+e2)**2/(1+b[0,0]*e1+b[0,1]*e2)/(1+b[1,0]*e1+b[1,1]*e2)\n\treturn tmp * (1+sum(b[0]))*(1+sum(b[1]))/16","def butter_bandstop_filter(data, lowcut, highcut, fs, order):\n\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n\n i, u = sg.butter(order, (low, high), btype='bandstop')\n y = sg.filtfilt(i, u, data)\n return y","def _butter_bandpass(lowcut: float, highcut: float, fs: float, order: int = 5) -> tuple:\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n b, a = butter(order, [low, high], btype=\"band\")\n return b, a","def make_butter_sp(self, wn, order):\n nyquist = self.s_freq/2\n wn_arr=np.asarray(wn)\n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\n \n self.sp_sos = butter(order, wn_arr, btype='bandpass', output='sos')\n print(f\"Zero phase butterworth filter successfully created: order = {order}x{order} bandpass = {wn}\")","def init_lowpass(self, lowpass_cutoff, lowpass_order):\n if lowpass_cutoff > 0 or self._fs_out < self._fs_in:\n nyquist = self._fs_out / 2\n if lowpass_cutoff > nyquist or (self._fs_out < self._fs_in and\n lowpass_cutoff == 0):\n lowpass_cutoff = 0.75 * nyquist\n lowpass_order = 10\n print('Using %gHz low-pass filter to prevent aliasing'\n % lowpass_cutoff)\n self._lowpass_cutoff = lowpass_cutoff\n self._lowpass_order = lowpass_order\n logging.info('Low-pass filtering the data with the 3dB point at %gHz.',\n lowpass_cutoff)\n self._lowpass_sos = scipy.signal.butter(lowpass_order, lowpass_cutoff,\n 'lp', output='sos', fs=self.fs_in)\n self._lowpass_state = None # to be created later when we know sizes\n else:\n self._lowpass_sos = None","def make_butter_so(self, wn, order):\n \n nyquist = self.s_freq/2\n wn_arr = np.asarray(wn)\n \n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\n \n self.so_sos = butter(order, wn_arr, btype='bandpass', output='sos')\n print(f\"Zero phase butterworth filter successfully created: order = {order}x{order}, bandpass = {wn}\")","def get_butterworth_high_pass_filter(self, shape, cutoff, order):\r\n\r\n #Hint: May be one can use the low pass filter function to get a high pass mask\r\n # 1 - butter low pass\r\n mask = 1 - self.get_butterworth_low_pass_filter(shape, cutoff, order)\r\n\r\n return mask","def get_butterworth_high_pass_filter(shape, cutoff, order):\n \n # Hint: May be one can use the low pass filter function to get a high pass mask\n print(\"butterworth_high_pass_filter = \")\n print(\"cutoff: \",cutoff)\n print(\"order: \",order)\n filter = get_butterworth_low_pass_filter(shape, cutoff, order)\n\n for i in range(shape[0]):\n for j in range(shape[1]):\n filter[i, j] = 1 - filter[i, j]\n\n # return filter\n return process_filter(image, filter)","def _signal_filter_butterworth(signal, sampling_rate=1000, lowcut=None, highcut=None, order=2):\n if lowcut is not None and highcut is not None:\n sos = scipy.signal.butter(order, [lowcut, highcut], btype=\"bandpass\", output='sos', fs=sampling_rate)\n elif lowcut is not None:\n sos = scipy.signal.butter(order, [lowcut], btype=\"highpass\", output='sos', fs=sampling_rate)\n elif highcut is not None:\n sos = scipy.signal.butter(order, [highcut], btype=\"lowpass\", output='sos', fs=sampling_rate)\n\n filtered = scipy.signal.sosfiltfilt(sos, signal)\n return filtered","def butterworth_bandpass(lowcut, highcut, fs, order=5):\n nyq = 0.5 * fs # nyquist sampling rate\n low = lowcut / nyq # normalize frequency\n high = highcut / nyq # normalize frequency\n b, a = butter(order, [low, high], btype='band')\n return b, a","def butterworth(dx, order, cutoff, /, btype='low'):\n # Initial stuff\n # * Need to run *forward and backward* to prevent time-shifting.\n # * The 'analog' means units of cutoffs are rad/s.\n # * Unlike Lanczos filter, the *length* of this should be\n # determined always as function of timestep, because really high\n # order filters can get pretty wonky.\n # * Cutoff is point at which gain reduces to 1/sqrt(2) of the\n # initial frequency. If doing bandpass, can\n # N = (width/dx)//1 # convert to timestep units\n # N = (N//2)*2 + 1 # odd numbered\n N = order # or order\n analog = False # lfilter seems to need digital\n if analog:\n cutoff = 2 * np.pi / (cutoff / dx) # from wavelengths to rad/steps\n else:\n cutoff = 1.0 / cutoff # to Hz, or cycles/unit\n cutoff = cutoff * (2 * dx) # to cycles / (2 timesteps)\n if cutoff > 1:\n raise ValueError(\n 'Cuttoff frequency must be in [0, 1]. Remember you pass a cutoff '\n '*wavelength* to this function, not a frequency.'\n )\n\n # Apply filter\n print(f'Order-{order} Butterworth filter')\n b, a = signal.butter(N - 1, cutoff, btype=btype, analog=analog, output='ba')\n return b, a","def bpfilter(\n data: numpy.ndarray, short_min: float = 2, long_min: float = 12\n) -> Optional[numpy.ndarray]:\n return butter_bandpass_filter(\n data, 1 / (long_min * 60), 1 / (short_min * 60), 1 / DATA_RATE\n )","def butter_bp_coe(lowcut, highcut, fs, order=1):\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n b, a = butter(order, [low, high], btype='band')\n return b, a","def lowpass_filter(s, sample_rate, cutoff_freq, filter_order=5, rescale=False):\n #create a butterworth filter\n nyq = sample_rate / 2.0\n b,a = filter_design.butter(filter_order, cutoff_freq / nyq)\n\n #filter the signal\n filtered_s = filtfilt(b, a, s)\n\n if rescale:\n #rescale filtered signal\n filtered_s /= filtered_s.max()\n filtered_s *= s.max()\n\n return filtered_s","def bandpass_filter_audio(audio, f_low=400, f_high=450):\n filtered_audio = core.sinc_filter(audio, f_low, window_size=256, high_pass=True)\n filtered_audio = core.sinc_filter(filtered_audio, f_high, window_size=256, high_pass=False)\n return tf.squeeze(filtered_audio)","def get_butterworth_low_pass_filter(self, shape, cutoff, order):\r\n P = shape[0]\r\n Q = shape[1]\r\n mask = np.zeros((P, Q))\r\n for u in range(P):\r\n for v in range(Q):\r\n dist = ((u - (P / 2)) ** 2 + (v - (Q / 2)) ** 2) ** (1 / 2)\r\n mask[u][v] = 1 / (1 + (dist/cutoff)**(2*order))\r\n\r\n return mask","def bandpass_filter(s, sample_rate, low_freq, high_freq, filter_order=5, rescale=False):\n #create a butterworth filter\n nyq = sample_rate / 2.0\n f = np.array([low_freq, high_freq]) / nyq\n b,a = filter_design.butter(filter_order, f, btype='bandpass')\n\n #filter the signal\n filtered_s = filtfilt(b, a, s)\n\n if rescale:\n #rescale filtered signal\n filtered_s /= filtered_s.max()\n filtered_s *= s.max()\n\n return filtered_s","def get_butterworth_low_pass_filter(self, shape, cutoff, order):\n \n mask = zeros(shape)\n row_size, col_size = shape[0], shape[1]\n center_row, center_col = row_size/2 , col_size/2\n for r in range(0, row_size):\n for c in range(0, col_size):\n freq_dist = sqrt( (r-center_row)**2 + (c-center_col)**2 )\n mask[r,c] = (1/(1+(freq_dist/cutoff)*order)) if freq_dist > cutoff else 1.0\n\n return mask","def butter_filter(image, n, f0):\n [ny, nx] = image.shape\n dx = 2.0/nx\n dy = 2.0/nx\n dfx = 0.5\n dfy = 0.5\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\n FX, FY = np.meshgrid(fx, fy)\n shift = np.exp(-2*np.pi*1j*(FX+FY))\n sin_pad = np.sin(image)\n cos_pad = np.cos(image)\n ft_sin = shift * np.fft.fftshift(np.fft.fft2(sin_pad))\n ft_cos = shift * np.fft.fftshift(np.fft.fft2(cos_pad))\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\n sin_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_sin)) / shift)\n cos_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_cos)) / shift)\n phase_filt = np.arctan2(sin_filt, cos_filt)\n return phase_filt","def design_filter(interpolation, decimation, fractional_bw):\n\n if fractional_bw >= 0.5 or fractional_bw <= 0:\n raise ValueError('Invalid fractional bandwidth, must be in (0, 0.5)')\n\n if decimation < 1 or interpolation < 1:\n raise ValueError('Invalid interpolation or decimation rate. Must be a non-zero positive integer.')\n\n beta = 7.0\n halfband = 0.5\n rate = float(interpolation)/float(decimation)\n if(rate >= 1.0):\n trans_width = halfband - fractional_bw\n mid_transition_band = halfband - trans_width/2.0\n else:\n trans_width = rate*(halfband - fractional_bw)\n mid_transition_band = rate*halfband - trans_width/2.0\n\n taps = filter.firdes.low_pass(interpolation, # gain\n interpolation, # Fs\n mid_transition_band, # trans mid point\n trans_width, # transition width\n filter.firdes.WIN_KAISER,\n beta) # beta\n\n return taps","def butter_hpf(highcut, fs, order):\n nyq = 0.5 * fs\n high = highcut / nyq\n b, a = signal.butter(order, high, btype='highpass')\n w, h = signal.freqz(b, a, worN=1000)\n# plt.figure()\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\n return b, a","def highpass_filter(s, sample_rate, cutoff_freq, filter_order=5, rescale=False):\n #create a butterworth filter\n nyq = sample_rate / 2.0\n b,a = filter_design.butter(filter_order, cutoff_freq / nyq, btype='high')\n\n #filter the signal\n filtered_s = filtfilt(b, a, s)\n\n if rescale:\n #rescale filtered signal\n filtered_s /= filtered_s.max()\n filtered_s *= s.max()\n\n return filtered_s","def make_butter_spso(self, spso_wn_pass, spso_wn_stop, spso_order):\n nyquist = self.s_freq/2\n wn_pass_arr = np.asarray(spso_wn_pass)\n wn_stop_arr = np.asarray(spso_wn_stop)\n \n # must remake filter for each pt bc of differences in s_freq\n if np.any(wn_pass_arr <=0) or np.any(wn_pass_arr >=1):\n wn_pass_arr = wn_pass_arr/nyquist \n \n if np.any(wn_stop_arr <=0) or np.any(wn_stop_arr >=1):\n wn_stop_arr = wn_stop_arr/nyquist\n\n self.spso_sos_bandstop = butter(spso_order, wn_stop_arr, btype='bandstop', output='sos')\n self.spso_sos_bandpass = butter(spso_order, wn_pass_arr, btype='bandpass', output='sos')\n print(f\"Zero phase butterworth filter successfully created: order = {spso_order}x{spso_order} bandpass = {spso_wn_pass}\")\n print(f\"Zero phase butterworth filter successfully created: order = {spso_order}x{spso_order} bandstop = {spso_wn_stop}\")","def init_highpass(self, highpass_cutoff, highpass_order):\n if highpass_cutoff > 0:\n self._highpass_cutoff = highpass_cutoff\n self._highpass_order = highpass_order\n logging.info('High-pass filtering the data with the 3dB point at %gHz.',\n highpass_cutoff)\n self._highpass_sos = scipy.signal.butter(highpass_order, highpass_cutoff,\n 'hp', output='sos',\n fs=self.fs_in)\n self._highpass_state = None # to be created later when we know sizes\n else:\n self._highpass_sos = None","def butter_lpf(fc, fs, order):\n nyq = 0.5 * fs\n high = fc / nyq\n b, a = signal.butter(order, high, btype='lowpass', analog=False)\n w, h = signal.freqz(b, a, worN=1000)\n# plt.figure()\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\n return b, a","def create_low_pass_frequency_kernel(im, radius):\n kernel = create_high_pass_frequency_kernel(im, radius)\n kernel = 1 - kernel\n return kernel","def create_low_pass_frequency_kernel(im, radius):\n kernel = create_high_pass_frequency_kernel(im, radius)\n kernel = 1 - kernel\n return kernel","def get_gaussian_low_pass_filter(shape, cutoff, order):\n \n print(\"gaussian_low_pass_filter = \")\n print(\"cutoff: \",cutoff)\n print(\"order: \",order)\n filter = np.zeros(shape)\n\n for i in range(shape[0]):\n for j in range(shape[1]):\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\n\n filter[i, j] = math.exp(-D ** 2 / (2 * (cutoff ** 2)))\n\n # return filter\n return process_filter(image, filter)","async def low_pass(\n client,\n event,\n smoothing: P('float', 'smoothing', min_value = 0.0, max_value = 5.0),\n):\n player = get_player_or_abort(client, event)\n \n filter = LowPass(smoothing)\n player.add_filter(filter)\n await player.apply_filters()\n \n return create_filter_added_embed(filter)","def filt_bp(sig: np.ndarray, Ss: int, Cfs0: int, Cfs1: None,\n order=5) -> np.ndarray:\n nyq = 0.5 * Ss\n normal_cutoff1 = Cfs0 / nyq\n normal_cutoff2 = Cfs1 / nyq\n b, a = butter(order, (normal_cutoff1, normal_cutoff2),\n btype='band',\n analog=False)\n return lfilter(b, a, sig)","def iirfilter(x, N=4, pass_freq=0.7 / 12.):\n b, a = signal.butter(N, pass_freq, \"low\", analog=False)\n return signal.filtfilt(b, a, x)","def butter_filter_unwrapped(image, n, f0, pad = False):\n if pad == True:\n res = [2**kji for kji in range(15)]\n N_int_x = image.shape[1]\n N_int_y = image.shape[0]\n nx_pad = np.where(res > np.tile(N_int_x, len(res)))\n nx_pad = res[nx_pad[0][0]]\n ny_pad = np.where(res > np.tile(N_int_y, len(res)))\n ny_pad = res[ny_pad[0][0]]\n dif_x = (nx_pad - N_int_x)/2\n dif_y = (ny_pad - N_int_y)/2\n orig_shape = image.shape\n image = np.lib.pad(image, ((dif_y, dif_y), (dif_x, dif_x)), 'reflect')\n \n [ny, nx] = image.shape\n dx = 2.0/nx\n dy = 2.0/ny\n dfx = 0.5\n dfy = 0.5\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\n FX, FY = np.meshgrid(fx, fy)\n shift = np.exp(-2*np.pi*1j*(FX+FY))\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\n ft_img = shift * np.fft.fftshift(np.fft.fft2(image))\n \n buttered = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_img))/ shift)\n if pad == True:\n assert(buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x].shape == orig_shape)\n return buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x]\n else:\n assert(buttered.shape == image.shape)\n return buttered","def lowpass(data,filterSize=None):\n\n def convolve(signal,kernel):\n pad=np.ones(len(kernel)/2)\n signal=np.concatenate((pad*signal[0],signal,pad*signal[-1]))\n signal=np.convolve(signal,kernel,mode='same')\n signal=signal[len(pad):-len(pad)]\n return signal\n\n def kernel_gaussian(size=100, sigma=None, forwardOnly=False):\n if sigma is None:\n sigma=size/10\n size=int(size)\n points=np.exp(-np.power(np.arange(size)-size/2,2)/(2*np.power(sigma,2)))\n if forwardOnly:\n points[:int(len(points)/2)]=0\n return points/sum(points)\n\n if filterSize is None:\n filterSize=len(data)/10\n kernel=kernel_gaussian(size=filterSize)\n data=convolve(data,kernel) # do the convolution with padded edges\n return data","def bandpass_filter(data, lowcut, highcut, fs=2000, numtaps=255):\n nyq = fs / 2\n\n # design filter\n fe1 = lowcut / nyq\n fe2 = highcut / nyq\n b = firwin(numtaps, (fe1, fe2), pass_zero=False)\n\n filtered = lfilter(b, 1, data)\n\n return filtered","def __band_filter(data: dict, lowFreq: Union[int, float], highFreq: Union[int, float], timestep: int=0,\n samplingFreq: int=240, order: int=5, eegSensor: int=0, filterType: str='bandpass',\n lengthOfTestSeconds: Union[int, float]=32, example: int=0) -> dict:\n #Test\n # Filter.__band_filter_test(data=data, low=lowFreq, high=highFreq, samplingFreq=samplingFreq, order=order,\n # eegSensor=eegSensor, filterType=filterType, lengthOfTestSeconds=lengthOfTestSeconds)\n #Code\n nyq = 0.5 * samplingFreq\n low = lowFreq / nyq\n high = highFreq / nyq\n b, a = signal.butter(order, [low, high], btype=filterType)\n y = signal.lfilter(b, a, data['Signal'])\n ##Graph - This belongs somewhere else probably.\n # t = np.linspace(0, len(data), len(data), endpoint=False)\n # plt.plot(t, y, label='Sensor #' + str(eegSensor) + ' (' + str(lowFreq) + '-' + str(highFreq) + ') Hz')\n # plt.grid(True)\n # plt.axis('tight')\n # plt.xticks(range(10), range(lengthOfTestSeconds)) ##32 seconds per test?\n # plt.xlabel(\"Time in Seconds\")\n # plt.legend(loc='upper left')\n # plt.show()\n output = {}\n timestep = []\n for index, eegChannel in enumerate(y[0]):#the extra [0] is becuase signal.lfilter() puts it in a 1D array. Grrr\n timestep.append(eegChannel)\n output['Signal'] = timestep\n Visualization.channelGraph(y[0][0])\n return output #output is 2D 64xTimeSamples","def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=(500, 10000)):\n if freq_cutoffs[0] <= 0:\n raise ValueError('Low frequency cutoff {} is invalid, '\n 'must be greater than zero.'\n .format(freq_cutoffs[0]))\n\n Nyquist_rate = samp_freq / 2\n if freq_cutoffs[1] >= Nyquist_rate:\n raise ValueError('High frequency cutoff {} is invalid, '\n 'must be less than Nyquist rate, {}.'\n .format(freq_cutoffs[1], Nyquist_rate))\n\n if rawsong.shape[-1] < 387:\n numtaps = 64\n elif rawsong.shape[-1] < 771:\n numtaps = 128\n elif rawsong.shape[-1] < 1539:\n numtaps = 256\n else:\n numtaps = 512\n\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\n freq_cutoffs[1] / Nyquist_rate])\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\n # window to design filter, but default for matlab's fir1\n # is actually Hamming\n # note that first parameter for scipy.signal.firwin is filter *length*\n # whereas argument to matlab's fir1 is filter *order*\n # for linear FIR, filter length is filter order + 1\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\n a = np.zeros((numtaps+1,))\n a[0] = 1 # make an \"all-zero filter\"\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\n return filtsong","def get_butterworth_high_pass_filter(self, shape, cutoff, order):\n\n #Hint: May be one can use the low pass filter function to get a high pass mask\n mask = zeros(shape)\n row_size, col_size = shape[0], shape[1]\n center_row, center_col = row_size/2 , col_size/2\n for r in range(0, row_size):\n for c in range(0, col_size):\n freq_dist = sqrt( (r-center_row)**2 + (c-center_col)**2 )\n mask[r,c] = (1/(1+(freq_dist/cutoff)*order*2)) if freq_dist < cutoff else 1.0\n\n return mask\n # return 1 - self.get_butterworth_low_pass_filter(shape, cutoff, order*2) # wrong ?","def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=None):\n\n Nyquist_rate = samp_freq / 2\n if freq_cutoffs is None:\n freq_cutoffs = [500, 10000]\n if rawsong.shape[-1] < 387:\n numtaps = 64\n elif rawsong.shape[-1] < 771:\n numtaps = 128\n elif rawsong.shape[-1] < 1539:\n numtaps = 256\n else:\n numtaps = 512\n\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\n freq_cutoffs[1] / Nyquist_rate])\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\n # window to design filter, but default for matlab's fir1\n # is actually Hamming\n # note that first parameter for scipy.signal.firwin is filter *length*\n # whereas argument to matlab's fir1 is filter *order*\n # for linear FIR, filter length is filter order + 1\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\n a = np.zeros((numtaps+1,))\n a[0] = 1 # make an \"all-zero filter\"\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\n return filtsong","def _butter_pass(cutoff, fs, order=5, btype='high'):\r\n nyq = 0.5*fs\r\n normal_cutoff = cutoff/nyq\r\n# print \"normalized cutoff: \", normal_cutoff\r\n if normal_cutoff >= 1.:\r\n normal_cutoff = 1.\r\n b, a = signal.butter(order, normal_cutoff, btype=btype, analog=False)\r\n return b, a","def filter_pupil(self, hp=0.01, lp=10.0):\r\n self.logger.info('Band-pass filtering of pupil signals, hp = %2.3f, lp = %2.3f'%(hp, lp))\r\n\r\n self.lp_filt_pupil = _butter_lowpass(data=self.interpolated_pupil.astype('float64'), highcut=lp, fs=self.sample_rate, order=3)\r\n self.hp_filt_pupil = _butter_highpass(data=self.interpolated_pupil.astype('float64'), lowcut=hp, fs=self.sample_rate, order=3)\r\n self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\r\n self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\r\n\r\n # import mne\r\n # from mne import filter\r\n # self.lp_filt_pupil = mne.filter.low_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=lp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\r\n # self.hp_filt_pupil = mne.filter.high_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=hp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\r\n # self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\r\n # self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\r","def filter(sig, sampling_rate, lc, hc, order=2):\n\n # Construct butterworth band-pass filter\n b1, a1 = butter(order, [2.0 * lc / sampling_rate,\n 2.0 * hc / sampling_rate], btype=\"band\")\n nchan, nsamp = sig.shape\n fsig = np.copy(sig)\n\n # Apply cosine taper then apply band-pass filter in both directions\n for ch in range(0, nchan):\n fsig[ch, :] = fsig[ch, :] - fsig[ch, 0]\n tap = cosine_taper(len(fsig[ch, :]), 0.1)\n fsig[ch, :] = fsig[ch, :] * tap\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, ::-1])[::-1]\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, :])\n\n return fsig","def butterworthsmoothing(df, column_names: list = None, Wn = 0.015):\n\n if column_names is None:\n return df\n else:\n # First, design the Buterworth filter\n N = 2 # Filter order\n Wn = Wn # Cutoff frequency\n B, A = signal.butter(N, Wn, output='ba')\n for i in column_names:\n df[i] = signal.filtfilt(B, A, df[i])\n df.dropna(axis=0, how='any', inplace=True)\n return df","def filtroBilateral(frame):\n fb = cv2.bilateralFilter(frame, 0, 32, 2)\n return fb","def butter2d_lp(shape, f, n):\n \n rows, cols = shape \n x = np.linspace(-0.5, 0.5, cols)\n y = np.linspace(-0.5, 0.5, rows)\n radius = np.sqrt((x**2)[np.newaxis] + (y**2)[:, np.newaxis]) \n filt = 1 / (1.0 + (radius / f)**(2*n))\n \n return (filt)","def _get_fir_filter(passband, fs, order=183, weights=[5.75, 1., 5.75], mask=[0, 1, 0]):\n # return remez(order, passband, mask, weights, Hz=fs), 1.\n return remez(order, passband, mask, Hz=fs), 1.","def band_pass_eeg(eeg, freq_range, order=4):\n return ButterworthFilter(eeg, freq_range, filt_type='pass', order=order).filter()","def lowPassFilter(img, window=30):\n gray = grayscale(img)\n\tdft = cv2.dft(np.float32(gray), flags = cv2.DFT_COMPLEX_OUTPUT)\n\tdft_shift = np.fft.fftshift(dft)\n\trows, cols = gray.shape\n\tcrow, ccol = rows/2, cols/2\n\tmask = np.zeros((rows, cols, 2), np.uint8)\n\tmask[crow-window:crow+window, ccol-window:ccol+window] = 1\n\tfshift = dft_shift*mask\n\tf_ishift = np.fft.ifftshift(fshift)\n\timg_back = cv2.idft(f_ishift)\n\timg_back = cv2.magnitude(img_back[:,:,0], img_back[:,:,1])\n\treturn img_back","def get_ideal_low_pass_filter(shape, cutoff, order):\n \n print(\"ideal_low_pass_filter = \")\n print(\"cutoff: \",cutoff)\n print(\"order: \",order)\n \n filter = np.zeros(shape)\n\n D = 0\n\n for i in range(shape[0]):\n for j in range(shape[1]):\n\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\n\n if D <= cutoff:\n filter[i, j] = 1\n else:\n filter[i, j] = 0\n\n # return filter\n return process_filter(image, filter)","def butterworth_filter(dft4img, stopband2=10, order=3, showdft=False):\n h, w = dft4img.shape[0], dft4img.shape[1]\n P = h / 2\n Q = w / 2\n dst = np.zeros((h, w, 3), np.float64)\n for i in range(h):\n for j in range(w):\n r2 = float((i - P) ** 2 + (j - Q) ** 2)\n if r2 == 0:\n r2 = 1.0\n dst[i, j] = 1 / (1 + (r2 / stopband2) ** order)\n dst = np.float64(dst)\n if showdft:\n cv2.imshow(\"butterworth\", cv2.magnitude(dst[:, :, 0], dst[:, :, 1]))\n return dst","def filters(self, low_freq=1/7, high_freq=128, notch_freq=50):\n self.raw.filter(l_freq=low_freq, h_freq=high_freq)\n self.raw.notch_filter(range(notch_freq, high_freq, notch_freq), filter_length='auto',\n phase='zero', fir_design='firwin')","def butter_bp(n, wlo, whi):\n zeros = []\n poles = _butter_analog_poles(n)\n k = 1\n fs = 2\n\n warpedlo = 2 * fs * mp.tan(mp.pi * wlo / fs)\n warpedhi = 2 * fs * mp.tan(mp.pi * whi / fs)\n bw = warpedhi - warpedlo\n wo = mp.sqrt(warpedlo * warpedhi)\n z, p, k = _zpklp2bp(zeros, poles, k, wo=wo, bw=bw)\n z, p, k = _zpkbilinear(z, p, k, fs=fs)\n return z, p, k","def filters(array, sample_frequency):\n strain = TimeSeries(array, sample_rate=int(sample_frequency))\n white_data = strain.whiten(fftlength=4, fduration=4)\n bp_data = white_data.bandpass(50, 250)\n return bp_data.value","def lowpass_filter(self, data, reset=False):\n data = np.asarray(data)\n if self._lowpass_sos is not None:\n if self._lowpass_state is None or reset:\n self.lowpass_filter_reset(data)\n data, self._lowpass_state = scipy.signal.sosfilt(\n self._lowpass_sos, data, zi=self._lowpass_state, axis=0)\n return data\n return data","def A_weighting(fs):\n b, a = A_weighting_analog()\n\n # Use the bilinear transformation to get the digital filter.\n return bilinear(b, a, fs)","def initialize_filter(self):\n shape = self.filter_size + (self.input_shape[-1], self.channels)\n self.filter = self.filter_initializer(shape)","def bandpassFilter (self, lowerFreq, upperFreq):\n self.bandpassLimits = (lowerFreq, upperFreq)\n # stuff to do","def bessel_wave(freq, alpha, beta):\n return FMFilter(SineWave(freq), SineWave(alpha), beta)","def copy(self):\n new_filter = BloomFilter(self.capacity, self.error_rate)\n new_filter.filter = self.filter.copy()\n return new_filter","def bandpass_filter_raw_plot(data, fs, f1, f2):\n b, a = sp.butter(N=2, Wn=np.array([f1, f2]) / fs * 2, btype='bandpass') # build a bandpass butterworth filter of order 4, with cut-off frequencies 1 and 45\n w, h = sp.freqz(b, a) # compute the frequency response of the filter\n f = w / np.pi * fs / 2\n plt.figure()\n plt.plot(f, 10 * np.log10(abs(h)))\n plt.xlabel('frequency (Hz)')\n plt.ylabel('Magnitude (dB)')\n plt.title('frequency response of butterworth bandpass [1, 45]Hz')\n plt.grid()\n\n data1 = sp.filtfilt(b, a, data)\n return data1","def get_gaussian_low_pass_filter(self, shape, cutoff):\r\n P = shape[0]\r\n Q = shape[1]\r\n mask = np.zeros((P, Q))\r\n for u in range(P):\r\n for v in range(Q):\r\n dist = (((u - (P / 2)) ** 2) + ((v - (Q / 2)) ** 2)) ** (1 / 2)\r\n\r\n mask[u][v] = math.exp((-dist ** 2) / (2 * (cutoff ** 2)))\r\n\r\n return mask","def get_gaussian_high_pass_filter(self, shape, cutoff):\r\n\r\n #Hint: May be one can use the low pass filter function to get a high pass mask\r\n # 1 - gaussian low pass\r\n mask = 1 - self.get_gaussian_low_pass_filter(shape, cutoff)\r\n\r\n return mask","def highPassFilter(img, window=30):\n gray = grayscale(img)\n\tf = np.fft.fft2(gray)\n\tfshift = np.fft.fftshift(f)\n\trows, cols = gray.shape\n\tcrow, ccol = rows/2, cols/2\n\tfshift[crow-window:crow+window, ccol-window:ccol+window] = 0\n\tf_ishift = np.fft.ifftshift(fshift)\n\timg_back = np.fft.ifft2(f_ishift)\n\timg_back = np.abs(img_back)\n\treturn img_back","def custom_filter(image: Image) -> Image:\n image = image.filter(ImageFilter.Kernel(\n size=(3, 3), kernel=(1, 0, 1, 0, 0, 0, 1, 0, 1)))\n return image","def bandpass(filename,f1,f2,Q,wout=True,plot=True):\n start=time.time()\n n, data, data_dB,sr,ch=inputwav(filename)\n b, a = butter(Q,Wn=(f1/sr,f2/sr),btype='bandpass')\n data_filtered=lfilter(b,a,data,axis=0)\n print('Applying FFT...')\n if wout==True:\n print('Exporting...')\n sf.write(filename[0:len(filename)-4]+'_BP.wav',data_filtered,sr,'PCM_16')\n if plot==True:\n print('Plotting...')\n py.close()\n w, h = freqz(b,a,worN=16384)\n fig, (ax1, ax2) = py.subplots(nrows=2)\n ax1.semilogx(0.5*sr*w/np.pi,abs(h),'k-')\n ax1.set_xlabel('Frequency (Hz)')\n ax1.set_ylabel('Rel. Amplitude')\n ax1.grid()\n ax1.set_ylim(0,1.1)\n ax1.set_xlim(1,20000)\n ax2.plot(data,'k-',label='Raw data')\n ax2.plot(data_filtered,'m-',lw=1,label='Filtered data')\n ax2.set_xlim(0,10000)\n ax2.set_ylim(-1,1)\n ax2.set_ylabel('Amplitude (Norm Bits)')\n ax2.set_xlabel('Samples')\n ax2.legend(loc=2,frameon=False,ncol=2)\n py.subplots_adjust(hspace=0.35) \n print('Done!')\n end=time.time()\n elapsed=int(1000*(end-start))\n print('...............................')\n print('Completed in '+str(elapsed)+' milliseconds.')\n return data_filtered","def filt_hp(sig: np.ndarray, Ss: int, Cfs: int, Cfs1: None,\n order=5) -> np.ndarray:\n nyq = 0.5 * Ss\n normal_cutoff = Cfs / nyq\n b, a = butter(order, normal_cutoff, btype='high', analog=False)\n return lfilter(b, a, sig)","def __init__(self, fs=250, smoothing_win=20):\n self.fs = fs\n self.threshold = .35 # Generally between 0.3125 and 0.475\n self.ns200ms = int(self.fs * .2)\n self.r_peaks_buffer = [(0., 0.)]\n self.noise_peaks_buffer = [(0., 0., 0.)]\n self.prev_samples = np.zeros(smoothing_win)\n self.prev_diff_samples = np.zeros(smoothing_win)\n self.prev_times = np.zeros(smoothing_win)\n self.prev_max_slope = 0\n\n self.bp_filter = ExGFilter(cutoff_freq=(1, 30), filter_type='bandpass', s_rate=fs, n_chan=1, order=3)\n self.hamming_window = signal.windows.hamming(smoothing_win, sym=True)\n self.hamming_window /= self.hamming_window.sum()","def __init__(self, image, filter_name, cutoff, order = 0):\r\n self.image = image\r\n if filter_name == 'ideal_l':\r\n self.filter = self.get_ideal_low_pass_filter\r\n elif filter_name == 'ideal_h':\r\n self.filter = self.get_ideal_high_pass_filter\r\n elif filter_name == 'butterworth_l':\r\n self.filter = self.get_butterworth_low_pass_filter\r\n elif filter_name == 'butterworth_h':\r\n self.filter = self.get_butterworth_high_pass_filter\r\n elif filter_name == 'gaussian_l':\r\n self.filter = self.get_gaussian_low_pass_filter\r\n elif filter_name == 'gaussian_h':\r\n self.filter = self.get_gaussian_high_pass_filter\r\n\r\n self.cutoff = cutoff\r\n self.order = order\r\n self.filter_name = filter_name","def bandpass_filter(files, lowpass_freq=0.1, highpass_freq=0.01, tr=2):\n import os\n\n import nibabel as nb\n import numpy as np\n from nipype.utils.filemanip import (\n filename_to_list,\n list_to_filename,\n split_filename\n )\n\n fs = 1./tr\n\n out_files = []\n for filename in filename_to_list(files):\n path, name, ext = split_filename(filename)\n out_file = os.path.join(os.getcwd(), name + '_bandpassed' + ext)\n\n img = nb.load(filename)\n timepoints = img.shape[-1]\n F = np.zeros((timepoints))\n\n lowidx = int(timepoints / 2) + 1\n if lowpass_freq > 0:\n lowidx = np.round(float(lowpass_freq) / fs * timepoints)\n\n highidx = 0\n if highpass_freq > 0:\n highidx = np.round(float(highpass_freq) / fs * timepoints)\n F[int(highidx):int(lowidx)] = 1\n F = ((F + F[::-1]) > 0).astype(int)\n data = img.get_data()\n if np.all(F == 1):\n filtered_data = data\n else:\n filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F))\n img_out = nb.Nifti1Image(filtered_data, img.affine, img.header)\n img_out.to_filename(out_file)\n out_files.append(out_file)\n\n return list_to_filename(out_files)","def filt_lp(sig: np.ndarray, Ss: int, Cfs: int, Cfs1: None,\n order=5) -> np.ndarray:\n nyq = 0.5 * Ss\n normal_cutoff = Cfs / nyq\n b, a = butter(order, normal_cutoff, btype='low', analog=False)\n return lfilter(b, a, sig)","def _build_wavelet_bank(self):\n self._build_filters()\n wavelet_bank = torch.stack(self._filters)\n wavelet_bank = wavelet_bank.view(\n wavelet_bank.shape[0], 1, 1, wavelet_bank.shape[1]\n )\n wavelet_bank = torch.cat([wavelet_bank] * self.channels, 2)\n return wavelet_bank","def __init__(self, image, filter_name, cutoff, order = 0):\n self.filter_name = filter_name\n self.image = image\n if filter_name == 'ideal_l':\n self.filter = self.get_ideal_low_pass_filter\n elif filter_name == 'ideal_h':\n self.filter = self.get_ideal_high_pass_filter\n elif filter_name == 'butterworth_l':\n self.filter = self.get_butterworth_low_pass_filter\n elif filter_name == 'butterworth_h':\n self.filter = self.get_butterworth_high_pass_filter\n elif filter_name == 'gaussian_l':\n self.filter = self.get_gaussian_low_pass_filter\n elif filter_name == 'gaussian_h':\n self.filter = self.get_gaussian_high_pass_filter\n\n self.cutoff = cutoff\n self.order = order","def PassFilter(xdata, ydata, fs, order=5, btype='high', freq = None, cutoff=None):\r\n if freq == None:\r\n freq = _frequency_estimation(xdata, ydata)\r\n if cutoff==None:\r\n cutoff = _cutoff(xdata, ydata, btype, fs, ff = freq)\r\n b, a = _butter_pass(cutoff, fs, order=order, btype=btype)\r\n y = signal.filtfilt(b, a, ydata, padtype='even')\r\n return y","def xor_folding(self):\n lbs = round(self.bit_size / 2)\n cap = round(self.capacity / 2)\n\n fold_pos = round( len(self.filter) / 2 )\n\n a = self.filter[0:fold_pos]\n b = self.filter[fold_pos:]\n # print('======>',self.bit_size,'#',len(a),len(b))\n\n r = BloomFilter(cap=cap, fpr=self.false_positive_rate, bfpower=self.potencia, bs=lbs)\n r.filter = a.__ixor__(b)\n return r","def test_filtfilt_simple(self):\n waveform = get_whitenoise(sample_rate=8000, n_channels=2, dtype=self.dtype).to(device=self.device)\n b_coeffs = torch.tensor([0, 0, 0, 1], dtype=self.dtype, device=self.device)\n a_coeffs = torch.tensor([1, 0, 0, 0], dtype=self.dtype, device=self.device)\n padded_waveform = torch.cat((waveform, torch.zeros(2, 3, dtype=self.dtype, device=self.device)), axis=1)\n output_waveform = F.filtfilt(padded_waveform, a_coeffs, b_coeffs)\n\n self.assertEqual(output_waveform, padded_waveform, atol=1e-5, rtol=1e-5)","def get_gaussian_low_pass_filter(self, shape, cutoff):\n from numpy import exp\n \n mask = zeros(shape)\n row_size, col_size = shape[0], shape[1]\n center_row, center_col = row_size/2 , col_size/2\n for r in range(0, row_size):\n for c in range(0, col_size):\n freq_dist = sqrt( (r-center_row)**2 + (c-center_col)**2 )\n mask[r,c] = (exp(-(freq_dist**2)/(cutoff*2)**2)) if freq_dist > cutoff else 1.0\n\n return mask","def lowpass_filter_reset(self, data):\n zi = scipy.signal.sosfilt_zi(self._lowpass_sos)\n self._lowpass_state = data[0, :] * np.repeat(zi[:, :, np.newaxis],\n data.shape[1], axis=2)\n logging.info('Resetting the low-pass filter state.')","def gaussianFilter(gain,BT,spSym,nTaps):\n\n a = np.sqrt(np.log(2)/2)/BT\n t = np.linspace(-.5*nTaps,.5*nTaps-1,nTaps)/spSym\n\n ft = np.sqrt(np.pi)/a *np.exp(-(np.pi**2*(t)**2)/a**2)\n ft /= np.sum(ft) * gain # normalize filter\n\n return ft","def compute(self):\n Y = self.data[1]\n # Create an order 3 lowpass butterworth filter\n b, a = signal.butter(3, 0.05)\n # Apply the filter to Y. Use lfilter_zi to choose the initial condition of the filter\n zi = signal.lfilter_zi(b, a)\n z, _ = signal.lfilter(b, a, Y, zi=zi * Y[0])\n # Apply the filter again, to have a result filtered at an order the same as filtfilt\n z2, _ = signal.lfilter(b, a, z, zi=zi * z[0])\n # Use filtfilt to apply the filter\n self.data[2] = signal.filtfilt(b, a, Y)\n self.data[3] = self.data[2] - self.data[1] - self.dataSpan * 0.3\n self.updatePlot()","def __init__(self, init=None, filter_table=None, filter_name=None,\n wavecent=None, fwhm=None, **kwargs):\n super(MiriBandPassFilter, self).__init__(init=init,\n filter_table=filter_table,\n filter_name=filter_name,\n filter_type='BandPass',\n **kwargs)\n\n # Define the central wavelength and fwhm, if defined.\n if wavecent:\n self.meta.instrument.filter_wavecent = wavecent\n if fwhm:\n self.meta.instrument.filter_fwhm = fwhm","def dwt(image_array, quantization_Array):\n # Create the high pass and low pass filters\n # both filters are non-causal\n # symmetric\n # [-2, -1, 0, 1, 2]\n LPF = [-0.125, 0.25, 0.75, 0.25, -0.125]\n LPF_center = 2\n\n # [ -2,-1, 0]\n HPF = [-0.5, 1, -0.5]\n HPF_center = 2\n\n nrow, ncol = image_array.shape\n\n # create an array that will contain the 4 different subbands of the image\n LL = np.zeros((nrow, ncol))\n LH = np.zeros((nrow, ncol))\n HL = np.zeros((nrow, ncol))\n HH = np.zeros((nrow, ncol))\n filtered_image = [LL, LH, HL, HH]\n\n # filtering the rows using a low pass and high pass filters\n LowPass_rows = np.zeros((nrow, ncol))\n HighPass_rows = np.zeros((nrow, ncol))\n for i in range(0, nrow):\n LowPass_rows[i, :] = lfilter(LPF, image_array[i, :], LPF_center)\n HighPass_rows[i, :] = lfilter(HPF, image_array[i, :], HPF_center)\n\n # down sample rows.\n # which means we will have half the number of columns\n for i in range(0, len(filtered_image)):\n filtered_image[i] = filtered_image[i][:, ::2]\n\n # apply filters accross columns\n for i in range(0, ncol):\n LL[:, i] = lfilter(LPF, LowPass_rows[:, i], LPF_center)\n LH[:, i] = lfilter(HPF, LowPass_rows[:, i], HPF_center)\n HL[:, i] = lfilter(LPF, HighPass_rows[:, i], LPF_center)\n HH[:, i] = lfilter(HPF, HighPass_rows[:, i], HPF_center)\n\n # down sample columns and quantize\n for i in range(0, len(filtered_image)):\n filtered_image[i] = filtered_image[i][::2, :]\n filtered_image[i] = np.round(\n filtered_image[i]/quantization_Array[i]).astype(int)\n\n return filtered_image","def A_weight(signal, fs):\n\n b, a = A_weighting(fs)\n return lfilter(b, a, signal)"],"string":"[\n \"def butter_lowpass_filter(data, cutoff, fs, order=1):\\n b, a = butter_lowpass(cutoff, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def butter_lowpass_filter(self, data: np.ndarray, lowcut: float, fs: float, order: int = 4) -> np.ndarray:\\n b, a = self._butter_lowpass(lowcut, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def butter_filter(datalist):\\n fs = 200.00\\n fHigh = 50.00\\n fLow = 5.00\\n N=4\\n [b,a]=sg.butter(N,[fLow/fs, fHigh/fs], btype='band')\\n global filtered\\n #IIR filter\\n return sg.filtfilt(b,a,datalist)\",\n \"def butter_filter(self, data, low_pass, high_pass, fs, order=10):\\n\\n nyq = fs/2\\n low = low_pass/nyq\\n high = high_pass/nyq\\n\\n b, a = signal.butter(order, [low, high], btype='band')\\n filt_data = np.abs(signal.hilbert(signal.filtfilt(b, a, data, axis=1), axis=1))\\n return filt_data\",\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=1):\\n b, a = butter_bandpass(lowcut, highcut, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def _butter_bandpass_filter(self, data: np.ndarray, lowcut: float, highcut: float, fs: float, order: int = 5):\\n b, a = self._butter_bandpass(lowcut, highcut, fs, order=order)\\n y = lfilter(b, a, data)\\n return y\",\n \"def butter_lowpass_filter(data: np.ndarray, cutoff: float, fs: float, order: int) -> np.ndarray:\\n nyq = 0.5 * fs\\n normal_cutoff = cutoff / nyq\\n # Get the filter coefficients\\n b, a = signal.butter(order, normal_cutoff, btype='low', analog=False)\\n y = signal.filtfilt(b, a, data)\\n return y\",\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=5, axis=0): \\n omega = 0.5 * fs\\n low = lowcut / omega\\n high = highcut / omega\\n b, a = signal.butter(order, [low, high], btype='band')\\n y = signal.lfilter(b, a, data, axis=0)\\n return y\",\n \"def ButterworthFilter(\\n self,\\n name: str,\\n cutoffFrequency: float,\\n order: int = 2,\\n operation: SymbolicConstant = NONE,\\n halt: Boolean = OFF,\\n limit: float = None,\\n invariant: SymbolicConstant = NONE,\\n ) -> ButterworthFilter:\\n self.filters[name] = butterworthFilter = ButterworthFilter(\\n name, cutoffFrequency, order, operation, halt, limit, invariant\\n )\\n return butterworthFilter\",\n \"def butterworth_bandpass_filter( values, lowFreq, highFreq, sampleFreq, order=5):\\n nyq = 0.5 * sampleFreq\\n low = lowFreq / nyq\\n high = highFreq /nyq\\n b,a = butter( order, [low,high], btype='band' )\\n return y = lfilter(b, a, data)\",\n \"def butter_highpass_filter(data, cutoff, fs, order=1):\\n b, a = butter_highpass(cutoff, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=2):\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n \\n # butter() and lfilter() are from scipy.signal\\n \\n b, a = butter(order, [low, high], btype='band')\\n y = lfilter(b, a, data)\\n return y\",\n \"def butter_bandpass_filter(\\n data: numpy.ndarray,\\n lowcut: float,\\n highcut: float,\\n samplerate: float,\\n order: int = 2,\\n):\\n nyq = 0.5 * samplerate\\n lowf = lowcut / nyq\\n highf = highcut / nyq\\n # generic names for coefficients in filters\\n # pylint: disable=invalid-name\\n a, b = butter(order, [lowf, highf], btype=\\\"band\\\")\\n if len(data) < BUTTER_MIN_LENGTH:\\n return None\\n return filtfilt(a, b, data)\",\n \"def butterworth_filter(signal, Fs, highpassfreq=None, lowpassfreq=None, order=4, filtfunc='filtfilt'):\\n Fn = Fs / 2.\\n \\n # set the function for filtering\\n if filtfunc is 'lfilter':\\n ffunc = spsig.lfilter\\n elif filtfunc is 'filtfilt':\\n ffunc = spsig.filtfilt\\n else:\\n raise ValueError(\\\"filtfunc must to be either 'filtfilt' or 'lfilter'\\\")\\n \\n # set parameters\\n if lowpassfreq and highpassfreq:\\n if highpassfreq < lowpassfreq:\\n Wn = (highpassfreq / Fn, lowpassfreq / Fn)\\n btype = 'bandpass'\\n else:\\n Wn = (lowpassfreq / Fn, highpassfreq / Fn)\\n btype = 'bandstop'\\n elif lowpassfreq:\\n Wn = lowpassfreq / Fn\\n btype = 'lowpass'\\n elif highpassfreq:\\n Wn = highpassfreq / Fn\\n btype = 'highpass'\\n else:\\n raise ValueError(\\\"Specify highpassfreq and/or lowpathfreq\\\")\\n \\n # filter design\\n b, a = spsig.butter(order, Wn, btype=btype)\\n \\n return ffunc(b, a, signal)\",\n \"def lowpass_butter(fs, L, order, data, axis=-1, btype='low'):\\n from scipy.signal import butter, sosfiltfilt\\n\\n nyq = 0.5 * fs # Nyquist frequency\\n low = L / nyq\\n sos = butter(order, low, btype=btype, output='sos') # Coefficients for Butterworth filter\\n filtered = sosfiltfilt(sos, data, axis=axis)\\n\\n return filtered\",\n \"def get_butterworth_low_pass_filter(shape, cutoff, order):\\n \\n \\n print(\\\"butterworth_low_pass_filter = \\\")\\n print(\\\"cutoff: \\\",cutoff)\\n print(\\\"order: \\\",order)\\n filter = np.zeros(shape)\\n for i in range(shape[0]):\\n for j in range(shape[1]):\\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\\n filter[i, j] = 1 / (1 + (D / cutoff) ** (2 * order))\\n # print(\\\"\\\\n\\\\n\\\\n\\\\n\\\")\\n # print(filter)\\n # return filter\\n return process_filter(image, filter)\",\n \"def Butterworth_Filter(x,order,Low_High,Wn):\\r\\n\\r\\n\\r\\n # Create an order butterworth filter:\\r\\n\\r\\n b, a = signal.butter(order,Wn,Low_High);\\r\\n\\r\\n # Apply the filter to x. Use lfilter_zi to choose the initial condition of the filter:\\r\\n\\r\\n zi = signal.lfilter_zi(b, a);\\r\\n z, _ = signal.lfilter(b, a, x, zi=zi*x[0]);\\r\\n\\r\\n # Apply the filter again, to have a result filtered at an order the same as filtfilt:\\r\\n\\r\\n z2, _ = signal.lfilter(b, a, z, zi=zi*z[0])\\r\\n\\r\\n # Use filtfilt to apply the filter:\\r\\n\\r\\n y = signal.filtfilt(b, a, x);\\r\\n\\r\\n return y;\",\n \"def filter_low_pass(x, filt_data, cutoff, fs, order=1, rows=[0,-1]):\\n\\n from scipy.signal import butter, filtfilt\\n import numpy as np\\n import matplotlib.pyplot as plt \\n\\n def butter_lowpass(cutoff, fs, order=5):\\n nyq = 0.5 * fs\\n normal_cutoff = cutoff / nyq\\n b, a = butter(order, normal_cutoff, btype='low', analog=False)\\n return b, a \\n\\n b, a = butter_lowpass(cutoff, fs, order=order)\\n \\n slice_exp = filt_data[rows[0]:rows[1]]\\n lp_slice_exp = filtfilt(b, a, slice_exp)\\n lp = np.append(filt_data[:rows[0]],lp_slice_exp)\\n lp = np.append(lp,filt_data[rows[1]:])\\n\\n f, ax = plt.subplots(1,1,figsize=(8,8))\\n ax.plot(x,filt_data,'k',label='original data')\\n ax.plot(x,lp,'r',label='filtered data')\\n ax.legend(loc='best')\\n\\n return lp\",\n \"def lowpass_filter(data, Wn=0.014, N=2):\\n data = np.array(data)\\n data = data.astype(np.float)\\n # N = 5 # Filter order\\n # Wn = 0.02 # Cutoff frequency\\n B, A = signal.butter(N, Wn, output='ba')\\n\\n # Second, apply the filter\\n tempf = signal.filtfilt(B,A, data)\\n # print(tempf)\\n return tempf\",\n \"def butterworth_filter(freq):\\n\\tf_raw = 1/(0.00000002*100*33)\\n\\tb = np.array([[-32092,15750],[-31238,14895]])*2.0**(-14)\\n\\tomega = 2*np.pi*freq/f_raw\\n\\te1, e2 = np.exp(-1j*omega), np.exp(-2j*omega)\\n\\ttmp = (1+2*e1+e2)**2/(1+b[0,0]*e1+b[0,1]*e2)/(1+b[1,0]*e1+b[1,1]*e2)\\n\\treturn tmp * (1+sum(b[0]))*(1+sum(b[1]))/16\",\n \"def butter_bandstop_filter(data, lowcut, highcut, fs, order):\\n\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n\\n i, u = sg.butter(order, (low, high), btype='bandstop')\\n y = sg.filtfilt(i, u, data)\\n return y\",\n \"def _butter_bandpass(lowcut: float, highcut: float, fs: float, order: int = 5) -> tuple:\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n b, a = butter(order, [low, high], btype=\\\"band\\\")\\n return b, a\",\n \"def make_butter_sp(self, wn, order):\\n nyquist = self.s_freq/2\\n wn_arr=np.asarray(wn)\\n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\\n \\n self.sp_sos = butter(order, wn_arr, btype='bandpass', output='sos')\\n print(f\\\"Zero phase butterworth filter successfully created: order = {order}x{order} bandpass = {wn}\\\")\",\n \"def init_lowpass(self, lowpass_cutoff, lowpass_order):\\n if lowpass_cutoff > 0 or self._fs_out < self._fs_in:\\n nyquist = self._fs_out / 2\\n if lowpass_cutoff > nyquist or (self._fs_out < self._fs_in and\\n lowpass_cutoff == 0):\\n lowpass_cutoff = 0.75 * nyquist\\n lowpass_order = 10\\n print('Using %gHz low-pass filter to prevent aliasing'\\n % lowpass_cutoff)\\n self._lowpass_cutoff = lowpass_cutoff\\n self._lowpass_order = lowpass_order\\n logging.info('Low-pass filtering the data with the 3dB point at %gHz.',\\n lowpass_cutoff)\\n self._lowpass_sos = scipy.signal.butter(lowpass_order, lowpass_cutoff,\\n 'lp', output='sos', fs=self.fs_in)\\n self._lowpass_state = None # to be created later when we know sizes\\n else:\\n self._lowpass_sos = None\",\n \"def make_butter_so(self, wn, order):\\n \\n nyquist = self.s_freq/2\\n wn_arr = np.asarray(wn)\\n \\n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\\n \\n self.so_sos = butter(order, wn_arr, btype='bandpass', output='sos')\\n print(f\\\"Zero phase butterworth filter successfully created: order = {order}x{order}, bandpass = {wn}\\\")\",\n \"def get_butterworth_high_pass_filter(self, shape, cutoff, order):\\r\\n\\r\\n #Hint: May be one can use the low pass filter function to get a high pass mask\\r\\n # 1 - butter low pass\\r\\n mask = 1 - self.get_butterworth_low_pass_filter(shape, cutoff, order)\\r\\n\\r\\n return mask\",\n \"def get_butterworth_high_pass_filter(shape, cutoff, order):\\n \\n # Hint: May be one can use the low pass filter function to get a high pass mask\\n print(\\\"butterworth_high_pass_filter = \\\")\\n print(\\\"cutoff: \\\",cutoff)\\n print(\\\"order: \\\",order)\\n filter = get_butterworth_low_pass_filter(shape, cutoff, order)\\n\\n for i in range(shape[0]):\\n for j in range(shape[1]):\\n filter[i, j] = 1 - filter[i, j]\\n\\n # return filter\\n return process_filter(image, filter)\",\n \"def _signal_filter_butterworth(signal, sampling_rate=1000, lowcut=None, highcut=None, order=2):\\n if lowcut is not None and highcut is not None:\\n sos = scipy.signal.butter(order, [lowcut, highcut], btype=\\\"bandpass\\\", output='sos', fs=sampling_rate)\\n elif lowcut is not None:\\n sos = scipy.signal.butter(order, [lowcut], btype=\\\"highpass\\\", output='sos', fs=sampling_rate)\\n elif highcut is not None:\\n sos = scipy.signal.butter(order, [highcut], btype=\\\"lowpass\\\", output='sos', fs=sampling_rate)\\n\\n filtered = scipy.signal.sosfiltfilt(sos, signal)\\n return filtered\",\n \"def butterworth_bandpass(lowcut, highcut, fs, order=5):\\n nyq = 0.5 * fs # nyquist sampling rate\\n low = lowcut / nyq # normalize frequency\\n high = highcut / nyq # normalize frequency\\n b, a = butter(order, [low, high], btype='band')\\n return b, a\",\n \"def butterworth(dx, order, cutoff, /, btype='low'):\\n # Initial stuff\\n # * Need to run *forward and backward* to prevent time-shifting.\\n # * The 'analog' means units of cutoffs are rad/s.\\n # * Unlike Lanczos filter, the *length* of this should be\\n # determined always as function of timestep, because really high\\n # order filters can get pretty wonky.\\n # * Cutoff is point at which gain reduces to 1/sqrt(2) of the\\n # initial frequency. If doing bandpass, can\\n # N = (width/dx)//1 # convert to timestep units\\n # N = (N//2)*2 + 1 # odd numbered\\n N = order # or order\\n analog = False # lfilter seems to need digital\\n if analog:\\n cutoff = 2 * np.pi / (cutoff / dx) # from wavelengths to rad/steps\\n else:\\n cutoff = 1.0 / cutoff # to Hz, or cycles/unit\\n cutoff = cutoff * (2 * dx) # to cycles / (2 timesteps)\\n if cutoff > 1:\\n raise ValueError(\\n 'Cuttoff frequency must be in [0, 1]. Remember you pass a cutoff '\\n '*wavelength* to this function, not a frequency.'\\n )\\n\\n # Apply filter\\n print(f'Order-{order} Butterworth filter')\\n b, a = signal.butter(N - 1, cutoff, btype=btype, analog=analog, output='ba')\\n return b, a\",\n \"def bpfilter(\\n data: numpy.ndarray, short_min: float = 2, long_min: float = 12\\n) -> Optional[numpy.ndarray]:\\n return butter_bandpass_filter(\\n data, 1 / (long_min * 60), 1 / (short_min * 60), 1 / DATA_RATE\\n )\",\n \"def butter_bp_coe(lowcut, highcut, fs, order=1):\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n b, a = butter(order, [low, high], btype='band')\\n return b, a\",\n \"def lowpass_filter(s, sample_rate, cutoff_freq, filter_order=5, rescale=False):\\n #create a butterworth filter\\n nyq = sample_rate / 2.0\\n b,a = filter_design.butter(filter_order, cutoff_freq / nyq)\\n\\n #filter the signal\\n filtered_s = filtfilt(b, a, s)\\n\\n if rescale:\\n #rescale filtered signal\\n filtered_s /= filtered_s.max()\\n filtered_s *= s.max()\\n\\n return filtered_s\",\n \"def bandpass_filter_audio(audio, f_low=400, f_high=450):\\n filtered_audio = core.sinc_filter(audio, f_low, window_size=256, high_pass=True)\\n filtered_audio = core.sinc_filter(filtered_audio, f_high, window_size=256, high_pass=False)\\n return tf.squeeze(filtered_audio)\",\n \"def get_butterworth_low_pass_filter(self, shape, cutoff, order):\\r\\n P = shape[0]\\r\\n Q = shape[1]\\r\\n mask = np.zeros((P, Q))\\r\\n for u in range(P):\\r\\n for v in range(Q):\\r\\n dist = ((u - (P / 2)) ** 2 + (v - (Q / 2)) ** 2) ** (1 / 2)\\r\\n mask[u][v] = 1 / (1 + (dist/cutoff)**(2*order))\\r\\n\\r\\n return mask\",\n \"def bandpass_filter(s, sample_rate, low_freq, high_freq, filter_order=5, rescale=False):\\n #create a butterworth filter\\n nyq = sample_rate / 2.0\\n f = np.array([low_freq, high_freq]) / nyq\\n b,a = filter_design.butter(filter_order, f, btype='bandpass')\\n\\n #filter the signal\\n filtered_s = filtfilt(b, a, s)\\n\\n if rescale:\\n #rescale filtered signal\\n filtered_s /= filtered_s.max()\\n filtered_s *= s.max()\\n\\n return filtered_s\",\n \"def get_butterworth_low_pass_filter(self, shape, cutoff, order):\\n \\n mask = zeros(shape)\\n row_size, col_size = shape[0], shape[1]\\n center_row, center_col = row_size/2 , col_size/2\\n for r in range(0, row_size):\\n for c in range(0, col_size):\\n freq_dist = sqrt( (r-center_row)**2 + (c-center_col)**2 )\\n mask[r,c] = (1/(1+(freq_dist/cutoff)*order)) if freq_dist > cutoff else 1.0\\n\\n return mask\",\n \"def butter_filter(image, n, f0):\\n [ny, nx] = image.shape\\n dx = 2.0/nx\\n dy = 2.0/nx\\n dfx = 0.5\\n dfy = 0.5\\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\\n FX, FY = np.meshgrid(fx, fy)\\n shift = np.exp(-2*np.pi*1j*(FX+FY))\\n sin_pad = np.sin(image)\\n cos_pad = np.cos(image)\\n ft_sin = shift * np.fft.fftshift(np.fft.fft2(sin_pad))\\n ft_cos = shift * np.fft.fftshift(np.fft.fft2(cos_pad))\\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\\n sin_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_sin)) / shift)\\n cos_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_cos)) / shift)\\n phase_filt = np.arctan2(sin_filt, cos_filt)\\n return phase_filt\",\n \"def design_filter(interpolation, decimation, fractional_bw):\\n\\n if fractional_bw >= 0.5 or fractional_bw <= 0:\\n raise ValueError('Invalid fractional bandwidth, must be in (0, 0.5)')\\n\\n if decimation < 1 or interpolation < 1:\\n raise ValueError('Invalid interpolation or decimation rate. Must be a non-zero positive integer.')\\n\\n beta = 7.0\\n halfband = 0.5\\n rate = float(interpolation)/float(decimation)\\n if(rate >= 1.0):\\n trans_width = halfband - fractional_bw\\n mid_transition_band = halfband - trans_width/2.0\\n else:\\n trans_width = rate*(halfband - fractional_bw)\\n mid_transition_band = rate*halfband - trans_width/2.0\\n\\n taps = filter.firdes.low_pass(interpolation, # gain\\n interpolation, # Fs\\n mid_transition_band, # trans mid point\\n trans_width, # transition width\\n filter.firdes.WIN_KAISER,\\n beta) # beta\\n\\n return taps\",\n \"def butter_hpf(highcut, fs, order):\\n nyq = 0.5 * fs\\n high = highcut / nyq\\n b, a = signal.butter(order, high, btype='highpass')\\n w, h = signal.freqz(b, a, worN=1000)\\n# plt.figure()\\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\\n return b, a\",\n \"def highpass_filter(s, sample_rate, cutoff_freq, filter_order=5, rescale=False):\\n #create a butterworth filter\\n nyq = sample_rate / 2.0\\n b,a = filter_design.butter(filter_order, cutoff_freq / nyq, btype='high')\\n\\n #filter the signal\\n filtered_s = filtfilt(b, a, s)\\n\\n if rescale:\\n #rescale filtered signal\\n filtered_s /= filtered_s.max()\\n filtered_s *= s.max()\\n\\n return filtered_s\",\n \"def make_butter_spso(self, spso_wn_pass, spso_wn_stop, spso_order):\\n nyquist = self.s_freq/2\\n wn_pass_arr = np.asarray(spso_wn_pass)\\n wn_stop_arr = np.asarray(spso_wn_stop)\\n \\n # must remake filter for each pt bc of differences in s_freq\\n if np.any(wn_pass_arr <=0) or np.any(wn_pass_arr >=1):\\n wn_pass_arr = wn_pass_arr/nyquist \\n \\n if np.any(wn_stop_arr <=0) or np.any(wn_stop_arr >=1):\\n wn_stop_arr = wn_stop_arr/nyquist\\n\\n self.spso_sos_bandstop = butter(spso_order, wn_stop_arr, btype='bandstop', output='sos')\\n self.spso_sos_bandpass = butter(spso_order, wn_pass_arr, btype='bandpass', output='sos')\\n print(f\\\"Zero phase butterworth filter successfully created: order = {spso_order}x{spso_order} bandpass = {spso_wn_pass}\\\")\\n print(f\\\"Zero phase butterworth filter successfully created: order = {spso_order}x{spso_order} bandstop = {spso_wn_stop}\\\")\",\n \"def init_highpass(self, highpass_cutoff, highpass_order):\\n if highpass_cutoff > 0:\\n self._highpass_cutoff = highpass_cutoff\\n self._highpass_order = highpass_order\\n logging.info('High-pass filtering the data with the 3dB point at %gHz.',\\n highpass_cutoff)\\n self._highpass_sos = scipy.signal.butter(highpass_order, highpass_cutoff,\\n 'hp', output='sos',\\n fs=self.fs_in)\\n self._highpass_state = None # to be created later when we know sizes\\n else:\\n self._highpass_sos = None\",\n \"def butter_lpf(fc, fs, order):\\n nyq = 0.5 * fs\\n high = fc / nyq\\n b, a = signal.butter(order, high, btype='lowpass', analog=False)\\n w, h = signal.freqz(b, a, worN=1000)\\n# plt.figure()\\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\\n return b, a\",\n \"def create_low_pass_frequency_kernel(im, radius):\\n kernel = create_high_pass_frequency_kernel(im, radius)\\n kernel = 1 - kernel\\n return kernel\",\n \"def create_low_pass_frequency_kernel(im, radius):\\n kernel = create_high_pass_frequency_kernel(im, radius)\\n kernel = 1 - kernel\\n return kernel\",\n \"def get_gaussian_low_pass_filter(shape, cutoff, order):\\n \\n print(\\\"gaussian_low_pass_filter = \\\")\\n print(\\\"cutoff: \\\",cutoff)\\n print(\\\"order: \\\",order)\\n filter = np.zeros(shape)\\n\\n for i in range(shape[0]):\\n for j in range(shape[1]):\\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\\n\\n filter[i, j] = math.exp(-D ** 2 / (2 * (cutoff ** 2)))\\n\\n # return filter\\n return process_filter(image, filter)\",\n \"async def low_pass(\\n client,\\n event,\\n smoothing: P('float', 'smoothing', min_value = 0.0, max_value = 5.0),\\n):\\n player = get_player_or_abort(client, event)\\n \\n filter = LowPass(smoothing)\\n player.add_filter(filter)\\n await player.apply_filters()\\n \\n return create_filter_added_embed(filter)\",\n \"def filt_bp(sig: np.ndarray, Ss: int, Cfs0: int, Cfs1: None,\\n order=5) -> np.ndarray:\\n nyq = 0.5 * Ss\\n normal_cutoff1 = Cfs0 / nyq\\n normal_cutoff2 = Cfs1 / nyq\\n b, a = butter(order, (normal_cutoff1, normal_cutoff2),\\n btype='band',\\n analog=False)\\n return lfilter(b, a, sig)\",\n \"def iirfilter(x, N=4, pass_freq=0.7 / 12.):\\n b, a = signal.butter(N, pass_freq, \\\"low\\\", analog=False)\\n return signal.filtfilt(b, a, x)\",\n \"def butter_filter_unwrapped(image, n, f0, pad = False):\\n if pad == True:\\n res = [2**kji for kji in range(15)]\\n N_int_x = image.shape[1]\\n N_int_y = image.shape[0]\\n nx_pad = np.where(res > np.tile(N_int_x, len(res)))\\n nx_pad = res[nx_pad[0][0]]\\n ny_pad = np.where(res > np.tile(N_int_y, len(res)))\\n ny_pad = res[ny_pad[0][0]]\\n dif_x = (nx_pad - N_int_x)/2\\n dif_y = (ny_pad - N_int_y)/2\\n orig_shape = image.shape\\n image = np.lib.pad(image, ((dif_y, dif_y), (dif_x, dif_x)), 'reflect')\\n \\n [ny, nx] = image.shape\\n dx = 2.0/nx\\n dy = 2.0/ny\\n dfx = 0.5\\n dfy = 0.5\\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\\n FX, FY = np.meshgrid(fx, fy)\\n shift = np.exp(-2*np.pi*1j*(FX+FY))\\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\\n ft_img = shift * np.fft.fftshift(np.fft.fft2(image))\\n \\n buttered = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_img))/ shift)\\n if pad == True:\\n assert(buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x].shape == orig_shape)\\n return buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x]\\n else:\\n assert(buttered.shape == image.shape)\\n return buttered\",\n \"def lowpass(data,filterSize=None):\\n\\n def convolve(signal,kernel):\\n pad=np.ones(len(kernel)/2)\\n signal=np.concatenate((pad*signal[0],signal,pad*signal[-1]))\\n signal=np.convolve(signal,kernel,mode='same')\\n signal=signal[len(pad):-len(pad)]\\n return signal\\n\\n def kernel_gaussian(size=100, sigma=None, forwardOnly=False):\\n if sigma is None:\\n sigma=size/10\\n size=int(size)\\n points=np.exp(-np.power(np.arange(size)-size/2,2)/(2*np.power(sigma,2)))\\n if forwardOnly:\\n points[:int(len(points)/2)]=0\\n return points/sum(points)\\n\\n if filterSize is None:\\n filterSize=len(data)/10\\n kernel=kernel_gaussian(size=filterSize)\\n data=convolve(data,kernel) # do the convolution with padded edges\\n return data\",\n \"def bandpass_filter(data, lowcut, highcut, fs=2000, numtaps=255):\\n nyq = fs / 2\\n\\n # design filter\\n fe1 = lowcut / nyq\\n fe2 = highcut / nyq\\n b = firwin(numtaps, (fe1, fe2), pass_zero=False)\\n\\n filtered = lfilter(b, 1, data)\\n\\n return filtered\",\n \"def __band_filter(data: dict, lowFreq: Union[int, float], highFreq: Union[int, float], timestep: int=0,\\n samplingFreq: int=240, order: int=5, eegSensor: int=0, filterType: str='bandpass',\\n lengthOfTestSeconds: Union[int, float]=32, example: int=0) -> dict:\\n #Test\\n # Filter.__band_filter_test(data=data, low=lowFreq, high=highFreq, samplingFreq=samplingFreq, order=order,\\n # eegSensor=eegSensor, filterType=filterType, lengthOfTestSeconds=lengthOfTestSeconds)\\n #Code\\n nyq = 0.5 * samplingFreq\\n low = lowFreq / nyq\\n high = highFreq / nyq\\n b, a = signal.butter(order, [low, high], btype=filterType)\\n y = signal.lfilter(b, a, data['Signal'])\\n ##Graph - This belongs somewhere else probably.\\n # t = np.linspace(0, len(data), len(data), endpoint=False)\\n # plt.plot(t, y, label='Sensor #' + str(eegSensor) + ' (' + str(lowFreq) + '-' + str(highFreq) + ') Hz')\\n # plt.grid(True)\\n # plt.axis('tight')\\n # plt.xticks(range(10), range(lengthOfTestSeconds)) ##32 seconds per test?\\n # plt.xlabel(\\\"Time in Seconds\\\")\\n # plt.legend(loc='upper left')\\n # plt.show()\\n output = {}\\n timestep = []\\n for index, eegChannel in enumerate(y[0]):#the extra [0] is becuase signal.lfilter() puts it in a 1D array. Grrr\\n timestep.append(eegChannel)\\n output['Signal'] = timestep\\n Visualization.channelGraph(y[0][0])\\n return output #output is 2D 64xTimeSamples\",\n \"def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=(500, 10000)):\\n if freq_cutoffs[0] <= 0:\\n raise ValueError('Low frequency cutoff {} is invalid, '\\n 'must be greater than zero.'\\n .format(freq_cutoffs[0]))\\n\\n Nyquist_rate = samp_freq / 2\\n if freq_cutoffs[1] >= Nyquist_rate:\\n raise ValueError('High frequency cutoff {} is invalid, '\\n 'must be less than Nyquist rate, {}.'\\n .format(freq_cutoffs[1], Nyquist_rate))\\n\\n if rawsong.shape[-1] < 387:\\n numtaps = 64\\n elif rawsong.shape[-1] < 771:\\n numtaps = 128\\n elif rawsong.shape[-1] < 1539:\\n numtaps = 256\\n else:\\n numtaps = 512\\n\\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\\n freq_cutoffs[1] / Nyquist_rate])\\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\\n # window to design filter, but default for matlab's fir1\\n # is actually Hamming\\n # note that first parameter for scipy.signal.firwin is filter *length*\\n # whereas argument to matlab's fir1 is filter *order*\\n # for linear FIR, filter length is filter order + 1\\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\\n a = np.zeros((numtaps+1,))\\n a[0] = 1 # make an \\\"all-zero filter\\\"\\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\\n return filtsong\",\n \"def get_butterworth_high_pass_filter(self, shape, cutoff, order):\\n\\n #Hint: May be one can use the low pass filter function to get a high pass mask\\n mask = zeros(shape)\\n row_size, col_size = shape[0], shape[1]\\n center_row, center_col = row_size/2 , col_size/2\\n for r in range(0, row_size):\\n for c in range(0, col_size):\\n freq_dist = sqrt( (r-center_row)**2 + (c-center_col)**2 )\\n mask[r,c] = (1/(1+(freq_dist/cutoff)*order*2)) if freq_dist < cutoff else 1.0\\n\\n return mask\\n # return 1 - self.get_butterworth_low_pass_filter(shape, cutoff, order*2) # wrong ?\",\n \"def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=None):\\n\\n Nyquist_rate = samp_freq / 2\\n if freq_cutoffs is None:\\n freq_cutoffs = [500, 10000]\\n if rawsong.shape[-1] < 387:\\n numtaps = 64\\n elif rawsong.shape[-1] < 771:\\n numtaps = 128\\n elif rawsong.shape[-1] < 1539:\\n numtaps = 256\\n else:\\n numtaps = 512\\n\\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\\n freq_cutoffs[1] / Nyquist_rate])\\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\\n # window to design filter, but default for matlab's fir1\\n # is actually Hamming\\n # note that first parameter for scipy.signal.firwin is filter *length*\\n # whereas argument to matlab's fir1 is filter *order*\\n # for linear FIR, filter length is filter order + 1\\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\\n a = np.zeros((numtaps+1,))\\n a[0] = 1 # make an \\\"all-zero filter\\\"\\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\\n return filtsong\",\n \"def _butter_pass(cutoff, fs, order=5, btype='high'):\\r\\n nyq = 0.5*fs\\r\\n normal_cutoff = cutoff/nyq\\r\\n# print \\\"normalized cutoff: \\\", normal_cutoff\\r\\n if normal_cutoff >= 1.:\\r\\n normal_cutoff = 1.\\r\\n b, a = signal.butter(order, normal_cutoff, btype=btype, analog=False)\\r\\n return b, a\",\n \"def filter_pupil(self, hp=0.01, lp=10.0):\\r\\n self.logger.info('Band-pass filtering of pupil signals, hp = %2.3f, lp = %2.3f'%(hp, lp))\\r\\n\\r\\n self.lp_filt_pupil = _butter_lowpass(data=self.interpolated_pupil.astype('float64'), highcut=lp, fs=self.sample_rate, order=3)\\r\\n self.hp_filt_pupil = _butter_highpass(data=self.interpolated_pupil.astype('float64'), lowcut=hp, fs=self.sample_rate, order=3)\\r\\n self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\\r\\n self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\\r\\n\\r\\n # import mne\\r\\n # from mne import filter\\r\\n # self.lp_filt_pupil = mne.filter.low_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=lp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\\r\\n # self.hp_filt_pupil = mne.filter.high_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=hp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\\r\\n # self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\\r\\n # self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\\r\",\n \"def filter(sig, sampling_rate, lc, hc, order=2):\\n\\n # Construct butterworth band-pass filter\\n b1, a1 = butter(order, [2.0 * lc / sampling_rate,\\n 2.0 * hc / sampling_rate], btype=\\\"band\\\")\\n nchan, nsamp = sig.shape\\n fsig = np.copy(sig)\\n\\n # Apply cosine taper then apply band-pass filter in both directions\\n for ch in range(0, nchan):\\n fsig[ch, :] = fsig[ch, :] - fsig[ch, 0]\\n tap = cosine_taper(len(fsig[ch, :]), 0.1)\\n fsig[ch, :] = fsig[ch, :] * tap\\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, ::-1])[::-1]\\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, :])\\n\\n return fsig\",\n \"def butterworthsmoothing(df, column_names: list = None, Wn = 0.015):\\n\\n if column_names is None:\\n return df\\n else:\\n # First, design the Buterworth filter\\n N = 2 # Filter order\\n Wn = Wn # Cutoff frequency\\n B, A = signal.butter(N, Wn, output='ba')\\n for i in column_names:\\n df[i] = signal.filtfilt(B, A, df[i])\\n df.dropna(axis=0, how='any', inplace=True)\\n return df\",\n \"def filtroBilateral(frame):\\n fb = cv2.bilateralFilter(frame, 0, 32, 2)\\n return fb\",\n \"def butter2d_lp(shape, f, n):\\n \\n rows, cols = shape \\n x = np.linspace(-0.5, 0.5, cols)\\n y = np.linspace(-0.5, 0.5, rows)\\n radius = np.sqrt((x**2)[np.newaxis] + (y**2)[:, np.newaxis]) \\n filt = 1 / (1.0 + (radius / f)**(2*n))\\n \\n return (filt)\",\n \"def _get_fir_filter(passband, fs, order=183, weights=[5.75, 1., 5.75], mask=[0, 1, 0]):\\n # return remez(order, passband, mask, weights, Hz=fs), 1.\\n return remez(order, passband, mask, Hz=fs), 1.\",\n \"def band_pass_eeg(eeg, freq_range, order=4):\\n return ButterworthFilter(eeg, freq_range, filt_type='pass', order=order).filter()\",\n \"def lowPassFilter(img, window=30):\\n gray = grayscale(img)\\n\\tdft = cv2.dft(np.float32(gray), flags = cv2.DFT_COMPLEX_OUTPUT)\\n\\tdft_shift = np.fft.fftshift(dft)\\n\\trows, cols = gray.shape\\n\\tcrow, ccol = rows/2, cols/2\\n\\tmask = np.zeros((rows, cols, 2), np.uint8)\\n\\tmask[crow-window:crow+window, ccol-window:ccol+window] = 1\\n\\tfshift = dft_shift*mask\\n\\tf_ishift = np.fft.ifftshift(fshift)\\n\\timg_back = cv2.idft(f_ishift)\\n\\timg_back = cv2.magnitude(img_back[:,:,0], img_back[:,:,1])\\n\\treturn img_back\",\n \"def get_ideal_low_pass_filter(shape, cutoff, order):\\n \\n print(\\\"ideal_low_pass_filter = \\\")\\n print(\\\"cutoff: \\\",cutoff)\\n print(\\\"order: \\\",order)\\n \\n filter = np.zeros(shape)\\n\\n D = 0\\n\\n for i in range(shape[0]):\\n for j in range(shape[1]):\\n\\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\\n\\n if D <= cutoff:\\n filter[i, j] = 1\\n else:\\n filter[i, j] = 0\\n\\n # return filter\\n return process_filter(image, filter)\",\n \"def butterworth_filter(dft4img, stopband2=10, order=3, showdft=False):\\n h, w = dft4img.shape[0], dft4img.shape[1]\\n P = h / 2\\n Q = w / 2\\n dst = np.zeros((h, w, 3), np.float64)\\n for i in range(h):\\n for j in range(w):\\n r2 = float((i - P) ** 2 + (j - Q) ** 2)\\n if r2 == 0:\\n r2 = 1.0\\n dst[i, j] = 1 / (1 + (r2 / stopband2) ** order)\\n dst = np.float64(dst)\\n if showdft:\\n cv2.imshow(\\\"butterworth\\\", cv2.magnitude(dst[:, :, 0], dst[:, :, 1]))\\n return dst\",\n \"def filters(self, low_freq=1/7, high_freq=128, notch_freq=50):\\n self.raw.filter(l_freq=low_freq, h_freq=high_freq)\\n self.raw.notch_filter(range(notch_freq, high_freq, notch_freq), filter_length='auto',\\n phase='zero', fir_design='firwin')\",\n \"def butter_bp(n, wlo, whi):\\n zeros = []\\n poles = _butter_analog_poles(n)\\n k = 1\\n fs = 2\\n\\n warpedlo = 2 * fs * mp.tan(mp.pi * wlo / fs)\\n warpedhi = 2 * fs * mp.tan(mp.pi * whi / fs)\\n bw = warpedhi - warpedlo\\n wo = mp.sqrt(warpedlo * warpedhi)\\n z, p, k = _zpklp2bp(zeros, poles, k, wo=wo, bw=bw)\\n z, p, k = _zpkbilinear(z, p, k, fs=fs)\\n return z, p, k\",\n \"def filters(array, sample_frequency):\\n strain = TimeSeries(array, sample_rate=int(sample_frequency))\\n white_data = strain.whiten(fftlength=4, fduration=4)\\n bp_data = white_data.bandpass(50, 250)\\n return bp_data.value\",\n \"def lowpass_filter(self, data, reset=False):\\n data = np.asarray(data)\\n if self._lowpass_sos is not None:\\n if self._lowpass_state is None or reset:\\n self.lowpass_filter_reset(data)\\n data, self._lowpass_state = scipy.signal.sosfilt(\\n self._lowpass_sos, data, zi=self._lowpass_state, axis=0)\\n return data\\n return data\",\n \"def A_weighting(fs):\\n b, a = A_weighting_analog()\\n\\n # Use the bilinear transformation to get the digital filter.\\n return bilinear(b, a, fs)\",\n \"def initialize_filter(self):\\n shape = self.filter_size + (self.input_shape[-1], self.channels)\\n self.filter = self.filter_initializer(shape)\",\n \"def bandpassFilter (self, lowerFreq, upperFreq):\\n self.bandpassLimits = (lowerFreq, upperFreq)\\n # stuff to do\",\n \"def bessel_wave(freq, alpha, beta):\\n return FMFilter(SineWave(freq), SineWave(alpha), beta)\",\n \"def copy(self):\\n new_filter = BloomFilter(self.capacity, self.error_rate)\\n new_filter.filter = self.filter.copy()\\n return new_filter\",\n \"def bandpass_filter_raw_plot(data, fs, f1, f2):\\n b, a = sp.butter(N=2, Wn=np.array([f1, f2]) / fs * 2, btype='bandpass') # build a bandpass butterworth filter of order 4, with cut-off frequencies 1 and 45\\n w, h = sp.freqz(b, a) # compute the frequency response of the filter\\n f = w / np.pi * fs / 2\\n plt.figure()\\n plt.plot(f, 10 * np.log10(abs(h)))\\n plt.xlabel('frequency (Hz)')\\n plt.ylabel('Magnitude (dB)')\\n plt.title('frequency response of butterworth bandpass [1, 45]Hz')\\n plt.grid()\\n\\n data1 = sp.filtfilt(b, a, data)\\n return data1\",\n \"def get_gaussian_low_pass_filter(self, shape, cutoff):\\r\\n P = shape[0]\\r\\n Q = shape[1]\\r\\n mask = np.zeros((P, Q))\\r\\n for u in range(P):\\r\\n for v in range(Q):\\r\\n dist = (((u - (P / 2)) ** 2) + ((v - (Q / 2)) ** 2)) ** (1 / 2)\\r\\n\\r\\n mask[u][v] = math.exp((-dist ** 2) / (2 * (cutoff ** 2)))\\r\\n\\r\\n return mask\",\n \"def get_gaussian_high_pass_filter(self, shape, cutoff):\\r\\n\\r\\n #Hint: May be one can use the low pass filter function to get a high pass mask\\r\\n # 1 - gaussian low pass\\r\\n mask = 1 - self.get_gaussian_low_pass_filter(shape, cutoff)\\r\\n\\r\\n return mask\",\n \"def highPassFilter(img, window=30):\\n gray = grayscale(img)\\n\\tf = np.fft.fft2(gray)\\n\\tfshift = np.fft.fftshift(f)\\n\\trows, cols = gray.shape\\n\\tcrow, ccol = rows/2, cols/2\\n\\tfshift[crow-window:crow+window, ccol-window:ccol+window] = 0\\n\\tf_ishift = np.fft.ifftshift(fshift)\\n\\timg_back = np.fft.ifft2(f_ishift)\\n\\timg_back = np.abs(img_back)\\n\\treturn img_back\",\n \"def custom_filter(image: Image) -> Image:\\n image = image.filter(ImageFilter.Kernel(\\n size=(3, 3), kernel=(1, 0, 1, 0, 0, 0, 1, 0, 1)))\\n return image\",\n \"def bandpass(filename,f1,f2,Q,wout=True,plot=True):\\n start=time.time()\\n n, data, data_dB,sr,ch=inputwav(filename)\\n b, a = butter(Q,Wn=(f1/sr,f2/sr),btype='bandpass')\\n data_filtered=lfilter(b,a,data,axis=0)\\n print('Applying FFT...')\\n if wout==True:\\n print('Exporting...')\\n sf.write(filename[0:len(filename)-4]+'_BP.wav',data_filtered,sr,'PCM_16')\\n if plot==True:\\n print('Plotting...')\\n py.close()\\n w, h = freqz(b,a,worN=16384)\\n fig, (ax1, ax2) = py.subplots(nrows=2)\\n ax1.semilogx(0.5*sr*w/np.pi,abs(h),'k-')\\n ax1.set_xlabel('Frequency (Hz)')\\n ax1.set_ylabel('Rel. Amplitude')\\n ax1.grid()\\n ax1.set_ylim(0,1.1)\\n ax1.set_xlim(1,20000)\\n ax2.plot(data,'k-',label='Raw data')\\n ax2.plot(data_filtered,'m-',lw=1,label='Filtered data')\\n ax2.set_xlim(0,10000)\\n ax2.set_ylim(-1,1)\\n ax2.set_ylabel('Amplitude (Norm Bits)')\\n ax2.set_xlabel('Samples')\\n ax2.legend(loc=2,frameon=False,ncol=2)\\n py.subplots_adjust(hspace=0.35) \\n print('Done!')\\n end=time.time()\\n elapsed=int(1000*(end-start))\\n print('...............................')\\n print('Completed in '+str(elapsed)+' milliseconds.')\\n return data_filtered\",\n \"def filt_hp(sig: np.ndarray, Ss: int, Cfs: int, Cfs1: None,\\n order=5) -> np.ndarray:\\n nyq = 0.5 * Ss\\n normal_cutoff = Cfs / nyq\\n b, a = butter(order, normal_cutoff, btype='high', analog=False)\\n return lfilter(b, a, sig)\",\n \"def __init__(self, fs=250, smoothing_win=20):\\n self.fs = fs\\n self.threshold = .35 # Generally between 0.3125 and 0.475\\n self.ns200ms = int(self.fs * .2)\\n self.r_peaks_buffer = [(0., 0.)]\\n self.noise_peaks_buffer = [(0., 0., 0.)]\\n self.prev_samples = np.zeros(smoothing_win)\\n self.prev_diff_samples = np.zeros(smoothing_win)\\n self.prev_times = np.zeros(smoothing_win)\\n self.prev_max_slope = 0\\n\\n self.bp_filter = ExGFilter(cutoff_freq=(1, 30), filter_type='bandpass', s_rate=fs, n_chan=1, order=3)\\n self.hamming_window = signal.windows.hamming(smoothing_win, sym=True)\\n self.hamming_window /= self.hamming_window.sum()\",\n \"def __init__(self, image, filter_name, cutoff, order = 0):\\r\\n self.image = image\\r\\n if filter_name == 'ideal_l':\\r\\n self.filter = self.get_ideal_low_pass_filter\\r\\n elif filter_name == 'ideal_h':\\r\\n self.filter = self.get_ideal_high_pass_filter\\r\\n elif filter_name == 'butterworth_l':\\r\\n self.filter = self.get_butterworth_low_pass_filter\\r\\n elif filter_name == 'butterworth_h':\\r\\n self.filter = self.get_butterworth_high_pass_filter\\r\\n elif filter_name == 'gaussian_l':\\r\\n self.filter = self.get_gaussian_low_pass_filter\\r\\n elif filter_name == 'gaussian_h':\\r\\n self.filter = self.get_gaussian_high_pass_filter\\r\\n\\r\\n self.cutoff = cutoff\\r\\n self.order = order\\r\\n self.filter_name = filter_name\",\n \"def bandpass_filter(files, lowpass_freq=0.1, highpass_freq=0.01, tr=2):\\n import os\\n\\n import nibabel as nb\\n import numpy as np\\n from nipype.utils.filemanip import (\\n filename_to_list,\\n list_to_filename,\\n split_filename\\n )\\n\\n fs = 1./tr\\n\\n out_files = []\\n for filename in filename_to_list(files):\\n path, name, ext = split_filename(filename)\\n out_file = os.path.join(os.getcwd(), name + '_bandpassed' + ext)\\n\\n img = nb.load(filename)\\n timepoints = img.shape[-1]\\n F = np.zeros((timepoints))\\n\\n lowidx = int(timepoints / 2) + 1\\n if lowpass_freq > 0:\\n lowidx = np.round(float(lowpass_freq) / fs * timepoints)\\n\\n highidx = 0\\n if highpass_freq > 0:\\n highidx = np.round(float(highpass_freq) / fs * timepoints)\\n F[int(highidx):int(lowidx)] = 1\\n F = ((F + F[::-1]) > 0).astype(int)\\n data = img.get_data()\\n if np.all(F == 1):\\n filtered_data = data\\n else:\\n filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F))\\n img_out = nb.Nifti1Image(filtered_data, img.affine, img.header)\\n img_out.to_filename(out_file)\\n out_files.append(out_file)\\n\\n return list_to_filename(out_files)\",\n \"def filt_lp(sig: np.ndarray, Ss: int, Cfs: int, Cfs1: None,\\n order=5) -> np.ndarray:\\n nyq = 0.5 * Ss\\n normal_cutoff = Cfs / nyq\\n b, a = butter(order, normal_cutoff, btype='low', analog=False)\\n return lfilter(b, a, sig)\",\n \"def _build_wavelet_bank(self):\\n self._build_filters()\\n wavelet_bank = torch.stack(self._filters)\\n wavelet_bank = wavelet_bank.view(\\n wavelet_bank.shape[0], 1, 1, wavelet_bank.shape[1]\\n )\\n wavelet_bank = torch.cat([wavelet_bank] * self.channels, 2)\\n return wavelet_bank\",\n \"def __init__(self, image, filter_name, cutoff, order = 0):\\n self.filter_name = filter_name\\n self.image = image\\n if filter_name == 'ideal_l':\\n self.filter = self.get_ideal_low_pass_filter\\n elif filter_name == 'ideal_h':\\n self.filter = self.get_ideal_high_pass_filter\\n elif filter_name == 'butterworth_l':\\n self.filter = self.get_butterworth_low_pass_filter\\n elif filter_name == 'butterworth_h':\\n self.filter = self.get_butterworth_high_pass_filter\\n elif filter_name == 'gaussian_l':\\n self.filter = self.get_gaussian_low_pass_filter\\n elif filter_name == 'gaussian_h':\\n self.filter = self.get_gaussian_high_pass_filter\\n\\n self.cutoff = cutoff\\n self.order = order\",\n \"def PassFilter(xdata, ydata, fs, order=5, btype='high', freq = None, cutoff=None):\\r\\n if freq == None:\\r\\n freq = _frequency_estimation(xdata, ydata)\\r\\n if cutoff==None:\\r\\n cutoff = _cutoff(xdata, ydata, btype, fs, ff = freq)\\r\\n b, a = _butter_pass(cutoff, fs, order=order, btype=btype)\\r\\n y = signal.filtfilt(b, a, ydata, padtype='even')\\r\\n return y\",\n \"def xor_folding(self):\\n lbs = round(self.bit_size / 2)\\n cap = round(self.capacity / 2)\\n\\n fold_pos = round( len(self.filter) / 2 )\\n\\n a = self.filter[0:fold_pos]\\n b = self.filter[fold_pos:]\\n # print('======>',self.bit_size,'#',len(a),len(b))\\n\\n r = BloomFilter(cap=cap, fpr=self.false_positive_rate, bfpower=self.potencia, bs=lbs)\\n r.filter = a.__ixor__(b)\\n return r\",\n \"def test_filtfilt_simple(self):\\n waveform = get_whitenoise(sample_rate=8000, n_channels=2, dtype=self.dtype).to(device=self.device)\\n b_coeffs = torch.tensor([0, 0, 0, 1], dtype=self.dtype, device=self.device)\\n a_coeffs = torch.tensor([1, 0, 0, 0], dtype=self.dtype, device=self.device)\\n padded_waveform = torch.cat((waveform, torch.zeros(2, 3, dtype=self.dtype, device=self.device)), axis=1)\\n output_waveform = F.filtfilt(padded_waveform, a_coeffs, b_coeffs)\\n\\n self.assertEqual(output_waveform, padded_waveform, atol=1e-5, rtol=1e-5)\",\n \"def get_gaussian_low_pass_filter(self, shape, cutoff):\\n from numpy import exp\\n \\n mask = zeros(shape)\\n row_size, col_size = shape[0], shape[1]\\n center_row, center_col = row_size/2 , col_size/2\\n for r in range(0, row_size):\\n for c in range(0, col_size):\\n freq_dist = sqrt( (r-center_row)**2 + (c-center_col)**2 )\\n mask[r,c] = (exp(-(freq_dist**2)/(cutoff*2)**2)) if freq_dist > cutoff else 1.0\\n\\n return mask\",\n \"def lowpass_filter_reset(self, data):\\n zi = scipy.signal.sosfilt_zi(self._lowpass_sos)\\n self._lowpass_state = data[0, :] * np.repeat(zi[:, :, np.newaxis],\\n data.shape[1], axis=2)\\n logging.info('Resetting the low-pass filter state.')\",\n \"def gaussianFilter(gain,BT,spSym,nTaps):\\n\\n a = np.sqrt(np.log(2)/2)/BT\\n t = np.linspace(-.5*nTaps,.5*nTaps-1,nTaps)/spSym\\n\\n ft = np.sqrt(np.pi)/a *np.exp(-(np.pi**2*(t)**2)/a**2)\\n ft /= np.sum(ft) * gain # normalize filter\\n\\n return ft\",\n \"def compute(self):\\n Y = self.data[1]\\n # Create an order 3 lowpass butterworth filter\\n b, a = signal.butter(3, 0.05)\\n # Apply the filter to Y. Use lfilter_zi to choose the initial condition of the filter\\n zi = signal.lfilter_zi(b, a)\\n z, _ = signal.lfilter(b, a, Y, zi=zi * Y[0])\\n # Apply the filter again, to have a result filtered at an order the same as filtfilt\\n z2, _ = signal.lfilter(b, a, z, zi=zi * z[0])\\n # Use filtfilt to apply the filter\\n self.data[2] = signal.filtfilt(b, a, Y)\\n self.data[3] = self.data[2] - self.data[1] - self.dataSpan * 0.3\\n self.updatePlot()\",\n \"def __init__(self, init=None, filter_table=None, filter_name=None,\\n wavecent=None, fwhm=None, **kwargs):\\n super(MiriBandPassFilter, self).__init__(init=init,\\n filter_table=filter_table,\\n filter_name=filter_name,\\n filter_type='BandPass',\\n **kwargs)\\n\\n # Define the central wavelength and fwhm, if defined.\\n if wavecent:\\n self.meta.instrument.filter_wavecent = wavecent\\n if fwhm:\\n self.meta.instrument.filter_fwhm = fwhm\",\n \"def dwt(image_array, quantization_Array):\\n # Create the high pass and low pass filters\\n # both filters are non-causal\\n # symmetric\\n # [-2, -1, 0, 1, 2]\\n LPF = [-0.125, 0.25, 0.75, 0.25, -0.125]\\n LPF_center = 2\\n\\n # [ -2,-1, 0]\\n HPF = [-0.5, 1, -0.5]\\n HPF_center = 2\\n\\n nrow, ncol = image_array.shape\\n\\n # create an array that will contain the 4 different subbands of the image\\n LL = np.zeros((nrow, ncol))\\n LH = np.zeros((nrow, ncol))\\n HL = np.zeros((nrow, ncol))\\n HH = np.zeros((nrow, ncol))\\n filtered_image = [LL, LH, HL, HH]\\n\\n # filtering the rows using a low pass and high pass filters\\n LowPass_rows = np.zeros((nrow, ncol))\\n HighPass_rows = np.zeros((nrow, ncol))\\n for i in range(0, nrow):\\n LowPass_rows[i, :] = lfilter(LPF, image_array[i, :], LPF_center)\\n HighPass_rows[i, :] = lfilter(HPF, image_array[i, :], HPF_center)\\n\\n # down sample rows.\\n # which means we will have half the number of columns\\n for i in range(0, len(filtered_image)):\\n filtered_image[i] = filtered_image[i][:, ::2]\\n\\n # apply filters accross columns\\n for i in range(0, ncol):\\n LL[:, i] = lfilter(LPF, LowPass_rows[:, i], LPF_center)\\n LH[:, i] = lfilter(HPF, LowPass_rows[:, i], HPF_center)\\n HL[:, i] = lfilter(LPF, HighPass_rows[:, i], LPF_center)\\n HH[:, i] = lfilter(HPF, HighPass_rows[:, i], HPF_center)\\n\\n # down sample columns and quantize\\n for i in range(0, len(filtered_image)):\\n filtered_image[i] = filtered_image[i][::2, :]\\n filtered_image[i] = np.round(\\n filtered_image[i]/quantization_Array[i]).astype(int)\\n\\n return filtered_image\",\n \"def A_weight(signal, fs):\\n\\n b, a = A_weighting(fs)\\n return lfilter(b, a, signal)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.744177","0.7354153","0.7298044","0.72915983","0.72183937","0.72033155","0.7202647","0.70877373","0.7069501","0.70666546","0.702754","0.7013197","0.70112276","0.7000103","0.69962335","0.69581854","0.69211996","0.66302556","0.6578073","0.65766674","0.6520236","0.6517953","0.6426987","0.63905966","0.6370572","0.6349561","0.6345935","0.63318497","0.6302448","0.62304085","0.61933076","0.6191057","0.61774874","0.61233693","0.6119173","0.6089817","0.60682666","0.60093546","0.59500396","0.59102553","0.5887067","0.58708155","0.58649886","0.58623946","0.58614594","0.58614594","0.58447975","0.5842456","0.5819834","0.57890433","0.5783222","0.5771117","0.5769979","0.5732166","0.5721338","0.57176363","0.56785184","0.5659254","0.564926","0.56474537","0.56345785","0.5616027","0.56122375","0.55874634","0.55700207","0.5569645","0.5558971","0.55225885","0.552194","0.551874","0.54812104","0.5471789","0.5456812","0.5436439","0.5426267","0.5425943","0.54197514","0.5411662","0.5410328","0.5401451","0.5393738","0.53895384","0.53784513","0.53586596","0.53574514","0.5340269","0.5335187","0.53346276","0.5331133","0.53065974","0.530067","0.5291008","0.5261541","0.5248678","0.52422494","0.5232199","0.52258235","0.521808","0.5214903","0.52074784"],"string":"[\n \"0.744177\",\n \"0.7354153\",\n \"0.7298044\",\n \"0.72915983\",\n \"0.72183937\",\n \"0.72033155\",\n \"0.7202647\",\n \"0.70877373\",\n \"0.7069501\",\n \"0.70666546\",\n \"0.702754\",\n \"0.7013197\",\n \"0.70112276\",\n \"0.7000103\",\n \"0.69962335\",\n \"0.69581854\",\n \"0.69211996\",\n \"0.66302556\",\n \"0.6578073\",\n \"0.65766674\",\n \"0.6520236\",\n \"0.6517953\",\n \"0.6426987\",\n \"0.63905966\",\n \"0.6370572\",\n \"0.6349561\",\n \"0.6345935\",\n \"0.63318497\",\n \"0.6302448\",\n \"0.62304085\",\n \"0.61933076\",\n \"0.6191057\",\n \"0.61774874\",\n \"0.61233693\",\n \"0.6119173\",\n \"0.6089817\",\n \"0.60682666\",\n \"0.60093546\",\n \"0.59500396\",\n \"0.59102553\",\n \"0.5887067\",\n \"0.58708155\",\n \"0.58649886\",\n \"0.58623946\",\n \"0.58614594\",\n \"0.58614594\",\n \"0.58447975\",\n \"0.5842456\",\n \"0.5819834\",\n \"0.57890433\",\n \"0.5783222\",\n \"0.5771117\",\n \"0.5769979\",\n \"0.5732166\",\n \"0.5721338\",\n \"0.57176363\",\n \"0.56785184\",\n \"0.5659254\",\n \"0.564926\",\n \"0.56474537\",\n \"0.56345785\",\n \"0.5616027\",\n \"0.56122375\",\n \"0.55874634\",\n \"0.55700207\",\n \"0.5569645\",\n \"0.5558971\",\n \"0.55225885\",\n \"0.552194\",\n \"0.551874\",\n \"0.54812104\",\n \"0.5471789\",\n \"0.5456812\",\n \"0.5436439\",\n \"0.5426267\",\n \"0.5425943\",\n \"0.54197514\",\n \"0.5411662\",\n \"0.5410328\",\n \"0.5401451\",\n \"0.5393738\",\n \"0.53895384\",\n \"0.53784513\",\n \"0.53586596\",\n \"0.53574514\",\n \"0.5340269\",\n \"0.5335187\",\n \"0.53346276\",\n \"0.5331133\",\n \"0.53065974\",\n \"0.530067\",\n \"0.5291008\",\n \"0.5261541\",\n \"0.5248678\",\n \"0.52422494\",\n \"0.5232199\",\n \"0.52258235\",\n \"0.521808\",\n \"0.5214903\",\n \"0.52074784\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6737992"},"document_rank":{"kind":"string","value":"17"}}},{"rowIdx":84593,"cells":{"query":{"kind":"string","value":"Apply a butter bandpass filter."},"document":{"kind":"string","value":"def _butter_bandpass_filter(self, data: np.ndarray, lowcut: float, highcut: float, fs: float, order: int = 5):\n b, a = self._butter_bandpass(lowcut, highcut, fs, order=order)\n y = lfilter(b, a, data)\n return 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 butter_bandpass_filter(data, lowcut, highcut, fs, order=5, axis=0): \n omega = 0.5 * fs\n low = lowcut / omega\n high = highcut / omega\n b, a = signal.butter(order, [low, high], btype='band')\n y = signal.lfilter(b, a, data, axis=0)\n return y","def butter_filter(datalist):\n fs = 200.00\n fHigh = 50.00\n fLow = 5.00\n N=4\n [b,a]=sg.butter(N,[fLow/fs, fHigh/fs], btype='band')\n global filtered\n #IIR filter\n return sg.filtfilt(b,a,datalist)","def butter_bandpass_filter(data, lowcut, highcut, fs, order=1):\n b, a = butter_bandpass(lowcut, highcut, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def butterworth_bandpass_filter( values, lowFreq, highFreq, sampleFreq, order=5):\n nyq = 0.5 * sampleFreq\n low = lowFreq / nyq\n high = highFreq /nyq\n b,a = butter( order, [low,high], btype='band' )\n return y = lfilter(b, a, data)","def butter_bandpass_filter(data, lowcut, highcut, fs, order=2):\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n \n # butter() and lfilter() are from scipy.signal\n \n b, a = butter(order, [low, high], btype='band')\n y = lfilter(b, a, data)\n return y","def butter_filter(self, data, low_pass, high_pass, fs, order=10):\n\n nyq = fs/2\n low = low_pass/nyq\n high = high_pass/nyq\n\n b, a = signal.butter(order, [low, high], btype='band')\n filt_data = np.abs(signal.hilbert(signal.filtfilt(b, a, data, axis=1), axis=1))\n return filt_data","def butter_bandpass_filter(\n data: numpy.ndarray,\n lowcut: float,\n highcut: float,\n samplerate: float,\n order: int = 2,\n):\n nyq = 0.5 * samplerate\n lowf = lowcut / nyq\n highf = highcut / nyq\n # generic names for coefficients in filters\n # pylint: disable=invalid-name\n a, b = butter(order, [lowf, highf], btype=\"band\")\n if len(data) < BUTTER_MIN_LENGTH:\n return None\n return filtfilt(a, b, data)","def butterworth_filter(signal, Fs, highpassfreq=None, lowpassfreq=None, order=4, filtfunc='filtfilt'):\n Fn = Fs / 2.\n \n # set the function for filtering\n if filtfunc is 'lfilter':\n ffunc = spsig.lfilter\n elif filtfunc is 'filtfilt':\n ffunc = spsig.filtfilt\n else:\n raise ValueError(\"filtfunc must to be either 'filtfilt' or 'lfilter'\")\n \n # set parameters\n if lowpassfreq and highpassfreq:\n if highpassfreq < lowpassfreq:\n Wn = (highpassfreq / Fn, lowpassfreq / Fn)\n btype = 'bandpass'\n else:\n Wn = (lowpassfreq / Fn, highpassfreq / Fn)\n btype = 'bandstop'\n elif lowpassfreq:\n Wn = lowpassfreq / Fn\n btype = 'lowpass'\n elif highpassfreq:\n Wn = highpassfreq / Fn\n btype = 'highpass'\n else:\n raise ValueError(\"Specify highpassfreq and/or lowpathfreq\")\n \n # filter design\n b, a = spsig.butter(order, Wn, btype=btype)\n \n return ffunc(b, a, signal)","def _butter_bandpass(lowcut: float, highcut: float, fs: float, order: int = 5) -> tuple:\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n b, a = butter(order, [low, high], btype=\"band\")\n return b, a","def butterworth_bandpass(lowcut, highcut, fs, order=5):\n nyq = 0.5 * fs # nyquist sampling rate\n low = lowcut / nyq # normalize frequency\n high = highcut / nyq # normalize frequency\n b, a = butter(order, [low, high], btype='band')\n return b, a","def Butterworth_Filter(x,order,Low_High,Wn):\r\n\r\n\r\n # Create an order butterworth filter:\r\n\r\n b, a = signal.butter(order,Wn,Low_High);\r\n\r\n # Apply the filter to x. Use lfilter_zi to choose the initial condition of the filter:\r\n\r\n zi = signal.lfilter_zi(b, a);\r\n z, _ = signal.lfilter(b, a, x, zi=zi*x[0]);\r\n\r\n # Apply the filter again, to have a result filtered at an order the same as filtfilt:\r\n\r\n z2, _ = signal.lfilter(b, a, z, zi=zi*z[0])\r\n\r\n # Use filtfilt to apply the filter:\r\n\r\n y = signal.filtfilt(b, a, x);\r\n\r\n return y;","def butter_bandstop_filter(data, lowcut, highcut, fs, order):\n\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n\n i, u = sg.butter(order, (low, high), btype='bandstop')\n y = sg.filtfilt(i, u, data)\n return y","def butterworth_filter(freq):\n\tf_raw = 1/(0.00000002*100*33)\n\tb = np.array([[-32092,15750],[-31238,14895]])*2.0**(-14)\n\tomega = 2*np.pi*freq/f_raw\n\te1, e2 = np.exp(-1j*omega), np.exp(-2j*omega)\n\ttmp = (1+2*e1+e2)**2/(1+b[0,0]*e1+b[0,1]*e2)/(1+b[1,0]*e1+b[1,1]*e2)\n\treturn tmp * (1+sum(b[0]))*(1+sum(b[1]))/16","def butterworth(dx, order, cutoff, /, btype='low'):\n # Initial stuff\n # * Need to run *forward and backward* to prevent time-shifting.\n # * The 'analog' means units of cutoffs are rad/s.\n # * Unlike Lanczos filter, the *length* of this should be\n # determined always as function of timestep, because really high\n # order filters can get pretty wonky.\n # * Cutoff is point at which gain reduces to 1/sqrt(2) of the\n # initial frequency. If doing bandpass, can\n # N = (width/dx)//1 # convert to timestep units\n # N = (N//2)*2 + 1 # odd numbered\n N = order # or order\n analog = False # lfilter seems to need digital\n if analog:\n cutoff = 2 * np.pi / (cutoff / dx) # from wavelengths to rad/steps\n else:\n cutoff = 1.0 / cutoff # to Hz, or cycles/unit\n cutoff = cutoff * (2 * dx) # to cycles / (2 timesteps)\n if cutoff > 1:\n raise ValueError(\n 'Cuttoff frequency must be in [0, 1]. Remember you pass a cutoff '\n '*wavelength* to this function, not a frequency.'\n )\n\n # Apply filter\n print(f'Order-{order} Butterworth filter')\n b, a = signal.butter(N - 1, cutoff, btype=btype, analog=analog, output='ba')\n return b, a","def ButterworthFilter(\n self,\n name: str,\n cutoffFrequency: float,\n order: int = 2,\n operation: SymbolicConstant = NONE,\n halt: Boolean = OFF,\n limit: float = None,\n invariant: SymbolicConstant = NONE,\n ) -> ButterworthFilter:\n self.filters[name] = butterworthFilter = ButterworthFilter(\n name, cutoffFrequency, order, operation, halt, limit, invariant\n )\n return butterworthFilter","def butter_bp_coe(lowcut, highcut, fs, order=1):\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n b, a = butter(order, [low, high], btype='band')\n return b, a","def butter_highpass_filter(data, cutoff, fs, order=1):\n b, a = butter_highpass(cutoff, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def bandpass(filename,f1,f2,Q,wout=True,plot=True):\n start=time.time()\n n, data, data_dB,sr,ch=inputwav(filename)\n b, a = butter(Q,Wn=(f1/sr,f2/sr),btype='bandpass')\n data_filtered=lfilter(b,a,data,axis=0)\n print('Applying FFT...')\n if wout==True:\n print('Exporting...')\n sf.write(filename[0:len(filename)-4]+'_BP.wav',data_filtered,sr,'PCM_16')\n if plot==True:\n print('Plotting...')\n py.close()\n w, h = freqz(b,a,worN=16384)\n fig, (ax1, ax2) = py.subplots(nrows=2)\n ax1.semilogx(0.5*sr*w/np.pi,abs(h),'k-')\n ax1.set_xlabel('Frequency (Hz)')\n ax1.set_ylabel('Rel. Amplitude')\n ax1.grid()\n ax1.set_ylim(0,1.1)\n ax1.set_xlim(1,20000)\n ax2.plot(data,'k-',label='Raw data')\n ax2.plot(data_filtered,'m-',lw=1,label='Filtered data')\n ax2.set_xlim(0,10000)\n ax2.set_ylim(-1,1)\n ax2.set_ylabel('Amplitude (Norm Bits)')\n ax2.set_xlabel('Samples')\n ax2.legend(loc=2,frameon=False,ncol=2)\n py.subplots_adjust(hspace=0.35) \n print('Done!')\n end=time.time()\n elapsed=int(1000*(end-start))\n print('...............................')\n print('Completed in '+str(elapsed)+' milliseconds.')\n return data_filtered","def bandpass_filter(s, sample_rate, low_freq, high_freq, filter_order=5, rescale=False):\n #create a butterworth filter\n nyq = sample_rate / 2.0\n f = np.array([low_freq, high_freq]) / nyq\n b,a = filter_design.butter(filter_order, f, btype='bandpass')\n\n #filter the signal\n filtered_s = filtfilt(b, a, s)\n\n if rescale:\n #rescale filtered signal\n filtered_s /= filtered_s.max()\n filtered_s *= s.max()\n\n return filtered_s","def butter_filter(image, n, f0):\n [ny, nx] = image.shape\n dx = 2.0/nx\n dy = 2.0/nx\n dfx = 0.5\n dfy = 0.5\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\n FX, FY = np.meshgrid(fx, fy)\n shift = np.exp(-2*np.pi*1j*(FX+FY))\n sin_pad = np.sin(image)\n cos_pad = np.cos(image)\n ft_sin = shift * np.fft.fftshift(np.fft.fft2(sin_pad))\n ft_cos = shift * np.fft.fftshift(np.fft.fft2(cos_pad))\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\n sin_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_sin)) / shift)\n cos_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_cos)) / shift)\n phase_filt = np.arctan2(sin_filt, cos_filt)\n return phase_filt","def lowpass_butter(fs, L, order, data, axis=-1, btype='low'):\n from scipy.signal import butter, sosfiltfilt\n\n nyq = 0.5 * fs # Nyquist frequency\n low = L / nyq\n sos = butter(order, low, btype=btype, output='sos') # Coefficients for Butterworth filter\n filtered = sosfiltfilt(sos, data, axis=axis)\n\n return filtered","def apply_band_pass(ftd, freq, omega, bp_wid=1):\n # Find number of frequencies\n nf = len(freq)\n # Find index for band pass, only consider indices of positive freqs\n idx_om = hf.find_nearest_index(freq[0:nf//2], omega)\n # Filter out frequencies left of band pass\n ftd[:,0:idx_om-1-bp_wid] = 0.0\n # Filter out frequencies left of omega\n ftd[:,idx_om+1+bp_wid:-1] = 0.0\n # Correct for lost amplitude\n ftd[:,idx_om-bp_wid:idx_om+bp_wid] = ftd[:,idx_om-bp_wid:idx_om+bp_wid] * 2.0\n return ftd","def butterworth_filter(dft4img, stopband2=10, order=3, showdft=False):\n h, w = dft4img.shape[0], dft4img.shape[1]\n P = h / 2\n Q = w / 2\n dst = np.zeros((h, w, 3), np.float64)\n for i in range(h):\n for j in range(w):\n r2 = float((i - P) ** 2 + (j - Q) ** 2)\n if r2 == 0:\n r2 = 1.0\n dst[i, j] = 1 / (1 + (r2 / stopband2) ** order)\n dst = np.float64(dst)\n if showdft:\n cv2.imshow(\"butterworth\", cv2.magnitude(dst[:, :, 0], dst[:, :, 1]))\n return dst","def _butter_pass(cutoff, fs, order=5, btype='high'):\r\n nyq = 0.5*fs\r\n normal_cutoff = cutoff/nyq\r\n# print \"normalized cutoff: \", normal_cutoff\r\n if normal_cutoff >= 1.:\r\n normal_cutoff = 1.\r\n b, a = signal.butter(order, normal_cutoff, btype=btype, analog=False)\r\n return b, a","def make_butter_sp(self, wn, order):\n nyquist = self.s_freq/2\n wn_arr=np.asarray(wn)\n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\n \n self.sp_sos = butter(order, wn_arr, btype='bandpass', output='sos')\n print(f\"Zero phase butterworth filter successfully created: order = {order}x{order} bandpass = {wn}\")","def _signal_filter_butterworth(signal, sampling_rate=1000, lowcut=None, highcut=None, order=2):\n if lowcut is not None and highcut is not None:\n sos = scipy.signal.butter(order, [lowcut, highcut], btype=\"bandpass\", output='sos', fs=sampling_rate)\n elif lowcut is not None:\n sos = scipy.signal.butter(order, [lowcut], btype=\"highpass\", output='sos', fs=sampling_rate)\n elif highcut is not None:\n sos = scipy.signal.butter(order, [highcut], btype=\"lowpass\", output='sos', fs=sampling_rate)\n\n filtered = scipy.signal.sosfiltfilt(sos, signal)\n return filtered","def butterworthsmoothing(df, column_names: list = None, Wn = 0.015):\n\n if column_names is None:\n return df\n else:\n # First, design the Buterworth filter\n N = 2 # Filter order\n Wn = Wn # Cutoff frequency\n B, A = signal.butter(N, Wn, output='ba')\n for i in column_names:\n df[i] = signal.filtfilt(B, A, df[i])\n df.dropna(axis=0, how='any', inplace=True)\n return df","def make_butter_so(self, wn, order):\n \n nyquist = self.s_freq/2\n wn_arr = np.asarray(wn)\n \n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\n \n self.so_sos = butter(order, wn_arr, btype='bandpass', output='sos')\n print(f\"Zero phase butterworth filter successfully created: order = {order}x{order}, bandpass = {wn}\")","def butter_lowpass_filter(data, cutoff, fs, order=1):\n b, a = butter_lowpass(cutoff, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def bandpass_filterbank(bands, fs=1.0, order=8, output=\"sos\"):\n\n filters = []\n nyquist = fs / 2.0\n\n for band in bands:\n # remove bands above nyquist frequency\n if band[0] >= nyquist:\n raise ValueError(\"Bands should be below Nyquist frequency\")\n\n # Truncate the highest band to Nyquist frequency\n norm_band = np.minimum(0.99, np.array(band) / nyquist)\n\n # Compute coefficients\n coeffs = butter(order / 2, norm_band, \"bandpass\", output=output)\n filters.append(coeffs)\n\n return filters","def compute(self):\n Y = self.data[1]\n # Create an order 3 lowpass butterworth filter\n b, a = signal.butter(3, 0.05)\n # Apply the filter to Y. Use lfilter_zi to choose the initial condition of the filter\n zi = signal.lfilter_zi(b, a)\n z, _ = signal.lfilter(b, a, Y, zi=zi * Y[0])\n # Apply the filter again, to have a result filtered at an order the same as filtfilt\n z2, _ = signal.lfilter(b, a, z, zi=zi * z[0])\n # Use filtfilt to apply the filter\n self.data[2] = signal.filtfilt(b, a, Y)\n self.data[3] = self.data[2] - self.data[1] - self.dataSpan * 0.3\n self.updatePlot()","def bandpassFilter (self, lowerFreq, upperFreq):\n self.bandpassLimits = (lowerFreq, upperFreq)\n # stuff to do","def butter_lowpass_filter(data: np.ndarray, cutoff: float, fs: float, order: int) -> np.ndarray:\n nyq = 0.5 * fs\n normal_cutoff = cutoff / nyq\n # Get the filter coefficients\n b, a = signal.butter(order, normal_cutoff, btype='low', analog=False)\n y = signal.filtfilt(b, a, data)\n return y","def bpfilter(\n data: numpy.ndarray, short_min: float = 2, long_min: float = 12\n) -> Optional[numpy.ndarray]:\n return butter_bandpass_filter(\n data, 1 / (long_min * 60), 1 / (short_min * 60), 1 / DATA_RATE\n )","def butter_lowpass_filter(self, data: np.ndarray, lowcut: float, fs: float, order: int = 4) -> np.ndarray:\n b, a = self._butter_lowpass(lowcut, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def butter_filter_unwrapped(image, n, f0, pad = False):\n if pad == True:\n res = [2**kji for kji in range(15)]\n N_int_x = image.shape[1]\n N_int_y = image.shape[0]\n nx_pad = np.where(res > np.tile(N_int_x, len(res)))\n nx_pad = res[nx_pad[0][0]]\n ny_pad = np.where(res > np.tile(N_int_y, len(res)))\n ny_pad = res[ny_pad[0][0]]\n dif_x = (nx_pad - N_int_x)/2\n dif_y = (ny_pad - N_int_y)/2\n orig_shape = image.shape\n image = np.lib.pad(image, ((dif_y, dif_y), (dif_x, dif_x)), 'reflect')\n \n [ny, nx] = image.shape\n dx = 2.0/nx\n dy = 2.0/ny\n dfx = 0.5\n dfy = 0.5\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\n FX, FY = np.meshgrid(fx, fy)\n shift = np.exp(-2*np.pi*1j*(FX+FY))\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\n ft_img = shift * np.fft.fftshift(np.fft.fft2(image))\n \n buttered = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_img))/ shift)\n if pad == True:\n assert(buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x].shape == orig_shape)\n return buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x]\n else:\n assert(buttered.shape == image.shape)\n return buttered","def filt_bp(sig: np.ndarray, Ss: int, Cfs0: int, Cfs1: None,\n order=5) -> np.ndarray:\n nyq = 0.5 * Ss\n normal_cutoff1 = Cfs0 / nyq\n normal_cutoff2 = Cfs1 / nyq\n b, a = butter(order, (normal_cutoff1, normal_cutoff2),\n btype='band',\n analog=False)\n return lfilter(b, a, sig)","def _butter_lowpass(lowcut, fs, order=4) -> tuple:\n nyq = 0.5 * fs\n low = lowcut / nyq\n b, a = butter(order, [low], btype=\"low\")\n return b, a","def filters(array, sample_frequency):\n strain = TimeSeries(array, sample_rate=int(sample_frequency))\n white_data = strain.whiten(fftlength=4, fduration=4)\n bp_data = white_data.bandpass(50, 250)\n return bp_data.value","def bessel_wave(freq, alpha, beta):\n return FMFilter(SineWave(freq), SineWave(alpha), beta)","def _get_fir_filter(passband, fs, order=183, weights=[5.75, 1., 5.75], mask=[0, 1, 0]):\n # return remez(order, passband, mask, weights, Hz=fs), 1.\n return remez(order, passband, mask, Hz=fs), 1.","def butter_bp(n, wlo, whi):\n zeros = []\n poles = _butter_analog_poles(n)\n k = 1\n fs = 2\n\n warpedlo = 2 * fs * mp.tan(mp.pi * wlo / fs)\n warpedhi = 2 * fs * mp.tan(mp.pi * whi / fs)\n bw = warpedhi - warpedlo\n wo = mp.sqrt(warpedlo * warpedhi)\n z, p, k = _zpklp2bp(zeros, poles, k, wo=wo, bw=bw)\n z, p, k = _zpkbilinear(z, p, k, fs=fs)\n return z, p, k","def apply_filter(self, image):\n pass","def bandpass_filter(data, lowcut, highcut, fs=2000, numtaps=255):\n nyq = fs / 2\n\n # design filter\n fe1 = lowcut / nyq\n fe2 = highcut / nyq\n b = firwin(numtaps, (fe1, fe2), pass_zero=False)\n\n filtered = lfilter(b, 1, data)\n\n return filtered","def design_filter(interpolation, decimation, fractional_bw):\n\n if fractional_bw >= 0.5 or fractional_bw <= 0:\n raise ValueError('Invalid fractional bandwidth, must be in (0, 0.5)')\n\n if decimation < 1 or interpolation < 1:\n raise ValueError('Invalid interpolation or decimation rate. Must be a non-zero positive integer.')\n\n beta = 7.0\n halfband = 0.5\n rate = float(interpolation)/float(decimation)\n if(rate >= 1.0):\n trans_width = halfband - fractional_bw\n mid_transition_band = halfband - trans_width/2.0\n else:\n trans_width = rate*(halfband - fractional_bw)\n mid_transition_band = rate*halfband - trans_width/2.0\n\n taps = filter.firdes.low_pass(interpolation, # gain\n interpolation, # Fs\n mid_transition_band, # trans mid point\n trans_width, # transition width\n filter.firdes.WIN_KAISER,\n beta) # beta\n\n return taps","def estimate_bandpass(data):\n \n est = filter(data, params.st_bp_window_f, axis=0)\n est = filter(est, params.st_bp_window_t, axis=1)\n \n return est","def bandpass_filter_raw_plot(data, fs, f1, f2):\n b, a = sp.butter(N=2, Wn=np.array([f1, f2]) / fs * 2, btype='bandpass') # build a bandpass butterworth filter of order 4, with cut-off frequencies 1 and 45\n w, h = sp.freqz(b, a) # compute the frequency response of the filter\n f = w / np.pi * fs / 2\n plt.figure()\n plt.plot(f, 10 * np.log10(abs(h)))\n plt.xlabel('frequency (Hz)')\n plt.ylabel('Magnitude (dB)')\n plt.title('frequency response of butterworth bandpass [1, 45]Hz')\n plt.grid()\n\n data1 = sp.filtfilt(b, a, data)\n return data1","def bandpass_filter_audio(audio, f_low=400, f_high=450):\n filtered_audio = core.sinc_filter(audio, f_low, window_size=256, high_pass=True)\n filtered_audio = core.sinc_filter(filtered_audio, f_high, window_size=256, high_pass=False)\n return tf.squeeze(filtered_audio)","def fastbias(self, fo, fbDac, data, slow):\n if fbDac not in [0, 1]:\n raise RuntimeError('fbDac must be 0 or 1')\n if slow not in [0, 1]:\n raise RuntimeError('slow must be 0 or 1')\n a = {0: 0x100000, 1: 0x200000}[fo]\n b = (data & 0xffff) << 3\n c = fbDac << 19\n d = slow << 2\n self.append(a + b + c + d)\n return self","def iirfilter(x, N=4, pass_freq=0.7 / 12.):\n b, a = signal.butter(N, pass_freq, \"low\", analog=False)\n return signal.filtfilt(b, a, x)","def __band_filter(data: dict, lowFreq: Union[int, float], highFreq: Union[int, float], timestep: int=0,\n samplingFreq: int=240, order: int=5, eegSensor: int=0, filterType: str='bandpass',\n lengthOfTestSeconds: Union[int, float]=32, example: int=0) -> dict:\n #Test\n # Filter.__band_filter_test(data=data, low=lowFreq, high=highFreq, samplingFreq=samplingFreq, order=order,\n # eegSensor=eegSensor, filterType=filterType, lengthOfTestSeconds=lengthOfTestSeconds)\n #Code\n nyq = 0.5 * samplingFreq\n low = lowFreq / nyq\n high = highFreq / nyq\n b, a = signal.butter(order, [low, high], btype=filterType)\n y = signal.lfilter(b, a, data['Signal'])\n ##Graph - This belongs somewhere else probably.\n # t = np.linspace(0, len(data), len(data), endpoint=False)\n # plt.plot(t, y, label='Sensor #' + str(eegSensor) + ' (' + str(lowFreq) + '-' + str(highFreq) + ') Hz')\n # plt.grid(True)\n # plt.axis('tight')\n # plt.xticks(range(10), range(lengthOfTestSeconds)) ##32 seconds per test?\n # plt.xlabel(\"Time in Seconds\")\n # plt.legend(loc='upper left')\n # plt.show()\n output = {}\n timestep = []\n for index, eegChannel in enumerate(y[0]):#the extra [0] is becuase signal.lfilter() puts it in a 1D array. Grrr\n timestep.append(eegChannel)\n output['Signal'] = timestep\n Visualization.channelGraph(y[0][0])\n return output #output is 2D 64xTimeSamples","def butterworth(path_to_data, dtype, n_channels, data_order,\n low_frequency, high_factor, order, sampling_frequency,\n max_memory, output_path, output_dtype, standarize=False,\n output_filename='filtered.bin', if_file_exists='skip',\n processes='max'):\n processes = multiprocess.cpu_count() if processes == 'max' else processes\n\n # init batch processor\n bp = BatchProcessor(path_to_data, dtype, n_channels, data_order,\n max_memory, buffer_size=200)\n\n if standarize:\n bp_ = BatchProcessor(path_to_data, dtype, n_channels, data_order,\n max_memory, buffer_size=0)\n\n filtering = partial(_butterworth, low_frequency=low_frequency,\n high_factor=high_factor,\n order=order,\n sampling_frequency=sampling_frequency)\n\n # if standarize, estimate sd from first batch and use\n # _butterworth_scale function, pass filtering to estimate sd from the\n # filtered data\n sd = standard_deviation(bp_, sampling_frequency,\n preprocess_fn=filtering)\n fn = partial(_butterworth_scale, denominator=sd)\n # add name to the partial object, since it is not added...\n fn.__name__ = _butterworth_scale.__name__\n else:\n # otherwise use _butterworth function\n fn = _butterworth\n\n _output_path = os.path.join(output_path, output_filename)\n\n (path,\n params) = bp.multi_channel_apply(fn, mode='disk',\n cleanup_function=fix_indexes,\n output_path=_output_path,\n if_file_exists=if_file_exists,\n cast_dtype=output_dtype,\n low_frequency=low_frequency,\n high_factor=high_factor,\n order=order,\n sampling_frequency=sampling_frequency,\n processes=processes)\n\n return path, params","def band_pass_eeg(eeg, freq_range, order=4):\n return ButterworthFilter(eeg, freq_range, filt_type='pass', order=order).filter()","def butter_hpf(highcut, fs, order):\n nyq = 0.5 * fs\n high = highcut / nyq\n b, a = signal.butter(order, high, btype='highpass')\n w, h = signal.freqz(b, a, worN=1000)\n# plt.figure()\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\n return b, a","def filtroBilateral(frame):\n fb = cv2.bilateralFilter(frame, 0, 32, 2)\n return fb","def butter_lpf(fc, fs, order):\n nyq = 0.5 * fs\n high = fc / nyq\n b, a = signal.butter(order, high, btype='lowpass', analog=False)\n w, h = signal.freqz(b, a, worN=1000)\n# plt.figure()\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\n return b, a","def make_butter_spso(self, spso_wn_pass, spso_wn_stop, spso_order):\n nyquist = self.s_freq/2\n wn_pass_arr = np.asarray(spso_wn_pass)\n wn_stop_arr = np.asarray(spso_wn_stop)\n \n # must remake filter for each pt bc of differences in s_freq\n if np.any(wn_pass_arr <=0) or np.any(wn_pass_arr >=1):\n wn_pass_arr = wn_pass_arr/nyquist \n \n if np.any(wn_stop_arr <=0) or np.any(wn_stop_arr >=1):\n wn_stop_arr = wn_stop_arr/nyquist\n\n self.spso_sos_bandstop = butter(spso_order, wn_stop_arr, btype='bandstop', output='sos')\n self.spso_sos_bandpass = butter(spso_order, wn_pass_arr, btype='bandpass', output='sos')\n print(f\"Zero phase butterworth filter successfully created: order = {spso_order}x{spso_order} bandpass = {spso_wn_pass}\")\n print(f\"Zero phase butterworth filter successfully created: order = {spso_order}x{spso_order} bandstop = {spso_wn_stop}\")","def PassFilter(xdata, ydata, fs, order=5, btype='high', freq = None, cutoff=None):\r\n if freq == None:\r\n freq = _frequency_estimation(xdata, ydata)\r\n if cutoff==None:\r\n cutoff = _cutoff(xdata, ydata, btype, fs, ff = freq)\r\n b, a = _butter_pass(cutoff, fs, order=order, btype=btype)\r\n y = signal.filtfilt(b, a, ydata, padtype='even')\r\n return y","def get_butterworth_high_pass_filter(shape, cutoff, order):\n \n # Hint: May be one can use the low pass filter function to get a high pass mask\n print(\"butterworth_high_pass_filter = \")\n print(\"cutoff: \",cutoff)\n print(\"order: \",order)\n filter = get_butterworth_low_pass_filter(shape, cutoff, order)\n\n for i in range(shape[0]):\n for j in range(shape[1]):\n filter[i, j] = 1 - filter[i, j]\n\n # return filter\n return process_filter(image, filter)","def __init__(self, init=None, filter_table=None, filter_name=None,\n wavecent=None, fwhm=None, **kwargs):\n super(MiriBandPassFilter, self).__init__(init=init,\n filter_table=filter_table,\n filter_name=filter_name,\n filter_type='BandPass',\n **kwargs)\n\n # Define the central wavelength and fwhm, if defined.\n if wavecent:\n self.meta.instrument.filter_wavecent = wavecent\n if fwhm:\n self.meta.instrument.filter_fwhm = fwhm","def A_weighting(fs):\n b, a = A_weighting_analog()\n\n # Use the bilinear transformation to get the digital filter.\n return bilinear(b, a, fs)","def filter(sig, sampling_rate, lc, hc, order=2):\n\n # Construct butterworth band-pass filter\n b1, a1 = butter(order, [2.0 * lc / sampling_rate,\n 2.0 * hc / sampling_rate], btype=\"band\")\n nchan, nsamp = sig.shape\n fsig = np.copy(sig)\n\n # Apply cosine taper then apply band-pass filter in both directions\n for ch in range(0, nchan):\n fsig[ch, :] = fsig[ch, :] - fsig[ch, 0]\n tap = cosine_taper(len(fsig[ch, :]), 0.1)\n fsig[ch, :] = fsig[ch, :] * tap\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, ::-1])[::-1]\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, :])\n\n return fsig","def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=(500, 10000)):\n if freq_cutoffs[0] <= 0:\n raise ValueError('Low frequency cutoff {} is invalid, '\n 'must be greater than zero.'\n .format(freq_cutoffs[0]))\n\n Nyquist_rate = samp_freq / 2\n if freq_cutoffs[1] >= Nyquist_rate:\n raise ValueError('High frequency cutoff {} is invalid, '\n 'must be less than Nyquist rate, {}.'\n .format(freq_cutoffs[1], Nyquist_rate))\n\n if rawsong.shape[-1] < 387:\n numtaps = 64\n elif rawsong.shape[-1] < 771:\n numtaps = 128\n elif rawsong.shape[-1] < 1539:\n numtaps = 256\n else:\n numtaps = 512\n\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\n freq_cutoffs[1] / Nyquist_rate])\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\n # window to design filter, but default for matlab's fir1\n # is actually Hamming\n # note that first parameter for scipy.signal.firwin is filter *length*\n # whereas argument to matlab's fir1 is filter *order*\n # for linear FIR, filter length is filter order + 1\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\n a = np.zeros((numtaps+1,))\n a[0] = 1 # make an \"all-zero filter\"\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\n return filtsong","def bessel_bandpass_filter(data, lowcut, highcut, fs, order=2):\n\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n\n # bessel() and lfilter() are from scipy.signal\n\n b, a = bessel(order, [low, high], btype='band')\n y = lfilter(b, a, data)\n return y","def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=None):\n\n Nyquist_rate = samp_freq / 2\n if freq_cutoffs is None:\n freq_cutoffs = [500, 10000]\n if rawsong.shape[-1] < 387:\n numtaps = 64\n elif rawsong.shape[-1] < 771:\n numtaps = 128\n elif rawsong.shape[-1] < 1539:\n numtaps = 256\n else:\n numtaps = 512\n\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\n freq_cutoffs[1] / Nyquist_rate])\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\n # window to design filter, but default for matlab's fir1\n # is actually Hamming\n # note that first parameter for scipy.signal.firwin is filter *length*\n # whereas argument to matlab's fir1 is filter *order*\n # for linear FIR, filter length is filter order + 1\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\n a = np.zeros((numtaps+1,))\n a[0] = 1 # make an \"all-zero filter\"\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\n return filtsong","def band_filter(self, bands) -> 'ImageCollection':\n\n process_id = 'filter_bands'\n args = {\n 'imagery': self.graph,\n 'bands': bands\n }\n return self.graph_add_process(process_id, args)","def get_butterworth_high_pass_filter(self, shape, cutoff, order):\r\n\r\n #Hint: May be one can use the low pass filter function to get a high pass mask\r\n # 1 - butter low pass\r\n mask = 1 - self.get_butterworth_low_pass_filter(shape, cutoff, order)\r\n\r\n return mask","def get_butterworth_low_pass_filter(shape, cutoff, order):\n \n \n print(\"butterworth_low_pass_filter = \")\n print(\"cutoff: \",cutoff)\n print(\"order: \",order)\n filter = np.zeros(shape)\n for i in range(shape[0]):\n for j in range(shape[1]):\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\n filter[i, j] = 1 / (1 + (D / cutoff) ** (2 * order))\n # print(\"\\n\\n\\n\\n\")\n # print(filter)\n # return filter\n return process_filter(image, filter)","def filt(self,cutoff_dt, btype='low',order=3,axis=-1):\r\n \r\n if self.isequal==False and self.VERBOSE:\r\n print 'Warning - time series is unequally spaced. Use self.interp to interpolate onto an equal grid'\r\n \r\n if not btype == 'band':\r\n Wn = self.dt/cutoff_dt\r\n else:\r\n Wn = [self.dt/co for co in cutoff_dt]\r\n \r\n (b, a) = signal.butter(order, Wn, btype=btype, analog=0, output='ba')\r\n \r\n return signal.filtfilt(b, a, self.y, axis=axis)","def blurd_image(img,order=5,direction='horizontal',strength=0.25,speed='slow'):\n\tny,nx = np.shape(img)\n\tif speed == 'slow':\n\t\tb, a = scig.butter(order, strength)\n\t\tif direction == 'horizontal':\n\t\t\tfor i in range(ny):\n\t\t\t\timg[i,:] = scig.filtfilt(b, a, img[i,:])\n\t\telif direction == 'vertical':\n\t\t\tfor i in range(nx):\n\t\t\t\timg[:,i] = scig.filtfilt(b, a, img[:,i])\n\t\treturn img\n\telif speed=='fast':\n\t\tK = np.ones((int(strength),1))\n\t\tK = K/np.sum(K)\n\t\tif direction=='vertical':\n\t\t\timg=scig.convolve2d(img,K,mode='same')\n\t\telif direction=='horizontal':\n\t\t\timg=scig.convolve2d(img,K.transpose(),mode='same')\n\t\treturn img","def apply_filter(data, filter_bank, sfreq): \n if data.ndim == 1:\n filtered = np.zeros((1, filter_bank.shape[0], sfreq))\n for filt in range(filter_bank.shape[0]):\n filtered[0, filt, :] = np.convolve(filter_bank[filt,:], data)[int(sfreq-sfreq/2):int(sfreq+sfreq/2)]\n elif data.ndim == 2:\n filtered = np.zeros((data.shape[0], filter_bank.shape[0], sfreq))\n for chan in range(data.shape[0]):\n for filt in range(filter_bank.shape[0]):\n filtered[chan, filt, :] = np.convolve(filter_bank[filt, :], \\\n data[chan,:])[int(sfreq-sfreq/2):int(sfreq+sfreq/2)] # mode=\"full\"\n return filtered","def bias(self, bias_value):\n if bias_value == 0:\n return\n new_channel = sppasChannel()\n new_channel.set_sampwidth(self._sampwidth)\n new_channel.set_framerate(self._framerate)\n a = sppasAudioFrames(self._channel.get_frames(self._channel.get_nframes()), self._channel.get_sampwidth(), 1)\n new_channel.set_frames(a.bias(bias_value))\n\n self._channel = new_channel","def butter2d_lp(shape, f, n):\n \n rows, cols = shape \n x = np.linspace(-0.5, 0.5, cols)\n y = np.linspace(-0.5, 0.5, rows)\n radius = np.sqrt((x**2)[np.newaxis] + (y**2)[:, np.newaxis]) \n filt = 1 / (1.0 + (radius / f)**(2*n))\n \n return (filt)","def calculate_flux(self, band):\n\n if (self.wavelength[0] > band.wavelength[0] or\n self.wavelength[-1] < band.wavelength[-1]):\n\n warn('Spectrum does not cover the whole bandpass, '\n 'extrapolating...')\n dw = np.median(np.diff(self.wavelength.value))\n spec_wavelength = np.arange(\n band.wavelength.value[0],\n band.wavelength.value[-1] + dw, dw) * angstrom\n spec_flux = np.interp(spec_wavelength, self.wavelength,\n self.flux.value)\n\n else:\n spec_wavelength = self.wavelength\n spec_flux = self.flux.value\n\n i, j = spec_wavelength.searchsorted(\n Quantity([band.wavelength[0], band.wavelength[-1]]))\n wavelength = spec_wavelength[i:j]\n flux = spec_flux[i:j]\n\n dw_band = np.median(np.diff(band.wavelength))\n dw_spec = np.median(np.diff(wavelength))\n\n if dw_spec.value > dw_band.value > 20:\n\n warn('Spectrum wavelength sampling interval {0:.2f}, but bandpass'\n 'sampling interval {1:.2f}'.format(dw_spec, dw_band))\n\n # Interpolate the spectrum to the passband wavelengths:\n flux = np.interp(band.wavelength, wavelength, flux)\n band_transmission = band.transmission\n wavelength = band.wavelength\n\n else:\n # Interpolate the band transmission to the spectrum wavelengths:\n band_transmission = np.interp(\n wavelength, band.wavelength, band.transmission)\n\n # Weight by the response and wavelength, appropriate when we're\n # counting the number of photons within the band:\n flux = (np.trapz(band_transmission * flux * wavelength, wavelength) /\n np.trapz(band_transmission * wavelength, wavelength))\n flux *= erg / s / cm ** 2 / angstrom\n\n return flux","def lowpass_filter(data, Wn=0.014, N=2):\n data = np.array(data)\n data = data.astype(np.float)\n # N = 5 # Filter order\n # Wn = 0.02 # Cutoff frequency\n B, A = signal.butter(N, Wn, output='ba')\n\n # Second, apply the filter\n tempf = signal.filtfilt(B,A, data)\n # print(tempf)\n return tempf","def butterfly(self):\n\n self.log.info(\"Begin Butterfly\")\n\n dst = os.path.join(self.cfg['start_dir'], 'Butterfly', 'src')\n try:\n os.chdir(dst)\n except OSError, err:\n self.log.error(\"Butterfly: failed to change to dst dir %s\" % (dst, err))\n\n cmd = \"ant\"\n run_cmd(cmd)\n\n self.log.info(\"End Butterfly\")","def bandpass_filter(files, lowpass_freq=0.1, highpass_freq=0.01, tr=2):\n import os\n\n import nibabel as nb\n import numpy as np\n from nipype.utils.filemanip import (\n filename_to_list,\n list_to_filename,\n split_filename\n )\n\n fs = 1./tr\n\n out_files = []\n for filename in filename_to_list(files):\n path, name, ext = split_filename(filename)\n out_file = os.path.join(os.getcwd(), name + '_bandpassed' + ext)\n\n img = nb.load(filename)\n timepoints = img.shape[-1]\n F = np.zeros((timepoints))\n\n lowidx = int(timepoints / 2) + 1\n if lowpass_freq > 0:\n lowidx = np.round(float(lowpass_freq) / fs * timepoints)\n\n highidx = 0\n if highpass_freq > 0:\n highidx = np.round(float(highpass_freq) / fs * timepoints)\n F[int(highidx):int(lowidx)] = 1\n F = ((F + F[::-1]) > 0).astype(int)\n data = img.get_data()\n if np.all(F == 1):\n filtered_data = data\n else:\n filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F))\n img_out = nb.Nifti1Image(filtered_data, img.affine, img.header)\n img_out.to_filename(out_file)\n out_files.append(out_file)\n\n return list_to_filename(out_files)","def filter_low_pass(x, filt_data, cutoff, fs, order=1, rows=[0,-1]):\n\n from scipy.signal import butter, filtfilt\n import numpy as np\n import matplotlib.pyplot as plt \n\n def butter_lowpass(cutoff, fs, order=5):\n nyq = 0.5 * fs\n normal_cutoff = cutoff / nyq\n b, a = butter(order, normal_cutoff, btype='low', analog=False)\n return b, a \n\n b, a = butter_lowpass(cutoff, fs, order=order)\n \n slice_exp = filt_data[rows[0]:rows[1]]\n lp_slice_exp = filtfilt(b, a, slice_exp)\n lp = np.append(filt_data[:rows[0]],lp_slice_exp)\n lp = np.append(lp,filt_data[rows[1]:])\n\n f, ax = plt.subplots(1,1,figsize=(8,8))\n ax.plot(x,filt_data,'k',label='original data')\n ax.plot(x,lp,'r',label='filtered data')\n ax.legend(loc='best')\n\n return lp","def apply_bandpass_filter_timeseries(self, folder_name, indices, start_stop_freq, stop_stop_freq):\n (x_index, y_index) = indices\n photo_list = self.get_photo_list(folder_name)\n\n ts = self.get_pixel_timeseries(folder_name, (x_index, y_index))\n self.plot_fft_pixel_timeseries(folder_name, ts, str(x_index) + '_' + str(y_index) + 'pre_butterworth')\n n = len(ts)\n frequency = self.get_sampling_frequency(folder_name)\n d = 1.0 / frequency # 'sample spacing'\n fig, ax = plt.subplots()\n sample_freqs = np.fft.rfftfreq(n, d)\n fourier = np.fft.rfft(ts)\n print(sample_freqs)\n nyquist = frequency / 2.0\n\n start_stop_band = start_stop_freq / nyquist\n stop_stop_band = stop_stop_freq / nyquist\n\n print(start_stop_band)\n print(stop_stop_band)\n\n sos = sgnl.butter(2, Wn=[start_stop_band, stop_stop_band], btype='bandstop', output='sos')\n filtered = sgnl.sosfilt(sos, ts)\n self.plot_fft_pixel_timeseries(folder_name, filtered, str(x_index) + '_' + str(y_index) + 'post_butterworth')\n fig, ax = plt.subplots()\n indices = self.get_indices_from_filenames(folder_name)\n index_dates = dates.date2num(indices)\n ax.plot_date(index_dates, ts, xdate=True, linestyle='solid', marker='None',\n label=str(x_index) + ' , ' + str(y_index))\n ax.plot_date(index_dates, filtered, xdate=True, linestyle='solid', marker='None',\n label=str(x_index) + ' , ' + str(y_index) + ' filtered')\n\n ax.legend()\n ax.grid(b=True, which='major', color='#666666', linestyle='-')\n\n # Show the minor grid lines with very faint and almost transparent grey lines\n ax.minorticks_on()\n ax.grid(b=True, which='minor', color='#999999', linestyle='-', alpha=0.2)\n fig.set_figwidth(40)\n fig.savefig(self.parent_folder + 'analysis/timeseries_filtered_' + str(x_index) + '_' + str(y_index) + '.png')\n fig.savefig(self.parent_folder + 'analysis/timeseries_filtered_' + str(x_index) + '_' + str(y_index) + '.svg')\n fig.clf()","def blur(self, shape, dist_fr, dist_to, amount):\r\n shape.unif[42] = dist_fr # shader unif[14]\r\n shape.unif[43] = dist_to\r\n shape.unif[44] = amount\r\n shape.unif[45] = 1.0/self.ix # shader unif[15]\r\n shape.unif[46] = 1.0/self.iy\r\n shape.draw(self.shader, [self], 0.0, 0.0)","def highpass_filter(s, sample_rate, cutoff_freq, filter_order=5, rescale=False):\n #create a butterworth filter\n nyq = sample_rate / 2.0\n b,a = filter_design.butter(filter_order, cutoff_freq / nyq, btype='high')\n\n #filter the signal\n filtered_s = filtfilt(b, a, s)\n\n if rescale:\n #rescale filtered signal\n filtered_s /= filtered_s.max()\n filtered_s *= s.max()\n\n return filtered_s","def bandpass(self, gulp=512, **kwargs):\n bpass_ar = np.zeros(self.header.nchans, dtype=\"float64\")\n num_samples = 0\n for nsamps, _ii, data in self.readPlan(gulp, **kwargs):\n lib.getBpass(data, bpass_ar, self.header.nchans, nsamps)\n num_samples += nsamps\n bpass_ar /= num_samples\n return TimeSeries(bpass_ar, self.header.newHeader({\"nchans\": 1}))","def _make_filters(self):\n\n \"\"\"\n filter_bank = bandpass_filterbank(\n self.bands, fs=self.fs, order=order, output=output\n )\n\n return [lambda sig: sosfiltfilt(bpf, sig) for bpf in filter_bank]\n \"\"\"\n\n # This seems to work only for Octave bands out of the box\n centers = self.centers\n n = len(self.centers)\n\n new_bands = [[centers[0] / 2, centers[1]]]\n for i in range(1, n - 1):\n new_bands.append([centers[i - 1], centers[i + 1]])\n new_bands.append([centers[-2], self.fs / 2])\n\n n_freq = self.n_fft // 2 + 1\n freq_resp = np.zeros((n_freq, n))\n freq = np.arange(n_freq) / self.n_fft * self.fs\n\n for b, (band, center) in enumerate(zip(new_bands, centers)):\n lo = np.logical_and(band[0] <= freq, freq < center)\n freq_resp[lo, b] = 0.5 * (1 + np.cos(2 * np.pi * freq[lo] / center))\n\n if b != n - 1:\n hi = np.logical_and(center <= freq, freq < band[1])\n freq_resp[hi, b] = 0.5 * (1 - np.cos(2 * np.pi * freq[hi] / band[1]))\n else:\n hi = center <= freq\n freq_resp[hi, b] = 1.0\n\n filters = np.fft.fftshift(\n np.fft.irfft(freq_resp, n=self.n_fft, axis=0),\n axes=[0],\n )\n\n # remove the first sample to make them odd-length symmetric filters\n self.filters = filters[1:, :]","def apply_1d_filter(bfilter, timage):\n image_length = len(timage)\n ovrlay = int(bfilter.shape[0] / 2)\n tmp_array = np.zeros(image_length + 2 * ovrlay)\n tmp_array[ovrlay:-ovrlay] = timage\n res_array = np.zeros(image_length )\n for i in np.arange(image_length) + ovrlay:\n local_matrix = tmp_array[i - ovrlay:i + ovrlay + 1]\n res_array[i - ovrlay] = sum(local_matrix * bfilter)\n return res_array","def _butterworth_scale(ts, low_frequency, high_factor, order,\n sampling_frequency, denominator):\n filtered = _butterworth(ts, low_frequency, high_factor, order,\n sampling_frequency)\n\n return np.divide(filtered, denominator)","def compress(self, samples):\n rms = np.sqrt(np.dot(samples, samples) / window)\n power = self.power * (1.0 - self.smooth) + rms * self.smooth\n self.power = power\n if power <= 1e-40:\n samples *= 0\n return\n db_in = 10.0 * math.log10(power)\n if db_in <= self.limit:\n samples *= 0\n return\n db_out = self.cf(db_in)\n db_gain = db_out - db_in + self.postgain\n gain = 10**(0.1 * db_gain)\n samples *= gain","def c_test_weighting_bias(self, function):\r\n return general_weighting_bias(self.verbosity, function)","def c_test_weighting_bias(self, function):\r\n return general_weighting_bias(self.verbosity, function)","def c_test_weighting_bias(self, function):\r\n return general_weighting_bias(self.verbosity, function)","def blur_fourier(im, kernel_size):\n kernel = gaus_kernel_calc(kernel_size)\n\n zeros = np.zeros(im.shape)\n x_mid = np.math.floor(im.shape[1] / 2)\n y_mid = np.math.floor(im.shape[0] / 2)\n distance = np.math.floor(kernel_size / 2)\n zeros[x_mid - distance: x_mid + distance + 1, y_mid - distance: y_mid + distance + 1] = kernel\n\n fourier_kernel = DFT2(np.fft.ifftshift(zeros))\n fourier_img = DFT2(im)\n fourier_blured = fourier_kernel * fourier_img\n\n return IDFT2(fourier_blured).real.astype(np.float64)","def execute_filter(self, b, a, buffer, pre_buffer):\n timing = time.time()\n pre_buffer = np.concatenate([pre_buffer, buffer])\n\n # Execute the filter onto the buffer. \n output = signal.lfilter(b, a, pre_buffer)\n\n # Only return the output based on the current buffer (drop pre_buffer)\n return output[len(output)/2:]","def apply_filter(a_slice_prev, W, b):\n product = np.multiply(a_slice_prev, W)\n z = np.sum(product) + np.float(b)\n return z","def filter_pupil(self, hp=0.01, lp=10.0):\r\n self.logger.info('Band-pass filtering of pupil signals, hp = %2.3f, lp = %2.3f'%(hp, lp))\r\n\r\n self.lp_filt_pupil = _butter_lowpass(data=self.interpolated_pupil.astype('float64'), highcut=lp, fs=self.sample_rate, order=3)\r\n self.hp_filt_pupil = _butter_highpass(data=self.interpolated_pupil.astype('float64'), lowcut=hp, fs=self.sample_rate, order=3)\r\n self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\r\n self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\r\n\r\n # import mne\r\n # from mne import filter\r\n # self.lp_filt_pupil = mne.filter.low_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=lp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\r\n # self.hp_filt_pupil = mne.filter.high_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=hp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\r\n # self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\r\n # self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\r","def dwt(image_array, quantization_Array):\n # Create the high pass and low pass filters\n # both filters are non-causal\n # symmetric\n # [-2, -1, 0, 1, 2]\n LPF = [-0.125, 0.25, 0.75, 0.25, -0.125]\n LPF_center = 2\n\n # [ -2,-1, 0]\n HPF = [-0.5, 1, -0.5]\n HPF_center = 2\n\n nrow, ncol = image_array.shape\n\n # create an array that will contain the 4 different subbands of the image\n LL = np.zeros((nrow, ncol))\n LH = np.zeros((nrow, ncol))\n HL = np.zeros((nrow, ncol))\n HH = np.zeros((nrow, ncol))\n filtered_image = [LL, LH, HL, HH]\n\n # filtering the rows using a low pass and high pass filters\n LowPass_rows = np.zeros((nrow, ncol))\n HighPass_rows = np.zeros((nrow, ncol))\n for i in range(0, nrow):\n LowPass_rows[i, :] = lfilter(LPF, image_array[i, :], LPF_center)\n HighPass_rows[i, :] = lfilter(HPF, image_array[i, :], HPF_center)\n\n # down sample rows.\n # which means we will have half the number of columns\n for i in range(0, len(filtered_image)):\n filtered_image[i] = filtered_image[i][:, ::2]\n\n # apply filters accross columns\n for i in range(0, ncol):\n LL[:, i] = lfilter(LPF, LowPass_rows[:, i], LPF_center)\n LH[:, i] = lfilter(HPF, LowPass_rows[:, i], HPF_center)\n HL[:, i] = lfilter(LPF, HighPass_rows[:, i], LPF_center)\n HH[:, i] = lfilter(HPF, HighPass_rows[:, i], HPF_center)\n\n # down sample columns and quantize\n for i in range(0, len(filtered_image)):\n filtered_image[i] = filtered_image[i][::2, :]\n filtered_image[i] = np.round(\n filtered_image[i]/quantization_Array[i]).astype(int)\n\n return filtered_image","def bandpass_cnt(data, low_cut_hz, high_cut_hz, fs, filt_order=3, axis=0):\n if (low_cut_hz == 0 or low_cut_hz is None) and (\n high_cut_hz == None or high_cut_hz == fs / 2.0):\n log.info(\"Not doing any bandpass, since low 0 or None and \"\n \"high None or nyquist frequency\")\n return data.copy()\n if low_cut_hz == 0 or low_cut_hz == None:\n log.info(\"Using lowpass filter since low cut hz is 0 or None\")\n return lowpass_cnt(data, high_cut_hz, fs, filt_order=filt_order, axis=axis)\n if high_cut_hz == None or high_cut_hz == (fs / 2.0):\n log.info(\n \"Using highpass filter since high cut hz is None or nyquist freq\")\n return highpass_cnt(data, low_cut_hz, fs, filt_order=filt_order, axis=axis)\n\n nyq_freq = 0.5 * fs\n low = low_cut_hz / nyq_freq\n high = high_cut_hz / nyq_freq\n b, a = scipy.signal.butter(filt_order, [low, high], btype='bandpass')\n assert filter_is_stable(a), \"Filter should be stable...\"\n data_bandpassed = scipy.signal.lfilter(b, a, data, axis=axis)\n return data_bandpassed","def A_weight(signal, fs):\n\n b, a = A_weighting(fs)\n return lfilter(b, a, signal)","def applyGapFilter(image, bandNames):\n filtered = applyForwardNoDataFilter(image, bandNames)\n filtered = applyBackwardNoDataFilter(filtered, bandNames)\n return filtered","def test_filt_abmag(self):\n sun = Sun.from_builtin('E490_2014')\n V = get_bandpass('johnson v')\n wave, fluxd = sun.filt(V, unit=u.ABmag)\n assert np.isclose(fluxd.value, -26.77, atol=0.007)","def fbank(signal,samplerate=16000,winlen=0.025,winstep=0.01,\n nfilt=40,nfft=512,lowfreq=0,highfreq=None,dither=1.0,remove_dc_offset=True, preemph=0.97, \n wintype='hamming'):\n highfreq= highfreq or samplerate/2\n frames,raw_frames = sigproc.framesig(signal, winlen*samplerate, winstep*samplerate, dither, preemph, remove_dc_offset, wintype)\n pspec = sigproc.powspec(frames,nfft) # nearly the same until this part\n energy = numpy.sum(raw_frames**2,1) # this stores the raw energy in each frame\n energy = numpy.where(energy == 0,numpy.finfo(float).eps,energy) # if energy is zero, we get problems with log\n\n fb = get_filterbanks(nfilt,nfft,samplerate,lowfreq,highfreq)\n feat = numpy.dot(pspec,fb.T) # compute the filterbank energies\n feat = numpy.where(feat == 0,numpy.finfo(float).eps,feat) # if feat is zero, we get problems with log\n\n return feat,energy","def broadbandfilter(self):\n _, = self.broadbandfilters\n return _"],"string":"[\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=5, axis=0): \\n omega = 0.5 * fs\\n low = lowcut / omega\\n high = highcut / omega\\n b, a = signal.butter(order, [low, high], btype='band')\\n y = signal.lfilter(b, a, data, axis=0)\\n return y\",\n \"def butter_filter(datalist):\\n fs = 200.00\\n fHigh = 50.00\\n fLow = 5.00\\n N=4\\n [b,a]=sg.butter(N,[fLow/fs, fHigh/fs], btype='band')\\n global filtered\\n #IIR filter\\n return sg.filtfilt(b,a,datalist)\",\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=1):\\n b, a = butter_bandpass(lowcut, highcut, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def butterworth_bandpass_filter( values, lowFreq, highFreq, sampleFreq, order=5):\\n nyq = 0.5 * sampleFreq\\n low = lowFreq / nyq\\n high = highFreq /nyq\\n b,a = butter( order, [low,high], btype='band' )\\n return y = lfilter(b, a, data)\",\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=2):\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n \\n # butter() and lfilter() are from scipy.signal\\n \\n b, a = butter(order, [low, high], btype='band')\\n y = lfilter(b, a, data)\\n return y\",\n \"def butter_filter(self, data, low_pass, high_pass, fs, order=10):\\n\\n nyq = fs/2\\n low = low_pass/nyq\\n high = high_pass/nyq\\n\\n b, a = signal.butter(order, [low, high], btype='band')\\n filt_data = np.abs(signal.hilbert(signal.filtfilt(b, a, data, axis=1), axis=1))\\n return filt_data\",\n \"def butter_bandpass_filter(\\n data: numpy.ndarray,\\n lowcut: float,\\n highcut: float,\\n samplerate: float,\\n order: int = 2,\\n):\\n nyq = 0.5 * samplerate\\n lowf = lowcut / nyq\\n highf = highcut / nyq\\n # generic names for coefficients in filters\\n # pylint: disable=invalid-name\\n a, b = butter(order, [lowf, highf], btype=\\\"band\\\")\\n if len(data) < BUTTER_MIN_LENGTH:\\n return None\\n return filtfilt(a, b, data)\",\n \"def butterworth_filter(signal, Fs, highpassfreq=None, lowpassfreq=None, order=4, filtfunc='filtfilt'):\\n Fn = Fs / 2.\\n \\n # set the function for filtering\\n if filtfunc is 'lfilter':\\n ffunc = spsig.lfilter\\n elif filtfunc is 'filtfilt':\\n ffunc = spsig.filtfilt\\n else:\\n raise ValueError(\\\"filtfunc must to be either 'filtfilt' or 'lfilter'\\\")\\n \\n # set parameters\\n if lowpassfreq and highpassfreq:\\n if highpassfreq < lowpassfreq:\\n Wn = (highpassfreq / Fn, lowpassfreq / Fn)\\n btype = 'bandpass'\\n else:\\n Wn = (lowpassfreq / Fn, highpassfreq / Fn)\\n btype = 'bandstop'\\n elif lowpassfreq:\\n Wn = lowpassfreq / Fn\\n btype = 'lowpass'\\n elif highpassfreq:\\n Wn = highpassfreq / Fn\\n btype = 'highpass'\\n else:\\n raise ValueError(\\\"Specify highpassfreq and/or lowpathfreq\\\")\\n \\n # filter design\\n b, a = spsig.butter(order, Wn, btype=btype)\\n \\n return ffunc(b, a, signal)\",\n \"def _butter_bandpass(lowcut: float, highcut: float, fs: float, order: int = 5) -> tuple:\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n b, a = butter(order, [low, high], btype=\\\"band\\\")\\n return b, a\",\n \"def butterworth_bandpass(lowcut, highcut, fs, order=5):\\n nyq = 0.5 * fs # nyquist sampling rate\\n low = lowcut / nyq # normalize frequency\\n high = highcut / nyq # normalize frequency\\n b, a = butter(order, [low, high], btype='band')\\n return b, a\",\n \"def Butterworth_Filter(x,order,Low_High,Wn):\\r\\n\\r\\n\\r\\n # Create an order butterworth filter:\\r\\n\\r\\n b, a = signal.butter(order,Wn,Low_High);\\r\\n\\r\\n # Apply the filter to x. Use lfilter_zi to choose the initial condition of the filter:\\r\\n\\r\\n zi = signal.lfilter_zi(b, a);\\r\\n z, _ = signal.lfilter(b, a, x, zi=zi*x[0]);\\r\\n\\r\\n # Apply the filter again, to have a result filtered at an order the same as filtfilt:\\r\\n\\r\\n z2, _ = signal.lfilter(b, a, z, zi=zi*z[0])\\r\\n\\r\\n # Use filtfilt to apply the filter:\\r\\n\\r\\n y = signal.filtfilt(b, a, x);\\r\\n\\r\\n return y;\",\n \"def butter_bandstop_filter(data, lowcut, highcut, fs, order):\\n\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n\\n i, u = sg.butter(order, (low, high), btype='bandstop')\\n y = sg.filtfilt(i, u, data)\\n return y\",\n \"def butterworth_filter(freq):\\n\\tf_raw = 1/(0.00000002*100*33)\\n\\tb = np.array([[-32092,15750],[-31238,14895]])*2.0**(-14)\\n\\tomega = 2*np.pi*freq/f_raw\\n\\te1, e2 = np.exp(-1j*omega), np.exp(-2j*omega)\\n\\ttmp = (1+2*e1+e2)**2/(1+b[0,0]*e1+b[0,1]*e2)/(1+b[1,0]*e1+b[1,1]*e2)\\n\\treturn tmp * (1+sum(b[0]))*(1+sum(b[1]))/16\",\n \"def butterworth(dx, order, cutoff, /, btype='low'):\\n # Initial stuff\\n # * Need to run *forward and backward* to prevent time-shifting.\\n # * The 'analog' means units of cutoffs are rad/s.\\n # * Unlike Lanczos filter, the *length* of this should be\\n # determined always as function of timestep, because really high\\n # order filters can get pretty wonky.\\n # * Cutoff is point at which gain reduces to 1/sqrt(2) of the\\n # initial frequency. If doing bandpass, can\\n # N = (width/dx)//1 # convert to timestep units\\n # N = (N//2)*2 + 1 # odd numbered\\n N = order # or order\\n analog = False # lfilter seems to need digital\\n if analog:\\n cutoff = 2 * np.pi / (cutoff / dx) # from wavelengths to rad/steps\\n else:\\n cutoff = 1.0 / cutoff # to Hz, or cycles/unit\\n cutoff = cutoff * (2 * dx) # to cycles / (2 timesteps)\\n if cutoff > 1:\\n raise ValueError(\\n 'Cuttoff frequency must be in [0, 1]. Remember you pass a cutoff '\\n '*wavelength* to this function, not a frequency.'\\n )\\n\\n # Apply filter\\n print(f'Order-{order} Butterworth filter')\\n b, a = signal.butter(N - 1, cutoff, btype=btype, analog=analog, output='ba')\\n return b, a\",\n \"def ButterworthFilter(\\n self,\\n name: str,\\n cutoffFrequency: float,\\n order: int = 2,\\n operation: SymbolicConstant = NONE,\\n halt: Boolean = OFF,\\n limit: float = None,\\n invariant: SymbolicConstant = NONE,\\n ) -> ButterworthFilter:\\n self.filters[name] = butterworthFilter = ButterworthFilter(\\n name, cutoffFrequency, order, operation, halt, limit, invariant\\n )\\n return butterworthFilter\",\n \"def butter_bp_coe(lowcut, highcut, fs, order=1):\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n b, a = butter(order, [low, high], btype='band')\\n return b, a\",\n \"def butter_highpass_filter(data, cutoff, fs, order=1):\\n b, a = butter_highpass(cutoff, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def bandpass(filename,f1,f2,Q,wout=True,plot=True):\\n start=time.time()\\n n, data, data_dB,sr,ch=inputwav(filename)\\n b, a = butter(Q,Wn=(f1/sr,f2/sr),btype='bandpass')\\n data_filtered=lfilter(b,a,data,axis=0)\\n print('Applying FFT...')\\n if wout==True:\\n print('Exporting...')\\n sf.write(filename[0:len(filename)-4]+'_BP.wav',data_filtered,sr,'PCM_16')\\n if plot==True:\\n print('Plotting...')\\n py.close()\\n w, h = freqz(b,a,worN=16384)\\n fig, (ax1, ax2) = py.subplots(nrows=2)\\n ax1.semilogx(0.5*sr*w/np.pi,abs(h),'k-')\\n ax1.set_xlabel('Frequency (Hz)')\\n ax1.set_ylabel('Rel. Amplitude')\\n ax1.grid()\\n ax1.set_ylim(0,1.1)\\n ax1.set_xlim(1,20000)\\n ax2.plot(data,'k-',label='Raw data')\\n ax2.plot(data_filtered,'m-',lw=1,label='Filtered data')\\n ax2.set_xlim(0,10000)\\n ax2.set_ylim(-1,1)\\n ax2.set_ylabel('Amplitude (Norm Bits)')\\n ax2.set_xlabel('Samples')\\n ax2.legend(loc=2,frameon=False,ncol=2)\\n py.subplots_adjust(hspace=0.35) \\n print('Done!')\\n end=time.time()\\n elapsed=int(1000*(end-start))\\n print('...............................')\\n print('Completed in '+str(elapsed)+' milliseconds.')\\n return data_filtered\",\n \"def bandpass_filter(s, sample_rate, low_freq, high_freq, filter_order=5, rescale=False):\\n #create a butterworth filter\\n nyq = sample_rate / 2.0\\n f = np.array([low_freq, high_freq]) / nyq\\n b,a = filter_design.butter(filter_order, f, btype='bandpass')\\n\\n #filter the signal\\n filtered_s = filtfilt(b, a, s)\\n\\n if rescale:\\n #rescale filtered signal\\n filtered_s /= filtered_s.max()\\n filtered_s *= s.max()\\n\\n return filtered_s\",\n \"def butter_filter(image, n, f0):\\n [ny, nx] = image.shape\\n dx = 2.0/nx\\n dy = 2.0/nx\\n dfx = 0.5\\n dfy = 0.5\\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\\n FX, FY = np.meshgrid(fx, fy)\\n shift = np.exp(-2*np.pi*1j*(FX+FY))\\n sin_pad = np.sin(image)\\n cos_pad = np.cos(image)\\n ft_sin = shift * np.fft.fftshift(np.fft.fft2(sin_pad))\\n ft_cos = shift * np.fft.fftshift(np.fft.fft2(cos_pad))\\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\\n sin_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_sin)) / shift)\\n cos_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_cos)) / shift)\\n phase_filt = np.arctan2(sin_filt, cos_filt)\\n return phase_filt\",\n \"def lowpass_butter(fs, L, order, data, axis=-1, btype='low'):\\n from scipy.signal import butter, sosfiltfilt\\n\\n nyq = 0.5 * fs # Nyquist frequency\\n low = L / nyq\\n sos = butter(order, low, btype=btype, output='sos') # Coefficients for Butterworth filter\\n filtered = sosfiltfilt(sos, data, axis=axis)\\n\\n return filtered\",\n \"def apply_band_pass(ftd, freq, omega, bp_wid=1):\\n # Find number of frequencies\\n nf = len(freq)\\n # Find index for band pass, only consider indices of positive freqs\\n idx_om = hf.find_nearest_index(freq[0:nf//2], omega)\\n # Filter out frequencies left of band pass\\n ftd[:,0:idx_om-1-bp_wid] = 0.0\\n # Filter out frequencies left of omega\\n ftd[:,idx_om+1+bp_wid:-1] = 0.0\\n # Correct for lost amplitude\\n ftd[:,idx_om-bp_wid:idx_om+bp_wid] = ftd[:,idx_om-bp_wid:idx_om+bp_wid] * 2.0\\n return ftd\",\n \"def butterworth_filter(dft4img, stopband2=10, order=3, showdft=False):\\n h, w = dft4img.shape[0], dft4img.shape[1]\\n P = h / 2\\n Q = w / 2\\n dst = np.zeros((h, w, 3), np.float64)\\n for i in range(h):\\n for j in range(w):\\n r2 = float((i - P) ** 2 + (j - Q) ** 2)\\n if r2 == 0:\\n r2 = 1.0\\n dst[i, j] = 1 / (1 + (r2 / stopband2) ** order)\\n dst = np.float64(dst)\\n if showdft:\\n cv2.imshow(\\\"butterworth\\\", cv2.magnitude(dst[:, :, 0], dst[:, :, 1]))\\n return dst\",\n \"def _butter_pass(cutoff, fs, order=5, btype='high'):\\r\\n nyq = 0.5*fs\\r\\n normal_cutoff = cutoff/nyq\\r\\n# print \\\"normalized cutoff: \\\", normal_cutoff\\r\\n if normal_cutoff >= 1.:\\r\\n normal_cutoff = 1.\\r\\n b, a = signal.butter(order, normal_cutoff, btype=btype, analog=False)\\r\\n return b, a\",\n \"def make_butter_sp(self, wn, order):\\n nyquist = self.s_freq/2\\n wn_arr=np.asarray(wn)\\n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\\n \\n self.sp_sos = butter(order, wn_arr, btype='bandpass', output='sos')\\n print(f\\\"Zero phase butterworth filter successfully created: order = {order}x{order} bandpass = {wn}\\\")\",\n \"def _signal_filter_butterworth(signal, sampling_rate=1000, lowcut=None, highcut=None, order=2):\\n if lowcut is not None and highcut is not None:\\n sos = scipy.signal.butter(order, [lowcut, highcut], btype=\\\"bandpass\\\", output='sos', fs=sampling_rate)\\n elif lowcut is not None:\\n sos = scipy.signal.butter(order, [lowcut], btype=\\\"highpass\\\", output='sos', fs=sampling_rate)\\n elif highcut is not None:\\n sos = scipy.signal.butter(order, [highcut], btype=\\\"lowpass\\\", output='sos', fs=sampling_rate)\\n\\n filtered = scipy.signal.sosfiltfilt(sos, signal)\\n return filtered\",\n \"def butterworthsmoothing(df, column_names: list = None, Wn = 0.015):\\n\\n if column_names is None:\\n return df\\n else:\\n # First, design the Buterworth filter\\n N = 2 # Filter order\\n Wn = Wn # Cutoff frequency\\n B, A = signal.butter(N, Wn, output='ba')\\n for i in column_names:\\n df[i] = signal.filtfilt(B, A, df[i])\\n df.dropna(axis=0, how='any', inplace=True)\\n return df\",\n \"def make_butter_so(self, wn, order):\\n \\n nyquist = self.s_freq/2\\n wn_arr = np.asarray(wn)\\n \\n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\\n \\n self.so_sos = butter(order, wn_arr, btype='bandpass', output='sos')\\n print(f\\\"Zero phase butterworth filter successfully created: order = {order}x{order}, bandpass = {wn}\\\")\",\n \"def butter_lowpass_filter(data, cutoff, fs, order=1):\\n b, a = butter_lowpass(cutoff, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def bandpass_filterbank(bands, fs=1.0, order=8, output=\\\"sos\\\"):\\n\\n filters = []\\n nyquist = fs / 2.0\\n\\n for band in bands:\\n # remove bands above nyquist frequency\\n if band[0] >= nyquist:\\n raise ValueError(\\\"Bands should be below Nyquist frequency\\\")\\n\\n # Truncate the highest band to Nyquist frequency\\n norm_band = np.minimum(0.99, np.array(band) / nyquist)\\n\\n # Compute coefficients\\n coeffs = butter(order / 2, norm_band, \\\"bandpass\\\", output=output)\\n filters.append(coeffs)\\n\\n return filters\",\n \"def compute(self):\\n Y = self.data[1]\\n # Create an order 3 lowpass butterworth filter\\n b, a = signal.butter(3, 0.05)\\n # Apply the filter to Y. Use lfilter_zi to choose the initial condition of the filter\\n zi = signal.lfilter_zi(b, a)\\n z, _ = signal.lfilter(b, a, Y, zi=zi * Y[0])\\n # Apply the filter again, to have a result filtered at an order the same as filtfilt\\n z2, _ = signal.lfilter(b, a, z, zi=zi * z[0])\\n # Use filtfilt to apply the filter\\n self.data[2] = signal.filtfilt(b, a, Y)\\n self.data[3] = self.data[2] - self.data[1] - self.dataSpan * 0.3\\n self.updatePlot()\",\n \"def bandpassFilter (self, lowerFreq, upperFreq):\\n self.bandpassLimits = (lowerFreq, upperFreq)\\n # stuff to do\",\n \"def butter_lowpass_filter(data: np.ndarray, cutoff: float, fs: float, order: int) -> np.ndarray:\\n nyq = 0.5 * fs\\n normal_cutoff = cutoff / nyq\\n # Get the filter coefficients\\n b, a = signal.butter(order, normal_cutoff, btype='low', analog=False)\\n y = signal.filtfilt(b, a, data)\\n return y\",\n \"def bpfilter(\\n data: numpy.ndarray, short_min: float = 2, long_min: float = 12\\n) -> Optional[numpy.ndarray]:\\n return butter_bandpass_filter(\\n data, 1 / (long_min * 60), 1 / (short_min * 60), 1 / DATA_RATE\\n )\",\n \"def butter_lowpass_filter(self, data: np.ndarray, lowcut: float, fs: float, order: int = 4) -> np.ndarray:\\n b, a = self._butter_lowpass(lowcut, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def butter_filter_unwrapped(image, n, f0, pad = False):\\n if pad == True:\\n res = [2**kji for kji in range(15)]\\n N_int_x = image.shape[1]\\n N_int_y = image.shape[0]\\n nx_pad = np.where(res > np.tile(N_int_x, len(res)))\\n nx_pad = res[nx_pad[0][0]]\\n ny_pad = np.where(res > np.tile(N_int_y, len(res)))\\n ny_pad = res[ny_pad[0][0]]\\n dif_x = (nx_pad - N_int_x)/2\\n dif_y = (ny_pad - N_int_y)/2\\n orig_shape = image.shape\\n image = np.lib.pad(image, ((dif_y, dif_y), (dif_x, dif_x)), 'reflect')\\n \\n [ny, nx] = image.shape\\n dx = 2.0/nx\\n dy = 2.0/ny\\n dfx = 0.5\\n dfy = 0.5\\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\\n FX, FY = np.meshgrid(fx, fy)\\n shift = np.exp(-2*np.pi*1j*(FX+FY))\\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\\n ft_img = shift * np.fft.fftshift(np.fft.fft2(image))\\n \\n buttered = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_img))/ shift)\\n if pad == True:\\n assert(buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x].shape == orig_shape)\\n return buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x]\\n else:\\n assert(buttered.shape == image.shape)\\n return buttered\",\n \"def filt_bp(sig: np.ndarray, Ss: int, Cfs0: int, Cfs1: None,\\n order=5) -> np.ndarray:\\n nyq = 0.5 * Ss\\n normal_cutoff1 = Cfs0 / nyq\\n normal_cutoff2 = Cfs1 / nyq\\n b, a = butter(order, (normal_cutoff1, normal_cutoff2),\\n btype='band',\\n analog=False)\\n return lfilter(b, a, sig)\",\n \"def _butter_lowpass(lowcut, fs, order=4) -> tuple:\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n b, a = butter(order, [low], btype=\\\"low\\\")\\n return b, a\",\n \"def filters(array, sample_frequency):\\n strain = TimeSeries(array, sample_rate=int(sample_frequency))\\n white_data = strain.whiten(fftlength=4, fduration=4)\\n bp_data = white_data.bandpass(50, 250)\\n return bp_data.value\",\n \"def bessel_wave(freq, alpha, beta):\\n return FMFilter(SineWave(freq), SineWave(alpha), beta)\",\n \"def _get_fir_filter(passband, fs, order=183, weights=[5.75, 1., 5.75], mask=[0, 1, 0]):\\n # return remez(order, passband, mask, weights, Hz=fs), 1.\\n return remez(order, passband, mask, Hz=fs), 1.\",\n \"def butter_bp(n, wlo, whi):\\n zeros = []\\n poles = _butter_analog_poles(n)\\n k = 1\\n fs = 2\\n\\n warpedlo = 2 * fs * mp.tan(mp.pi * wlo / fs)\\n warpedhi = 2 * fs * mp.tan(mp.pi * whi / fs)\\n bw = warpedhi - warpedlo\\n wo = mp.sqrt(warpedlo * warpedhi)\\n z, p, k = _zpklp2bp(zeros, poles, k, wo=wo, bw=bw)\\n z, p, k = _zpkbilinear(z, p, k, fs=fs)\\n return z, p, k\",\n \"def apply_filter(self, image):\\n pass\",\n \"def bandpass_filter(data, lowcut, highcut, fs=2000, numtaps=255):\\n nyq = fs / 2\\n\\n # design filter\\n fe1 = lowcut / nyq\\n fe2 = highcut / nyq\\n b = firwin(numtaps, (fe1, fe2), pass_zero=False)\\n\\n filtered = lfilter(b, 1, data)\\n\\n return filtered\",\n \"def design_filter(interpolation, decimation, fractional_bw):\\n\\n if fractional_bw >= 0.5 or fractional_bw <= 0:\\n raise ValueError('Invalid fractional bandwidth, must be in (0, 0.5)')\\n\\n if decimation < 1 or interpolation < 1:\\n raise ValueError('Invalid interpolation or decimation rate. Must be a non-zero positive integer.')\\n\\n beta = 7.0\\n halfband = 0.5\\n rate = float(interpolation)/float(decimation)\\n if(rate >= 1.0):\\n trans_width = halfband - fractional_bw\\n mid_transition_band = halfband - trans_width/2.0\\n else:\\n trans_width = rate*(halfband - fractional_bw)\\n mid_transition_band = rate*halfband - trans_width/2.0\\n\\n taps = filter.firdes.low_pass(interpolation, # gain\\n interpolation, # Fs\\n mid_transition_band, # trans mid point\\n trans_width, # transition width\\n filter.firdes.WIN_KAISER,\\n beta) # beta\\n\\n return taps\",\n \"def estimate_bandpass(data):\\n \\n est = filter(data, params.st_bp_window_f, axis=0)\\n est = filter(est, params.st_bp_window_t, axis=1)\\n \\n return est\",\n \"def bandpass_filter_raw_plot(data, fs, f1, f2):\\n b, a = sp.butter(N=2, Wn=np.array([f1, f2]) / fs * 2, btype='bandpass') # build a bandpass butterworth filter of order 4, with cut-off frequencies 1 and 45\\n w, h = sp.freqz(b, a) # compute the frequency response of the filter\\n f = w / np.pi * fs / 2\\n plt.figure()\\n plt.plot(f, 10 * np.log10(abs(h)))\\n plt.xlabel('frequency (Hz)')\\n plt.ylabel('Magnitude (dB)')\\n plt.title('frequency response of butterworth bandpass [1, 45]Hz')\\n plt.grid()\\n\\n data1 = sp.filtfilt(b, a, data)\\n return data1\",\n \"def bandpass_filter_audio(audio, f_low=400, f_high=450):\\n filtered_audio = core.sinc_filter(audio, f_low, window_size=256, high_pass=True)\\n filtered_audio = core.sinc_filter(filtered_audio, f_high, window_size=256, high_pass=False)\\n return tf.squeeze(filtered_audio)\",\n \"def fastbias(self, fo, fbDac, data, slow):\\n if fbDac not in [0, 1]:\\n raise RuntimeError('fbDac must be 0 or 1')\\n if slow not in [0, 1]:\\n raise RuntimeError('slow must be 0 or 1')\\n a = {0: 0x100000, 1: 0x200000}[fo]\\n b = (data & 0xffff) << 3\\n c = fbDac << 19\\n d = slow << 2\\n self.append(a + b + c + d)\\n return self\",\n \"def iirfilter(x, N=4, pass_freq=0.7 / 12.):\\n b, a = signal.butter(N, pass_freq, \\\"low\\\", analog=False)\\n return signal.filtfilt(b, a, x)\",\n \"def __band_filter(data: dict, lowFreq: Union[int, float], highFreq: Union[int, float], timestep: int=0,\\n samplingFreq: int=240, order: int=5, eegSensor: int=0, filterType: str='bandpass',\\n lengthOfTestSeconds: Union[int, float]=32, example: int=0) -> dict:\\n #Test\\n # Filter.__band_filter_test(data=data, low=lowFreq, high=highFreq, samplingFreq=samplingFreq, order=order,\\n # eegSensor=eegSensor, filterType=filterType, lengthOfTestSeconds=lengthOfTestSeconds)\\n #Code\\n nyq = 0.5 * samplingFreq\\n low = lowFreq / nyq\\n high = highFreq / nyq\\n b, a = signal.butter(order, [low, high], btype=filterType)\\n y = signal.lfilter(b, a, data['Signal'])\\n ##Graph - This belongs somewhere else probably.\\n # t = np.linspace(0, len(data), len(data), endpoint=False)\\n # plt.plot(t, y, label='Sensor #' + str(eegSensor) + ' (' + str(lowFreq) + '-' + str(highFreq) + ') Hz')\\n # plt.grid(True)\\n # plt.axis('tight')\\n # plt.xticks(range(10), range(lengthOfTestSeconds)) ##32 seconds per test?\\n # plt.xlabel(\\\"Time in Seconds\\\")\\n # plt.legend(loc='upper left')\\n # plt.show()\\n output = {}\\n timestep = []\\n for index, eegChannel in enumerate(y[0]):#the extra [0] is becuase signal.lfilter() puts it in a 1D array. Grrr\\n timestep.append(eegChannel)\\n output['Signal'] = timestep\\n Visualization.channelGraph(y[0][0])\\n return output #output is 2D 64xTimeSamples\",\n \"def butterworth(path_to_data, dtype, n_channels, data_order,\\n low_frequency, high_factor, order, sampling_frequency,\\n max_memory, output_path, output_dtype, standarize=False,\\n output_filename='filtered.bin', if_file_exists='skip',\\n processes='max'):\\n processes = multiprocess.cpu_count() if processes == 'max' else processes\\n\\n # init batch processor\\n bp = BatchProcessor(path_to_data, dtype, n_channels, data_order,\\n max_memory, buffer_size=200)\\n\\n if standarize:\\n bp_ = BatchProcessor(path_to_data, dtype, n_channels, data_order,\\n max_memory, buffer_size=0)\\n\\n filtering = partial(_butterworth, low_frequency=low_frequency,\\n high_factor=high_factor,\\n order=order,\\n sampling_frequency=sampling_frequency)\\n\\n # if standarize, estimate sd from first batch and use\\n # _butterworth_scale function, pass filtering to estimate sd from the\\n # filtered data\\n sd = standard_deviation(bp_, sampling_frequency,\\n preprocess_fn=filtering)\\n fn = partial(_butterworth_scale, denominator=sd)\\n # add name to the partial object, since it is not added...\\n fn.__name__ = _butterworth_scale.__name__\\n else:\\n # otherwise use _butterworth function\\n fn = _butterworth\\n\\n _output_path = os.path.join(output_path, output_filename)\\n\\n (path,\\n params) = bp.multi_channel_apply(fn, mode='disk',\\n cleanup_function=fix_indexes,\\n output_path=_output_path,\\n if_file_exists=if_file_exists,\\n cast_dtype=output_dtype,\\n low_frequency=low_frequency,\\n high_factor=high_factor,\\n order=order,\\n sampling_frequency=sampling_frequency,\\n processes=processes)\\n\\n return path, params\",\n \"def band_pass_eeg(eeg, freq_range, order=4):\\n return ButterworthFilter(eeg, freq_range, filt_type='pass', order=order).filter()\",\n \"def butter_hpf(highcut, fs, order):\\n nyq = 0.5 * fs\\n high = highcut / nyq\\n b, a = signal.butter(order, high, btype='highpass')\\n w, h = signal.freqz(b, a, worN=1000)\\n# plt.figure()\\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\\n return b, a\",\n \"def filtroBilateral(frame):\\n fb = cv2.bilateralFilter(frame, 0, 32, 2)\\n return fb\",\n \"def butter_lpf(fc, fs, order):\\n nyq = 0.5 * fs\\n high = fc / nyq\\n b, a = signal.butter(order, high, btype='lowpass', analog=False)\\n w, h = signal.freqz(b, a, worN=1000)\\n# plt.figure()\\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\\n return b, a\",\n \"def make_butter_spso(self, spso_wn_pass, spso_wn_stop, spso_order):\\n nyquist = self.s_freq/2\\n wn_pass_arr = np.asarray(spso_wn_pass)\\n wn_stop_arr = np.asarray(spso_wn_stop)\\n \\n # must remake filter for each pt bc of differences in s_freq\\n if np.any(wn_pass_arr <=0) or np.any(wn_pass_arr >=1):\\n wn_pass_arr = wn_pass_arr/nyquist \\n \\n if np.any(wn_stop_arr <=0) or np.any(wn_stop_arr >=1):\\n wn_stop_arr = wn_stop_arr/nyquist\\n\\n self.spso_sos_bandstop = butter(spso_order, wn_stop_arr, btype='bandstop', output='sos')\\n self.spso_sos_bandpass = butter(spso_order, wn_pass_arr, btype='bandpass', output='sos')\\n print(f\\\"Zero phase butterworth filter successfully created: order = {spso_order}x{spso_order} bandpass = {spso_wn_pass}\\\")\\n print(f\\\"Zero phase butterworth filter successfully created: order = {spso_order}x{spso_order} bandstop = {spso_wn_stop}\\\")\",\n \"def PassFilter(xdata, ydata, fs, order=5, btype='high', freq = None, cutoff=None):\\r\\n if freq == None:\\r\\n freq = _frequency_estimation(xdata, ydata)\\r\\n if cutoff==None:\\r\\n cutoff = _cutoff(xdata, ydata, btype, fs, ff = freq)\\r\\n b, a = _butter_pass(cutoff, fs, order=order, btype=btype)\\r\\n y = signal.filtfilt(b, a, ydata, padtype='even')\\r\\n return y\",\n \"def get_butterworth_high_pass_filter(shape, cutoff, order):\\n \\n # Hint: May be one can use the low pass filter function to get a high pass mask\\n print(\\\"butterworth_high_pass_filter = \\\")\\n print(\\\"cutoff: \\\",cutoff)\\n print(\\\"order: \\\",order)\\n filter = get_butterworth_low_pass_filter(shape, cutoff, order)\\n\\n for i in range(shape[0]):\\n for j in range(shape[1]):\\n filter[i, j] = 1 - filter[i, j]\\n\\n # return filter\\n return process_filter(image, filter)\",\n \"def __init__(self, init=None, filter_table=None, filter_name=None,\\n wavecent=None, fwhm=None, **kwargs):\\n super(MiriBandPassFilter, self).__init__(init=init,\\n filter_table=filter_table,\\n filter_name=filter_name,\\n filter_type='BandPass',\\n **kwargs)\\n\\n # Define the central wavelength and fwhm, if defined.\\n if wavecent:\\n self.meta.instrument.filter_wavecent = wavecent\\n if fwhm:\\n self.meta.instrument.filter_fwhm = fwhm\",\n \"def A_weighting(fs):\\n b, a = A_weighting_analog()\\n\\n # Use the bilinear transformation to get the digital filter.\\n return bilinear(b, a, fs)\",\n \"def filter(sig, sampling_rate, lc, hc, order=2):\\n\\n # Construct butterworth band-pass filter\\n b1, a1 = butter(order, [2.0 * lc / sampling_rate,\\n 2.0 * hc / sampling_rate], btype=\\\"band\\\")\\n nchan, nsamp = sig.shape\\n fsig = np.copy(sig)\\n\\n # Apply cosine taper then apply band-pass filter in both directions\\n for ch in range(0, nchan):\\n fsig[ch, :] = fsig[ch, :] - fsig[ch, 0]\\n tap = cosine_taper(len(fsig[ch, :]), 0.1)\\n fsig[ch, :] = fsig[ch, :] * tap\\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, ::-1])[::-1]\\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, :])\\n\\n return fsig\",\n \"def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=(500, 10000)):\\n if freq_cutoffs[0] <= 0:\\n raise ValueError('Low frequency cutoff {} is invalid, '\\n 'must be greater than zero.'\\n .format(freq_cutoffs[0]))\\n\\n Nyquist_rate = samp_freq / 2\\n if freq_cutoffs[1] >= Nyquist_rate:\\n raise ValueError('High frequency cutoff {} is invalid, '\\n 'must be less than Nyquist rate, {}.'\\n .format(freq_cutoffs[1], Nyquist_rate))\\n\\n if rawsong.shape[-1] < 387:\\n numtaps = 64\\n elif rawsong.shape[-1] < 771:\\n numtaps = 128\\n elif rawsong.shape[-1] < 1539:\\n numtaps = 256\\n else:\\n numtaps = 512\\n\\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\\n freq_cutoffs[1] / Nyquist_rate])\\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\\n # window to design filter, but default for matlab's fir1\\n # is actually Hamming\\n # note that first parameter for scipy.signal.firwin is filter *length*\\n # whereas argument to matlab's fir1 is filter *order*\\n # for linear FIR, filter length is filter order + 1\\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\\n a = np.zeros((numtaps+1,))\\n a[0] = 1 # make an \\\"all-zero filter\\\"\\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\\n return filtsong\",\n \"def bessel_bandpass_filter(data, lowcut, highcut, fs, order=2):\\n\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n\\n # bessel() and lfilter() are from scipy.signal\\n\\n b, a = bessel(order, [low, high], btype='band')\\n y = lfilter(b, a, data)\\n return y\",\n \"def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=None):\\n\\n Nyquist_rate = samp_freq / 2\\n if freq_cutoffs is None:\\n freq_cutoffs = [500, 10000]\\n if rawsong.shape[-1] < 387:\\n numtaps = 64\\n elif rawsong.shape[-1] < 771:\\n numtaps = 128\\n elif rawsong.shape[-1] < 1539:\\n numtaps = 256\\n else:\\n numtaps = 512\\n\\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\\n freq_cutoffs[1] / Nyquist_rate])\\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\\n # window to design filter, but default for matlab's fir1\\n # is actually Hamming\\n # note that first parameter for scipy.signal.firwin is filter *length*\\n # whereas argument to matlab's fir1 is filter *order*\\n # for linear FIR, filter length is filter order + 1\\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\\n a = np.zeros((numtaps+1,))\\n a[0] = 1 # make an \\\"all-zero filter\\\"\\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\\n return filtsong\",\n \"def band_filter(self, bands) -> 'ImageCollection':\\n\\n process_id = 'filter_bands'\\n args = {\\n 'imagery': self.graph,\\n 'bands': bands\\n }\\n return self.graph_add_process(process_id, args)\",\n \"def get_butterworth_high_pass_filter(self, shape, cutoff, order):\\r\\n\\r\\n #Hint: May be one can use the low pass filter function to get a high pass mask\\r\\n # 1 - butter low pass\\r\\n mask = 1 - self.get_butterworth_low_pass_filter(shape, cutoff, order)\\r\\n\\r\\n return mask\",\n \"def get_butterworth_low_pass_filter(shape, cutoff, order):\\n \\n \\n print(\\\"butterworth_low_pass_filter = \\\")\\n print(\\\"cutoff: \\\",cutoff)\\n print(\\\"order: \\\",order)\\n filter = np.zeros(shape)\\n for i in range(shape[0]):\\n for j in range(shape[1]):\\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\\n filter[i, j] = 1 / (1 + (D / cutoff) ** (2 * order))\\n # print(\\\"\\\\n\\\\n\\\\n\\\\n\\\")\\n # print(filter)\\n # return filter\\n return process_filter(image, filter)\",\n \"def filt(self,cutoff_dt, btype='low',order=3,axis=-1):\\r\\n \\r\\n if self.isequal==False and self.VERBOSE:\\r\\n print 'Warning - time series is unequally spaced. Use self.interp to interpolate onto an equal grid'\\r\\n \\r\\n if not btype == 'band':\\r\\n Wn = self.dt/cutoff_dt\\r\\n else:\\r\\n Wn = [self.dt/co for co in cutoff_dt]\\r\\n \\r\\n (b, a) = signal.butter(order, Wn, btype=btype, analog=0, output='ba')\\r\\n \\r\\n return signal.filtfilt(b, a, self.y, axis=axis)\",\n \"def blurd_image(img,order=5,direction='horizontal',strength=0.25,speed='slow'):\\n\\tny,nx = np.shape(img)\\n\\tif speed == 'slow':\\n\\t\\tb, a = scig.butter(order, strength)\\n\\t\\tif direction == 'horizontal':\\n\\t\\t\\tfor i in range(ny):\\n\\t\\t\\t\\timg[i,:] = scig.filtfilt(b, a, img[i,:])\\n\\t\\telif direction == 'vertical':\\n\\t\\t\\tfor i in range(nx):\\n\\t\\t\\t\\timg[:,i] = scig.filtfilt(b, a, img[:,i])\\n\\t\\treturn img\\n\\telif speed=='fast':\\n\\t\\tK = np.ones((int(strength),1))\\n\\t\\tK = K/np.sum(K)\\n\\t\\tif direction=='vertical':\\n\\t\\t\\timg=scig.convolve2d(img,K,mode='same')\\n\\t\\telif direction=='horizontal':\\n\\t\\t\\timg=scig.convolve2d(img,K.transpose(),mode='same')\\n\\t\\treturn img\",\n \"def apply_filter(data, filter_bank, sfreq): \\n if data.ndim == 1:\\n filtered = np.zeros((1, filter_bank.shape[0], sfreq))\\n for filt in range(filter_bank.shape[0]):\\n filtered[0, filt, :] = np.convolve(filter_bank[filt,:], data)[int(sfreq-sfreq/2):int(sfreq+sfreq/2)]\\n elif data.ndim == 2:\\n filtered = np.zeros((data.shape[0], filter_bank.shape[0], sfreq))\\n for chan in range(data.shape[0]):\\n for filt in range(filter_bank.shape[0]):\\n filtered[chan, filt, :] = np.convolve(filter_bank[filt, :], \\\\\\n data[chan,:])[int(sfreq-sfreq/2):int(sfreq+sfreq/2)] # mode=\\\"full\\\"\\n return filtered\",\n \"def bias(self, bias_value):\\n if bias_value == 0:\\n return\\n new_channel = sppasChannel()\\n new_channel.set_sampwidth(self._sampwidth)\\n new_channel.set_framerate(self._framerate)\\n a = sppasAudioFrames(self._channel.get_frames(self._channel.get_nframes()), self._channel.get_sampwidth(), 1)\\n new_channel.set_frames(a.bias(bias_value))\\n\\n self._channel = new_channel\",\n \"def butter2d_lp(shape, f, n):\\n \\n rows, cols = shape \\n x = np.linspace(-0.5, 0.5, cols)\\n y = np.linspace(-0.5, 0.5, rows)\\n radius = np.sqrt((x**2)[np.newaxis] + (y**2)[:, np.newaxis]) \\n filt = 1 / (1.0 + (radius / f)**(2*n))\\n \\n return (filt)\",\n \"def calculate_flux(self, band):\\n\\n if (self.wavelength[0] > band.wavelength[0] or\\n self.wavelength[-1] < band.wavelength[-1]):\\n\\n warn('Spectrum does not cover the whole bandpass, '\\n 'extrapolating...')\\n dw = np.median(np.diff(self.wavelength.value))\\n spec_wavelength = np.arange(\\n band.wavelength.value[0],\\n band.wavelength.value[-1] + dw, dw) * angstrom\\n spec_flux = np.interp(spec_wavelength, self.wavelength,\\n self.flux.value)\\n\\n else:\\n spec_wavelength = self.wavelength\\n spec_flux = self.flux.value\\n\\n i, j = spec_wavelength.searchsorted(\\n Quantity([band.wavelength[0], band.wavelength[-1]]))\\n wavelength = spec_wavelength[i:j]\\n flux = spec_flux[i:j]\\n\\n dw_band = np.median(np.diff(band.wavelength))\\n dw_spec = np.median(np.diff(wavelength))\\n\\n if dw_spec.value > dw_band.value > 20:\\n\\n warn('Spectrum wavelength sampling interval {0:.2f}, but bandpass'\\n 'sampling interval {1:.2f}'.format(dw_spec, dw_band))\\n\\n # Interpolate the spectrum to the passband wavelengths:\\n flux = np.interp(band.wavelength, wavelength, flux)\\n band_transmission = band.transmission\\n wavelength = band.wavelength\\n\\n else:\\n # Interpolate the band transmission to the spectrum wavelengths:\\n band_transmission = np.interp(\\n wavelength, band.wavelength, band.transmission)\\n\\n # Weight by the response and wavelength, appropriate when we're\\n # counting the number of photons within the band:\\n flux = (np.trapz(band_transmission * flux * wavelength, wavelength) /\\n np.trapz(band_transmission * wavelength, wavelength))\\n flux *= erg / s / cm ** 2 / angstrom\\n\\n return flux\",\n \"def lowpass_filter(data, Wn=0.014, N=2):\\n data = np.array(data)\\n data = data.astype(np.float)\\n # N = 5 # Filter order\\n # Wn = 0.02 # Cutoff frequency\\n B, A = signal.butter(N, Wn, output='ba')\\n\\n # Second, apply the filter\\n tempf = signal.filtfilt(B,A, data)\\n # print(tempf)\\n return tempf\",\n \"def butterfly(self):\\n\\n self.log.info(\\\"Begin Butterfly\\\")\\n\\n dst = os.path.join(self.cfg['start_dir'], 'Butterfly', 'src')\\n try:\\n os.chdir(dst)\\n except OSError, err:\\n self.log.error(\\\"Butterfly: failed to change to dst dir %s\\\" % (dst, err))\\n\\n cmd = \\\"ant\\\"\\n run_cmd(cmd)\\n\\n self.log.info(\\\"End Butterfly\\\")\",\n \"def bandpass_filter(files, lowpass_freq=0.1, highpass_freq=0.01, tr=2):\\n import os\\n\\n import nibabel as nb\\n import numpy as np\\n from nipype.utils.filemanip import (\\n filename_to_list,\\n list_to_filename,\\n split_filename\\n )\\n\\n fs = 1./tr\\n\\n out_files = []\\n for filename in filename_to_list(files):\\n path, name, ext = split_filename(filename)\\n out_file = os.path.join(os.getcwd(), name + '_bandpassed' + ext)\\n\\n img = nb.load(filename)\\n timepoints = img.shape[-1]\\n F = np.zeros((timepoints))\\n\\n lowidx = int(timepoints / 2) + 1\\n if lowpass_freq > 0:\\n lowidx = np.round(float(lowpass_freq) / fs * timepoints)\\n\\n highidx = 0\\n if highpass_freq > 0:\\n highidx = np.round(float(highpass_freq) / fs * timepoints)\\n F[int(highidx):int(lowidx)] = 1\\n F = ((F + F[::-1]) > 0).astype(int)\\n data = img.get_data()\\n if np.all(F == 1):\\n filtered_data = data\\n else:\\n filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F))\\n img_out = nb.Nifti1Image(filtered_data, img.affine, img.header)\\n img_out.to_filename(out_file)\\n out_files.append(out_file)\\n\\n return list_to_filename(out_files)\",\n \"def filter_low_pass(x, filt_data, cutoff, fs, order=1, rows=[0,-1]):\\n\\n from scipy.signal import butter, filtfilt\\n import numpy as np\\n import matplotlib.pyplot as plt \\n\\n def butter_lowpass(cutoff, fs, order=5):\\n nyq = 0.5 * fs\\n normal_cutoff = cutoff / nyq\\n b, a = butter(order, normal_cutoff, btype='low', analog=False)\\n return b, a \\n\\n b, a = butter_lowpass(cutoff, fs, order=order)\\n \\n slice_exp = filt_data[rows[0]:rows[1]]\\n lp_slice_exp = filtfilt(b, a, slice_exp)\\n lp = np.append(filt_data[:rows[0]],lp_slice_exp)\\n lp = np.append(lp,filt_data[rows[1]:])\\n\\n f, ax = plt.subplots(1,1,figsize=(8,8))\\n ax.plot(x,filt_data,'k',label='original data')\\n ax.plot(x,lp,'r',label='filtered data')\\n ax.legend(loc='best')\\n\\n return lp\",\n \"def apply_bandpass_filter_timeseries(self, folder_name, indices, start_stop_freq, stop_stop_freq):\\n (x_index, y_index) = indices\\n photo_list = self.get_photo_list(folder_name)\\n\\n ts = self.get_pixel_timeseries(folder_name, (x_index, y_index))\\n self.plot_fft_pixel_timeseries(folder_name, ts, str(x_index) + '_' + str(y_index) + 'pre_butterworth')\\n n = len(ts)\\n frequency = self.get_sampling_frequency(folder_name)\\n d = 1.0 / frequency # 'sample spacing'\\n fig, ax = plt.subplots()\\n sample_freqs = np.fft.rfftfreq(n, d)\\n fourier = np.fft.rfft(ts)\\n print(sample_freqs)\\n nyquist = frequency / 2.0\\n\\n start_stop_band = start_stop_freq / nyquist\\n stop_stop_band = stop_stop_freq / nyquist\\n\\n print(start_stop_band)\\n print(stop_stop_band)\\n\\n sos = sgnl.butter(2, Wn=[start_stop_band, stop_stop_band], btype='bandstop', output='sos')\\n filtered = sgnl.sosfilt(sos, ts)\\n self.plot_fft_pixel_timeseries(folder_name, filtered, str(x_index) + '_' + str(y_index) + 'post_butterworth')\\n fig, ax = plt.subplots()\\n indices = self.get_indices_from_filenames(folder_name)\\n index_dates = dates.date2num(indices)\\n ax.plot_date(index_dates, ts, xdate=True, linestyle='solid', marker='None',\\n label=str(x_index) + ' , ' + str(y_index))\\n ax.plot_date(index_dates, filtered, xdate=True, linestyle='solid', marker='None',\\n label=str(x_index) + ' , ' + str(y_index) + ' filtered')\\n\\n ax.legend()\\n ax.grid(b=True, which='major', color='#666666', linestyle='-')\\n\\n # Show the minor grid lines with very faint and almost transparent grey lines\\n ax.minorticks_on()\\n ax.grid(b=True, which='minor', color='#999999', linestyle='-', alpha=0.2)\\n fig.set_figwidth(40)\\n fig.savefig(self.parent_folder + 'analysis/timeseries_filtered_' + str(x_index) + '_' + str(y_index) + '.png')\\n fig.savefig(self.parent_folder + 'analysis/timeseries_filtered_' + str(x_index) + '_' + str(y_index) + '.svg')\\n fig.clf()\",\n \"def blur(self, shape, dist_fr, dist_to, amount):\\r\\n shape.unif[42] = dist_fr # shader unif[14]\\r\\n shape.unif[43] = dist_to\\r\\n shape.unif[44] = amount\\r\\n shape.unif[45] = 1.0/self.ix # shader unif[15]\\r\\n shape.unif[46] = 1.0/self.iy\\r\\n shape.draw(self.shader, [self], 0.0, 0.0)\",\n \"def highpass_filter(s, sample_rate, cutoff_freq, filter_order=5, rescale=False):\\n #create a butterworth filter\\n nyq = sample_rate / 2.0\\n b,a = filter_design.butter(filter_order, cutoff_freq / nyq, btype='high')\\n\\n #filter the signal\\n filtered_s = filtfilt(b, a, s)\\n\\n if rescale:\\n #rescale filtered signal\\n filtered_s /= filtered_s.max()\\n filtered_s *= s.max()\\n\\n return filtered_s\",\n \"def bandpass(self, gulp=512, **kwargs):\\n bpass_ar = np.zeros(self.header.nchans, dtype=\\\"float64\\\")\\n num_samples = 0\\n for nsamps, _ii, data in self.readPlan(gulp, **kwargs):\\n lib.getBpass(data, bpass_ar, self.header.nchans, nsamps)\\n num_samples += nsamps\\n bpass_ar /= num_samples\\n return TimeSeries(bpass_ar, self.header.newHeader({\\\"nchans\\\": 1}))\",\n \"def _make_filters(self):\\n\\n \\\"\\\"\\\"\\n filter_bank = bandpass_filterbank(\\n self.bands, fs=self.fs, order=order, output=output\\n )\\n\\n return [lambda sig: sosfiltfilt(bpf, sig) for bpf in filter_bank]\\n \\\"\\\"\\\"\\n\\n # This seems to work only for Octave bands out of the box\\n centers = self.centers\\n n = len(self.centers)\\n\\n new_bands = [[centers[0] / 2, centers[1]]]\\n for i in range(1, n - 1):\\n new_bands.append([centers[i - 1], centers[i + 1]])\\n new_bands.append([centers[-2], self.fs / 2])\\n\\n n_freq = self.n_fft // 2 + 1\\n freq_resp = np.zeros((n_freq, n))\\n freq = np.arange(n_freq) / self.n_fft * self.fs\\n\\n for b, (band, center) in enumerate(zip(new_bands, centers)):\\n lo = np.logical_and(band[0] <= freq, freq < center)\\n freq_resp[lo, b] = 0.5 * (1 + np.cos(2 * np.pi * freq[lo] / center))\\n\\n if b != n - 1:\\n hi = np.logical_and(center <= freq, freq < band[1])\\n freq_resp[hi, b] = 0.5 * (1 - np.cos(2 * np.pi * freq[hi] / band[1]))\\n else:\\n hi = center <= freq\\n freq_resp[hi, b] = 1.0\\n\\n filters = np.fft.fftshift(\\n np.fft.irfft(freq_resp, n=self.n_fft, axis=0),\\n axes=[0],\\n )\\n\\n # remove the first sample to make them odd-length symmetric filters\\n self.filters = filters[1:, :]\",\n \"def apply_1d_filter(bfilter, timage):\\n image_length = len(timage)\\n ovrlay = int(bfilter.shape[0] / 2)\\n tmp_array = np.zeros(image_length + 2 * ovrlay)\\n tmp_array[ovrlay:-ovrlay] = timage\\n res_array = np.zeros(image_length )\\n for i in np.arange(image_length) + ovrlay:\\n local_matrix = tmp_array[i - ovrlay:i + ovrlay + 1]\\n res_array[i - ovrlay] = sum(local_matrix * bfilter)\\n return res_array\",\n \"def _butterworth_scale(ts, low_frequency, high_factor, order,\\n sampling_frequency, denominator):\\n filtered = _butterworth(ts, low_frequency, high_factor, order,\\n sampling_frequency)\\n\\n return np.divide(filtered, denominator)\",\n \"def compress(self, samples):\\n rms = np.sqrt(np.dot(samples, samples) / window)\\n power = self.power * (1.0 - self.smooth) + rms * self.smooth\\n self.power = power\\n if power <= 1e-40:\\n samples *= 0\\n return\\n db_in = 10.0 * math.log10(power)\\n if db_in <= self.limit:\\n samples *= 0\\n return\\n db_out = self.cf(db_in)\\n db_gain = db_out - db_in + self.postgain\\n gain = 10**(0.1 * db_gain)\\n samples *= gain\",\n \"def c_test_weighting_bias(self, function):\\r\\n return general_weighting_bias(self.verbosity, function)\",\n \"def c_test_weighting_bias(self, function):\\r\\n return general_weighting_bias(self.verbosity, function)\",\n \"def c_test_weighting_bias(self, function):\\r\\n return general_weighting_bias(self.verbosity, function)\",\n \"def blur_fourier(im, kernel_size):\\n kernel = gaus_kernel_calc(kernel_size)\\n\\n zeros = np.zeros(im.shape)\\n x_mid = np.math.floor(im.shape[1] / 2)\\n y_mid = np.math.floor(im.shape[0] / 2)\\n distance = np.math.floor(kernel_size / 2)\\n zeros[x_mid - distance: x_mid + distance + 1, y_mid - distance: y_mid + distance + 1] = kernel\\n\\n fourier_kernel = DFT2(np.fft.ifftshift(zeros))\\n fourier_img = DFT2(im)\\n fourier_blured = fourier_kernel * fourier_img\\n\\n return IDFT2(fourier_blured).real.astype(np.float64)\",\n \"def execute_filter(self, b, a, buffer, pre_buffer):\\n timing = time.time()\\n pre_buffer = np.concatenate([pre_buffer, buffer])\\n\\n # Execute the filter onto the buffer. \\n output = signal.lfilter(b, a, pre_buffer)\\n\\n # Only return the output based on the current buffer (drop pre_buffer)\\n return output[len(output)/2:]\",\n \"def apply_filter(a_slice_prev, W, b):\\n product = np.multiply(a_slice_prev, W)\\n z = np.sum(product) + np.float(b)\\n return z\",\n \"def filter_pupil(self, hp=0.01, lp=10.0):\\r\\n self.logger.info('Band-pass filtering of pupil signals, hp = %2.3f, lp = %2.3f'%(hp, lp))\\r\\n\\r\\n self.lp_filt_pupil = _butter_lowpass(data=self.interpolated_pupil.astype('float64'), highcut=lp, fs=self.sample_rate, order=3)\\r\\n self.hp_filt_pupil = _butter_highpass(data=self.interpolated_pupil.astype('float64'), lowcut=hp, fs=self.sample_rate, order=3)\\r\\n self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\\r\\n self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\\r\\n\\r\\n # import mne\\r\\n # from mne import filter\\r\\n # self.lp_filt_pupil = mne.filter.low_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=lp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\\r\\n # self.hp_filt_pupil = mne.filter.high_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=hp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\\r\\n # self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\\r\\n # self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\\r\",\n \"def dwt(image_array, quantization_Array):\\n # Create the high pass and low pass filters\\n # both filters are non-causal\\n # symmetric\\n # [-2, -1, 0, 1, 2]\\n LPF = [-0.125, 0.25, 0.75, 0.25, -0.125]\\n LPF_center = 2\\n\\n # [ -2,-1, 0]\\n HPF = [-0.5, 1, -0.5]\\n HPF_center = 2\\n\\n nrow, ncol = image_array.shape\\n\\n # create an array that will contain the 4 different subbands of the image\\n LL = np.zeros((nrow, ncol))\\n LH = np.zeros((nrow, ncol))\\n HL = np.zeros((nrow, ncol))\\n HH = np.zeros((nrow, ncol))\\n filtered_image = [LL, LH, HL, HH]\\n\\n # filtering the rows using a low pass and high pass filters\\n LowPass_rows = np.zeros((nrow, ncol))\\n HighPass_rows = np.zeros((nrow, ncol))\\n for i in range(0, nrow):\\n LowPass_rows[i, :] = lfilter(LPF, image_array[i, :], LPF_center)\\n HighPass_rows[i, :] = lfilter(HPF, image_array[i, :], HPF_center)\\n\\n # down sample rows.\\n # which means we will have half the number of columns\\n for i in range(0, len(filtered_image)):\\n filtered_image[i] = filtered_image[i][:, ::2]\\n\\n # apply filters accross columns\\n for i in range(0, ncol):\\n LL[:, i] = lfilter(LPF, LowPass_rows[:, i], LPF_center)\\n LH[:, i] = lfilter(HPF, LowPass_rows[:, i], HPF_center)\\n HL[:, i] = lfilter(LPF, HighPass_rows[:, i], LPF_center)\\n HH[:, i] = lfilter(HPF, HighPass_rows[:, i], HPF_center)\\n\\n # down sample columns and quantize\\n for i in range(0, len(filtered_image)):\\n filtered_image[i] = filtered_image[i][::2, :]\\n filtered_image[i] = np.round(\\n filtered_image[i]/quantization_Array[i]).astype(int)\\n\\n return filtered_image\",\n \"def bandpass_cnt(data, low_cut_hz, high_cut_hz, fs, filt_order=3, axis=0):\\n if (low_cut_hz == 0 or low_cut_hz is None) and (\\n high_cut_hz == None or high_cut_hz == fs / 2.0):\\n log.info(\\\"Not doing any bandpass, since low 0 or None and \\\"\\n \\\"high None or nyquist frequency\\\")\\n return data.copy()\\n if low_cut_hz == 0 or low_cut_hz == None:\\n log.info(\\\"Using lowpass filter since low cut hz is 0 or None\\\")\\n return lowpass_cnt(data, high_cut_hz, fs, filt_order=filt_order, axis=axis)\\n if high_cut_hz == None or high_cut_hz == (fs / 2.0):\\n log.info(\\n \\\"Using highpass filter since high cut hz is None or nyquist freq\\\")\\n return highpass_cnt(data, low_cut_hz, fs, filt_order=filt_order, axis=axis)\\n\\n nyq_freq = 0.5 * fs\\n low = low_cut_hz / nyq_freq\\n high = high_cut_hz / nyq_freq\\n b, a = scipy.signal.butter(filt_order, [low, high], btype='bandpass')\\n assert filter_is_stable(a), \\\"Filter should be stable...\\\"\\n data_bandpassed = scipy.signal.lfilter(b, a, data, axis=axis)\\n return data_bandpassed\",\n \"def A_weight(signal, fs):\\n\\n b, a = A_weighting(fs)\\n return lfilter(b, a, signal)\",\n \"def applyGapFilter(image, bandNames):\\n filtered = applyForwardNoDataFilter(image, bandNames)\\n filtered = applyBackwardNoDataFilter(filtered, bandNames)\\n return filtered\",\n \"def test_filt_abmag(self):\\n sun = Sun.from_builtin('E490_2014')\\n V = get_bandpass('johnson v')\\n wave, fluxd = sun.filt(V, unit=u.ABmag)\\n assert np.isclose(fluxd.value, -26.77, atol=0.007)\",\n \"def fbank(signal,samplerate=16000,winlen=0.025,winstep=0.01,\\n nfilt=40,nfft=512,lowfreq=0,highfreq=None,dither=1.0,remove_dc_offset=True, preemph=0.97, \\n wintype='hamming'):\\n highfreq= highfreq or samplerate/2\\n frames,raw_frames = sigproc.framesig(signal, winlen*samplerate, winstep*samplerate, dither, preemph, remove_dc_offset, wintype)\\n pspec = sigproc.powspec(frames,nfft) # nearly the same until this part\\n energy = numpy.sum(raw_frames**2,1) # this stores the raw energy in each frame\\n energy = numpy.where(energy == 0,numpy.finfo(float).eps,energy) # if energy is zero, we get problems with log\\n\\n fb = get_filterbanks(nfilt,nfft,samplerate,lowfreq,highfreq)\\n feat = numpy.dot(pspec,fb.T) # compute the filterbank energies\\n feat = numpy.where(feat == 0,numpy.finfo(float).eps,feat) # if feat is zero, we get problems with log\\n\\n return feat,energy\",\n \"def broadbandfilter(self):\\n _, = self.broadbandfilters\\n return _\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7581869","0.75664645","0.7475748","0.74545556","0.7397321","0.73342526","0.7259128","0.7098314","0.70211107","0.6906156","0.6815835","0.66446453","0.6626587","0.66065145","0.6584951","0.65104455","0.64792573","0.6366289","0.634029","0.629268","0.62335944","0.6207938","0.6207698","0.61803466","0.6148735","0.61424464","0.61129856","0.6108775","0.60327977","0.60284853","0.5998356","0.5959925","0.5950835","0.5936989","0.59338534","0.5912427","0.5902298","0.5878924","0.58465594","0.5767047","0.5763024","0.57500696","0.5737677","0.57273895","0.5722594","0.57161707","0.57125103","0.5683453","0.56747925","0.5662286","0.5632798","0.5631118","0.56215554","0.56189626","0.5609998","0.55622303","0.55483794","0.55470896","0.5544967","0.55227786","0.54877824","0.5476699","0.54148054","0.53895605","0.53808343","0.53789455","0.536052","0.5350546","0.5319749","0.5288023","0.52821606","0.5279569","0.5270763","0.52423376","0.524019","0.5240174","0.5233847","0.52276695","0.52210665","0.52174646","0.5209472","0.52091885","0.519567","0.5179457","0.51737607","0.51681215","0.51660323","0.51660323","0.51660323","0.51608896","0.51587915","0.5157048","0.51513124","0.5149095","0.5138359","0.5134382","0.51289845","0.512443","0.5121353","0.5114255"],"string":"[\n \"0.7581869\",\n \"0.75664645\",\n \"0.7475748\",\n \"0.74545556\",\n \"0.7397321\",\n \"0.73342526\",\n \"0.7259128\",\n \"0.7098314\",\n \"0.70211107\",\n \"0.6906156\",\n \"0.6815835\",\n \"0.66446453\",\n \"0.6626587\",\n \"0.66065145\",\n \"0.6584951\",\n \"0.65104455\",\n \"0.64792573\",\n \"0.6366289\",\n \"0.634029\",\n \"0.629268\",\n \"0.62335944\",\n \"0.6207938\",\n \"0.6207698\",\n \"0.61803466\",\n \"0.6148735\",\n \"0.61424464\",\n \"0.61129856\",\n \"0.6108775\",\n \"0.60327977\",\n \"0.60284853\",\n \"0.5998356\",\n \"0.5959925\",\n \"0.5950835\",\n \"0.5936989\",\n \"0.59338534\",\n \"0.5912427\",\n \"0.5902298\",\n \"0.5878924\",\n \"0.58465594\",\n \"0.5767047\",\n \"0.5763024\",\n \"0.57500696\",\n \"0.5737677\",\n \"0.57273895\",\n \"0.5722594\",\n \"0.57161707\",\n \"0.57125103\",\n \"0.5683453\",\n \"0.56747925\",\n \"0.5662286\",\n \"0.5632798\",\n \"0.5631118\",\n \"0.56215554\",\n \"0.56189626\",\n \"0.5609998\",\n \"0.55622303\",\n \"0.55483794\",\n \"0.55470896\",\n \"0.5544967\",\n \"0.55227786\",\n \"0.54877824\",\n \"0.5476699\",\n \"0.54148054\",\n \"0.53895605\",\n \"0.53808343\",\n \"0.53789455\",\n \"0.536052\",\n \"0.5350546\",\n \"0.5319749\",\n \"0.5288023\",\n \"0.52821606\",\n \"0.5279569\",\n \"0.5270763\",\n \"0.52423376\",\n \"0.524019\",\n \"0.5240174\",\n \"0.5233847\",\n \"0.52276695\",\n \"0.52210665\",\n \"0.52174646\",\n \"0.5209472\",\n \"0.52091885\",\n \"0.519567\",\n \"0.5179457\",\n \"0.51737607\",\n \"0.51681215\",\n \"0.51660323\",\n \"0.51660323\",\n \"0.51660323\",\n \"0.51608896\",\n \"0.51587915\",\n \"0.5157048\",\n \"0.51513124\",\n \"0.5149095\",\n \"0.5138359\",\n \"0.5134382\",\n \"0.51289845\",\n \"0.512443\",\n \"0.5121353\",\n \"0.5114255\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7138827"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":84594,"cells":{"query":{"kind":"string","value":"Apply a butter lowpass filter."},"document":{"kind":"string","value":"def butter_lowpass_filter(self, data: np.ndarray, lowcut: float, fs: float, order: int = 4) -> np.ndarray:\n b, a = self._butter_lowpass(lowcut, fs, order=order)\n y = filtfilt(b, a, data)\n return 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 butter_lowpass_filter(data, cutoff, fs, order=1):\n b, a = butter_lowpass(cutoff, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def butter_bandpass_filter(data, lowcut, highcut, fs, order=1):\n b, a = butter_bandpass(lowcut, highcut, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def butter_filter(self, data, low_pass, high_pass, fs, order=10):\n\n nyq = fs/2\n low = low_pass/nyq\n high = high_pass/nyq\n\n b, a = signal.butter(order, [low, high], btype='band')\n filt_data = np.abs(signal.hilbert(signal.filtfilt(b, a, data, axis=1), axis=1))\n return filt_data","def butterworth_bandpass_filter( values, lowFreq, highFreq, sampleFreq, order=5):\n nyq = 0.5 * sampleFreq\n low = lowFreq / nyq\n high = highFreq /nyq\n b,a = butter( order, [low,high], btype='band' )\n return y = lfilter(b, a, data)","def butter_bandpass_filter(data, lowcut, highcut, fs, order=5, axis=0): \n omega = 0.5 * fs\n low = lowcut / omega\n high = highcut / omega\n b, a = signal.butter(order, [low, high], btype='band')\n y = signal.lfilter(b, a, data, axis=0)\n return y","def butterworth_filter(signal, Fs, highpassfreq=None, lowpassfreq=None, order=4, filtfunc='filtfilt'):\n Fn = Fs / 2.\n \n # set the function for filtering\n if filtfunc is 'lfilter':\n ffunc = spsig.lfilter\n elif filtfunc is 'filtfilt':\n ffunc = spsig.filtfilt\n else:\n raise ValueError(\"filtfunc must to be either 'filtfilt' or 'lfilter'\")\n \n # set parameters\n if lowpassfreq and highpassfreq:\n if highpassfreq < lowpassfreq:\n Wn = (highpassfreq / Fn, lowpassfreq / Fn)\n btype = 'bandpass'\n else:\n Wn = (lowpassfreq / Fn, highpassfreq / Fn)\n btype = 'bandstop'\n elif lowpassfreq:\n Wn = lowpassfreq / Fn\n btype = 'lowpass'\n elif highpassfreq:\n Wn = highpassfreq / Fn\n btype = 'highpass'\n else:\n raise ValueError(\"Specify highpassfreq and/or lowpathfreq\")\n \n # filter design\n b, a = spsig.butter(order, Wn, btype=btype)\n \n return ffunc(b, a, signal)","def _butter_bandpass_filter(self, data: np.ndarray, lowcut: float, highcut: float, fs: float, order: int = 5):\n b, a = self._butter_bandpass(lowcut, highcut, fs, order=order)\n y = lfilter(b, a, data)\n return y","def butter_bandpass_filter(data, lowcut, highcut, fs, order=2):\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n \n # butter() and lfilter() are from scipy.signal\n \n b, a = butter(order, [low, high], btype='band')\n y = lfilter(b, a, data)\n return y","def butter_lowpass_filter(data: np.ndarray, cutoff: float, fs: float, order: int) -> np.ndarray:\n nyq = 0.5 * fs\n normal_cutoff = cutoff / nyq\n # Get the filter coefficients\n b, a = signal.butter(order, normal_cutoff, btype='low', analog=False)\n y = signal.filtfilt(b, a, data)\n return y","def butter_filter(datalist):\n fs = 200.00\n fHigh = 50.00\n fLow = 5.00\n N=4\n [b,a]=sg.butter(N,[fLow/fs, fHigh/fs], btype='band')\n global filtered\n #IIR filter\n return sg.filtfilt(b,a,datalist)","def lowpass_butter(fs, L, order, data, axis=-1, btype='low'):\n from scipy.signal import butter, sosfiltfilt\n\n nyq = 0.5 * fs # Nyquist frequency\n low = L / nyq\n sos = butter(order, low, btype=btype, output='sos') # Coefficients for Butterworth filter\n filtered = sosfiltfilt(sos, data, axis=axis)\n\n return filtered","def butter_highpass_filter(data, cutoff, fs, order=1):\n b, a = butter_highpass(cutoff, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def butter_bandpass_filter(\n data: numpy.ndarray,\n lowcut: float,\n highcut: float,\n samplerate: float,\n order: int = 2,\n):\n nyq = 0.5 * samplerate\n lowf = lowcut / nyq\n highf = highcut / nyq\n # generic names for coefficients in filters\n # pylint: disable=invalid-name\n a, b = butter(order, [lowf, highf], btype=\"band\")\n if len(data) < BUTTER_MIN_LENGTH:\n return None\n return filtfilt(a, b, data)","def Butterworth_Filter(x,order,Low_High,Wn):\r\n\r\n\r\n # Create an order butterworth filter:\r\n\r\n b, a = signal.butter(order,Wn,Low_High);\r\n\r\n # Apply the filter to x. Use lfilter_zi to choose the initial condition of the filter:\r\n\r\n zi = signal.lfilter_zi(b, a);\r\n z, _ = signal.lfilter(b, a, x, zi=zi*x[0]);\r\n\r\n # Apply the filter again, to have a result filtered at an order the same as filtfilt:\r\n\r\n z2, _ = signal.lfilter(b, a, z, zi=zi*z[0])\r\n\r\n # Use filtfilt to apply the filter:\r\n\r\n y = signal.filtfilt(b, a, x);\r\n\r\n return y;","def _butter_lowpass(lowcut, fs, order=4) -> tuple:\n nyq = 0.5 * fs\n low = lowcut / nyq\n b, a = butter(order, [low], btype=\"low\")\n return b, a","def filter_low_pass(x, filt_data, cutoff, fs, order=1, rows=[0,-1]):\n\n from scipy.signal import butter, filtfilt\n import numpy as np\n import matplotlib.pyplot as plt \n\n def butter_lowpass(cutoff, fs, order=5):\n nyq = 0.5 * fs\n normal_cutoff = cutoff / nyq\n b, a = butter(order, normal_cutoff, btype='low', analog=False)\n return b, a \n\n b, a = butter_lowpass(cutoff, fs, order=order)\n \n slice_exp = filt_data[rows[0]:rows[1]]\n lp_slice_exp = filtfilt(b, a, slice_exp)\n lp = np.append(filt_data[:rows[0]],lp_slice_exp)\n lp = np.append(lp,filt_data[rows[1]:])\n\n f, ax = plt.subplots(1,1,figsize=(8,8))\n ax.plot(x,filt_data,'k',label='original data')\n ax.plot(x,lp,'r',label='filtered data')\n ax.legend(loc='best')\n\n return lp","def butterworth_filter(freq):\n\tf_raw = 1/(0.00000002*100*33)\n\tb = np.array([[-32092,15750],[-31238,14895]])*2.0**(-14)\n\tomega = 2*np.pi*freq/f_raw\n\te1, e2 = np.exp(-1j*omega), np.exp(-2j*omega)\n\ttmp = (1+2*e1+e2)**2/(1+b[0,0]*e1+b[0,1]*e2)/(1+b[1,0]*e1+b[1,1]*e2)\n\treturn tmp * (1+sum(b[0]))*(1+sum(b[1]))/16","def get_butterworth_low_pass_filter(shape, cutoff, order):\n \n \n print(\"butterworth_low_pass_filter = \")\n print(\"cutoff: \",cutoff)\n print(\"order: \",order)\n filter = np.zeros(shape)\n for i in range(shape[0]):\n for j in range(shape[1]):\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\n filter[i, j] = 1 / (1 + (D / cutoff) ** (2 * order))\n # print(\"\\n\\n\\n\\n\")\n # print(filter)\n # return filter\n return process_filter(image, filter)","def lowpass_filter(data, Wn=0.014, N=2):\n data = np.array(data)\n data = data.astype(np.float)\n # N = 5 # Filter order\n # Wn = 0.02 # Cutoff frequency\n B, A = signal.butter(N, Wn, output='ba')\n\n # Second, apply the filter\n tempf = signal.filtfilt(B,A, data)\n # print(tempf)\n return tempf","def butterworth_bandpass(lowcut, highcut, fs, order=5):\n nyq = 0.5 * fs # nyquist sampling rate\n low = lowcut / nyq # normalize frequency\n high = highcut / nyq # normalize frequency\n b, a = butter(order, [low, high], btype='band')\n return b, a","def _signal_filter_butterworth(signal, sampling_rate=1000, lowcut=None, highcut=None, order=2):\n if lowcut is not None and highcut is not None:\n sos = scipy.signal.butter(order, [lowcut, highcut], btype=\"bandpass\", output='sos', fs=sampling_rate)\n elif lowcut is not None:\n sos = scipy.signal.butter(order, [lowcut], btype=\"highpass\", output='sos', fs=sampling_rate)\n elif highcut is not None:\n sos = scipy.signal.butter(order, [highcut], btype=\"lowpass\", output='sos', fs=sampling_rate)\n\n filtered = scipy.signal.sosfiltfilt(sos, signal)\n return filtered","def ButterworthFilter(\n self,\n name: str,\n cutoffFrequency: float,\n order: int = 2,\n operation: SymbolicConstant = NONE,\n halt: Boolean = OFF,\n limit: float = None,\n invariant: SymbolicConstant = NONE,\n ) -> ButterworthFilter:\n self.filters[name] = butterworthFilter = ButterworthFilter(\n name, cutoffFrequency, order, operation, halt, limit, invariant\n )\n return butterworthFilter","def _butter_bandpass(lowcut: float, highcut: float, fs: float, order: int = 5) -> tuple:\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n b, a = butter(order, [low, high], btype=\"band\")\n return b, a","def butter_bandstop_filter(data, lowcut, highcut, fs, order):\n\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n\n i, u = sg.butter(order, (low, high), btype='bandstop')\n y = sg.filtfilt(i, u, data)\n return y","def butterworth(dx, order, cutoff, /, btype='low'):\n # Initial stuff\n # * Need to run *forward and backward* to prevent time-shifting.\n # * The 'analog' means units of cutoffs are rad/s.\n # * Unlike Lanczos filter, the *length* of this should be\n # determined always as function of timestep, because really high\n # order filters can get pretty wonky.\n # * Cutoff is point at which gain reduces to 1/sqrt(2) of the\n # initial frequency. If doing bandpass, can\n # N = (width/dx)//1 # convert to timestep units\n # N = (N//2)*2 + 1 # odd numbered\n N = order # or order\n analog = False # lfilter seems to need digital\n if analog:\n cutoff = 2 * np.pi / (cutoff / dx) # from wavelengths to rad/steps\n else:\n cutoff = 1.0 / cutoff # to Hz, or cycles/unit\n cutoff = cutoff * (2 * dx) # to cycles / (2 timesteps)\n if cutoff > 1:\n raise ValueError(\n 'Cuttoff frequency must be in [0, 1]. Remember you pass a cutoff '\n '*wavelength* to this function, not a frequency.'\n )\n\n # Apply filter\n print(f'Order-{order} Butterworth filter')\n b, a = signal.butter(N - 1, cutoff, btype=btype, analog=analog, output='ba')\n return b, a","def lowpass_filter(s, sample_rate, cutoff_freq, filter_order=5, rescale=False):\n #create a butterworth filter\n nyq = sample_rate / 2.0\n b,a = filter_design.butter(filter_order, cutoff_freq / nyq)\n\n #filter the signal\n filtered_s = filtfilt(b, a, s)\n\n if rescale:\n #rescale filtered signal\n filtered_s /= filtered_s.max()\n filtered_s *= s.max()\n\n return filtered_s","def bandpass_filter(s, sample_rate, low_freq, high_freq, filter_order=5, rescale=False):\n #create a butterworth filter\n nyq = sample_rate / 2.0\n f = np.array([low_freq, high_freq]) / nyq\n b,a = filter_design.butter(filter_order, f, btype='bandpass')\n\n #filter the signal\n filtered_s = filtfilt(b, a, s)\n\n if rescale:\n #rescale filtered signal\n filtered_s /= filtered_s.max()\n filtered_s *= s.max()\n\n return filtered_s","def bandpass_filter_audio(audio, f_low=400, f_high=450):\n filtered_audio = core.sinc_filter(audio, f_low, window_size=256, high_pass=True)\n filtered_audio = core.sinc_filter(filtered_audio, f_high, window_size=256, high_pass=False)\n return tf.squeeze(filtered_audio)","def get_butterworth_high_pass_filter(shape, cutoff, order):\n \n # Hint: May be one can use the low pass filter function to get a high pass mask\n print(\"butterworth_high_pass_filter = \")\n print(\"cutoff: \",cutoff)\n print(\"order: \",order)\n filter = get_butterworth_low_pass_filter(shape, cutoff, order)\n\n for i in range(shape[0]):\n for j in range(shape[1]):\n filter[i, j] = 1 - filter[i, j]\n\n # return filter\n return process_filter(image, filter)","def init_lowpass(self, lowpass_cutoff, lowpass_order):\n if lowpass_cutoff > 0 or self._fs_out < self._fs_in:\n nyquist = self._fs_out / 2\n if lowpass_cutoff > nyquist or (self._fs_out < self._fs_in and\n lowpass_cutoff == 0):\n lowpass_cutoff = 0.75 * nyquist\n lowpass_order = 10\n print('Using %gHz low-pass filter to prevent aliasing'\n % lowpass_cutoff)\n self._lowpass_cutoff = lowpass_cutoff\n self._lowpass_order = lowpass_order\n logging.info('Low-pass filtering the data with the 3dB point at %gHz.',\n lowpass_cutoff)\n self._lowpass_sos = scipy.signal.butter(lowpass_order, lowpass_cutoff,\n 'lp', output='sos', fs=self.fs_in)\n self._lowpass_state = None # to be created later when we know sizes\n else:\n self._lowpass_sos = None","def compute(self):\n Y = self.data[1]\n # Create an order 3 lowpass butterworth filter\n b, a = signal.butter(3, 0.05)\n # Apply the filter to Y. Use lfilter_zi to choose the initial condition of the filter\n zi = signal.lfilter_zi(b, a)\n z, _ = signal.lfilter(b, a, Y, zi=zi * Y[0])\n # Apply the filter again, to have a result filtered at an order the same as filtfilt\n z2, _ = signal.lfilter(b, a, z, zi=zi * z[0])\n # Use filtfilt to apply the filter\n self.data[2] = signal.filtfilt(b, a, Y)\n self.data[3] = self.data[2] - self.data[1] - self.dataSpan * 0.3\n self.updatePlot()","def get_butterworth_high_pass_filter(self, shape, cutoff, order):\r\n\r\n #Hint: May be one can use the low pass filter function to get a high pass mask\r\n # 1 - butter low pass\r\n mask = 1 - self.get_butterworth_low_pass_filter(shape, cutoff, order)\r\n\r\n return mask","def butter_bp_coe(lowcut, highcut, fs, order=1):\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n b, a = butter(order, [low, high], btype='band')\n return b, a","def highpass_filter(s, sample_rate, cutoff_freq, filter_order=5, rescale=False):\n #create a butterworth filter\n nyq = sample_rate / 2.0\n b,a = filter_design.butter(filter_order, cutoff_freq / nyq, btype='high')\n\n #filter the signal\n filtered_s = filtfilt(b, a, s)\n\n if rescale:\n #rescale filtered signal\n filtered_s /= filtered_s.max()\n filtered_s *= s.max()\n\n return filtered_s","def filter(sig, sampling_rate, lc, hc, order=2):\n\n # Construct butterworth band-pass filter\n b1, a1 = butter(order, [2.0 * lc / sampling_rate,\n 2.0 * hc / sampling_rate], btype=\"band\")\n nchan, nsamp = sig.shape\n fsig = np.copy(sig)\n\n # Apply cosine taper then apply band-pass filter in both directions\n for ch in range(0, nchan):\n fsig[ch, :] = fsig[ch, :] - fsig[ch, 0]\n tap = cosine_taper(len(fsig[ch, :]), 0.1)\n fsig[ch, :] = fsig[ch, :] * tap\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, ::-1])[::-1]\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, :])\n\n return fsig","async def low_pass(\n client,\n event,\n smoothing: P('float', 'smoothing', min_value = 0.0, max_value = 5.0),\n):\n player = get_player_or_abort(client, event)\n \n filter = LowPass(smoothing)\n player.add_filter(filter)\n await player.apply_filters()\n \n return create_filter_added_embed(filter)","def iirfilter(x, N=4, pass_freq=0.7 / 12.):\n b, a = signal.butter(N, pass_freq, \"low\", analog=False)\n return signal.filtfilt(b, a, x)","def bpfilter(\n data: numpy.ndarray, short_min: float = 2, long_min: float = 12\n) -> Optional[numpy.ndarray]:\n return butter_bandpass_filter(\n data, 1 / (long_min * 60), 1 / (short_min * 60), 1 / DATA_RATE\n )","def butter_filter(image, n, f0):\n [ny, nx] = image.shape\n dx = 2.0/nx\n dy = 2.0/nx\n dfx = 0.5\n dfy = 0.5\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\n FX, FY = np.meshgrid(fx, fy)\n shift = np.exp(-2*np.pi*1j*(FX+FY))\n sin_pad = np.sin(image)\n cos_pad = np.cos(image)\n ft_sin = shift * np.fft.fftshift(np.fft.fft2(sin_pad))\n ft_cos = shift * np.fft.fftshift(np.fft.fft2(cos_pad))\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\n sin_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_sin)) / shift)\n cos_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_cos)) / shift)\n phase_filt = np.arctan2(sin_filt, cos_filt)\n return phase_filt","def lowpass_filter(self, data, reset=False):\n data = np.asarray(data)\n if self._lowpass_sos is not None:\n if self._lowpass_state is None or reset:\n self.lowpass_filter_reset(data)\n data, self._lowpass_state = scipy.signal.sosfilt(\n self._lowpass_sos, data, zi=self._lowpass_state, axis=0)\n return data\n return data","def butterworthsmoothing(df, column_names: list = None, Wn = 0.015):\n\n if column_names is None:\n return df\n else:\n # First, design the Buterworth filter\n N = 2 # Filter order\n Wn = Wn # Cutoff frequency\n B, A = signal.butter(N, Wn, output='ba')\n for i in column_names:\n df[i] = signal.filtfilt(B, A, df[i])\n df.dropna(axis=0, how='any', inplace=True)\n return df","def apply_filter(self, image):\n pass","def filter_pupil(self, hp=0.01, lp=10.0):\r\n self.logger.info('Band-pass filtering of pupil signals, hp = %2.3f, lp = %2.3f'%(hp, lp))\r\n\r\n self.lp_filt_pupil = _butter_lowpass(data=self.interpolated_pupil.astype('float64'), highcut=lp, fs=self.sample_rate, order=3)\r\n self.hp_filt_pupil = _butter_highpass(data=self.interpolated_pupil.astype('float64'), lowcut=hp, fs=self.sample_rate, order=3)\r\n self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\r\n self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\r\n\r\n # import mne\r\n # from mne import filter\r\n # self.lp_filt_pupil = mne.filter.low_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=lp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\r\n # self.hp_filt_pupil = mne.filter.high_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=hp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\r\n # self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\r\n # self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\r","def butter_hpf(highcut, fs, order):\n nyq = 0.5 * fs\n high = highcut / nyq\n b, a = signal.butter(order, high, btype='highpass')\n w, h = signal.freqz(b, a, worN=1000)\n# plt.figure()\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\n return b, a","def bandpass_filter(data, lowcut, highcut, fs=2000, numtaps=255):\n nyq = fs / 2\n\n # design filter\n fe1 = lowcut / nyq\n fe2 = highcut / nyq\n b = firwin(numtaps, (fe1, fe2), pass_zero=False)\n\n filtered = lfilter(b, 1, data)\n\n return filtered","def filt_bp(sig: np.ndarray, Ss: int, Cfs0: int, Cfs1: None,\n order=5) -> np.ndarray:\n nyq = 0.5 * Ss\n normal_cutoff1 = Cfs0 / nyq\n normal_cutoff2 = Cfs1 / nyq\n b, a = butter(order, (normal_cutoff1, normal_cutoff2),\n btype='band',\n analog=False)\n return lfilter(b, a, sig)","def get_butterworth_low_pass_filter(self, shape, cutoff, order):\n \n mask = zeros(shape)\n row_size, col_size = shape[0], shape[1]\n center_row, center_col = row_size/2 , col_size/2\n for r in range(0, row_size):\n for c in range(0, col_size):\n freq_dist = sqrt( (r-center_row)**2 + (c-center_col)**2 )\n mask[r,c] = (1/(1+(freq_dist/cutoff)*order)) if freq_dist > cutoff else 1.0\n\n return mask","def lowpass(data,filterSize=None):\n\n def convolve(signal,kernel):\n pad=np.ones(len(kernel)/2)\n signal=np.concatenate((pad*signal[0],signal,pad*signal[-1]))\n signal=np.convolve(signal,kernel,mode='same')\n signal=signal[len(pad):-len(pad)]\n return signal\n\n def kernel_gaussian(size=100, sigma=None, forwardOnly=False):\n if sigma is None:\n sigma=size/10\n size=int(size)\n points=np.exp(-np.power(np.arange(size)-size/2,2)/(2*np.power(sigma,2)))\n if forwardOnly:\n points[:int(len(points)/2)]=0\n return points/sum(points)\n\n if filterSize is None:\n filterSize=len(data)/10\n kernel=kernel_gaussian(size=filterSize)\n data=convolve(data,kernel) # do the convolution with padded edges\n return data","def A_weight(signal, fs):\n\n b, a = A_weighting(fs)\n return lfilter(b, a, signal)","def butter_lpf(fc, fs, order):\n nyq = 0.5 * fs\n high = fc / nyq\n b, a = signal.butter(order, high, btype='lowpass', analog=False)\n w, h = signal.freqz(b, a, worN=1000)\n# plt.figure()\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\n return b, a","def make_butter_so(self, wn, order):\n \n nyquist = self.s_freq/2\n wn_arr = np.asarray(wn)\n \n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\n \n self.so_sos = butter(order, wn_arr, btype='bandpass', output='sos')\n print(f\"Zero phase butterworth filter successfully created: order = {order}x{order}, bandpass = {wn}\")","def butter_filter_unwrapped(image, n, f0, pad = False):\n if pad == True:\n res = [2**kji for kji in range(15)]\n N_int_x = image.shape[1]\n N_int_y = image.shape[0]\n nx_pad = np.where(res > np.tile(N_int_x, len(res)))\n nx_pad = res[nx_pad[0][0]]\n ny_pad = np.where(res > np.tile(N_int_y, len(res)))\n ny_pad = res[ny_pad[0][0]]\n dif_x = (nx_pad - N_int_x)/2\n dif_y = (ny_pad - N_int_y)/2\n orig_shape = image.shape\n image = np.lib.pad(image, ((dif_y, dif_y), (dif_x, dif_x)), 'reflect')\n \n [ny, nx] = image.shape\n dx = 2.0/nx\n dy = 2.0/ny\n dfx = 0.5\n dfy = 0.5\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\n FX, FY = np.meshgrid(fx, fy)\n shift = np.exp(-2*np.pi*1j*(FX+FY))\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\n ft_img = shift * np.fft.fftshift(np.fft.fft2(image))\n \n buttered = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_img))/ shift)\n if pad == True:\n assert(buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x].shape == orig_shape)\n return buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x]\n else:\n assert(buttered.shape == image.shape)\n return buttered","def PassFilter(xdata, ydata, fs, order=5, btype='high', freq = None, cutoff=None):\r\n if freq == None:\r\n freq = _frequency_estimation(xdata, ydata)\r\n if cutoff==None:\r\n cutoff = _cutoff(xdata, ydata, btype, fs, ff = freq)\r\n b, a = _butter_pass(cutoff, fs, order=order, btype=btype)\r\n y = signal.filtfilt(b, a, ydata, padtype='even')\r\n return y","def _butter_pass(cutoff, fs, order=5, btype='high'):\r\n nyq = 0.5*fs\r\n normal_cutoff = cutoff/nyq\r\n# print \"normalized cutoff: \", normal_cutoff\r\n if normal_cutoff >= 1.:\r\n normal_cutoff = 1.\r\n b, a = signal.butter(order, normal_cutoff, btype=btype, analog=False)\r\n return b, a","def get_butterworth_low_pass_filter(self, shape, cutoff, order):\r\n P = shape[0]\r\n Q = shape[1]\r\n mask = np.zeros((P, Q))\r\n for u in range(P):\r\n for v in range(Q):\r\n dist = ((u - (P / 2)) ** 2 + (v - (Q / 2)) ** 2) ** (1 / 2)\r\n mask[u][v] = 1 / (1 + (dist/cutoff)**(2*order))\r\n\r\n return mask","def make_butter_sp(self, wn, order):\n nyquist = self.s_freq/2\n wn_arr=np.asarray(wn)\n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\n \n self.sp_sos = butter(order, wn_arr, btype='bandpass', output='sos')\n print(f\"Zero phase butterworth filter successfully created: order = {order}x{order} bandpass = {wn}\")","def _get_fir_filter(passband, fs, order=183, weights=[5.75, 1., 5.75], mask=[0, 1, 0]):\n # return remez(order, passband, mask, weights, Hz=fs), 1.\n return remez(order, passband, mask, Hz=fs), 1.","def bandpassFilter (self, lowerFreq, upperFreq):\n self.bandpassLimits = (lowerFreq, upperFreq)\n # stuff to do","def filters(self, low_freq=1/7, high_freq=128, notch_freq=50):\n self.raw.filter(l_freq=low_freq, h_freq=high_freq)\n self.raw.notch_filter(range(notch_freq, high_freq, notch_freq), filter_length='auto',\n phase='zero', fir_design='firwin')","def init_highpass(self, highpass_cutoff, highpass_order):\n if highpass_cutoff > 0:\n self._highpass_cutoff = highpass_cutoff\n self._highpass_order = highpass_order\n logging.info('High-pass filtering the data with the 3dB point at %gHz.',\n highpass_cutoff)\n self._highpass_sos = scipy.signal.butter(highpass_order, highpass_cutoff,\n 'hp', output='sos',\n fs=self.fs_in)\n self._highpass_state = None # to be created later when we know sizes\n else:\n self._highpass_sos = None","def get_gaussian_low_pass_filter(shape, cutoff, order):\n \n print(\"gaussian_low_pass_filter = \")\n print(\"cutoff: \",cutoff)\n print(\"order: \",order)\n filter = np.zeros(shape)\n\n for i in range(shape[0]):\n for j in range(shape[1]):\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\n\n filter[i, j] = math.exp(-D ** 2 / (2 * (cutoff ** 2)))\n\n # return filter\n return process_filter(image, filter)","def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=(500, 10000)):\n if freq_cutoffs[0] <= 0:\n raise ValueError('Low frequency cutoff {} is invalid, '\n 'must be greater than zero.'\n .format(freq_cutoffs[0]))\n\n Nyquist_rate = samp_freq / 2\n if freq_cutoffs[1] >= Nyquist_rate:\n raise ValueError('High frequency cutoff {} is invalid, '\n 'must be less than Nyquist rate, {}.'\n .format(freq_cutoffs[1], Nyquist_rate))\n\n if rawsong.shape[-1] < 387:\n numtaps = 64\n elif rawsong.shape[-1] < 771:\n numtaps = 128\n elif rawsong.shape[-1] < 1539:\n numtaps = 256\n else:\n numtaps = 512\n\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\n freq_cutoffs[1] / Nyquist_rate])\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\n # window to design filter, but default for matlab's fir1\n # is actually Hamming\n # note that first parameter for scipy.signal.firwin is filter *length*\n # whereas argument to matlab's fir1 is filter *order*\n # for linear FIR, filter length is filter order + 1\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\n a = np.zeros((numtaps+1,))\n a[0] = 1 # make an \"all-zero filter\"\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\n return filtsong","def lowPassFilter(img, window=30):\n gray = grayscale(img)\n\tdft = cv2.dft(np.float32(gray), flags = cv2.DFT_COMPLEX_OUTPUT)\n\tdft_shift = np.fft.fftshift(dft)\n\trows, cols = gray.shape\n\tcrow, ccol = rows/2, cols/2\n\tmask = np.zeros((rows, cols, 2), np.uint8)\n\tmask[crow-window:crow+window, ccol-window:ccol+window] = 1\n\tfshift = dft_shift*mask\n\tf_ishift = np.fft.ifftshift(fshift)\n\timg_back = cv2.idft(f_ishift)\n\timg_back = cv2.magnitude(img_back[:,:,0], img_back[:,:,1])\n\treturn img_back","def butterworth_filter(dft4img, stopband2=10, order=3, showdft=False):\n h, w = dft4img.shape[0], dft4img.shape[1]\n P = h / 2\n Q = w / 2\n dst = np.zeros((h, w, 3), np.float64)\n for i in range(h):\n for j in range(w):\n r2 = float((i - P) ** 2 + (j - Q) ** 2)\n if r2 == 0:\n r2 = 1.0\n dst[i, j] = 1 / (1 + (r2 / stopband2) ** order)\n dst = np.float64(dst)\n if showdft:\n cv2.imshow(\"butterworth\", cv2.magnitude(dst[:, :, 0], dst[:, :, 1]))\n return dst","def filters(array, sample_frequency):\n strain = TimeSeries(array, sample_rate=int(sample_frequency))\n white_data = strain.whiten(fftlength=4, fduration=4)\n bp_data = white_data.bandpass(50, 250)\n return bp_data.value","def A_weighting(fs):\n b, a = A_weighting_analog()\n\n # Use the bilinear transformation to get the digital filter.\n return bilinear(b, a, fs)","def bandpass(filename,f1,f2,Q,wout=True,plot=True):\n start=time.time()\n n, data, data_dB,sr,ch=inputwav(filename)\n b, a = butter(Q,Wn=(f1/sr,f2/sr),btype='bandpass')\n data_filtered=lfilter(b,a,data,axis=0)\n print('Applying FFT...')\n if wout==True:\n print('Exporting...')\n sf.write(filename[0:len(filename)-4]+'_BP.wav',data_filtered,sr,'PCM_16')\n if plot==True:\n print('Plotting...')\n py.close()\n w, h = freqz(b,a,worN=16384)\n fig, (ax1, ax2) = py.subplots(nrows=2)\n ax1.semilogx(0.5*sr*w/np.pi,abs(h),'k-')\n ax1.set_xlabel('Frequency (Hz)')\n ax1.set_ylabel('Rel. Amplitude')\n ax1.grid()\n ax1.set_ylim(0,1.1)\n ax1.set_xlim(1,20000)\n ax2.plot(data,'k-',label='Raw data')\n ax2.plot(data_filtered,'m-',lw=1,label='Filtered data')\n ax2.set_xlim(0,10000)\n ax2.set_ylim(-1,1)\n ax2.set_ylabel('Amplitude (Norm Bits)')\n ax2.set_xlabel('Samples')\n ax2.legend(loc=2,frameon=False,ncol=2)\n py.subplots_adjust(hspace=0.35) \n print('Done!')\n end=time.time()\n elapsed=int(1000*(end-start))\n print('...............................')\n print('Completed in '+str(elapsed)+' milliseconds.')\n return data_filtered","def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=None):\n\n Nyquist_rate = samp_freq / 2\n if freq_cutoffs is None:\n freq_cutoffs = [500, 10000]\n if rawsong.shape[-1] < 387:\n numtaps = 64\n elif rawsong.shape[-1] < 771:\n numtaps = 128\n elif rawsong.shape[-1] < 1539:\n numtaps = 256\n else:\n numtaps = 512\n\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\n freq_cutoffs[1] / Nyquist_rate])\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\n # window to design filter, but default for matlab's fir1\n # is actually Hamming\n # note that first parameter for scipy.signal.firwin is filter *length*\n # whereas argument to matlab's fir1 is filter *order*\n # for linear FIR, filter length is filter order + 1\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\n a = np.zeros((numtaps+1,))\n a[0] = 1 # make an \"all-zero filter\"\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\n return filtsong","def get_butterworth_high_pass_filter(self, shape, cutoff, order):\n\n #Hint: May be one can use the low pass filter function to get a high pass mask\n mask = zeros(shape)\n row_size, col_size = shape[0], shape[1]\n center_row, center_col = row_size/2 , col_size/2\n for r in range(0, row_size):\n for c in range(0, col_size):\n freq_dist = sqrt( (r-center_row)**2 + (c-center_col)**2 )\n mask[r,c] = (1/(1+(freq_dist/cutoff)*order*2)) if freq_dist < cutoff else 1.0\n\n return mask\n # return 1 - self.get_butterworth_low_pass_filter(shape, cutoff, order*2) # wrong ?","def butterworth(path_to_data, dtype, n_channels, data_order,\n low_frequency, high_factor, order, sampling_frequency,\n max_memory, output_path, output_dtype, standarize=False,\n output_filename='filtered.bin', if_file_exists='skip',\n processes='max'):\n processes = multiprocess.cpu_count() if processes == 'max' else processes\n\n # init batch processor\n bp = BatchProcessor(path_to_data, dtype, n_channels, data_order,\n max_memory, buffer_size=200)\n\n if standarize:\n bp_ = BatchProcessor(path_to_data, dtype, n_channels, data_order,\n max_memory, buffer_size=0)\n\n filtering = partial(_butterworth, low_frequency=low_frequency,\n high_factor=high_factor,\n order=order,\n sampling_frequency=sampling_frequency)\n\n # if standarize, estimate sd from first batch and use\n # _butterworth_scale function, pass filtering to estimate sd from the\n # filtered data\n sd = standard_deviation(bp_, sampling_frequency,\n preprocess_fn=filtering)\n fn = partial(_butterworth_scale, denominator=sd)\n # add name to the partial object, since it is not added...\n fn.__name__ = _butterworth_scale.__name__\n else:\n # otherwise use _butterworth function\n fn = _butterworth\n\n _output_path = os.path.join(output_path, output_filename)\n\n (path,\n params) = bp.multi_channel_apply(fn, mode='disk',\n cleanup_function=fix_indexes,\n output_path=_output_path,\n if_file_exists=if_file_exists,\n cast_dtype=output_dtype,\n low_frequency=low_frequency,\n high_factor=high_factor,\n order=order,\n sampling_frequency=sampling_frequency,\n processes=processes)\n\n return path, params","def apply_filter(self, image):\n gauss_low = cv2.GaussianBlur(image, ksize=(0,0), sigmaX=self._sigma_low , sigmaY=self._sigma_low)\n gauss_high = cv2.GaussianBlur(image, ksize=(0,0), sigmaX=self._sigma_high, sigmaY=self._sigma_high)\n\n filtered_image = gauss_low - gauss_high\n\n return normalize(filtered_image, nb_bits=8)","def highpass_filter(self, data, reset=False):\n data = np.asarray(data)\n if self._highpass_sos is not None:\n if self._highpass_state is None or reset:\n self.highpass_filter_reset(data)\n data, self._highpass_state = scipy.signal.sosfilt(\n self._highpass_sos, data, zi=self._highpass_state, axis=0)\n return data\n return data","def __band_filter(data: dict, lowFreq: Union[int, float], highFreq: Union[int, float], timestep: int=0,\n samplingFreq: int=240, order: int=5, eegSensor: int=0, filterType: str='bandpass',\n lengthOfTestSeconds: Union[int, float]=32, example: int=0) -> dict:\n #Test\n # Filter.__band_filter_test(data=data, low=lowFreq, high=highFreq, samplingFreq=samplingFreq, order=order,\n # eegSensor=eegSensor, filterType=filterType, lengthOfTestSeconds=lengthOfTestSeconds)\n #Code\n nyq = 0.5 * samplingFreq\n low = lowFreq / nyq\n high = highFreq / nyq\n b, a = signal.butter(order, [low, high], btype=filterType)\n y = signal.lfilter(b, a, data['Signal'])\n ##Graph - This belongs somewhere else probably.\n # t = np.linspace(0, len(data), len(data), endpoint=False)\n # plt.plot(t, y, label='Sensor #' + str(eegSensor) + ' (' + str(lowFreq) + '-' + str(highFreq) + ') Hz')\n # plt.grid(True)\n # plt.axis('tight')\n # plt.xticks(range(10), range(lengthOfTestSeconds)) ##32 seconds per test?\n # plt.xlabel(\"Time in Seconds\")\n # plt.legend(loc='upper left')\n # plt.show()\n output = {}\n timestep = []\n for index, eegChannel in enumerate(y[0]):#the extra [0] is becuase signal.lfilter() puts it in a 1D array. Grrr\n timestep.append(eegChannel)\n output['Signal'] = timestep\n Visualization.channelGraph(y[0][0])\n return output #output is 2D 64xTimeSamples","def lowpass_filter_reset(self, data):\n zi = scipy.signal.sosfilt_zi(self._lowpass_sos)\n self._lowpass_state = data[0, :] * np.repeat(zi[:, :, np.newaxis],\n data.shape[1], axis=2)\n logging.info('Resetting the low-pass filter state.')","def highPassFilter(img, window=30):\n gray = grayscale(img)\n\tf = np.fft.fft2(gray)\n\tfshift = np.fft.fftshift(f)\n\trows, cols = gray.shape\n\tcrow, ccol = rows/2, cols/2\n\tfshift[crow-window:crow+window, ccol-window:ccol+window] = 0\n\tf_ishift = np.fft.ifftshift(fshift)\n\timg_back = np.fft.ifft2(f_ishift)\n\timg_back = np.abs(img_back)\n\treturn img_back","def filtroBilateral(frame):\n fb = cv2.bilateralFilter(frame, 0, 32, 2)\n return fb","def band_pass_eeg(eeg, freq_range, order=4):\n return ButterworthFilter(eeg, freq_range, filt_type='pass', order=order).filter()","def filt_lp(sig: np.ndarray, Ss: int, Cfs: int, Cfs1: None,\n order=5) -> np.ndarray:\n nyq = 0.5 * Ss\n normal_cutoff = Cfs / nyq\n b, a = butter(order, normal_cutoff, btype='low', analog=False)\n return lfilter(b, a, sig)","def bandpass_filter(files, lowpass_freq=0.1, highpass_freq=0.01, tr=2):\n import os\n\n import nibabel as nb\n import numpy as np\n from nipype.utils.filemanip import (\n filename_to_list,\n list_to_filename,\n split_filename\n )\n\n fs = 1./tr\n\n out_files = []\n for filename in filename_to_list(files):\n path, name, ext = split_filename(filename)\n out_file = os.path.join(os.getcwd(), name + '_bandpassed' + ext)\n\n img = nb.load(filename)\n timepoints = img.shape[-1]\n F = np.zeros((timepoints))\n\n lowidx = int(timepoints / 2) + 1\n if lowpass_freq > 0:\n lowidx = np.round(float(lowpass_freq) / fs * timepoints)\n\n highidx = 0\n if highpass_freq > 0:\n highidx = np.round(float(highpass_freq) / fs * timepoints)\n F[int(highidx):int(lowidx)] = 1\n F = ((F + F[::-1]) > 0).astype(int)\n data = img.get_data()\n if np.all(F == 1):\n filtered_data = data\n else:\n filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F))\n img_out = nb.Nifti1Image(filtered_data, img.affine, img.header)\n img_out.to_filename(out_file)\n out_files.append(out_file)\n\n return list_to_filename(out_files)","def light(brightness, filter):\n brightness = clamp(MIN_BRIGHTNESS, round(brightness), MAX_BRIGHTNESS)\n for col in range(DISPLAY_WIDTH):\n for row in range(DISPLAY_HEIGHT):\n if filter(col, row):\n microbit.display.set_pixel(col, row, brightness)","def filt_hp(sig: np.ndarray, Ss: int, Cfs: int, Cfs1: None,\n order=5) -> np.ndarray:\n nyq = 0.5 * Ss\n normal_cutoff = Cfs / nyq\n b, a = butter(order, normal_cutoff, btype='high', analog=False)\n return lfilter(b, a, sig)","def _lowpass(self, signal, dx, Lmax):\n W = np.fft.rfftfreq(len(signal), dx)\n f_signal = np.fft.rfft(signal)\n filtered_signal = f_signal.copy()\n filtered_signal[np.where(self._div0(1,W) > Lmax)] = 0+0j\n return np.fft.irfft(filtered_signal, n=len(signal)), f_signal","def blurd_image(img,order=5,direction='horizontal',strength=0.25,speed='slow'):\n\tny,nx = np.shape(img)\n\tif speed == 'slow':\n\t\tb, a = scig.butter(order, strength)\n\t\tif direction == 'horizontal':\n\t\t\tfor i in range(ny):\n\t\t\t\timg[i,:] = scig.filtfilt(b, a, img[i,:])\n\t\telif direction == 'vertical':\n\t\t\tfor i in range(nx):\n\t\t\t\timg[:,i] = scig.filtfilt(b, a, img[:,i])\n\t\treturn img\n\telif speed=='fast':\n\t\tK = np.ones((int(strength),1))\n\t\tK = K/np.sum(K)\n\t\tif direction=='vertical':\n\t\t\timg=scig.convolve2d(img,K,mode='same')\n\t\telif direction=='horizontal':\n\t\t\timg=scig.convolve2d(img,K.transpose(),mode='same')\n\t\treturn img","def apply_smoothing(image, kernel_size=3):\n return cv2.GaussianBlur(image, (kernel_size, kernel_size), 0)","def compress(self, samples):\n rms = np.sqrt(np.dot(samples, samples) / window)\n power = self.power * (1.0 - self.smooth) + rms * self.smooth\n self.power = power\n if power <= 1e-40:\n samples *= 0\n return\n db_in = 10.0 * math.log10(power)\n if db_in <= self.limit:\n samples *= 0\n return\n db_out = self.cf(db_in)\n db_gain = db_out - db_in + self.postgain\n gain = 10**(0.1 * db_gain)\n samples *= gain","def get_ideal_low_pass_filter(shape, cutoff, order):\n \n print(\"ideal_low_pass_filter = \")\n print(\"cutoff: \",cutoff)\n print(\"order: \",order)\n \n filter = np.zeros(shape)\n\n D = 0\n\n for i in range(shape[0]):\n for j in range(shape[1]):\n\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\n\n if D <= cutoff:\n filter[i, j] = 1\n else:\n filter[i, j] = 0\n\n # return filter\n return process_filter(image, filter)","def filter(self, data):\n self.data = pysap.Image(data=self.flt.filter(data))","def design_filter(interpolation, decimation, fractional_bw):\n\n if fractional_bw >= 0.5 or fractional_bw <= 0:\n raise ValueError('Invalid fractional bandwidth, must be in (0, 0.5)')\n\n if decimation < 1 or interpolation < 1:\n raise ValueError('Invalid interpolation or decimation rate. Must be a non-zero positive integer.')\n\n beta = 7.0\n halfband = 0.5\n rate = float(interpolation)/float(decimation)\n if(rate >= 1.0):\n trans_width = halfband - fractional_bw\n mid_transition_band = halfband - trans_width/2.0\n else:\n trans_width = rate*(halfband - fractional_bw)\n mid_transition_band = rate*halfband - trans_width/2.0\n\n taps = filter.firdes.low_pass(interpolation, # gain\n interpolation, # Fs\n mid_transition_band, # trans mid point\n trans_width, # transition width\n filter.firdes.WIN_KAISER,\n beta) # beta\n\n return taps","def bandpass_filter_raw_plot(data, fs, f1, f2):\n b, a = sp.butter(N=2, Wn=np.array([f1, f2]) / fs * 2, btype='bandpass') # build a bandpass butterworth filter of order 4, with cut-off frequencies 1 and 45\n w, h = sp.freqz(b, a) # compute the frequency response of the filter\n f = w / np.pi * fs / 2\n plt.figure()\n plt.plot(f, 10 * np.log10(abs(h)))\n plt.xlabel('frequency (Hz)')\n plt.ylabel('Magnitude (dB)')\n plt.title('frequency response of butterworth bandpass [1, 45]Hz')\n plt.grid()\n\n data1 = sp.filtfilt(b, a, data)\n return data1","def lowpassFFT(signal, rate, cutoff):\n fft = np.fft.fft(signal)\n fftfreq = np.fft.fftfreq(len(signal), 1/rate)\n for i, freq in enumerate(fftfreq):\n if abs(freq) >= cutoff:\n fft[i] = 0\n signal = np.fft.ifft(fft)\n return signal","def bandpass_cnt(data, low_cut_hz, high_cut_hz, fs, filt_order=3, axis=0):\n if (low_cut_hz == 0 or low_cut_hz is None) and (\n high_cut_hz == None or high_cut_hz == fs / 2.0):\n log.info(\"Not doing any bandpass, since low 0 or None and \"\n \"high None or nyquist frequency\")\n return data.copy()\n if low_cut_hz == 0 or low_cut_hz == None:\n log.info(\"Using lowpass filter since low cut hz is 0 or None\")\n return lowpass_cnt(data, high_cut_hz, fs, filt_order=filt_order, axis=axis)\n if high_cut_hz == None or high_cut_hz == (fs / 2.0):\n log.info(\n \"Using highpass filter since high cut hz is None or nyquist freq\")\n return highpass_cnt(data, low_cut_hz, fs, filt_order=filt_order, axis=axis)\n\n nyq_freq = 0.5 * fs\n low = low_cut_hz / nyq_freq\n high = high_cut_hz / nyq_freq\n b, a = scipy.signal.butter(filt_order, [low, high], btype='bandpass')\n assert filter_is_stable(a), \"Filter should be stable...\"\n data_bandpassed = scipy.signal.lfilter(b, a, data, axis=axis)\n return data_bandpassed","def apply_filter(a_slice_prev, W, b):\n product = np.multiply(a_slice_prev, W)\n z = np.sum(product) + np.float(b)\n return z","def apply_filter(image: np.ndarray) -> np.ndarray:\n # choose filters to apply\n return clahe(image)","def fastbias(self, fo, fbDac, data, slow):\n if fbDac not in [0, 1]:\n raise RuntimeError('fbDac must be 0 or 1')\n if slow not in [0, 1]:\n raise RuntimeError('slow must be 0 or 1')\n a = {0: 0x100000, 1: 0x200000}[fo]\n b = (data & 0xffff) << 3\n c = fbDac << 19\n d = slow << 2\n self.append(a + b + c + d)\n return self","def apply_band_pass(ftd, freq, omega, bp_wid=1):\n # Find number of frequencies\n nf = len(freq)\n # Find index for band pass, only consider indices of positive freqs\n idx_om = hf.find_nearest_index(freq[0:nf//2], omega)\n # Filter out frequencies left of band pass\n ftd[:,0:idx_om-1-bp_wid] = 0.0\n # Filter out frequencies left of omega\n ftd[:,idx_om+1+bp_wid:-1] = 0.0\n # Correct for lost amplitude\n ftd[:,idx_om-bp_wid:idx_om+bp_wid] = ftd[:,idx_om-bp_wid:idx_om+bp_wid] * 2.0\n return ftd","def bessel_bandpass_filter(data, lowcut, highcut, fs, order=2):\n\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n\n # bessel() and lfilter() are from scipy.signal\n\n b, a = bessel(order, [low, high], btype='band')\n y = lfilter(b, a, data)\n return y","def low_pass(self, x, kernel):\n\n ############################\n ### TODO: YOUR CODE HERE ###\n\n # HANDLE NON-SQUARE KERNELS!!!\n padX = kernel.shape[2]//2\n padY = kernel.shape[3]//2\n filtered_image = F.conv2d(x, kernel, padding=(padX, padY), groups=self.n_channels)\n\n # raise NotImplementedError('`low_pass` function in `models.py` needs to '\n # + 'be implemented')\n\n ### END OF STUDENT CODE ####\n ############################\n\n return filtered_image","def lowpass1(y, dt, fc=3) :\r\n tau=1/(2*np.pi*fc)\r\n alpha=dt/(tau+dt)\r\n y_filt=np.zeros(y.shape)\r\n y_filt[0]=y[0]\r\n for i in np.arange(1,len(y)):\r\n y_filt[i]=alpha*y[i] + (1-alpha)*y_filt[i-1]\r\n return y_filt","def _initial_blur(self):\n if self.init_sigma > self.cur_sigma:\n sigma = sqrt(self.init_sigma * self.init_sigma - self.cur_sigma * self.cur_sigma)\n self.data = gaussian_filter(self.raw, sigma)\n else:\n self.data = self.raw","def _butterworth_scale(ts, low_frequency, high_factor, order,\n sampling_frequency, denominator):\n filtered = _butterworth(ts, low_frequency, high_factor, order,\n sampling_frequency)\n\n return np.divide(filtered, denominator)"],"string":"[\n \"def butter_lowpass_filter(data, cutoff, fs, order=1):\\n b, a = butter_lowpass(cutoff, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=1):\\n b, a = butter_bandpass(lowcut, highcut, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def butter_filter(self, data, low_pass, high_pass, fs, order=10):\\n\\n nyq = fs/2\\n low = low_pass/nyq\\n high = high_pass/nyq\\n\\n b, a = signal.butter(order, [low, high], btype='band')\\n filt_data = np.abs(signal.hilbert(signal.filtfilt(b, a, data, axis=1), axis=1))\\n return filt_data\",\n \"def butterworth_bandpass_filter( values, lowFreq, highFreq, sampleFreq, order=5):\\n nyq = 0.5 * sampleFreq\\n low = lowFreq / nyq\\n high = highFreq /nyq\\n b,a = butter( order, [low,high], btype='band' )\\n return y = lfilter(b, a, data)\",\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=5, axis=0): \\n omega = 0.5 * fs\\n low = lowcut / omega\\n high = highcut / omega\\n b, a = signal.butter(order, [low, high], btype='band')\\n y = signal.lfilter(b, a, data, axis=0)\\n return y\",\n \"def butterworth_filter(signal, Fs, highpassfreq=None, lowpassfreq=None, order=4, filtfunc='filtfilt'):\\n Fn = Fs / 2.\\n \\n # set the function for filtering\\n if filtfunc is 'lfilter':\\n ffunc = spsig.lfilter\\n elif filtfunc is 'filtfilt':\\n ffunc = spsig.filtfilt\\n else:\\n raise ValueError(\\\"filtfunc must to be either 'filtfilt' or 'lfilter'\\\")\\n \\n # set parameters\\n if lowpassfreq and highpassfreq:\\n if highpassfreq < lowpassfreq:\\n Wn = (highpassfreq / Fn, lowpassfreq / Fn)\\n btype = 'bandpass'\\n else:\\n Wn = (lowpassfreq / Fn, highpassfreq / Fn)\\n btype = 'bandstop'\\n elif lowpassfreq:\\n Wn = lowpassfreq / Fn\\n btype = 'lowpass'\\n elif highpassfreq:\\n Wn = highpassfreq / Fn\\n btype = 'highpass'\\n else:\\n raise ValueError(\\\"Specify highpassfreq and/or lowpathfreq\\\")\\n \\n # filter design\\n b, a = spsig.butter(order, Wn, btype=btype)\\n \\n return ffunc(b, a, signal)\",\n \"def _butter_bandpass_filter(self, data: np.ndarray, lowcut: float, highcut: float, fs: float, order: int = 5):\\n b, a = self._butter_bandpass(lowcut, highcut, fs, order=order)\\n y = lfilter(b, a, data)\\n return y\",\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=2):\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n \\n # butter() and lfilter() are from scipy.signal\\n \\n b, a = butter(order, [low, high], btype='band')\\n y = lfilter(b, a, data)\\n return y\",\n \"def butter_lowpass_filter(data: np.ndarray, cutoff: float, fs: float, order: int) -> np.ndarray:\\n nyq = 0.5 * fs\\n normal_cutoff = cutoff / nyq\\n # Get the filter coefficients\\n b, a = signal.butter(order, normal_cutoff, btype='low', analog=False)\\n y = signal.filtfilt(b, a, data)\\n return y\",\n \"def butter_filter(datalist):\\n fs = 200.00\\n fHigh = 50.00\\n fLow = 5.00\\n N=4\\n [b,a]=sg.butter(N,[fLow/fs, fHigh/fs], btype='band')\\n global filtered\\n #IIR filter\\n return sg.filtfilt(b,a,datalist)\",\n \"def lowpass_butter(fs, L, order, data, axis=-1, btype='low'):\\n from scipy.signal import butter, sosfiltfilt\\n\\n nyq = 0.5 * fs # Nyquist frequency\\n low = L / nyq\\n sos = butter(order, low, btype=btype, output='sos') # Coefficients for Butterworth filter\\n filtered = sosfiltfilt(sos, data, axis=axis)\\n\\n return filtered\",\n \"def butter_highpass_filter(data, cutoff, fs, order=1):\\n b, a = butter_highpass(cutoff, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def butter_bandpass_filter(\\n data: numpy.ndarray,\\n lowcut: float,\\n highcut: float,\\n samplerate: float,\\n order: int = 2,\\n):\\n nyq = 0.5 * samplerate\\n lowf = lowcut / nyq\\n highf = highcut / nyq\\n # generic names for coefficients in filters\\n # pylint: disable=invalid-name\\n a, b = butter(order, [lowf, highf], btype=\\\"band\\\")\\n if len(data) < BUTTER_MIN_LENGTH:\\n return None\\n return filtfilt(a, b, data)\",\n \"def Butterworth_Filter(x,order,Low_High,Wn):\\r\\n\\r\\n\\r\\n # Create an order butterworth filter:\\r\\n\\r\\n b, a = signal.butter(order,Wn,Low_High);\\r\\n\\r\\n # Apply the filter to x. Use lfilter_zi to choose the initial condition of the filter:\\r\\n\\r\\n zi = signal.lfilter_zi(b, a);\\r\\n z, _ = signal.lfilter(b, a, x, zi=zi*x[0]);\\r\\n\\r\\n # Apply the filter again, to have a result filtered at an order the same as filtfilt:\\r\\n\\r\\n z2, _ = signal.lfilter(b, a, z, zi=zi*z[0])\\r\\n\\r\\n # Use filtfilt to apply the filter:\\r\\n\\r\\n y = signal.filtfilt(b, a, x);\\r\\n\\r\\n return y;\",\n \"def _butter_lowpass(lowcut, fs, order=4) -> tuple:\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n b, a = butter(order, [low], btype=\\\"low\\\")\\n return b, a\",\n \"def filter_low_pass(x, filt_data, cutoff, fs, order=1, rows=[0,-1]):\\n\\n from scipy.signal import butter, filtfilt\\n import numpy as np\\n import matplotlib.pyplot as plt \\n\\n def butter_lowpass(cutoff, fs, order=5):\\n nyq = 0.5 * fs\\n normal_cutoff = cutoff / nyq\\n b, a = butter(order, normal_cutoff, btype='low', analog=False)\\n return b, a \\n\\n b, a = butter_lowpass(cutoff, fs, order=order)\\n \\n slice_exp = filt_data[rows[0]:rows[1]]\\n lp_slice_exp = filtfilt(b, a, slice_exp)\\n lp = np.append(filt_data[:rows[0]],lp_slice_exp)\\n lp = np.append(lp,filt_data[rows[1]:])\\n\\n f, ax = plt.subplots(1,1,figsize=(8,8))\\n ax.plot(x,filt_data,'k',label='original data')\\n ax.plot(x,lp,'r',label='filtered data')\\n ax.legend(loc='best')\\n\\n return lp\",\n \"def butterworth_filter(freq):\\n\\tf_raw = 1/(0.00000002*100*33)\\n\\tb = np.array([[-32092,15750],[-31238,14895]])*2.0**(-14)\\n\\tomega = 2*np.pi*freq/f_raw\\n\\te1, e2 = np.exp(-1j*omega), np.exp(-2j*omega)\\n\\ttmp = (1+2*e1+e2)**2/(1+b[0,0]*e1+b[0,1]*e2)/(1+b[1,0]*e1+b[1,1]*e2)\\n\\treturn tmp * (1+sum(b[0]))*(1+sum(b[1]))/16\",\n \"def get_butterworth_low_pass_filter(shape, cutoff, order):\\n \\n \\n print(\\\"butterworth_low_pass_filter = \\\")\\n print(\\\"cutoff: \\\",cutoff)\\n print(\\\"order: \\\",order)\\n filter = np.zeros(shape)\\n for i in range(shape[0]):\\n for j in range(shape[1]):\\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\\n filter[i, j] = 1 / (1 + (D / cutoff) ** (2 * order))\\n # print(\\\"\\\\n\\\\n\\\\n\\\\n\\\")\\n # print(filter)\\n # return filter\\n return process_filter(image, filter)\",\n \"def lowpass_filter(data, Wn=0.014, N=2):\\n data = np.array(data)\\n data = data.astype(np.float)\\n # N = 5 # Filter order\\n # Wn = 0.02 # Cutoff frequency\\n B, A = signal.butter(N, Wn, output='ba')\\n\\n # Second, apply the filter\\n tempf = signal.filtfilt(B,A, data)\\n # print(tempf)\\n return tempf\",\n \"def butterworth_bandpass(lowcut, highcut, fs, order=5):\\n nyq = 0.5 * fs # nyquist sampling rate\\n low = lowcut / nyq # normalize frequency\\n high = highcut / nyq # normalize frequency\\n b, a = butter(order, [low, high], btype='band')\\n return b, a\",\n \"def _signal_filter_butterworth(signal, sampling_rate=1000, lowcut=None, highcut=None, order=2):\\n if lowcut is not None and highcut is not None:\\n sos = scipy.signal.butter(order, [lowcut, highcut], btype=\\\"bandpass\\\", output='sos', fs=sampling_rate)\\n elif lowcut is not None:\\n sos = scipy.signal.butter(order, [lowcut], btype=\\\"highpass\\\", output='sos', fs=sampling_rate)\\n elif highcut is not None:\\n sos = scipy.signal.butter(order, [highcut], btype=\\\"lowpass\\\", output='sos', fs=sampling_rate)\\n\\n filtered = scipy.signal.sosfiltfilt(sos, signal)\\n return filtered\",\n \"def ButterworthFilter(\\n self,\\n name: str,\\n cutoffFrequency: float,\\n order: int = 2,\\n operation: SymbolicConstant = NONE,\\n halt: Boolean = OFF,\\n limit: float = None,\\n invariant: SymbolicConstant = NONE,\\n ) -> ButterworthFilter:\\n self.filters[name] = butterworthFilter = ButterworthFilter(\\n name, cutoffFrequency, order, operation, halt, limit, invariant\\n )\\n return butterworthFilter\",\n \"def _butter_bandpass(lowcut: float, highcut: float, fs: float, order: int = 5) -> tuple:\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n b, a = butter(order, [low, high], btype=\\\"band\\\")\\n return b, a\",\n \"def butter_bandstop_filter(data, lowcut, highcut, fs, order):\\n\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n\\n i, u = sg.butter(order, (low, high), btype='bandstop')\\n y = sg.filtfilt(i, u, data)\\n return y\",\n \"def butterworth(dx, order, cutoff, /, btype='low'):\\n # Initial stuff\\n # * Need to run *forward and backward* to prevent time-shifting.\\n # * The 'analog' means units of cutoffs are rad/s.\\n # * Unlike Lanczos filter, the *length* of this should be\\n # determined always as function of timestep, because really high\\n # order filters can get pretty wonky.\\n # * Cutoff is point at which gain reduces to 1/sqrt(2) of the\\n # initial frequency. If doing bandpass, can\\n # N = (width/dx)//1 # convert to timestep units\\n # N = (N//2)*2 + 1 # odd numbered\\n N = order # or order\\n analog = False # lfilter seems to need digital\\n if analog:\\n cutoff = 2 * np.pi / (cutoff / dx) # from wavelengths to rad/steps\\n else:\\n cutoff = 1.0 / cutoff # to Hz, or cycles/unit\\n cutoff = cutoff * (2 * dx) # to cycles / (2 timesteps)\\n if cutoff > 1:\\n raise ValueError(\\n 'Cuttoff frequency must be in [0, 1]. Remember you pass a cutoff '\\n '*wavelength* to this function, not a frequency.'\\n )\\n\\n # Apply filter\\n print(f'Order-{order} Butterworth filter')\\n b, a = signal.butter(N - 1, cutoff, btype=btype, analog=analog, output='ba')\\n return b, a\",\n \"def lowpass_filter(s, sample_rate, cutoff_freq, filter_order=5, rescale=False):\\n #create a butterworth filter\\n nyq = sample_rate / 2.0\\n b,a = filter_design.butter(filter_order, cutoff_freq / nyq)\\n\\n #filter the signal\\n filtered_s = filtfilt(b, a, s)\\n\\n if rescale:\\n #rescale filtered signal\\n filtered_s /= filtered_s.max()\\n filtered_s *= s.max()\\n\\n return filtered_s\",\n \"def bandpass_filter(s, sample_rate, low_freq, high_freq, filter_order=5, rescale=False):\\n #create a butterworth filter\\n nyq = sample_rate / 2.0\\n f = np.array([low_freq, high_freq]) / nyq\\n b,a = filter_design.butter(filter_order, f, btype='bandpass')\\n\\n #filter the signal\\n filtered_s = filtfilt(b, a, s)\\n\\n if rescale:\\n #rescale filtered signal\\n filtered_s /= filtered_s.max()\\n filtered_s *= s.max()\\n\\n return filtered_s\",\n \"def bandpass_filter_audio(audio, f_low=400, f_high=450):\\n filtered_audio = core.sinc_filter(audio, f_low, window_size=256, high_pass=True)\\n filtered_audio = core.sinc_filter(filtered_audio, f_high, window_size=256, high_pass=False)\\n return tf.squeeze(filtered_audio)\",\n \"def get_butterworth_high_pass_filter(shape, cutoff, order):\\n \\n # Hint: May be one can use the low pass filter function to get a high pass mask\\n print(\\\"butterworth_high_pass_filter = \\\")\\n print(\\\"cutoff: \\\",cutoff)\\n print(\\\"order: \\\",order)\\n filter = get_butterworth_low_pass_filter(shape, cutoff, order)\\n\\n for i in range(shape[0]):\\n for j in range(shape[1]):\\n filter[i, j] = 1 - filter[i, j]\\n\\n # return filter\\n return process_filter(image, filter)\",\n \"def init_lowpass(self, lowpass_cutoff, lowpass_order):\\n if lowpass_cutoff > 0 or self._fs_out < self._fs_in:\\n nyquist = self._fs_out / 2\\n if lowpass_cutoff > nyquist or (self._fs_out < self._fs_in and\\n lowpass_cutoff == 0):\\n lowpass_cutoff = 0.75 * nyquist\\n lowpass_order = 10\\n print('Using %gHz low-pass filter to prevent aliasing'\\n % lowpass_cutoff)\\n self._lowpass_cutoff = lowpass_cutoff\\n self._lowpass_order = lowpass_order\\n logging.info('Low-pass filtering the data with the 3dB point at %gHz.',\\n lowpass_cutoff)\\n self._lowpass_sos = scipy.signal.butter(lowpass_order, lowpass_cutoff,\\n 'lp', output='sos', fs=self.fs_in)\\n self._lowpass_state = None # to be created later when we know sizes\\n else:\\n self._lowpass_sos = None\",\n \"def compute(self):\\n Y = self.data[1]\\n # Create an order 3 lowpass butterworth filter\\n b, a = signal.butter(3, 0.05)\\n # Apply the filter to Y. Use lfilter_zi to choose the initial condition of the filter\\n zi = signal.lfilter_zi(b, a)\\n z, _ = signal.lfilter(b, a, Y, zi=zi * Y[0])\\n # Apply the filter again, to have a result filtered at an order the same as filtfilt\\n z2, _ = signal.lfilter(b, a, z, zi=zi * z[0])\\n # Use filtfilt to apply the filter\\n self.data[2] = signal.filtfilt(b, a, Y)\\n self.data[3] = self.data[2] - self.data[1] - self.dataSpan * 0.3\\n self.updatePlot()\",\n \"def get_butterworth_high_pass_filter(self, shape, cutoff, order):\\r\\n\\r\\n #Hint: May be one can use the low pass filter function to get a high pass mask\\r\\n # 1 - butter low pass\\r\\n mask = 1 - self.get_butterworth_low_pass_filter(shape, cutoff, order)\\r\\n\\r\\n return mask\",\n \"def butter_bp_coe(lowcut, highcut, fs, order=1):\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n b, a = butter(order, [low, high], btype='band')\\n return b, a\",\n \"def highpass_filter(s, sample_rate, cutoff_freq, filter_order=5, rescale=False):\\n #create a butterworth filter\\n nyq = sample_rate / 2.0\\n b,a = filter_design.butter(filter_order, cutoff_freq / nyq, btype='high')\\n\\n #filter the signal\\n filtered_s = filtfilt(b, a, s)\\n\\n if rescale:\\n #rescale filtered signal\\n filtered_s /= filtered_s.max()\\n filtered_s *= s.max()\\n\\n return filtered_s\",\n \"def filter(sig, sampling_rate, lc, hc, order=2):\\n\\n # Construct butterworth band-pass filter\\n b1, a1 = butter(order, [2.0 * lc / sampling_rate,\\n 2.0 * hc / sampling_rate], btype=\\\"band\\\")\\n nchan, nsamp = sig.shape\\n fsig = np.copy(sig)\\n\\n # Apply cosine taper then apply band-pass filter in both directions\\n for ch in range(0, nchan):\\n fsig[ch, :] = fsig[ch, :] - fsig[ch, 0]\\n tap = cosine_taper(len(fsig[ch, :]), 0.1)\\n fsig[ch, :] = fsig[ch, :] * tap\\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, ::-1])[::-1]\\n fsig[ch, :] = lfilter(b1, a1, fsig[ch, :])\\n\\n return fsig\",\n \"async def low_pass(\\n client,\\n event,\\n smoothing: P('float', 'smoothing', min_value = 0.0, max_value = 5.0),\\n):\\n player = get_player_or_abort(client, event)\\n \\n filter = LowPass(smoothing)\\n player.add_filter(filter)\\n await player.apply_filters()\\n \\n return create_filter_added_embed(filter)\",\n \"def iirfilter(x, N=4, pass_freq=0.7 / 12.):\\n b, a = signal.butter(N, pass_freq, \\\"low\\\", analog=False)\\n return signal.filtfilt(b, a, x)\",\n \"def bpfilter(\\n data: numpy.ndarray, short_min: float = 2, long_min: float = 12\\n) -> Optional[numpy.ndarray]:\\n return butter_bandpass_filter(\\n data, 1 / (long_min * 60), 1 / (short_min * 60), 1 / DATA_RATE\\n )\",\n \"def butter_filter(image, n, f0):\\n [ny, nx] = image.shape\\n dx = 2.0/nx\\n dy = 2.0/nx\\n dfx = 0.5\\n dfy = 0.5\\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\\n FX, FY = np.meshgrid(fx, fy)\\n shift = np.exp(-2*np.pi*1j*(FX+FY))\\n sin_pad = np.sin(image)\\n cos_pad = np.cos(image)\\n ft_sin = shift * np.fft.fftshift(np.fft.fft2(sin_pad))\\n ft_cos = shift * np.fft.fftshift(np.fft.fft2(cos_pad))\\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\\n sin_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_sin)) / shift)\\n cos_filt = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_cos)) / shift)\\n phase_filt = np.arctan2(sin_filt, cos_filt)\\n return phase_filt\",\n \"def lowpass_filter(self, data, reset=False):\\n data = np.asarray(data)\\n if self._lowpass_sos is not None:\\n if self._lowpass_state is None or reset:\\n self.lowpass_filter_reset(data)\\n data, self._lowpass_state = scipy.signal.sosfilt(\\n self._lowpass_sos, data, zi=self._lowpass_state, axis=0)\\n return data\\n return data\",\n \"def butterworthsmoothing(df, column_names: list = None, Wn = 0.015):\\n\\n if column_names is None:\\n return df\\n else:\\n # First, design the Buterworth filter\\n N = 2 # Filter order\\n Wn = Wn # Cutoff frequency\\n B, A = signal.butter(N, Wn, output='ba')\\n for i in column_names:\\n df[i] = signal.filtfilt(B, A, df[i])\\n df.dropna(axis=0, how='any', inplace=True)\\n return df\",\n \"def apply_filter(self, image):\\n pass\",\n \"def filter_pupil(self, hp=0.01, lp=10.0):\\r\\n self.logger.info('Band-pass filtering of pupil signals, hp = %2.3f, lp = %2.3f'%(hp, lp))\\r\\n\\r\\n self.lp_filt_pupil = _butter_lowpass(data=self.interpolated_pupil.astype('float64'), highcut=lp, fs=self.sample_rate, order=3)\\r\\n self.hp_filt_pupil = _butter_highpass(data=self.interpolated_pupil.astype('float64'), lowcut=hp, fs=self.sample_rate, order=3)\\r\\n self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\\r\\n self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\\r\\n\\r\\n # import mne\\r\\n # from mne import filter\\r\\n # self.lp_filt_pupil = mne.filter.low_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=lp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\\r\\n # self.hp_filt_pupil = mne.filter.high_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=hp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\\r\\n # self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\\r\\n # self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\\r\",\n \"def butter_hpf(highcut, fs, order):\\n nyq = 0.5 * fs\\n high = highcut / nyq\\n b, a = signal.butter(order, high, btype='highpass')\\n w, h = signal.freqz(b, a, worN=1000)\\n# plt.figure()\\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\\n return b, a\",\n \"def bandpass_filter(data, lowcut, highcut, fs=2000, numtaps=255):\\n nyq = fs / 2\\n\\n # design filter\\n fe1 = lowcut / nyq\\n fe2 = highcut / nyq\\n b = firwin(numtaps, (fe1, fe2), pass_zero=False)\\n\\n filtered = lfilter(b, 1, data)\\n\\n return filtered\",\n \"def filt_bp(sig: np.ndarray, Ss: int, Cfs0: int, Cfs1: None,\\n order=5) -> np.ndarray:\\n nyq = 0.5 * Ss\\n normal_cutoff1 = Cfs0 / nyq\\n normal_cutoff2 = Cfs1 / nyq\\n b, a = butter(order, (normal_cutoff1, normal_cutoff2),\\n btype='band',\\n analog=False)\\n return lfilter(b, a, sig)\",\n \"def get_butterworth_low_pass_filter(self, shape, cutoff, order):\\n \\n mask = zeros(shape)\\n row_size, col_size = shape[0], shape[1]\\n center_row, center_col = row_size/2 , col_size/2\\n for r in range(0, row_size):\\n for c in range(0, col_size):\\n freq_dist = sqrt( (r-center_row)**2 + (c-center_col)**2 )\\n mask[r,c] = (1/(1+(freq_dist/cutoff)*order)) if freq_dist > cutoff else 1.0\\n\\n return mask\",\n \"def lowpass(data,filterSize=None):\\n\\n def convolve(signal,kernel):\\n pad=np.ones(len(kernel)/2)\\n signal=np.concatenate((pad*signal[0],signal,pad*signal[-1]))\\n signal=np.convolve(signal,kernel,mode='same')\\n signal=signal[len(pad):-len(pad)]\\n return signal\\n\\n def kernel_gaussian(size=100, sigma=None, forwardOnly=False):\\n if sigma is None:\\n sigma=size/10\\n size=int(size)\\n points=np.exp(-np.power(np.arange(size)-size/2,2)/(2*np.power(sigma,2)))\\n if forwardOnly:\\n points[:int(len(points)/2)]=0\\n return points/sum(points)\\n\\n if filterSize is None:\\n filterSize=len(data)/10\\n kernel=kernel_gaussian(size=filterSize)\\n data=convolve(data,kernel) # do the convolution with padded edges\\n return data\",\n \"def A_weight(signal, fs):\\n\\n b, a = A_weighting(fs)\\n return lfilter(b, a, signal)\",\n \"def butter_lpf(fc, fs, order):\\n nyq = 0.5 * fs\\n high = fc / nyq\\n b, a = signal.butter(order, high, btype='lowpass', analog=False)\\n w, h = signal.freqz(b, a, worN=1000)\\n# plt.figure()\\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\\n return b, a\",\n \"def make_butter_so(self, wn, order):\\n \\n nyquist = self.s_freq/2\\n wn_arr = np.asarray(wn)\\n \\n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\\n \\n self.so_sos = butter(order, wn_arr, btype='bandpass', output='sos')\\n print(f\\\"Zero phase butterworth filter successfully created: order = {order}x{order}, bandpass = {wn}\\\")\",\n \"def butter_filter_unwrapped(image, n, f0, pad = False):\\n if pad == True:\\n res = [2**kji for kji in range(15)]\\n N_int_x = image.shape[1]\\n N_int_y = image.shape[0]\\n nx_pad = np.where(res > np.tile(N_int_x, len(res)))\\n nx_pad = res[nx_pad[0][0]]\\n ny_pad = np.where(res > np.tile(N_int_y, len(res)))\\n ny_pad = res[ny_pad[0][0]]\\n dif_x = (nx_pad - N_int_x)/2\\n dif_y = (ny_pad - N_int_y)/2\\n orig_shape = image.shape\\n image = np.lib.pad(image, ((dif_y, dif_y), (dif_x, dif_x)), 'reflect')\\n \\n [ny, nx] = image.shape\\n dx = 2.0/nx\\n dy = 2.0/ny\\n dfx = 0.5\\n dfy = 0.5\\n fx = np.arange(-0.5/dx, 0.5/dx, dfx)\\n fy = np.arange(-0.5/dy, 0.5/dy, dfy)\\n FX, FY = np.meshgrid(fx, fy)\\n shift = np.exp(-2*np.pi*1j*(FX+FY))\\n butt_filt = 1/(1 + ( np.sqrt(FX**2 + FY**2)/f0)**(2*n))\\n ft_img = shift * np.fft.fftshift(np.fft.fft2(image))\\n \\n buttered = np.real(np.fft.ifftshift(np.fft.ifft2(butt_filt * ft_img))/ shift)\\n if pad == True:\\n assert(buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x].shape == orig_shape)\\n return buttered[dif_y: ny_pad - dif_y, dif_x:nx_pad - dif_x]\\n else:\\n assert(buttered.shape == image.shape)\\n return buttered\",\n \"def PassFilter(xdata, ydata, fs, order=5, btype='high', freq = None, cutoff=None):\\r\\n if freq == None:\\r\\n freq = _frequency_estimation(xdata, ydata)\\r\\n if cutoff==None:\\r\\n cutoff = _cutoff(xdata, ydata, btype, fs, ff = freq)\\r\\n b, a = _butter_pass(cutoff, fs, order=order, btype=btype)\\r\\n y = signal.filtfilt(b, a, ydata, padtype='even')\\r\\n return y\",\n \"def _butter_pass(cutoff, fs, order=5, btype='high'):\\r\\n nyq = 0.5*fs\\r\\n normal_cutoff = cutoff/nyq\\r\\n# print \\\"normalized cutoff: \\\", normal_cutoff\\r\\n if normal_cutoff >= 1.:\\r\\n normal_cutoff = 1.\\r\\n b, a = signal.butter(order, normal_cutoff, btype=btype, analog=False)\\r\\n return b, a\",\n \"def get_butterworth_low_pass_filter(self, shape, cutoff, order):\\r\\n P = shape[0]\\r\\n Q = shape[1]\\r\\n mask = np.zeros((P, Q))\\r\\n for u in range(P):\\r\\n for v in range(Q):\\r\\n dist = ((u - (P / 2)) ** 2 + (v - (Q / 2)) ** 2) ** (1 / 2)\\r\\n mask[u][v] = 1 / (1 + (dist/cutoff)**(2*order))\\r\\n\\r\\n return mask\",\n \"def make_butter_sp(self, wn, order):\\n nyquist = self.s_freq/2\\n wn_arr=np.asarray(wn)\\n if np.any(wn_arr <=0) or np.any(wn_arr >=1):\\n wn_arr = wn_arr/nyquist # must remake filter for each pt bc of differences in s_freq\\n \\n self.sp_sos = butter(order, wn_arr, btype='bandpass', output='sos')\\n print(f\\\"Zero phase butterworth filter successfully created: order = {order}x{order} bandpass = {wn}\\\")\",\n \"def _get_fir_filter(passband, fs, order=183, weights=[5.75, 1., 5.75], mask=[0, 1, 0]):\\n # return remez(order, passband, mask, weights, Hz=fs), 1.\\n return remez(order, passband, mask, Hz=fs), 1.\",\n \"def bandpassFilter (self, lowerFreq, upperFreq):\\n self.bandpassLimits = (lowerFreq, upperFreq)\\n # stuff to do\",\n \"def filters(self, low_freq=1/7, high_freq=128, notch_freq=50):\\n self.raw.filter(l_freq=low_freq, h_freq=high_freq)\\n self.raw.notch_filter(range(notch_freq, high_freq, notch_freq), filter_length='auto',\\n phase='zero', fir_design='firwin')\",\n \"def init_highpass(self, highpass_cutoff, highpass_order):\\n if highpass_cutoff > 0:\\n self._highpass_cutoff = highpass_cutoff\\n self._highpass_order = highpass_order\\n logging.info('High-pass filtering the data with the 3dB point at %gHz.',\\n highpass_cutoff)\\n self._highpass_sos = scipy.signal.butter(highpass_order, highpass_cutoff,\\n 'hp', output='sos',\\n fs=self.fs_in)\\n self._highpass_state = None # to be created later when we know sizes\\n else:\\n self._highpass_sos = None\",\n \"def get_gaussian_low_pass_filter(shape, cutoff, order):\\n \\n print(\\\"gaussian_low_pass_filter = \\\")\\n print(\\\"cutoff: \\\",cutoff)\\n print(\\\"order: \\\",order)\\n filter = np.zeros(shape)\\n\\n for i in range(shape[0]):\\n for j in range(shape[1]):\\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\\n\\n filter[i, j] = math.exp(-D ** 2 / (2 * (cutoff ** 2)))\\n\\n # return filter\\n return process_filter(image, filter)\",\n \"def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=(500, 10000)):\\n if freq_cutoffs[0] <= 0:\\n raise ValueError('Low frequency cutoff {} is invalid, '\\n 'must be greater than zero.'\\n .format(freq_cutoffs[0]))\\n\\n Nyquist_rate = samp_freq / 2\\n if freq_cutoffs[1] >= Nyquist_rate:\\n raise ValueError('High frequency cutoff {} is invalid, '\\n 'must be less than Nyquist rate, {}.'\\n .format(freq_cutoffs[1], Nyquist_rate))\\n\\n if rawsong.shape[-1] < 387:\\n numtaps = 64\\n elif rawsong.shape[-1] < 771:\\n numtaps = 128\\n elif rawsong.shape[-1] < 1539:\\n numtaps = 256\\n else:\\n numtaps = 512\\n\\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\\n freq_cutoffs[1] / Nyquist_rate])\\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\\n # window to design filter, but default for matlab's fir1\\n # is actually Hamming\\n # note that first parameter for scipy.signal.firwin is filter *length*\\n # whereas argument to matlab's fir1 is filter *order*\\n # for linear FIR, filter length is filter order + 1\\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\\n a = np.zeros((numtaps+1,))\\n a[0] = 1 # make an \\\"all-zero filter\\\"\\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\\n return filtsong\",\n \"def lowPassFilter(img, window=30):\\n gray = grayscale(img)\\n\\tdft = cv2.dft(np.float32(gray), flags = cv2.DFT_COMPLEX_OUTPUT)\\n\\tdft_shift = np.fft.fftshift(dft)\\n\\trows, cols = gray.shape\\n\\tcrow, ccol = rows/2, cols/2\\n\\tmask = np.zeros((rows, cols, 2), np.uint8)\\n\\tmask[crow-window:crow+window, ccol-window:ccol+window] = 1\\n\\tfshift = dft_shift*mask\\n\\tf_ishift = np.fft.ifftshift(fshift)\\n\\timg_back = cv2.idft(f_ishift)\\n\\timg_back = cv2.magnitude(img_back[:,:,0], img_back[:,:,1])\\n\\treturn img_back\",\n \"def butterworth_filter(dft4img, stopband2=10, order=3, showdft=False):\\n h, w = dft4img.shape[0], dft4img.shape[1]\\n P = h / 2\\n Q = w / 2\\n dst = np.zeros((h, w, 3), np.float64)\\n for i in range(h):\\n for j in range(w):\\n r2 = float((i - P) ** 2 + (j - Q) ** 2)\\n if r2 == 0:\\n r2 = 1.0\\n dst[i, j] = 1 / (1 + (r2 / stopband2) ** order)\\n dst = np.float64(dst)\\n if showdft:\\n cv2.imshow(\\\"butterworth\\\", cv2.magnitude(dst[:, :, 0], dst[:, :, 1]))\\n return dst\",\n \"def filters(array, sample_frequency):\\n strain = TimeSeries(array, sample_rate=int(sample_frequency))\\n white_data = strain.whiten(fftlength=4, fduration=4)\\n bp_data = white_data.bandpass(50, 250)\\n return bp_data.value\",\n \"def A_weighting(fs):\\n b, a = A_weighting_analog()\\n\\n # Use the bilinear transformation to get the digital filter.\\n return bilinear(b, a, fs)\",\n \"def bandpass(filename,f1,f2,Q,wout=True,plot=True):\\n start=time.time()\\n n, data, data_dB,sr,ch=inputwav(filename)\\n b, a = butter(Q,Wn=(f1/sr,f2/sr),btype='bandpass')\\n data_filtered=lfilter(b,a,data,axis=0)\\n print('Applying FFT...')\\n if wout==True:\\n print('Exporting...')\\n sf.write(filename[0:len(filename)-4]+'_BP.wav',data_filtered,sr,'PCM_16')\\n if plot==True:\\n print('Plotting...')\\n py.close()\\n w, h = freqz(b,a,worN=16384)\\n fig, (ax1, ax2) = py.subplots(nrows=2)\\n ax1.semilogx(0.5*sr*w/np.pi,abs(h),'k-')\\n ax1.set_xlabel('Frequency (Hz)')\\n ax1.set_ylabel('Rel. Amplitude')\\n ax1.grid()\\n ax1.set_ylim(0,1.1)\\n ax1.set_xlim(1,20000)\\n ax2.plot(data,'k-',label='Raw data')\\n ax2.plot(data_filtered,'m-',lw=1,label='Filtered data')\\n ax2.set_xlim(0,10000)\\n ax2.set_ylim(-1,1)\\n ax2.set_ylabel('Amplitude (Norm Bits)')\\n ax2.set_xlabel('Samples')\\n ax2.legend(loc=2,frameon=False,ncol=2)\\n py.subplots_adjust(hspace=0.35) \\n print('Done!')\\n end=time.time()\\n elapsed=int(1000*(end-start))\\n print('...............................')\\n print('Completed in '+str(elapsed)+' milliseconds.')\\n return data_filtered\",\n \"def bandpass_filtfilt(rawsong, samp_freq, freq_cutoffs=None):\\n\\n Nyquist_rate = samp_freq / 2\\n if freq_cutoffs is None:\\n freq_cutoffs = [500, 10000]\\n if rawsong.shape[-1] < 387:\\n numtaps = 64\\n elif rawsong.shape[-1] < 771:\\n numtaps = 128\\n elif rawsong.shape[-1] < 1539:\\n numtaps = 256\\n else:\\n numtaps = 512\\n\\n cutoffs = np.asarray([freq_cutoffs[0] / Nyquist_rate,\\n freq_cutoffs[1] / Nyquist_rate])\\n # code on which this is based, bandpass_filtfilt.m, says it uses Hann(ing)\\n # window to design filter, but default for matlab's fir1\\n # is actually Hamming\\n # note that first parameter for scipy.signal.firwin is filter *length*\\n # whereas argument to matlab's fir1 is filter *order*\\n # for linear FIR, filter length is filter order + 1\\n b = scipy.signal.firwin(numtaps + 1, cutoffs, pass_zero=False)\\n a = np.zeros((numtaps+1,))\\n a[0] = 1 # make an \\\"all-zero filter\\\"\\n padlen = np.max((b.shape[-1] - 1, a.shape[-1] - 1))\\n filtsong = scipy.signal.filtfilt(b, a, rawsong, padlen=padlen)\\n return filtsong\",\n \"def get_butterworth_high_pass_filter(self, shape, cutoff, order):\\n\\n #Hint: May be one can use the low pass filter function to get a high pass mask\\n mask = zeros(shape)\\n row_size, col_size = shape[0], shape[1]\\n center_row, center_col = row_size/2 , col_size/2\\n for r in range(0, row_size):\\n for c in range(0, col_size):\\n freq_dist = sqrt( (r-center_row)**2 + (c-center_col)**2 )\\n mask[r,c] = (1/(1+(freq_dist/cutoff)*order*2)) if freq_dist < cutoff else 1.0\\n\\n return mask\\n # return 1 - self.get_butterworth_low_pass_filter(shape, cutoff, order*2) # wrong ?\",\n \"def butterworth(path_to_data, dtype, n_channels, data_order,\\n low_frequency, high_factor, order, sampling_frequency,\\n max_memory, output_path, output_dtype, standarize=False,\\n output_filename='filtered.bin', if_file_exists='skip',\\n processes='max'):\\n processes = multiprocess.cpu_count() if processes == 'max' else processes\\n\\n # init batch processor\\n bp = BatchProcessor(path_to_data, dtype, n_channels, data_order,\\n max_memory, buffer_size=200)\\n\\n if standarize:\\n bp_ = BatchProcessor(path_to_data, dtype, n_channels, data_order,\\n max_memory, buffer_size=0)\\n\\n filtering = partial(_butterworth, low_frequency=low_frequency,\\n high_factor=high_factor,\\n order=order,\\n sampling_frequency=sampling_frequency)\\n\\n # if standarize, estimate sd from first batch and use\\n # _butterworth_scale function, pass filtering to estimate sd from the\\n # filtered data\\n sd = standard_deviation(bp_, sampling_frequency,\\n preprocess_fn=filtering)\\n fn = partial(_butterworth_scale, denominator=sd)\\n # add name to the partial object, since it is not added...\\n fn.__name__ = _butterworth_scale.__name__\\n else:\\n # otherwise use _butterworth function\\n fn = _butterworth\\n\\n _output_path = os.path.join(output_path, output_filename)\\n\\n (path,\\n params) = bp.multi_channel_apply(fn, mode='disk',\\n cleanup_function=fix_indexes,\\n output_path=_output_path,\\n if_file_exists=if_file_exists,\\n cast_dtype=output_dtype,\\n low_frequency=low_frequency,\\n high_factor=high_factor,\\n order=order,\\n sampling_frequency=sampling_frequency,\\n processes=processes)\\n\\n return path, params\",\n \"def apply_filter(self, image):\\n gauss_low = cv2.GaussianBlur(image, ksize=(0,0), sigmaX=self._sigma_low , sigmaY=self._sigma_low)\\n gauss_high = cv2.GaussianBlur(image, ksize=(0,0), sigmaX=self._sigma_high, sigmaY=self._sigma_high)\\n\\n filtered_image = gauss_low - gauss_high\\n\\n return normalize(filtered_image, nb_bits=8)\",\n \"def highpass_filter(self, data, reset=False):\\n data = np.asarray(data)\\n if self._highpass_sos is not None:\\n if self._highpass_state is None or reset:\\n self.highpass_filter_reset(data)\\n data, self._highpass_state = scipy.signal.sosfilt(\\n self._highpass_sos, data, zi=self._highpass_state, axis=0)\\n return data\\n return data\",\n \"def __band_filter(data: dict, lowFreq: Union[int, float], highFreq: Union[int, float], timestep: int=0,\\n samplingFreq: int=240, order: int=5, eegSensor: int=0, filterType: str='bandpass',\\n lengthOfTestSeconds: Union[int, float]=32, example: int=0) -> dict:\\n #Test\\n # Filter.__band_filter_test(data=data, low=lowFreq, high=highFreq, samplingFreq=samplingFreq, order=order,\\n # eegSensor=eegSensor, filterType=filterType, lengthOfTestSeconds=lengthOfTestSeconds)\\n #Code\\n nyq = 0.5 * samplingFreq\\n low = lowFreq / nyq\\n high = highFreq / nyq\\n b, a = signal.butter(order, [low, high], btype=filterType)\\n y = signal.lfilter(b, a, data['Signal'])\\n ##Graph - This belongs somewhere else probably.\\n # t = np.linspace(0, len(data), len(data), endpoint=False)\\n # plt.plot(t, y, label='Sensor #' + str(eegSensor) + ' (' + str(lowFreq) + '-' + str(highFreq) + ') Hz')\\n # plt.grid(True)\\n # plt.axis('tight')\\n # plt.xticks(range(10), range(lengthOfTestSeconds)) ##32 seconds per test?\\n # plt.xlabel(\\\"Time in Seconds\\\")\\n # plt.legend(loc='upper left')\\n # plt.show()\\n output = {}\\n timestep = []\\n for index, eegChannel in enumerate(y[0]):#the extra [0] is becuase signal.lfilter() puts it in a 1D array. Grrr\\n timestep.append(eegChannel)\\n output['Signal'] = timestep\\n Visualization.channelGraph(y[0][0])\\n return output #output is 2D 64xTimeSamples\",\n \"def lowpass_filter_reset(self, data):\\n zi = scipy.signal.sosfilt_zi(self._lowpass_sos)\\n self._lowpass_state = data[0, :] * np.repeat(zi[:, :, np.newaxis],\\n data.shape[1], axis=2)\\n logging.info('Resetting the low-pass filter state.')\",\n \"def highPassFilter(img, window=30):\\n gray = grayscale(img)\\n\\tf = np.fft.fft2(gray)\\n\\tfshift = np.fft.fftshift(f)\\n\\trows, cols = gray.shape\\n\\tcrow, ccol = rows/2, cols/2\\n\\tfshift[crow-window:crow+window, ccol-window:ccol+window] = 0\\n\\tf_ishift = np.fft.ifftshift(fshift)\\n\\timg_back = np.fft.ifft2(f_ishift)\\n\\timg_back = np.abs(img_back)\\n\\treturn img_back\",\n \"def filtroBilateral(frame):\\n fb = cv2.bilateralFilter(frame, 0, 32, 2)\\n return fb\",\n \"def band_pass_eeg(eeg, freq_range, order=4):\\n return ButterworthFilter(eeg, freq_range, filt_type='pass', order=order).filter()\",\n \"def filt_lp(sig: np.ndarray, Ss: int, Cfs: int, Cfs1: None,\\n order=5) -> np.ndarray:\\n nyq = 0.5 * Ss\\n normal_cutoff = Cfs / nyq\\n b, a = butter(order, normal_cutoff, btype='low', analog=False)\\n return lfilter(b, a, sig)\",\n \"def bandpass_filter(files, lowpass_freq=0.1, highpass_freq=0.01, tr=2):\\n import os\\n\\n import nibabel as nb\\n import numpy as np\\n from nipype.utils.filemanip import (\\n filename_to_list,\\n list_to_filename,\\n split_filename\\n )\\n\\n fs = 1./tr\\n\\n out_files = []\\n for filename in filename_to_list(files):\\n path, name, ext = split_filename(filename)\\n out_file = os.path.join(os.getcwd(), name + '_bandpassed' + ext)\\n\\n img = nb.load(filename)\\n timepoints = img.shape[-1]\\n F = np.zeros((timepoints))\\n\\n lowidx = int(timepoints / 2) + 1\\n if lowpass_freq > 0:\\n lowidx = np.round(float(lowpass_freq) / fs * timepoints)\\n\\n highidx = 0\\n if highpass_freq > 0:\\n highidx = np.round(float(highpass_freq) / fs * timepoints)\\n F[int(highidx):int(lowidx)] = 1\\n F = ((F + F[::-1]) > 0).astype(int)\\n data = img.get_data()\\n if np.all(F == 1):\\n filtered_data = data\\n else:\\n filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F))\\n img_out = nb.Nifti1Image(filtered_data, img.affine, img.header)\\n img_out.to_filename(out_file)\\n out_files.append(out_file)\\n\\n return list_to_filename(out_files)\",\n \"def light(brightness, filter):\\n brightness = clamp(MIN_BRIGHTNESS, round(brightness), MAX_BRIGHTNESS)\\n for col in range(DISPLAY_WIDTH):\\n for row in range(DISPLAY_HEIGHT):\\n if filter(col, row):\\n microbit.display.set_pixel(col, row, brightness)\",\n \"def filt_hp(sig: np.ndarray, Ss: int, Cfs: int, Cfs1: None,\\n order=5) -> np.ndarray:\\n nyq = 0.5 * Ss\\n normal_cutoff = Cfs / nyq\\n b, a = butter(order, normal_cutoff, btype='high', analog=False)\\n return lfilter(b, a, sig)\",\n \"def _lowpass(self, signal, dx, Lmax):\\n W = np.fft.rfftfreq(len(signal), dx)\\n f_signal = np.fft.rfft(signal)\\n filtered_signal = f_signal.copy()\\n filtered_signal[np.where(self._div0(1,W) > Lmax)] = 0+0j\\n return np.fft.irfft(filtered_signal, n=len(signal)), f_signal\",\n \"def blurd_image(img,order=5,direction='horizontal',strength=0.25,speed='slow'):\\n\\tny,nx = np.shape(img)\\n\\tif speed == 'slow':\\n\\t\\tb, a = scig.butter(order, strength)\\n\\t\\tif direction == 'horizontal':\\n\\t\\t\\tfor i in range(ny):\\n\\t\\t\\t\\timg[i,:] = scig.filtfilt(b, a, img[i,:])\\n\\t\\telif direction == 'vertical':\\n\\t\\t\\tfor i in range(nx):\\n\\t\\t\\t\\timg[:,i] = scig.filtfilt(b, a, img[:,i])\\n\\t\\treturn img\\n\\telif speed=='fast':\\n\\t\\tK = np.ones((int(strength),1))\\n\\t\\tK = K/np.sum(K)\\n\\t\\tif direction=='vertical':\\n\\t\\t\\timg=scig.convolve2d(img,K,mode='same')\\n\\t\\telif direction=='horizontal':\\n\\t\\t\\timg=scig.convolve2d(img,K.transpose(),mode='same')\\n\\t\\treturn img\",\n \"def apply_smoothing(image, kernel_size=3):\\n return cv2.GaussianBlur(image, (kernel_size, kernel_size), 0)\",\n \"def compress(self, samples):\\n rms = np.sqrt(np.dot(samples, samples) / window)\\n power = self.power * (1.0 - self.smooth) + rms * self.smooth\\n self.power = power\\n if power <= 1e-40:\\n samples *= 0\\n return\\n db_in = 10.0 * math.log10(power)\\n if db_in <= self.limit:\\n samples *= 0\\n return\\n db_out = self.cf(db_in)\\n db_gain = db_out - db_in + self.postgain\\n gain = 10**(0.1 * db_gain)\\n samples *= gain\",\n \"def get_ideal_low_pass_filter(shape, cutoff, order):\\n \\n print(\\\"ideal_low_pass_filter = \\\")\\n print(\\\"cutoff: \\\",cutoff)\\n print(\\\"order: \\\",order)\\n \\n filter = np.zeros(shape)\\n\\n D = 0\\n\\n for i in range(shape[0]):\\n for j in range(shape[1]):\\n\\n D = np.sqrt((i - (shape[0] / 2)) ** 2 + (j - (shape[1] / 2)) ** 2)\\n\\n if D <= cutoff:\\n filter[i, j] = 1\\n else:\\n filter[i, j] = 0\\n\\n # return filter\\n return process_filter(image, filter)\",\n \"def filter(self, data):\\n self.data = pysap.Image(data=self.flt.filter(data))\",\n \"def design_filter(interpolation, decimation, fractional_bw):\\n\\n if fractional_bw >= 0.5 or fractional_bw <= 0:\\n raise ValueError('Invalid fractional bandwidth, must be in (0, 0.5)')\\n\\n if decimation < 1 or interpolation < 1:\\n raise ValueError('Invalid interpolation or decimation rate. Must be a non-zero positive integer.')\\n\\n beta = 7.0\\n halfband = 0.5\\n rate = float(interpolation)/float(decimation)\\n if(rate >= 1.0):\\n trans_width = halfband - fractional_bw\\n mid_transition_band = halfband - trans_width/2.0\\n else:\\n trans_width = rate*(halfband - fractional_bw)\\n mid_transition_band = rate*halfband - trans_width/2.0\\n\\n taps = filter.firdes.low_pass(interpolation, # gain\\n interpolation, # Fs\\n mid_transition_band, # trans mid point\\n trans_width, # transition width\\n filter.firdes.WIN_KAISER,\\n beta) # beta\\n\\n return taps\",\n \"def bandpass_filter_raw_plot(data, fs, f1, f2):\\n b, a = sp.butter(N=2, Wn=np.array([f1, f2]) / fs * 2, btype='bandpass') # build a bandpass butterworth filter of order 4, with cut-off frequencies 1 and 45\\n w, h = sp.freqz(b, a) # compute the frequency response of the filter\\n f = w / np.pi * fs / 2\\n plt.figure()\\n plt.plot(f, 10 * np.log10(abs(h)))\\n plt.xlabel('frequency (Hz)')\\n plt.ylabel('Magnitude (dB)')\\n plt.title('frequency response of butterworth bandpass [1, 45]Hz')\\n plt.grid()\\n\\n data1 = sp.filtfilt(b, a, data)\\n return data1\",\n \"def lowpassFFT(signal, rate, cutoff):\\n fft = np.fft.fft(signal)\\n fftfreq = np.fft.fftfreq(len(signal), 1/rate)\\n for i, freq in enumerate(fftfreq):\\n if abs(freq) >= cutoff:\\n fft[i] = 0\\n signal = np.fft.ifft(fft)\\n return signal\",\n \"def bandpass_cnt(data, low_cut_hz, high_cut_hz, fs, filt_order=3, axis=0):\\n if (low_cut_hz == 0 or low_cut_hz is None) and (\\n high_cut_hz == None or high_cut_hz == fs / 2.0):\\n log.info(\\\"Not doing any bandpass, since low 0 or None and \\\"\\n \\\"high None or nyquist frequency\\\")\\n return data.copy()\\n if low_cut_hz == 0 or low_cut_hz == None:\\n log.info(\\\"Using lowpass filter since low cut hz is 0 or None\\\")\\n return lowpass_cnt(data, high_cut_hz, fs, filt_order=filt_order, axis=axis)\\n if high_cut_hz == None or high_cut_hz == (fs / 2.0):\\n log.info(\\n \\\"Using highpass filter since high cut hz is None or nyquist freq\\\")\\n return highpass_cnt(data, low_cut_hz, fs, filt_order=filt_order, axis=axis)\\n\\n nyq_freq = 0.5 * fs\\n low = low_cut_hz / nyq_freq\\n high = high_cut_hz / nyq_freq\\n b, a = scipy.signal.butter(filt_order, [low, high], btype='bandpass')\\n assert filter_is_stable(a), \\\"Filter should be stable...\\\"\\n data_bandpassed = scipy.signal.lfilter(b, a, data, axis=axis)\\n return data_bandpassed\",\n \"def apply_filter(a_slice_prev, W, b):\\n product = np.multiply(a_slice_prev, W)\\n z = np.sum(product) + np.float(b)\\n return z\",\n \"def apply_filter(image: np.ndarray) -> np.ndarray:\\n # choose filters to apply\\n return clahe(image)\",\n \"def fastbias(self, fo, fbDac, data, slow):\\n if fbDac not in [0, 1]:\\n raise RuntimeError('fbDac must be 0 or 1')\\n if slow not in [0, 1]:\\n raise RuntimeError('slow must be 0 or 1')\\n a = {0: 0x100000, 1: 0x200000}[fo]\\n b = (data & 0xffff) << 3\\n c = fbDac << 19\\n d = slow << 2\\n self.append(a + b + c + d)\\n return self\",\n \"def apply_band_pass(ftd, freq, omega, bp_wid=1):\\n # Find number of frequencies\\n nf = len(freq)\\n # Find index for band pass, only consider indices of positive freqs\\n idx_om = hf.find_nearest_index(freq[0:nf//2], omega)\\n # Filter out frequencies left of band pass\\n ftd[:,0:idx_om-1-bp_wid] = 0.0\\n # Filter out frequencies left of omega\\n ftd[:,idx_om+1+bp_wid:-1] = 0.0\\n # Correct for lost amplitude\\n ftd[:,idx_om-bp_wid:idx_om+bp_wid] = ftd[:,idx_om-bp_wid:idx_om+bp_wid] * 2.0\\n return ftd\",\n \"def bessel_bandpass_filter(data, lowcut, highcut, fs, order=2):\\n\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n\\n # bessel() and lfilter() are from scipy.signal\\n\\n b, a = bessel(order, [low, high], btype='band')\\n y = lfilter(b, a, data)\\n return y\",\n \"def low_pass(self, x, kernel):\\n\\n ############################\\n ### TODO: YOUR CODE HERE ###\\n\\n # HANDLE NON-SQUARE KERNELS!!!\\n padX = kernel.shape[2]//2\\n padY = kernel.shape[3]//2\\n filtered_image = F.conv2d(x, kernel, padding=(padX, padY), groups=self.n_channels)\\n\\n # raise NotImplementedError('`low_pass` function in `models.py` needs to '\\n # + 'be implemented')\\n\\n ### END OF STUDENT CODE ####\\n ############################\\n\\n return filtered_image\",\n \"def lowpass1(y, dt, fc=3) :\\r\\n tau=1/(2*np.pi*fc)\\r\\n alpha=dt/(tau+dt)\\r\\n y_filt=np.zeros(y.shape)\\r\\n y_filt[0]=y[0]\\r\\n for i in np.arange(1,len(y)):\\r\\n y_filt[i]=alpha*y[i] + (1-alpha)*y_filt[i-1]\\r\\n return y_filt\",\n \"def _initial_blur(self):\\n if self.init_sigma > self.cur_sigma:\\n sigma = sqrt(self.init_sigma * self.init_sigma - self.cur_sigma * self.cur_sigma)\\n self.data = gaussian_filter(self.raw, sigma)\\n else:\\n self.data = self.raw\",\n \"def _butterworth_scale(ts, low_frequency, high_factor, order,\\n sampling_frequency, denominator):\\n filtered = _butterworth(ts, low_frequency, high_factor, order,\\n sampling_frequency)\\n\\n return np.divide(filtered, denominator)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77225924","0.758474","0.75541186","0.74821657","0.74796224","0.74441874","0.74429524","0.7362974","0.7348949","0.7328772","0.73254126","0.7311591","0.72724277","0.71420956","0.7005642","0.6849895","0.6796962","0.6738573","0.66404504","0.660009","0.6575429","0.6567852","0.65568644","0.6529936","0.64395785","0.63452226","0.6330572","0.63280857","0.6268934","0.6236832","0.62176067","0.61502135","0.61392355","0.6118204","0.6097934","0.6071459","0.60366696","0.6034701","0.59745795","0.59602165","0.5934249","0.5894557","0.58833754","0.58796203","0.5863917","0.58567053","0.585544","0.5855372","0.5832528","0.5800916","0.5793926","0.5792699","0.5791408","0.57589483","0.57532495","0.57437813","0.57340443","0.5696243","0.56892693","0.5673544","0.565503","0.56546456","0.5638059","0.56317204","0.56238365","0.55983466","0.5593707","0.5592452","0.55748284","0.55717266","0.5570442","0.5558153","0.555601","0.5553548","0.5459507","0.544906","0.5431504","0.54223233","0.54122525","0.5411018","0.5390068","0.53896564","0.5388135","0.5386535","0.53853786","0.5383794","0.53767335","0.53617275","0.53538567","0.53536195","0.5348432","0.5339915","0.5338348","0.53250587","0.5315021","0.5303283","0.5290269","0.52862716","0.5277878","0.525352"],"string":"[\n \"0.77225924\",\n \"0.758474\",\n \"0.75541186\",\n \"0.74821657\",\n \"0.74796224\",\n \"0.74441874\",\n \"0.74429524\",\n \"0.7362974\",\n \"0.7348949\",\n \"0.7328772\",\n \"0.73254126\",\n \"0.7311591\",\n \"0.72724277\",\n \"0.71420956\",\n \"0.7005642\",\n \"0.6849895\",\n \"0.6796962\",\n \"0.6738573\",\n \"0.66404504\",\n \"0.660009\",\n \"0.6575429\",\n \"0.6567852\",\n \"0.65568644\",\n \"0.6529936\",\n \"0.64395785\",\n \"0.63452226\",\n \"0.6330572\",\n \"0.63280857\",\n \"0.6268934\",\n \"0.6236832\",\n \"0.62176067\",\n \"0.61502135\",\n \"0.61392355\",\n \"0.6118204\",\n \"0.6097934\",\n \"0.6071459\",\n \"0.60366696\",\n \"0.6034701\",\n \"0.59745795\",\n \"0.59602165\",\n \"0.5934249\",\n \"0.5894557\",\n \"0.58833754\",\n \"0.58796203\",\n \"0.5863917\",\n \"0.58567053\",\n \"0.585544\",\n \"0.5855372\",\n \"0.5832528\",\n \"0.5800916\",\n \"0.5793926\",\n \"0.5792699\",\n \"0.5791408\",\n \"0.57589483\",\n \"0.57532495\",\n \"0.57437813\",\n \"0.57340443\",\n \"0.5696243\",\n \"0.56892693\",\n \"0.5673544\",\n \"0.565503\",\n \"0.56546456\",\n \"0.5638059\",\n \"0.56317204\",\n \"0.56238365\",\n \"0.55983466\",\n \"0.5593707\",\n \"0.5592452\",\n \"0.55748284\",\n \"0.55717266\",\n \"0.5570442\",\n \"0.5558153\",\n \"0.555601\",\n \"0.5553548\",\n \"0.5459507\",\n \"0.544906\",\n \"0.5431504\",\n \"0.54223233\",\n \"0.54122525\",\n \"0.5411018\",\n \"0.5390068\",\n \"0.53896564\",\n \"0.5388135\",\n \"0.5386535\",\n \"0.53853786\",\n \"0.5383794\",\n \"0.53767335\",\n \"0.53617275\",\n \"0.53538567\",\n \"0.53536195\",\n \"0.5348432\",\n \"0.5339915\",\n \"0.5338348\",\n \"0.53250587\",\n \"0.5315021\",\n \"0.5303283\",\n \"0.5290269\",\n \"0.52862716\",\n \"0.5277878\",\n \"0.525352\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7719998"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84595,"cells":{"query":{"kind":"string","value":"Center the EMG data."},"document":{"kind":"string","value":"def center(emg_data: np.ndarray, center_value: float = None) -> np.ndarray:\n center_value = center_value if center_value else emg_data.mean(axis=1)\n emg_centered = np.copy(emg_data)\n for i in range(emg_data.shape[0]):\n emg_centered[i, :] = emg_data[i, :] - center_value[i]\n return emg_centered"},"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 centerAxis():\n dislin.center()","def center(self):\n cp = self.dat.flowsheet.getCenter()\n self.centerOn(cp[0], cp[1])","def GetCenter(self):\n ...","def GetCenter(self):\n ...","def GetCenter(self):\n ...","def GetCenter(self):\n ...","def center(self):\n return self['center']","def center_ava(self):\n\t\tself.rect.midbottom = self.screen_rect.midbottom\n\t\tself.x = float(self.rect.x)","def update_center(self): \r\n \r\n self.grfx[0].center = self.center\r\n\r\n self.update_bbox()","def center(self):\n if self.pos != 0.0:\n self.pos = 0.0","def resetAlignmentCenter(self):\n cent = self.TiltSeries_._TiltAlignmentParas.cent\n imdimX = self.TiltSeries_._imdimX\n imdimY = self.TiltSeries_._imdimY\n print(imdimX, imdimY)\n if cent[0] != imdimX//2+1 or cent[1] != imdimY//2+1:\n #rint \"Centers do not match: cent=\"+str(cent)+\", imdim=\"+str(imdim)\n self.TiltSeries_._TiltAlignmentParas.cent = [imdimX//2+1, imdimY//2+1]","def center(self):\n return self._center","def center(self):\r\n self.centerx = self.screen_rect.centerx \r\n self.centery = self.screen_rect.centery","def center_mario(self):\n self.rect.midbottom = self.screen_rect.midbottom\n self.x, self.y = float(self.rect.x), float(self.rect.y)","def to_center(self):\n self.ids.edit_area.to_center()","def _set_center(self):\n sl_center = np.array(\n [self.sl_list[k].mean_pos for k in range(self.nb_sl)]\n )\n sl_nb_pts = np.array(\n [self.sl_list[k].nb_points for k in range(self.nb_sl)]\n )\n sl_wcenter = [sl_center[k] * sl_nb_pts[k] for k in range(self.nb_sl)]\n self.center = np.sum(sl_wcenter, axis=0) / np.sum(sl_nb_pts)","def center(self, center):\n\n self._center = center","def _e0s_center(self, hdr):\n # Called E0SNano in OpenMIMS\n # b field index and e0s center enabled added to sub dict from main nano header\n d = {}\n d['b field index'], d['detector'], d['start'], \\\n d['step size'], d['count time'], d['center'], \\\n d['80% width'], d['E0S center enabled'] = \\\n unpack(self._bo + '5i 2d i', hdr.read(40))\n\n d['E0S center enabled'] = bool(d['E0S center enabled'])\n d['count time'] /= 100 # 10 ms increments to seconds\n if d['detector'] < 0:\n d['detector'] = None\n if d['b field index'] < 0:\n d['b field index'] = None\n return d","def center(self):\n return np.array([0,0,1/self.C+self.pos()])","def center(self):\n return self._lower + 0.5 * (self._upper - self._lower)","def center(self):\n self.root.update_idletasks()\n w = self.root.winfo_screenwidth()\n h = self.root.winfo_screenheight()\n size = tuple(int(_) for _ in self.root.geometry().split('+')[0].split('x'))\n x = w/2 - size[0]/2\n y = h/2 - size[1]/2\n self.root.geometry(\"240x80+%d+%d\" % (x, y))","def center(self):\n return self.pos + self.axis / 2.0","def center(self):\n return (self.upper_right + self.lower_left) * 0.5","def center(self):\n qr = self.frameGeometry()\n cp = QtWidgets.QDesktopWidget().availableGeometry().center()\n qr.moveCenter(cp)","def center(self, center_mass=False):\n if center_mass:\n com = self.center_of_mass\n self.xyz -= com\n else:\n self.xyz -= self.xyz.mean(0)","def get_center(self):\n return self.center","def centre(self):\n\n qr = self.frameGeometry()\n cp = QtWidgets.QDesktopWidget().availableGeometry().center()\n qr.moveCenter(cp)\n self.move(qr.topLeft())","def to_center():\n center_msg = b'\\x02\\x35\\x35\\x03'\n #qpt.write(center_msg)\n #feedback = qpt.readline()\n move_to_position(0,0)\n #return feedback","def centre(self):\n self.top.update_idletasks()\n # The horizontal position is calculated as (screenwidth - window_width)/2\n hpos = int((self.top.winfo_screenwidth() - self.top.winfo_width())/2)\n # And vertical position the same, but with the height dimensions\n vpos = int((self.top.winfo_screenheight() - self.top.winfo_height())/2)\n # And the move call repositions the window\n self.top.geometry('+{x}+{y}'.format(x=hpos, y=vpos))","def setCenter(self, p):\n self.__center = p","def InitialAlignment(self, scale = 0.15):\n\n\n pts3D = self.pts3D\n\n # Compute eigenvecs and rotate according to them\n pc, evals, mean = utils.pca(pts3D, remove_mean = True)\n pts3D_rot = np.dot(pc.T, pts3D)\n\n # Find length according to max eigenvector\n mins = np.min(pts3D_rot, axis=1)\n maxs = np.max(pts3D_rot, axis=1)\n max_length = maxs[0] - mins[0]\n \n # Rotation matrix is the covariance matrix, but we want Z as the leading\n # eigenvector:\n rot = np.c_[-pc[2], pc[1], pc[0]]\n\n # Transform model to have zero mean, reasonable scale and rotation.\n self.transform(rot, np.dot(rot, -mean), float(scale) / max_length)","def center(self):\n # minz to offset the heights to 0\n mz = (self.maxz-self.minz)/2\n #mz = self.minz\n return (self.minx + self.width / 2, self.miny + self.height / 2, mz)","def center(self):\n return (self.centerx, self.centery)","def center(self):\n # get the compute screen's size\n screen = QDesktopWidget().screenGeometry()\n # get the app windows' size\n size = self.geometry()\n self.move(int((screen.width() - size.width()) / 2), int((screen.height() - size.height()) / 2))","def center(self):\n return self.centralizer(self)","def center(self):\r\n qr = self.frameGeometry()\r\n cp = QtWidgets.QDesktopWidget().availableGeometry().center()\r\n qr.moveCenter(cp)\r\n self.move(qr.topLeft())","def center(self):\r\n frameGm = self.frameGeometry()\r\n screen = QtGui.QApplication.desktop().screenNumber(QtGui.QApplication.desktop().cursor().pos())\r\n centerPoint = QtGui.QApplication.desktop().screenGeometry(screen).center()\r\n frameGm.moveCenter(centerPoint)\r\n self.move(frameGm.topLeft())","def getcenter(self):\n return self.centro.cartesianas()","def center(self):\n return self.center_x, self.center_y","def center(self):\n try: \n return self._center\n except AttributeError:\n self._center = vector(ZZ, [0]*self.ambient_dim())\n for v in self.vertex_generator(): self._center += v.vector()\n self._center /= self.n_vertices()\n return self._center","def set_center(self,structure):\n for i,b in enumerate(self.bfs):\n b.set_center( structure[ self.LIST1[i] ] ) \n return","def center(self,c, ADDR):\r\n #FIGURE OUT HOW TO DO THIS\r\n #Actually pretty sure this is impossible to do from software\r\n returnValue('Success!')","def center(self, X):\n X = X - self.mu\n X = X / numpy.where(self.sigma == 0, 1e-30, self.sigma)\n return X","def set_center(self, center=0.0):\n\n self.centerFromImage = center\n\n tempCenter = [0] * 2\n\n tempCenter[0] = center[0] - 305 # Xcoord offset\n tempCenter[1] = 313 - center[1] # Ycoord offset\n\n self.centerFromRobot = tempCenter","def center(data, desired=0.0):\n\n return (data -data.mean()) + desired","def center(self):\n\n return (\n self.x() + (self.width() / 2),\n self.y() + (self.height() / 2)\n )","def center(self, obj):\n return self.phy2abs.center(obj)","def center(self):\n qr = self.frameGeometry()\n central_p = QDesktopWidget().availableGeometry().center()\n qr.moveCenter(central_p)\n self.move(qr.topLeft())","def center(self):\n qr = self.frameGeometry()\n cp = QDesktopWidget().availableGeometry().center()\n qr.moveCenter(cp)\n self.move(qr.topLeft())","def center(self):\n qr = self.frameGeometry()\n cp = QDesktopWidget().availableGeometry().center()\n qr.moveCenter(cp)\n self.move(qr.topLeft())","def _centre(self, period):\n if self.direction():\n mx = self.data[-1]\n else:\n mx = self.data[0]\n\n return ((mx // period) * period).squeeze()","def getCenter(self):\n return [self.tx/self.tw, self.ty/self.tw]","def set_center(self, center):\n self._center = center\n self._reset_slot_bounds()","def _setCenter(self, value, index):\n item = self.item()\n if item is not None:\n if value == 'Origin':\n value = 0.\n elif value not in self._ROTATION_CENTER_OPTIONS:\n value = float(value)\n else:\n value = value.lower()\n\n center = list(item.getRotationCenter())\n center[index] = value\n item.setRotationCenter(*center)","def calculateCenter(self):\n y_avg = int(sum(self.points[:,0])/float(len(self.points)))\n x_avg = int(sum(self.points[:,1])/float(len(self.points)))\n self.center = (x_avg, y_avg)\n return(x_avg,y_avg)","def center(self):\n \n geometry = self.frameGeometry()\n center_p = QDesktopWidget().availableGeometry().center()\n geometry.moveCenter(center_p)\n self.move(geometry.topLeft())","def setCentreCoordinates(self,xcenter,ycenter):\n self.x = xcenter\n self.y = ycenter","def position_center(self, x, y):\n self.x = x\n self.y = y\n self.pos[0] = x - self.pos[2]/2\n self.pos[1] = y - self.pos[3]/2","def center(self):\n return Point(self.width/2, self.height/2)","def compute_center(self, mole_object):\r\n if mole_object.plugin_type == \"PyMOL\":\r\n sel = PymolPlugin.PymolPlugin().get_model('all')\r\n cnt = len(sel.atom)\r\n\r\n else:\r\n sel = ChimeraPlugin.ChimeraPlugin().select()\r\n cnt = len(ChimeraPlugin.ChimeraPlugin().current_atoms())\r\n\r\n cent_x = 0\r\n cent_y = 0\r\n cent_z = 0\r\n\r\n if cnt == 0:\r\n return 0, 0, 0\r\n\r\n if mole_object.plugin_type == \"PyMOL\":\r\n\r\n for a in sel.atom:\r\n cent_x += a.coord[0]\r\n cent_y += a.coord[1]\r\n cent_z += a.coord[2]\r\n\r\n else:\r\n\r\n for a in ChimeraPlugin.ChimeraPlugin().current_atoms():\r\n cent_x += a.coord()[0]\r\n cent_y += a.coord()[1]\r\n cent_z += a.coord()[2]\r\n\r\n cent_x /= cnt\r\n cent_y /= cnt\r\n cent_z /= cnt\r\n\r\n self.point_x.component('entryfield').setentry(cent_x)\r\n self.point_y.component('entryfield').setentry(cent_y)\r\n self.point_z.component('entryfield').setentry(cent_z)\r\n\r\n self.show_crisscross(mole_object)","def rotation_center(self, *args, **kwargs) -> Any:\n pass","def getCenter(self):\n if self.__center is None:\n raise ValueError, \"Center is undefined.\"\n return self.__center","def center_me(self, container):\n x = (container.winfo_screenwidth() - container.winfo_reqwidth()) / 2\n y = (container.winfo_screenheight() - container.winfo_reqheight()) / 2\n container.geometry(\"+%d+%d\" % (x, y))","def center(self):\n\n ca_atoms = self.ca_atoms\n ca_atom_vectors = ca_atoms[\"ca.atom\"].to_list()\n ca_atom_vectors = [i for i in ca_atom_vectors if i is not None]\n centroid = self.center_of_mass(ca_atom_vectors, geometric=False)\n centroid = Vector(centroid)\n\n return centroid","def center(self):\n if not hasattr(self, '_center'):\n self._center = np.unique(self.points, axis=0).mean(axis=0)\n return self._center","def setCenter(self, np):\n p = self.getCenter()\n v = Vector.createFromTwoPoints(p, np)\n for i in range(len(self.points)):\n self.points[i] = v(self.points[i])","def center_ship(self):\r\n self.center = self.screen_rect.centerx","def center_ship(self):\r\n self.center = self.screen_rect.centerx","def update(self): \n super().update()\n if self.center_x < constants.left_limit:\n self.center_x = self.screen_width + constants.offscreen_space\n if self.center_x > self.screen_width + constants.offscreen_space:\n self.center_x = constants.left_limit\n if self.center_y > self.screen_height + constants.offscreen_space:\n self.center_y = constants.bottom_limit\n if self.center_y < constants.bottom_limit:\n self.center_y = self.screen_height + constants.offscreen_space","def rotation_pivot_to_center(self):\n pass","def setCenter(self, value):\r\n self._viewCenter = b2.b2Vec2(*value)\r\n self._viewCenter *= self._viewZoom\r\n self._viewOffset = self._viewCenter - self.screenSize/2","def center(self):\n xc = (self.x.max() + self.x.min())/2.\n yc = (self.y.max() + self.y.min())/2.\n return (xc, yc)","def center_ship(self):\n self.center = self.screen_rect.centerx","def center_ship(self):\n self.center = self.screen_rect.centerx","def center_ship(self):\n self.center = self.screen_rect.centerx","def move_center(obj):\n desktop = QApplication.desktop()\n dw = desktop.width()\n dh = desktop.height()\n size = obj.size()\n mw = size.width()\n mh = size.height()\n obj.move(dw/2-mw/2, dh/2-mh/2)","def center_of_mass(self, tolerance=1e-9):\n props = GProp_GProps()\n brepgprop_VolumeProperties(self.topods_solid(), props, tolerance)\n com = props.CentreOfMass()\n return geom_utils.gp_to_numpy(com)","def center(self):\n return np.sum(self.bbox, 0) / 2","def Center(self, *args):\n return _Bnd.Bnd_Sphere_Center(self, *args)","def CenterZombie(self):\n # Requirement ID: 8.0.1\n\n self.center = self.screen_rect.centerx","def center_window(self):\n\n\t\tframe_geo = self.frameGeometry()\n\t\tcursor_pos = QtWidgets.QApplication.desktop().cursor().pos()\n\t\tscreen = QtWidgets.QApplication.desktop().screenNumber(cursor_pos)\n\t\tcenter_point = QtWidgets.QApplication.desktop().screenGeometry(screen).center()\n\t\tframe_geo.moveCenter(center_point)\n\t\tself.move(frame_geo.topLeft())","def get_centre(self):\n return self.c","def center(x):\n return x - x.mean()","def vert_center(self):\n return self._vert_center","def vert_center(self):\n return self._vert_center","def center(self):\n return {self.identity}","def center_image(image):\r\n image.anchor_x = image.width / 2\r\n image.anchor_y = image.height / 2","def center_image(image):\r\n image.anchor_x = image.width / 2\r\n image.anchor_y = image.height / 2","def center(self, obj):\n mn0 = self.master.xy >= obj.center\n mn1 = self.master.xy <= obj.center\n\n point_list = [self.master.xy[mn0], self.master.xy[mn1], self.master.xy[mn0[0], mn1[1]], self.master.xy[mn1[0], mn0[1]]] # 4 physical points near the center coordinate.\n dist_list = []\n idx = 0\n for point in point_list:\n dist_list.append([idx, np.linalg.norm(point - obj.center)]) # Calculate Euclidean distances.\n idx += 1\n dist_sorted = sorted(dist_list, key=lambda distance : distance[1]) # Sort distances in ascending order.\n return self.master.mn(point_list[dist_sorted[0][0]]) # Convert the closest point to abstract coordinate and then return.","def mean_centered(self):\n return self._scala.meanCentered()","def get_center_of_mass_allies(self,obs):","def _center(self, forces):\n\t\t\n\t\tzipped = zip(self.grid.corners(), forces)\n\t\treturn self._weightedAverage(zipped)","def test_center(self):\n\n self.assertTrue((self.cs.center == np.array([[0], [0]])).all())","def get_center(self):\n return center_points(np.expand_dims(self.best_box, axis=0))[0]","def horiz_center(self):\n return self._horiz_center","def horiz_center(self):\n return self._horiz_center","def center(self, width, fillchar=' '):\n return asarray(center(self, width, fillchar))","def centerx(self):\n return self.left + self.width / 2","def pix_center(self):\n return self._pix_center","def centerWindow(self):\n framegeo = self.frameGeometry()\n center = QtGui.QDesktopWidget().availableGeometry().center()\n framegeo.moveCenter(center)\n self.move(framegeo.topLeft())"],"string":"[\n \"def centerAxis():\\n dislin.center()\",\n \"def center(self):\\n cp = self.dat.flowsheet.getCenter()\\n self.centerOn(cp[0], cp[1])\",\n \"def GetCenter(self):\\n ...\",\n \"def GetCenter(self):\\n ...\",\n \"def GetCenter(self):\\n ...\",\n \"def GetCenter(self):\\n ...\",\n \"def center(self):\\n return self['center']\",\n \"def center_ava(self):\\n\\t\\tself.rect.midbottom = self.screen_rect.midbottom\\n\\t\\tself.x = float(self.rect.x)\",\n \"def update_center(self): \\r\\n \\r\\n self.grfx[0].center = self.center\\r\\n\\r\\n self.update_bbox()\",\n \"def center(self):\\n if self.pos != 0.0:\\n self.pos = 0.0\",\n \"def resetAlignmentCenter(self):\\n cent = self.TiltSeries_._TiltAlignmentParas.cent\\n imdimX = self.TiltSeries_._imdimX\\n imdimY = self.TiltSeries_._imdimY\\n print(imdimX, imdimY)\\n if cent[0] != imdimX//2+1 or cent[1] != imdimY//2+1:\\n #rint \\\"Centers do not match: cent=\\\"+str(cent)+\\\", imdim=\\\"+str(imdim)\\n self.TiltSeries_._TiltAlignmentParas.cent = [imdimX//2+1, imdimY//2+1]\",\n \"def center(self):\\n return self._center\",\n \"def center(self):\\r\\n self.centerx = self.screen_rect.centerx \\r\\n self.centery = self.screen_rect.centery\",\n \"def center_mario(self):\\n self.rect.midbottom = self.screen_rect.midbottom\\n self.x, self.y = float(self.rect.x), float(self.rect.y)\",\n \"def to_center(self):\\n self.ids.edit_area.to_center()\",\n \"def _set_center(self):\\n sl_center = np.array(\\n [self.sl_list[k].mean_pos for k in range(self.nb_sl)]\\n )\\n sl_nb_pts = np.array(\\n [self.sl_list[k].nb_points for k in range(self.nb_sl)]\\n )\\n sl_wcenter = [sl_center[k] * sl_nb_pts[k] for k in range(self.nb_sl)]\\n self.center = np.sum(sl_wcenter, axis=0) / np.sum(sl_nb_pts)\",\n \"def center(self, center):\\n\\n self._center = center\",\n \"def _e0s_center(self, hdr):\\n # Called E0SNano in OpenMIMS\\n # b field index and e0s center enabled added to sub dict from main nano header\\n d = {}\\n d['b field index'], d['detector'], d['start'], \\\\\\n d['step size'], d['count time'], d['center'], \\\\\\n d['80% width'], d['E0S center enabled'] = \\\\\\n unpack(self._bo + '5i 2d i', hdr.read(40))\\n\\n d['E0S center enabled'] = bool(d['E0S center enabled'])\\n d['count time'] /= 100 # 10 ms increments to seconds\\n if d['detector'] < 0:\\n d['detector'] = None\\n if d['b field index'] < 0:\\n d['b field index'] = None\\n return d\",\n \"def center(self):\\n return np.array([0,0,1/self.C+self.pos()])\",\n \"def center(self):\\n return self._lower + 0.5 * (self._upper - self._lower)\",\n \"def center(self):\\n self.root.update_idletasks()\\n w = self.root.winfo_screenwidth()\\n h = self.root.winfo_screenheight()\\n size = tuple(int(_) for _ in self.root.geometry().split('+')[0].split('x'))\\n x = w/2 - size[0]/2\\n y = h/2 - size[1]/2\\n self.root.geometry(\\\"240x80+%d+%d\\\" % (x, y))\",\n \"def center(self):\\n return self.pos + self.axis / 2.0\",\n \"def center(self):\\n return (self.upper_right + self.lower_left) * 0.5\",\n \"def center(self):\\n qr = self.frameGeometry()\\n cp = QtWidgets.QDesktopWidget().availableGeometry().center()\\n qr.moveCenter(cp)\",\n \"def center(self, center_mass=False):\\n if center_mass:\\n com = self.center_of_mass\\n self.xyz -= com\\n else:\\n self.xyz -= self.xyz.mean(0)\",\n \"def get_center(self):\\n return self.center\",\n \"def centre(self):\\n\\n qr = self.frameGeometry()\\n cp = QtWidgets.QDesktopWidget().availableGeometry().center()\\n qr.moveCenter(cp)\\n self.move(qr.topLeft())\",\n \"def to_center():\\n center_msg = b'\\\\x02\\\\x35\\\\x35\\\\x03'\\n #qpt.write(center_msg)\\n #feedback = qpt.readline()\\n move_to_position(0,0)\\n #return feedback\",\n \"def centre(self):\\n self.top.update_idletasks()\\n # The horizontal position is calculated as (screenwidth - window_width)/2\\n hpos = int((self.top.winfo_screenwidth() - self.top.winfo_width())/2)\\n # And vertical position the same, but with the height dimensions\\n vpos = int((self.top.winfo_screenheight() - self.top.winfo_height())/2)\\n # And the move call repositions the window\\n self.top.geometry('+{x}+{y}'.format(x=hpos, y=vpos))\",\n \"def setCenter(self, p):\\n self.__center = p\",\n \"def InitialAlignment(self, scale = 0.15):\\n\\n\\n pts3D = self.pts3D\\n\\n # Compute eigenvecs and rotate according to them\\n pc, evals, mean = utils.pca(pts3D, remove_mean = True)\\n pts3D_rot = np.dot(pc.T, pts3D)\\n\\n # Find length according to max eigenvector\\n mins = np.min(pts3D_rot, axis=1)\\n maxs = np.max(pts3D_rot, axis=1)\\n max_length = maxs[0] - mins[0]\\n \\n # Rotation matrix is the covariance matrix, but we want Z as the leading\\n # eigenvector:\\n rot = np.c_[-pc[2], pc[1], pc[0]]\\n\\n # Transform model to have zero mean, reasonable scale and rotation.\\n self.transform(rot, np.dot(rot, -mean), float(scale) / max_length)\",\n \"def center(self):\\n # minz to offset the heights to 0\\n mz = (self.maxz-self.minz)/2\\n #mz = self.minz\\n return (self.minx + self.width / 2, self.miny + self.height / 2, mz)\",\n \"def center(self):\\n return (self.centerx, self.centery)\",\n \"def center(self):\\n # get the compute screen's size\\n screen = QDesktopWidget().screenGeometry()\\n # get the app windows' size\\n size = self.geometry()\\n self.move(int((screen.width() - size.width()) / 2), int((screen.height() - size.height()) / 2))\",\n \"def center(self):\\n return self.centralizer(self)\",\n \"def center(self):\\r\\n qr = self.frameGeometry()\\r\\n cp = QtWidgets.QDesktopWidget().availableGeometry().center()\\r\\n qr.moveCenter(cp)\\r\\n self.move(qr.topLeft())\",\n \"def center(self):\\r\\n frameGm = self.frameGeometry()\\r\\n screen = QtGui.QApplication.desktop().screenNumber(QtGui.QApplication.desktop().cursor().pos())\\r\\n centerPoint = QtGui.QApplication.desktop().screenGeometry(screen).center()\\r\\n frameGm.moveCenter(centerPoint)\\r\\n self.move(frameGm.topLeft())\",\n \"def getcenter(self):\\n return self.centro.cartesianas()\",\n \"def center(self):\\n return self.center_x, self.center_y\",\n \"def center(self):\\n try: \\n return self._center\\n except AttributeError:\\n self._center = vector(ZZ, [0]*self.ambient_dim())\\n for v in self.vertex_generator(): self._center += v.vector()\\n self._center /= self.n_vertices()\\n return self._center\",\n \"def set_center(self,structure):\\n for i,b in enumerate(self.bfs):\\n b.set_center( structure[ self.LIST1[i] ] ) \\n return\",\n \"def center(self,c, ADDR):\\r\\n #FIGURE OUT HOW TO DO THIS\\r\\n #Actually pretty sure this is impossible to do from software\\r\\n returnValue('Success!')\",\n \"def center(self, X):\\n X = X - self.mu\\n X = X / numpy.where(self.sigma == 0, 1e-30, self.sigma)\\n return X\",\n \"def set_center(self, center=0.0):\\n\\n self.centerFromImage = center\\n\\n tempCenter = [0] * 2\\n\\n tempCenter[0] = center[0] - 305 # Xcoord offset\\n tempCenter[1] = 313 - center[1] # Ycoord offset\\n\\n self.centerFromRobot = tempCenter\",\n \"def center(data, desired=0.0):\\n\\n return (data -data.mean()) + desired\",\n \"def center(self):\\n\\n return (\\n self.x() + (self.width() / 2),\\n self.y() + (self.height() / 2)\\n )\",\n \"def center(self, obj):\\n return self.phy2abs.center(obj)\",\n \"def center(self):\\n qr = self.frameGeometry()\\n central_p = QDesktopWidget().availableGeometry().center()\\n qr.moveCenter(central_p)\\n self.move(qr.topLeft())\",\n \"def center(self):\\n qr = self.frameGeometry()\\n cp = QDesktopWidget().availableGeometry().center()\\n qr.moveCenter(cp)\\n self.move(qr.topLeft())\",\n \"def center(self):\\n qr = self.frameGeometry()\\n cp = QDesktopWidget().availableGeometry().center()\\n qr.moveCenter(cp)\\n self.move(qr.topLeft())\",\n \"def _centre(self, period):\\n if self.direction():\\n mx = self.data[-1]\\n else:\\n mx = self.data[0]\\n\\n return ((mx // period) * period).squeeze()\",\n \"def getCenter(self):\\n return [self.tx/self.tw, self.ty/self.tw]\",\n \"def set_center(self, center):\\n self._center = center\\n self._reset_slot_bounds()\",\n \"def _setCenter(self, value, index):\\n item = self.item()\\n if item is not None:\\n if value == 'Origin':\\n value = 0.\\n elif value not in self._ROTATION_CENTER_OPTIONS:\\n value = float(value)\\n else:\\n value = value.lower()\\n\\n center = list(item.getRotationCenter())\\n center[index] = value\\n item.setRotationCenter(*center)\",\n \"def calculateCenter(self):\\n y_avg = int(sum(self.points[:,0])/float(len(self.points)))\\n x_avg = int(sum(self.points[:,1])/float(len(self.points)))\\n self.center = (x_avg, y_avg)\\n return(x_avg,y_avg)\",\n \"def center(self):\\n \\n geometry = self.frameGeometry()\\n center_p = QDesktopWidget().availableGeometry().center()\\n geometry.moveCenter(center_p)\\n self.move(geometry.topLeft())\",\n \"def setCentreCoordinates(self,xcenter,ycenter):\\n self.x = xcenter\\n self.y = ycenter\",\n \"def position_center(self, x, y):\\n self.x = x\\n self.y = y\\n self.pos[0] = x - self.pos[2]/2\\n self.pos[1] = y - self.pos[3]/2\",\n \"def center(self):\\n return Point(self.width/2, self.height/2)\",\n \"def compute_center(self, mole_object):\\r\\n if mole_object.plugin_type == \\\"PyMOL\\\":\\r\\n sel = PymolPlugin.PymolPlugin().get_model('all')\\r\\n cnt = len(sel.atom)\\r\\n\\r\\n else:\\r\\n sel = ChimeraPlugin.ChimeraPlugin().select()\\r\\n cnt = len(ChimeraPlugin.ChimeraPlugin().current_atoms())\\r\\n\\r\\n cent_x = 0\\r\\n cent_y = 0\\r\\n cent_z = 0\\r\\n\\r\\n if cnt == 0:\\r\\n return 0, 0, 0\\r\\n\\r\\n if mole_object.plugin_type == \\\"PyMOL\\\":\\r\\n\\r\\n for a in sel.atom:\\r\\n cent_x += a.coord[0]\\r\\n cent_y += a.coord[1]\\r\\n cent_z += a.coord[2]\\r\\n\\r\\n else:\\r\\n\\r\\n for a in ChimeraPlugin.ChimeraPlugin().current_atoms():\\r\\n cent_x += a.coord()[0]\\r\\n cent_y += a.coord()[1]\\r\\n cent_z += a.coord()[2]\\r\\n\\r\\n cent_x /= cnt\\r\\n cent_y /= cnt\\r\\n cent_z /= cnt\\r\\n\\r\\n self.point_x.component('entryfield').setentry(cent_x)\\r\\n self.point_y.component('entryfield').setentry(cent_y)\\r\\n self.point_z.component('entryfield').setentry(cent_z)\\r\\n\\r\\n self.show_crisscross(mole_object)\",\n \"def rotation_center(self, *args, **kwargs) -> Any:\\n pass\",\n \"def getCenter(self):\\n if self.__center is None:\\n raise ValueError, \\\"Center is undefined.\\\"\\n return self.__center\",\n \"def center_me(self, container):\\n x = (container.winfo_screenwidth() - container.winfo_reqwidth()) / 2\\n y = (container.winfo_screenheight() - container.winfo_reqheight()) / 2\\n container.geometry(\\\"+%d+%d\\\" % (x, y))\",\n \"def center(self):\\n\\n ca_atoms = self.ca_atoms\\n ca_atom_vectors = ca_atoms[\\\"ca.atom\\\"].to_list()\\n ca_atom_vectors = [i for i in ca_atom_vectors if i is not None]\\n centroid = self.center_of_mass(ca_atom_vectors, geometric=False)\\n centroid = Vector(centroid)\\n\\n return centroid\",\n \"def center(self):\\n if not hasattr(self, '_center'):\\n self._center = np.unique(self.points, axis=0).mean(axis=0)\\n return self._center\",\n \"def setCenter(self, np):\\n p = self.getCenter()\\n v = Vector.createFromTwoPoints(p, np)\\n for i in range(len(self.points)):\\n self.points[i] = v(self.points[i])\",\n \"def center_ship(self):\\r\\n self.center = self.screen_rect.centerx\",\n \"def center_ship(self):\\r\\n self.center = self.screen_rect.centerx\",\n \"def update(self): \\n super().update()\\n if self.center_x < constants.left_limit:\\n self.center_x = self.screen_width + constants.offscreen_space\\n if self.center_x > self.screen_width + constants.offscreen_space:\\n self.center_x = constants.left_limit\\n if self.center_y > self.screen_height + constants.offscreen_space:\\n self.center_y = constants.bottom_limit\\n if self.center_y < constants.bottom_limit:\\n self.center_y = self.screen_height + constants.offscreen_space\",\n \"def rotation_pivot_to_center(self):\\n pass\",\n \"def setCenter(self, value):\\r\\n self._viewCenter = b2.b2Vec2(*value)\\r\\n self._viewCenter *= self._viewZoom\\r\\n self._viewOffset = self._viewCenter - self.screenSize/2\",\n \"def center(self):\\n xc = (self.x.max() + self.x.min())/2.\\n yc = (self.y.max() + self.y.min())/2.\\n return (xc, yc)\",\n \"def center_ship(self):\\n self.center = self.screen_rect.centerx\",\n \"def center_ship(self):\\n self.center = self.screen_rect.centerx\",\n \"def center_ship(self):\\n self.center = self.screen_rect.centerx\",\n \"def move_center(obj):\\n desktop = QApplication.desktop()\\n dw = desktop.width()\\n dh = desktop.height()\\n size = obj.size()\\n mw = size.width()\\n mh = size.height()\\n obj.move(dw/2-mw/2, dh/2-mh/2)\",\n \"def center_of_mass(self, tolerance=1e-9):\\n props = GProp_GProps()\\n brepgprop_VolumeProperties(self.topods_solid(), props, tolerance)\\n com = props.CentreOfMass()\\n return geom_utils.gp_to_numpy(com)\",\n \"def center(self):\\n return np.sum(self.bbox, 0) / 2\",\n \"def Center(self, *args):\\n return _Bnd.Bnd_Sphere_Center(self, *args)\",\n \"def CenterZombie(self):\\n # Requirement ID: 8.0.1\\n\\n self.center = self.screen_rect.centerx\",\n \"def center_window(self):\\n\\n\\t\\tframe_geo = self.frameGeometry()\\n\\t\\tcursor_pos = QtWidgets.QApplication.desktop().cursor().pos()\\n\\t\\tscreen = QtWidgets.QApplication.desktop().screenNumber(cursor_pos)\\n\\t\\tcenter_point = QtWidgets.QApplication.desktop().screenGeometry(screen).center()\\n\\t\\tframe_geo.moveCenter(center_point)\\n\\t\\tself.move(frame_geo.topLeft())\",\n \"def get_centre(self):\\n return self.c\",\n \"def center(x):\\n return x - x.mean()\",\n \"def vert_center(self):\\n return self._vert_center\",\n \"def vert_center(self):\\n return self._vert_center\",\n \"def center(self):\\n return {self.identity}\",\n \"def center_image(image):\\r\\n image.anchor_x = image.width / 2\\r\\n image.anchor_y = image.height / 2\",\n \"def center_image(image):\\r\\n image.anchor_x = image.width / 2\\r\\n image.anchor_y = image.height / 2\",\n \"def center(self, obj):\\n mn0 = self.master.xy >= obj.center\\n mn1 = self.master.xy <= obj.center\\n\\n point_list = [self.master.xy[mn0], self.master.xy[mn1], self.master.xy[mn0[0], mn1[1]], self.master.xy[mn1[0], mn0[1]]] # 4 physical points near the center coordinate.\\n dist_list = []\\n idx = 0\\n for point in point_list:\\n dist_list.append([idx, np.linalg.norm(point - obj.center)]) # Calculate Euclidean distances.\\n idx += 1\\n dist_sorted = sorted(dist_list, key=lambda distance : distance[1]) # Sort distances in ascending order.\\n return self.master.mn(point_list[dist_sorted[0][0]]) # Convert the closest point to abstract coordinate and then return.\",\n \"def mean_centered(self):\\n return self._scala.meanCentered()\",\n \"def get_center_of_mass_allies(self,obs):\",\n \"def _center(self, forces):\\n\\t\\t\\n\\t\\tzipped = zip(self.grid.corners(), forces)\\n\\t\\treturn self._weightedAverage(zipped)\",\n \"def test_center(self):\\n\\n self.assertTrue((self.cs.center == np.array([[0], [0]])).all())\",\n \"def get_center(self):\\n return center_points(np.expand_dims(self.best_box, axis=0))[0]\",\n \"def horiz_center(self):\\n return self._horiz_center\",\n \"def horiz_center(self):\\n return self._horiz_center\",\n \"def center(self, width, fillchar=' '):\\n return asarray(center(self, width, fillchar))\",\n \"def centerx(self):\\n return self.left + self.width / 2\",\n \"def pix_center(self):\\n return self._pix_center\",\n \"def centerWindow(self):\\n framegeo = self.frameGeometry()\\n center = QtGui.QDesktopWidget().availableGeometry().center()\\n framegeo.moveCenter(center)\\n self.move(framegeo.topLeft())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.715392","0.7150732","0.7057086","0.7057086","0.7057086","0.7057086","0.6961718","0.6929149","0.68829924","0.6846377","0.6817087","0.67858565","0.6771365","0.6628032","0.66244245","0.6572838","0.65496373","0.65375334","0.6534411","0.6523956","0.6498194","0.648331","0.6476187","0.6469763","0.64408493","0.64366406","0.64350635","0.63908696","0.63848335","0.6374621","0.637043","0.6368671","0.63586223","0.63556707","0.6354709","0.6351498","0.6348162","0.63338286","0.6317693","0.6317431","0.63119817","0.6286857","0.6264037","0.6257911","0.6218939","0.6210244","0.62075084","0.6205609","0.62053084","0.62053084","0.61963093","0.6190346","0.617793","0.6168228","0.616274","0.6150437","0.6138302","0.6119165","0.6114929","0.61071056","0.60936207","0.60842776","0.6081767","0.607343","0.60648435","0.6038561","0.6032004","0.6032004","0.60091776","0.5999163","0.599247","0.5984103","0.5973313","0.5973313","0.5973313","0.59709555","0.59706986","0.59687203","0.59638804","0.5951136","0.5941525","0.59288925","0.5921135","0.5900909","0.5900909","0.59002197","0.5896502","0.5896502","0.58958185","0.58908564","0.5886805","0.58839715","0.5881594","0.5875617","0.5872134","0.5872134","0.5853082","0.5848169","0.5844216","0.5839967"],"string":"[\n \"0.715392\",\n \"0.7150732\",\n \"0.7057086\",\n \"0.7057086\",\n \"0.7057086\",\n \"0.7057086\",\n \"0.6961718\",\n \"0.6929149\",\n \"0.68829924\",\n \"0.6846377\",\n \"0.6817087\",\n \"0.67858565\",\n \"0.6771365\",\n \"0.6628032\",\n \"0.66244245\",\n \"0.6572838\",\n \"0.65496373\",\n \"0.65375334\",\n \"0.6534411\",\n \"0.6523956\",\n \"0.6498194\",\n \"0.648331\",\n \"0.6476187\",\n \"0.6469763\",\n \"0.64408493\",\n \"0.64366406\",\n \"0.64350635\",\n \"0.63908696\",\n \"0.63848335\",\n \"0.6374621\",\n \"0.637043\",\n \"0.6368671\",\n \"0.63586223\",\n \"0.63556707\",\n \"0.6354709\",\n \"0.6351498\",\n \"0.6348162\",\n \"0.63338286\",\n \"0.6317693\",\n \"0.6317431\",\n \"0.63119817\",\n \"0.6286857\",\n \"0.6264037\",\n \"0.6257911\",\n \"0.6218939\",\n \"0.6210244\",\n \"0.62075084\",\n \"0.6205609\",\n \"0.62053084\",\n \"0.62053084\",\n \"0.61963093\",\n \"0.6190346\",\n \"0.617793\",\n \"0.6168228\",\n \"0.616274\",\n \"0.6150437\",\n \"0.6138302\",\n \"0.6119165\",\n \"0.6114929\",\n \"0.61071056\",\n \"0.60936207\",\n \"0.60842776\",\n \"0.6081767\",\n \"0.607343\",\n \"0.60648435\",\n \"0.6038561\",\n \"0.6032004\",\n \"0.6032004\",\n \"0.60091776\",\n \"0.5999163\",\n \"0.599247\",\n \"0.5984103\",\n \"0.5973313\",\n \"0.5973313\",\n \"0.5973313\",\n \"0.59709555\",\n \"0.59706986\",\n \"0.59687203\",\n \"0.59638804\",\n \"0.5951136\",\n \"0.5941525\",\n \"0.59288925\",\n \"0.5921135\",\n \"0.5900909\",\n \"0.5900909\",\n \"0.59002197\",\n \"0.5896502\",\n \"0.5896502\",\n \"0.58958185\",\n \"0.58908564\",\n \"0.5886805\",\n \"0.58839715\",\n \"0.5881594\",\n \"0.5875617\",\n \"0.5872134\",\n \"0.5872134\",\n \"0.5853082\",\n \"0.5848169\",\n \"0.5844216\",\n \"0.5839967\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.687216"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":84596,"cells":{"query":{"kind":"string","value":"Apply a calibration matrix to the data."},"document":{"kind":"string","value":"def calibration_matrix(self, data: np.ndarray, matrix: np.ndarray) -> np.ndarray:\n tic = time.time()\n data_cal = np.dot(matrix, data)\n self.process_time.append(time.time() - tic)\n return data_cal"},"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 __call__(self, data):\n cal = self.calc()\n assert data.shape == cal.shape, \\\n \"data shape does not match calibration ({} != {})\".format(data.shape, cal.shape)\n return data * cal","def _applyCalibration(self, ws, detPos):\n alg = self.createChildAlgorithm('ApplyCalibration')\n alg.setProperty('Workspace', ws)\n alg.setProperty('PositionTable', detPos)\n alg.execute()","def _doCalibration(self):\n self._cmdCalibration(2)","def fit(self,data):\n A = data[:,0:self.dim]\n B = data[:,self.dim:]\n\n #Procrustean: CODE TO SOLVE FOR OPTIMAL (by least squares) EUCLIDEAN TRANSFORM (currently allows reflections):\n bReflection = True\n\n muA = np.mean(A,axis=0)\n muB = np.mean(B,axis=0)\n A0 = A - np.tile(muA,[A.shape[0],1])\n B0 = B - np.tile(muB,[B.shape[0],1])\n\n ssqA = np.sum(A0**2)\n ssqB = np.sum(B0**2)\n normA = np.sqrt(ssqA)\n normB = np.sqrt(ssqB)\n\n A0 = A0 / normA\n B0 = B0 / normB\n\n X = np.dot(A0.T,B0)\n [L, D, M] = np.linalg.svd(X)\n rotation = np.dot(M.T,L.T)\n\n traceTA = sum(D)\n if self.bScale:\n scale = traceTA * normA / normB\n else:\n scale = 1\n translation = muA - np.dot(scale*muB,rotation); \n\n self.scale = scale\n self.rot = rotation\n self.trans = translation\n return scale,rotation,translation\n #A - (np.dot((scale * B),rotation) + translation)","def calibrate(self, dataset: Iterable[Dict[str, np.ndarray]]) -> Dict[str, Tuple[float, float]]:\n return calibrate(self.model, dataset)","def apply_calibration(self, poses):\n new_poses = []\n for pose in poses:\n T = pose.copy()\n T[:3, :3] = np.eye(3)\n new_poses.append(T)\n return new_poses","def calibrate(self, Otrain, Ftrain, Feval):\n return Otrain[0] * np.ones(len(Feval))","def load_calib(self):\n # We'll build the calibration parameters as a dictionary, then\n # convert it to a namedtuple to prevent it from being modified later\n data = {}\n\n # Load the calibration file\n calib_filepath = os.path.join(self.sequence_path, 'calib.txt')\n filedata = utils.read_calib_file(calib_filepath)\n\n # Create 3x4 projection matrices\n P_rect_00 = np.reshape(filedata['P0'], (3, 4))\n P_rect_10 = np.reshape(filedata['P1'], (3, 4))\n P_rect_20 = np.reshape(filedata['P2'], (3, 4))\n P_rect_30 = np.reshape(filedata['P3'], (3, 4))\n\n # Compute the rectified extrinsics from cam0 to camN\n T1 = np.eye(4)\n T1[0, 3] = P_rect_10[0, 3] / P_rect_10[0, 0]\n T2 = np.eye(4)\n T2[0, 3] = P_rect_20[0, 3] / P_rect_20[0, 0]\n T3 = np.eye(4)\n T3[0, 3] = P_rect_30[0, 3] / P_rect_30[0, 0]\n\n # Compute the velodyne to rectified camera coordinate transforms\n data['T_cam0_velo'] = np.reshape(filedata['Tr'], (3, 4))\n data['T_cam0_velo'] = np.vstack([data['T_cam0_velo'], [0, 0, 0, 1]])\n data['T_cam1_velo'] = T1.dot(data['T_cam0_velo'])\n data['T_cam2_velo'] = T2.dot(data['T_cam0_velo'])\n data['T_cam3_velo'] = T3.dot(data['T_cam0_velo'])\n\n # Compute the camera intrinsics\n data['K_cam0'] = P_rect_00[0:3, 0:3]\n data['K_cam1'] = P_rect_10[0:3, 0:3]\n data['K_cam2'] = P_rect_20[0:3, 0:3]\n data['K_cam3'] = P_rect_30[0:3, 0:3]\n\n # Compute the stereo baselines in meters by projecting the origin of\n # each camera frame into the velodyne frame and computing the distances\n # between them\n p_cam = np.array([0, 0, 0, 1])\n p_velo0 = np.linalg.inv(data['T_cam0_velo']).dot(p_cam)\n p_velo1 = np.linalg.inv(data['T_cam1_velo']).dot(p_cam)\n p_velo2 = np.linalg.inv(data['T_cam2_velo']).dot(p_cam)\n p_velo3 = np.linalg.inv(data['T_cam3_velo']).dot(p_cam)\n\n data['b_gray'] = np.linalg.norm(p_velo1 - p_velo0) # gray baseline\n data['b_rgb'] = np.linalg.norm(p_velo3 - p_velo2) # rgb baseline\n\n self.calib = namedtuple('CalibData', data.keys())(*data.values())","def do_calibration(self):\n goal = CalculateParametersGoal()\n self.calibrate_client.send_goal(goal)\n self.calibrate_client.wait_for_result()\n result = self.calibrate_client.get_result()\n rospy.loginfo('Received the calibration results')\n if result.number_of_images is 0:\n rospy.logerr('Failed to calibrate the camera.')\n else:\n rospy.loginfo('Number of pictures: {}, error: {}'.format(result.number_of_images, result.error))\n self.save_calibration_parameters(result.intrinsics, result.error, result.number_of_images)","def calibrate(self, calib_fns, calib_params, analytes=None, drift_correct=False):\n # can have calibration function stored in self and pass *coefs?\n if analytes is None:\n analytes = self.analytes\n\n if 'calibrated' not in self.data.keys():\n self.data['calibrated'] = {}\n\n for a in analytes:\n if drift_correct:\n P = self.drift_params(calib_params, a)\n else:\n P = calib_params[a].values[0]\n\n self.data['calibrated'][a] = \\\n calib_fns[a](P,\n self.data['ratios'][a])\n\n # coefs = calib_params[a]\n # if len(coefs) == 1:\n # self.data['calibrated'][a] = \\\n # self.data['ratios'][a] * coefs\n # else:\n # self.data['calibrated'][a] = \\\n # np.polyval(coefs, self.data['ratios'][a])\n # self.data['ratios'][a] * coefs[0] + coefs[1]\n self.setfocus('calibrated')\n return","def calibrate(cols=9, rows=6, path=\"./camera_cal/\", debug=False):\n # termination criteria\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)\n\n # prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\n objp = np.zeros((cols*rows,3), np.float32)\n objp[:,:2] = np.mgrid[0:cols,0:rows].T.reshape(-1,2)\n\n # Arrays to store object points and image points from all the images.\n objpoints = [] # 3d point in real world space\n imgpoints = [] # 2d points in image plane.\n search_str = path+'*.jpg'\n images = glob.glob(search_str)\n print(\"Found {0} images for calibration.\".format(len(images)))\n\n for fname in images:\n img = cv2.imread(fname)\n gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n # Find the chess board corners\n ret, corners = cv2.findChessboardCorners(gray, (cols,rows), None)\n\n # If found, add object points, image points (after refining them)\n if ret == True:\n objpoints.append(objp)\n\n cv2.cornerSubPix(gray,corners,(11,11),(-1,-1),criteria)\n imgpoints.append(corners)\n\n if (debug):\n # Draw and display the corners\n cv2.drawChessboardCorners(img, (cols,rows), corners,ret)\n window_name = \"calib image\"\n cv2.imshow('calib image',img)\n cv2.moveWindow(\"calib image\", 10, 50);\n cv2.waitKey()\n cv2.destroyAllWindows()\n\n else:\n print(\"No chessboard corners in {0} found!!!\".format(fname))\n\n ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1],None,None)\n return mtx, dist","def fit_data(self, data):\n return dot(data, self._fit_matrix.T)","def apply_matrix(self, A):\n assert self.is_vector(), 'Can only apply matrices to vector-valued functions'\n C = np.matmul(A, self.coeffs[..., None])\n assert C.shape[-1] == 1 # this should have created a new singleton axis\n return BSplineFunc(self.kvs, np.squeeze(C, axis=-1))","def calibrate():\n if os.path.exists('calibration_data.pkl'):\n with open('calibration_data.pkl', 'rb') as f:\n return pickle.load(f)\n\n objp = np.zeros((6 * 9, 3), np.float32)\n objp[:, :2] = np.mgrid[0:9, 0:6].T.reshape(-1, 2)\n\n # Arrays to store object points and image points from all the images.\n objpoints = [] # 3d points in real world space\n imgpoints = [] # 2d points in image plane.\n\n for fname in glob.glob('camera_cal/calibration*.jpg'):\n img = cv2.imread(fname)\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n # print('{}: {}'.format(fname, gray.shape))\n\n # Find the chessboard corners\n ret, corners = cv2.findChessboardCorners(gray, (9, 6), None)\n\n if ret:\n objpoints.append(objp)\n imgpoints.append(corners)\n else:\n print('Failed to detect corners for {}'.format(fname))\n\n ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, (1280, 720), None, None)\n assert ret\n\n with open('calibration_data.pkl', 'wb') as f:\n pickle.dump((mtx, dist), f)\n\n return mtx, dist","def calibrate_camera(calib_path, display=True):\r\n assert path.exists(calib_path), '\"{}\" calibration images must be exist.'.format(calib_path)\r\n # prepare world points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\r\n # Set initial chessboard parameter matrix\r\n wdp = np.zeros((6 * 9, 3), np.float32)\r\n wdp[:, :2] = np.mgrid[0:9, 0:6].T.reshape(-1, 2)\r\n # Arrays to store object points and pixel points from all the images.\r\n worldpoints = [] # 3d points in real world space\r\n pixelpoints = [] # 2d points in pixel plane.\r\n # loads imgs into a list\r\n imgs = glob.glob(path.join(calib_path, 'calibration*.jpg'))\r\n # Step through the list and search for chessboard corners\r\n for filename in imgs:\r\n img = cv2.imread(filename)\r\n img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\r\n # Find the chessboard corners\r\n pattern_flag, corners = cv2.findChessboardCorners(img_gray, (9, 6), None)\r\n if pattern_flag is True:\r\n worldpoints.append(wdp)\r\n pixelpoints.append(corners)\r\n # for display result of calibration\r\n if display:\r\n # Draw and display the corners\r\n img = cv2.drawChessboardCorners(img, (9, 6), corners, pattern_flag)\r\n cv2.imshow('img',img)\r\n print(\"Picture: \" + filename + ' calibrating ...')\r\n cv2.waitKey(300)\r\n if display:\r\n cv2.destroyAllWindows()\r\n ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(worldpoints, pixelpoints, img_gray.shape[::-1], None, None)\r\n # print(mtx,dist)\r\n return mtx, dist","def calibration_matrix(resolution_px, diagonal_mm, focal_len_mm, skew=0.):\n # Camera intrinsics parameters\n resolution_x_px, resolution_y_px = resolution_px # image resolution in pixels\n diagonal_px = np.sqrt(resolution_x_px**2 + resolution_y_px**2)\n\n resolution_x_mm = resolution_x_px / diagonal_px * diagonal_mm\n resolution_y_mm = resolution_y_px / diagonal_px * diagonal_mm\n\n skew = skew # \"skew param will be zero for most normal cameras\" Hartley, Zisserman\n\n m_x = resolution_x_px / resolution_x_mm\n m_y = resolution_y_px / resolution_y_mm\n\n alpha_x = focal_len_mm * m_x # focal length of the camera in pixels\n alpha_y = focal_len_mm * m_y # focal length of the camera in pixels\n\n x_0 = resolution_x_px / 2\n y_0 = resolution_y_px / 2\n\n return np.array([[alpha_x, skew, x_0], [0, alpha_y, y_0], [0, 0, 1]])","def calibrate(self, Otrain, Ftrain, Feval):\n I = np.where((np.isnan(Otrain) == 0) & (np.isnan(Ftrain) == 0))[0]\n if len(I) == 0:\n return np.nan*np.zeros(Feval.shape)\n Ieval = np.where(np.isnan(Feval) == 0)[0]\n x = np.nan*np.zeros(Feval.shape)\n if len(Ieval) > 0:\n x[Ieval] = self._calibrate(Otrain[I], Ftrain[I], Feval[Ieval])\n return x","def calibrate(self):\n if self.iCAL_required:\n logger.info(\"iCAL-sensitive registers were modified, performing calibration...\")\n return self._run_ical()\n else:\n logger.info(\"iCAL-sensitive registers were not modified, skipping calibration...\")\n return 0 # Still success","def _calibrate(self, Otrain, Ftrain, Feval):\n raise NotImplementedError()","def fit(self, data):\n x, y = np.asarray(data, dtype=float)\n\n # Quadratic part of design matrix [eqn. 15] from (*)\n D1 = np.mat(np.vstack([x**2, x*y, y**2])).T\n # Linear part of design matrix [eqn. 16] from (*)\n D2 = np.mat(np.vstack([x, y, np.ones(len(x))])).T\n\n # forming scatter matrix [eqn. 17] from (*)\n S1 = D1.T*D1\n S2 = D1.T*D2\n S3 = D2.T*D2\n\n # Constraint matrix [eqn. 18]\n C1 = np.mat('0. 0. 2.; 0. -1. 0.; 2. 0. 0.')\n\n # Reduced scatter matrix [eqn. 29]\n M = C1.I*(S1-S2*S3.I*S2.T)\n\n # M*|a b c >=l|a b c >. Find eigenvalues and eigenvectors from this equation [eqn. 28]\n eval, evec = np.linalg.eig(M)\n\n # eigenvector must meet constraint 4ac - b^2 to be valid.\n cond = 4*np.multiply(evec[0, :], evec[2, :]) - \\\n np.power(evec[1, :], 2)\n a1 = evec[:, np.nonzero(cond.A > 0)[1]]\n\n # |d f g> = -S3^(-1)*S2^(T)*|a b c> [eqn. 24]\n a2 = -S3.I*S2.T*a1\n\n # eigenvectors |a b c d f g>\n self.coef = np.vstack([a1, a2])\n self._save_parameters()","def calibrate_onc(data, path, model_name):\n \n #split test data (subsets 7-9) into new test (7-8)/train(9) sets\n calibration_train_set = data[((data.subset==7)|(data.subset==8))].copy()\n calibration_test_set = data[data.subset==9].copy()\n\n #define calibration model\n ir = IsotonicRegression(out_of_bounds=\"clip\")\n #fit the model to the probas from the training set\n ir.fit(calibration_train_set.score, calibration_train_set.y )\n \n #evaluate with the test set and save\n calibration_test_set.loc[:,'p_calibrated'] = ir.transform(calibration_test_set.score) \n \n #calibration_test_set.loc[:,'p_calibrated'] = p_calibrated\n \n #save\n with open(path + 'model_calibrated_' + model_name + '.pickle', 'wb') as picklefile: \n pickle.dump(ir,picklefile)\n \n with open(path + 'y_calibrated_' + model_name + '.pickle', 'wb') as picklefile: \n pickle.dump(calibration_test_set, picklefile)\n \n print_calibrated_results(calibration_test_set.y, calibration_test_set.score, calibration_test_set.p_calibrated)\n return calibration_test_set","def calibrate(\n model: onnx.ModelProto, dataset: List[Dict[str, np.ndarray]]\n) -> Dict[str, Tuple[float, float]]:\n augmented_model = ONNXCalibrator(model).build_calibration_model()\n return calibrator.calibrate(augmented_model, dataset)","def estimate(self, data):\n\n A = np.c_[data[:, 0], data[:, 1], np.ones(data.shape[0])]\n C, _, _, _ = scipy.linalg.lstsq(A, data[:, 2]) # coefficients\n\n self.params = C\n\n return True","def loadCameraCalibration(self, file_name=None):\n\n mat_str = []\n if file_name == None:\n file_str = \"/home/student/armlab-w20/util/calibration.cfg\"\n else:\n file_str = file_name\n with open(file_str, 'r') as f:\n for line in f:\n line = line.replace('[', '')\n line = line.replace(']', '')\n line = line.replace('\\n', '')\n mat_str.append(line)\n cam_mat_str = mat_str[1:4]\n dist_coeffs = mat_str[-2:]\n dist_coeffs = \"\".join(dist_coeffs)\n dist_coeffs = dist_coeffs.split()\n dist_coeffs = [float(coeff) for coeff in dist_coeffs]\n self.cam_int_mat = []\n for row in cam_mat_str:\n mat_row = []\n mat_row = row.split()\n mat_row = [float(i) for i in mat_row]\n self.cam_int_mat.append(mat_row)\n self.cam_int_mat = np.asarray(self.cam_int_mat)\n self.dist_coeffs = np.asarray(dist_coeffs)","def calibration(self, cal: int, /) -> None:","def calibrate(self, cal=1.0, pol_eff=1.0):\n \n if self.ncomp == 1:\n self.data *= cal\n else:\n self.data[0] *= cal\n self.data[1] *= cal * pol_eff\n self.data[2] *= cal * pol_eff\n\n return self","def calib_raw(self, calib_func=\"kidsdata.kids_calib.get_calfact\", clean_raw=False, **kwargs):\n\n if getattr(self, \"__calib\", None) is None:\n self.__log.debug(\"calibration using {}\".format(calib_func))\n self.__check_attributes([\"I\", \"Q\"], read_missing=False)\n\n fmod = self.fmod\n mod_mask = self.mod_mask\n\n # Check about the 3rd bit and the fix_masq keyword\n if np.any(mod_mask & (1 << 2)) and kwargs.get(\"fix_masq\") is True:\n self.__log.error(\"fix_masq should not be used when 3rd bit is set\")\n\n self.__log.info(\"Calibrating with fmod={} and {}\".format(fmod, kwargs))\n calib_func = _import_from(calib_func)\n self.__calib = calib_func(self.I, self.Q, mod_mask, fmod=fmod, **kwargs)\n\n else:\n self.__log.error(\"calibrated data already present\")\n\n # Expand keys :\n # Does not double memory, but it will not be possible to\n # partially free memory : All attribute read at the same time\n # must be deleted together\n for ckey in self.__calib.keys():\n self.__dict__[ckey] = self.__calib[ckey]\n\n if clean_raw:\n self._clean_data(\"_KidsRawData__dataSd\")","def matrix_transform(data, fun, *args, **kwargs):\n if is_sparse_dataframe(data) or is_SparseDataFrame(data):\n data = data.copy()\n for col in data.columns:\n data[col] = fun(data[col], *args, **kwargs)\n elif sparse.issparse(data):\n if isinstance(data, (sparse.lil_matrix, sparse.dok_matrix)):\n data = data.tocsr()\n else:\n # avoid modifying in place\n data = data.copy()\n data.data = fun(data.data, *args, **kwargs)\n else:\n data = fun(data, *args, **kwargs)\n return data","def m(self) -> np.ndarray:\n assert self._k is not None and self._r is not None and self._t is not None, \"camera must be calibrated\"\n return forge_projective_matrix(self._k, r=self._r, t=self._t)","def fit_transform(self, data_matrix, target=None):\n self.fit(data_matrix, target)\n return self.transform(data_matrix)","def calculate_calibration(filename, nx=9, ny=6):\n # Make a list of calibration images\n img = cv2.imread(filename)\n\n # Convert to grayscale\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n\n # Find the chessboard corners\n objpoints = []\n imgpoints = []\n objp = np.zeros((ny*nx, 3), np.float32)\n objp[:, :2] = np.mgrid[0:nx, 0:ny].T.reshape(-1, 2)\n\n ret, corners = cv2.findChessboardCorners(gray, (nx, ny), None)\n if not ret:\n return None\n\n imgpoints.append(corners)\n objpoints.append(objp)\n\n ret, mtx, dist, a, b = cv2.calibrateCamera(\n objpoints, imgpoints,\n gray.shape[::-1], None, None\n )\n return img, corners, mtx, dist","def matrix_map(self, bkg_reduction=True, data_correction=True):\r\n\r\n if bkg_reduction is True:\r\n if data_correction is True:\r\n data = self.df4\r\n \r\n else:\r\n data = self.df2\r\n\r\n else:\r\n if data_correction is True:\r\n data = self.df3\r\n \r\n else:\r\n data = self.df1\r\n\r\n return data","def loadCameraCalibration(self):\n\n # Read calibration.csv\n with open(\"util/calibration.csv\", 'rb') as csvfile:\n csvreader = csv.reader(csvfile, delimiter=\",\", quotechar=\"|\")\n tmp = []\n intrinsic_matrix = []\n distort_coef = []\n i = 0\n for row in csvreader:\n for col in row:\n try:\n tmp.append(float(col))\n except:\n print(\"ERROR in calibration.csv intrinsic matrix\")\n if(i!=3):\n intrinsic_matrix.append(tmp)\n i += 1\n tmp = []\n if(i==3):\n distort_coef = tmp\n tmp = []\n \n return intrinsic_matrix, distort_coef","def build(self, data: np.ndarray):\n ret = data.dot(self.eigenvectors)\n self.pca_predictor_vars = ret\n return ret","def _RunCalibration(self, graph_key, gdef, input_data, config):\n return self._RunGraph(graph_key, gdef, input_data, config, 30)","def calibrate(self):\n if not self._calibrate:\n raise ValueError(\"calibrate parameter must be set\")\n\n if self.calibration_samples >= self._max_samples:\n return self._camera\n\n frame = self.capture()\n left = frame.images[0]\n right = frame.images[1]\n\n ret_l, corners_l = left.features\n ret_r, corners_r = right.features\n\n if self._last_timestamp is None:\n self._last_timestamp = frame.timestamp\n\n if ret_l is True and ret_r is True and (frame.timestamp - self._last_timestamp).total_seconds() > self._frame_delay:\n self.objpoints.append(self.objp)\n self.imgpoints_l.append(corners_l)\n self.imgpoints_r.append(corners_r)\n\n self.calibration_samples += 1\n self._last_timestamp = frame.timestamp\n\n if self.calibration_samples >= self._max_samples:\n img_shape = left.image.shape[::-1]\n self._camera = self._finish_calibration(self.objpoints, self.imgpoints_l, self.imgpoints_r, img_shape)\n return self._camera","def calibrate_camera(path_to_images='../camera_cal/calibration*.jpg', pattern=(9, 6)):\n # Prepare object points\n objp = np.zeros((pattern[1]*pattern[0],3), np.float32)\n objp[:,:2] = np.mgrid[0:pattern[0], 0:pattern[1]].T.reshape(-1,2)\n\n # Arrays to store object points and image points from all the images.\n objpoints = [] # 3d points in real world space\n imgpoints = [] # 2d points in image plane.\n\n # Make a list of calibration images\n images = glob.glob(path_to_images)\n img_w = 0\n img_h = 0\n\n # Step through the list and search for chessboard corners\n for idx, fname in enumerate(images):\n img = cv2.imread(fname)\n img_h, img_w, _ = img.shape\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n\n # Find the chessboard corners\n ret, corners = cv2.findChessboardCorners(gray, pattern, None)\n\n # If found, add object points, image points\n if ret == True:\n objpoints.append(objp)\n imgpoints.append(corners)\n \n # Calibrate camera\n ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, (img_w, img_h) ,None,None)\n \n # Return the camera matrix and distortion coefs\n return mtx, dist","def calibrate(self, chessboard_img_files, chessboard_size):\n # Create placeholder lists\n chess_rows, chess_cols = chessboard_size\n chess_corners = np.zeros((chess_cols * chess_rows, 3), np.float32)\n chess_corners[:, :2] = np.mgrid[0:chess_rows, 0:chess_cols].T.reshape(-1, 2)\n objpoints = [] # 3d points in real world space\n imgpoints = [] # 2d points in image plane.\n\n # Determine object point, image point pairs\n for fname in chessboard_img_files:\n # Load images\n img = cv2.imread(fname)\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n\n # Find the chessboard corners\n found, img_corners = cv2.findChessboardCorners(gray, (chess_rows, chess_cols), None)\n\n # If found, save object points, image points\n if found:\n objpoints.append(chess_corners)\n imgpoints.append(img_corners)\n\n # Perform calibration\n success, camera_matrix, dist_coeffs, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, self.img_size,\n None, None)\n if not success:\n raise Exception(\"Camera calibration unsuccessful.\")\n return camera_matrix, dist_coeffs","def project(self, new_expn):\n \"\"\"\n data = numpy.array(self.parent.serialisedArrayDataList)\n import sklearn\n skpca = sklearn.decomposition.PCA()\n X_r = skpca.fit(data).transform(data)\n \n self.__v = X_r\n \"\"\"\n # old martrisx\n matrix = numpy.array(self.parent.serialisedArrayDataList)\n U, S, V = numpy.linalg.svd(matrix.T, full_matrices=False)\n \n print(\"matrix\", matrix.shape)\n \n # set-ups\n self.parent = new_expn\n if self.rowwise:\n self.labels = new_expn[self.label_key]\n else:\n self.labels = new_expn.getConditionNames()\n \n matrix = numpy.array(self.parent.serialisedArrayDataList)\n S = numpy.diag(S)\n print(\"U\", U.shape)\n print(\"V\", V.shape)\n print(\"S\", S.shape)\n print(\"matrix\", matrix.shape)\n \n #data = np.dot(U, np.dot(S, V))\n #X_transformed = np.dot(X_transformed, self.V.T)\n print(numpy.dot(S, V).shape)\n\n pr = numpy.dot(matrix, S)\n print(\"pr\", pr.shape)\n #y = x*W;\n #y0 = Y(1,:);\n #sum(abs(y0 - y)) %\n \n # I want a new v. U and D are the same.\n \n self.__v = pr\n \n print(U)\n print()\n print(pr)\n \n print(numpy.allclose(U, pr)) \n print(numpy.allclose(matrix.T, numpy.dot(U, numpy.dot(S, V))))\n return(True)","def calibrate(): \n \n # Calibrate of the run using beam data. Creates a folder cal-files/caltag \n # containing all calibration data. \n CalObj = Calibration(steerfiles=steerfiles, name=localcaltag + '-cal') \n\n # Set Beam energy\n CalObj.set_beam_momentum(beamenergy)\n\n # Get gearfile and set air as DUT material\n localgearfile = CalObj.get_filename('gear.xml')\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='thickness', value=0.0001)\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='radLength', value=304000.0)\n \n # Create list of calibration steps \n calpath = create_calibration_path(CalObj)\n \n # Run the calibration steps \n CalObj.calibrate(path=calpath,ifile=rawfile_air,caltag=localcaltag)","def calibrate(self, master):\n if master.polyorder == 'linear':\n self.fitfunction = \"A0 + A1 * D\"\n self.fit_fkt = self.calc_lin\n elif master.polyorder == 'quadratic':\n self.fit_fkt = self.calc_quad\n self.fitfunction = \"A0 + A1 * D + A2 * D**2\"\n elif master.polyorder == \"cubic\":\n self.fitfunction = \"A0 + A1 * D + A2 * D**2 + A3 * D**3\"\n self.fit_fkt = self.calc_cubic\n else:\n print(\"Polynomgrad nicht definiert\")\n \n self.mw = np.asarray(self.mw)\n if master.sensortype == \"Druck\":\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\n else:\n print(\"Sensortyp noch nicht Hinterlegt\")","def transform(self, X):\n\n t0 = time.perf_counter()\n check_is_fitted(self)\n self.check_external_components_modified()#[WARN] in d3m, primitives can \"restore\" private class variables...\n X = self._validate_data(X, accept_sparse=[\"csr\", \"csc\"], reset=False)\n t1 = time.perf_counter()\n\n if X.shape[1] != self.components_af_.shape[1]:\n raise ValueError(\n \"Impossible to perform projection:\"\n \"X at fit stage had a different number of features. \"\n \"(%s != %s)\" % (X.shape[1], self.components_af_.shape[1])\n )\n\n #X_new = safe_sparse_dot(X, self.components_.T, dense_output=self.dense_output)\n #import pdb; pdb.set_trace()\n X_af = af.interop.from_ndarray(X).as_type(self.components_af_.dtype())\n X_new = af.matmulNT(X_af, self.components_af_)\n X_new = X_new.to_ndarray()\n t2 = time.perf_counter()\n return X_new","def m_c(self) -> np.ndarray:\n assert self._k is not None, \"camera must be calibrated\"\n return forge_projective_matrix(self._k)","def cam_calibration():\n # read all calibration images in a folder with similar names\n images = glob.glob('./camera_cal/calibration*.jpg')\n\n # calibrate camera and read object-points (3D), image points (2D) and image shape\n objpoints, imgpoints, img_shape = calibrate_camera(images)\n print(\"DONE: Camera calibration\")\n # save calibration parameters' pickle file\n save_calib_params(objpoints, imgpoints, img_shape)\n print(\"Calibration parameters pickle file saved \")","def calibrate(self):\n\n self.update_message('Calibrating platform...')\n\n self.calibrate_platform()\n\n self.update_message('Platform Calibrated.')\n\n # calibrate arm x axis\n self.update_message('Calibrating x axis...')\n calibrated = self.calibrate_arm(0)\n\n if not calibrated:\n self.update_message('ERROR: Could not calibrate x axis.')\n return 0\n else:\n self.update_message('x axis calibrated.')\n\n # calibrate arm y axis\n self.update_message('Calibrating y axis...')\n calibrated = self.calibrate_arm(1)\n\n if not calibrated:\n self.update_message('ERROR: Could not calibrate y axis.')\n return 0\n else:\n self.update_message('y axis calibrated.')\n\n # calibrate arm z axis\n self.update_message('Calibrating z axis...')\n calibrated = self.calibrate_arm(2)\n\n if not calibrated:\n self.update_message('ERROR: Could not calibrate z axis.')\n return 0\n else:\n self.update_message('z axis calibrated.\\n'\n 'Autocalibration done.\\n'\n 'Accuracy: {}'.format(self.matrix_accuracy()))\n\n # Getting the direction to withdraw pipette along x axis\n self.get_withdraw_sign()\n self.inv_mat = np.linalg.inv(self.mat)\n self.calibrated = 1\n self.cam.click_on_window = True\n self.save_calibration()\n return 1","def _calibration(\n name: str = CALIBRATION_NAME,\n eval_config: Optional[config_pb2.EvalConfig] = None,\n model_name: str = '',\n output_name: str = '',\n sub_key: Optional[metric_types.SubKey] = None,\n aggregation_type: Optional[metric_types.AggregationType] = None,\n class_weights: Optional[Dict[int, float]] = None,\n example_weighted: bool = False) -> metric_types.MetricComputations:\n key = metric_types.MetricKey(\n name=name,\n model_name=model_name,\n output_name=output_name,\n sub_key=sub_key,\n example_weighted=example_weighted)\n\n # Make sure weighted_labels_predictions_examples are calculated.\n computations = _weighted_labels_predictions_examples(\n eval_config=eval_config,\n model_name=model_name,\n output_name=output_name,\n sub_key=sub_key,\n aggregation_type=aggregation_type,\n class_weights=class_weights,\n example_weighted=example_weighted)\n weighted_labels_predictions_key = computations[-1].keys[-1]\n\n def result(\n metrics: Dict[metric_types.MetricKey, Any]\n ) -> Dict[metric_types.MetricKey, Any]:\n \"\"\"Returns calibration.\"\"\"\n metric = metrics[weighted_labels_predictions_key]\n if np.isclose(metric.total_weighted_labels, 0.0):\n value = float('nan')\n else:\n value = metric.total_weighted_predictions / metric.total_weighted_labels\n\n return {key: value}\n\n derived_computation = metric_types.DerivedMetricComputation(\n keys=[key], result=result)\n computations.append(derived_computation)\n return computations","def reconstruct(self,data):\n k,d = self.w.shape\n return dot(data,self.w)+self.mean.reshape(1,d)","def _apply_correction(self):\n np.copyto(self.network.weights, self.correction_matrix)","def fit(self, X):\n if self.n_components_ > X.shape[2]:\n raise ValueError(\"n_components is greater than number of features in X.\")\n\n if len(X.shape) != 3:\n raise ValueError(\"Data must be in 3 dimensions (conditions, time, features).\")\n\n if self.mean_subtract_:\n self.cross_condition_mean_ = np.mean(X, axis=0, keepdims=True)\n X = X - self.cross_condition_mean_\n\n X_flat = np.concatenate(X, axis=0)\n self.pca_ = PCA(n_components=self.n_components_)\n self.pca_.fit(X_flat)\n\n X_red = [self.pca_.transform(Xi) for Xi in X]\n dX = np.concatenate([np.diff(Xi, axis=0) for Xi in X_red], axis=0)\n X_prestate = np.concatenate([Xi[:-1] for Xi in X_red], axis=0)\n M_skew = self._fit_skew(X_prestate, dX)\n\n self.eigen_vals_, self.eigen_vecs_ = self._get_jpcs(M_skew)\n\n self.proj_vectors_ = []\n for i in range(len(self.eigen_vecs_) // 2):\n v1 = self.eigen_vecs_[2 * i]\n v2 = self.eigen_vecs_[2 * i + 1]\n real_v1 = np.real(v1 + v2)\n real_v1 /= np.linalg.norm(real_v1)\n real_v2 = np.imag(v1 - v2)\n real_v2 /= np.linalg.norm(real_v2)\n self.proj_vectors_.append(real_v1)\n self.proj_vectors_.append(real_v2)\n self.proj_vectors_ = np.array(self.proj_vectors_)\n return self","def mca_transformer(transform_data):\n M, dims, index, v0v1 = transform_data\n def transform(dfp):\n # dims, index, v0v1\n P = np.zeros((len(dfp), dims), dtype=float)\n print(\"transforming\")\n for i, (_, row) in (enumerate(dfp.iterrows())):\n ivec = np.zeros(M)\n for col, val in zip(row.index, row):\n if (col, val) in index:\n ivec[index[col, val]] = 1\n proj = ivec.dot(v0v1)\n assert(all(proj.imag == 0))\n P[i,:] = proj.real\n return P\n return transform","def calibration(self) -> int:","def transform(self,data):\n n,d = data.shape\n assert d==self.w.shape[1]\n assert self.w is not None\n k,d = self.w.shape\n return dot(data-self.mean.reshape(1,d),self.w.T)","def calibrate(self, calibration_dict=None):\n if calibration_dict is not None:\n for i in self.POSITIONS:\n if self.version == \"standard\" and i.startswith(\"save_image__\"):\n continue\n self.POSITIONS[i] = calibration_dict[i]\n else:\n if os.path.isfile(GoogleEarthProCalibration.SETTINGS_FILE):\n print \"Using config file\"\n with open(GoogleEarthProCalibration.SETTINGS_FILE, \"r\") as gf:\n for l in gf:\n cd = l.split(\",\")\n self.POSITIONS[cd[0]] = (int(cd[1]), int(cd[2]))\n else:\n to_offset = [i for i in self.POSITIONS \\\n if i is not \"google_earth_pro_offset\"]\n for i in to_offset:\n self.POSITIONS[i] = self.offset(self.POSITIONS[i])","def apply_observation_matrix(self, x, k, result=None):\n\n i = 0\n\n # vector case\n ssm_indices = self.active_ssms(k)\n if len(x.shape)==1:\n r = 0\n for j in ssm_indices:\n ssm, scale = self.ssms[j], self.scales[j]\n state_size = ssm.max_dimension\n ri = ssm.apply_observation_matrix(x[i:i+state_size], k-self.ssm_starts[j])\n if scale is not None:\n r += ri * scale[k-self.ssm_starts[j]]\n else:\n r += ri\n i += state_size\n return r\n\n # matrix case\n else:\n assert(len(x.shape)==2)\n\n try:\n rr = self.tmp_arrays[len(result)]\n except KeyError:\n rr = np.empty((len(result),))\n self.tmp_arrays[len(result)] = rr\n\n result[:] = 0\n for j in ssm_indices:\n ssm, scale = self.ssms[j], self.scales[j]\n state_size = ssm.max_dimension\n ssm.apply_observation_matrix(x[i:i+state_size,:], k-self.ssm_starts[j], rr)\n #print \"TSSM step %d applying obs matrix on ssm %d state_size %d n %d scale %f result[0] %f\\n\" % (k, j, state_size, len(result), scale[k-self.ssm_starts[j]] if scale is not None else 1.0, rr[0])\n if scale is not None:\n rr *= scale[k-self.ssm_starts[j]]\n result += rr\n i += state_size","def calcIntrasec(self, gui):\n count = len(self.points)\n numpoints = (self.chessSize[0]*self.chessSize[1])\n\n #create matrices that are needed to compute calibration\n mat = cv.CreateMat(3,3,cv.CV_32FC1)\n distCoeffs = cv.CreateMat(4,1,cv.CV_32FC1)\n p3d = cv.CreateMat(count,3,cv.CV_32FC1) #compute 3D points\n p2d = cv.CreateMat(count,2,cv.CV_32FC1) #compute 2D points\n pointCounts = cv.CreateMat( self.nframe ,1,cv.CV_32SC1) #give numpoints per images\n cv.Set(pointCounts,numpoints)\n rvecs = cv.CreateMat(self.nframe,3,cv.CV_32FC1)\n tvecs = cv.CreateMat(self.nframe,3,cv.CV_32FC1)\n\n i = 0\n row = 0\n col = 0\n cv.Set(p3d,0.0) #to set every values to 0.0... and not set Z value\n\n #this compute points in row and cols...\n for p in self.points:\n p2d[i,0] = p[0]\n p2d[i,1] = p[1]\n \n p3d[i,0] = col\n p3d[i,1] = row\n col+=1\n if col >= self.chessSize[0]: \n row+=1\n col=0\n if row >= self.chessSize[1]:\n row = 0\n i+=1\n\n #and now, calibrate...\n cv.CalibrateCamera2(p3d, p2d, pointCounts, self.framesize, mat, distCoeffs, rvecs, tvecs, flags=0)\n gui.setMessage(\"Intrasinc camera parameters checked\")\n\n return (mat, distCoeffs)","def fit_transform(self, x: Array2D) -> Array2D:","def calibrate_camera(cal_images, nx, ny):\n objpoints = [] # 3D points\n imgpoints = [] # 2D points\n\n objp = np.zeros((nx*ny,3), np.float32)\n objp[:,:2] = np.mgrid[0:nx,0:ny].T.reshape(-1, 2)\n\n for fname in cal_images:\n img = cv2.imread(fname)\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n\n ret, corners = cv2.findChessboardCorners(gray, (nx, ny), None)\n if ret == True:\n objpoints.append(objp)\n imgpoints.append(corners)\n\n ret, mtx, dst, rvecs, tvecs = cv2.calibrateCamera(objpoints, \n imgpoints, \n gray.shape[::-1],\n None, None)\n\n cam_cal = CameraCalibration(mtx=mtx, dst=dst, nx=nx, ny=ny, cal_images=cal_images)\n return cam_cal","def calibrate(self):\n with completion_context(\"Estimating sensor offset\", color=\"c\", bright=True):\n # Reset calibration\n self._sens_offset = np.zeros(4) # last two entries are never calibrated but useful for broadcasting\n self._wait_for_pole_at_rest()\n\n # Create parts of the calibration controller\n go_right = QQubeGoToLimCtrl(positive=True, cnt_done=int(1.5 / self._dt))\n go_left = QQubeGoToLimCtrl(positive=False, cnt_done=int(1.5 / self._dt))\n go_center = QQubePDCtrl(self.spec)\n\n # Estimate alpha offset. Go to both limits for theta calibration.\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\n while not go_right.done:\n meas = self._qsoc.snd_rcv(go_right(to.from_numpy(meas)))\n while not go_left.done:\n meas = self._qsoc.snd_rcv(go_left(to.from_numpy(meas)))\n self._sens_offset[0] = (go_right.th_lim + go_left.th_lim) / 2\n\n # Estimate alpha offset\n self._wait_for_pole_at_rest()\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\n self._sens_offset[1] = meas[1]\n\n print_cbt(\n f\"Sensor offset: \"\n f\"theta = {self._sens_offset[0]*180/np.pi:.3f} deg, \"\n f\"alpha = {self._sens_offset[1]*180/np.pi:.3f} deg\",\n \"g\",\n )\n\n with completion_context(\"Centering cube\", color=\"c\", bright=True):\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\n while not go_center.done:\n meas = self._qsoc.snd_rcv(go_center(to.from_numpy(meas - self._sens_offset)))","def calibrate(x, y, z, temperature=None, budget=1000, noise_cutoff_mg=13, hdf5_file=None, calibration_statistics=False):\n\n args = {\"x\": x, \"y\": y, \"z\": z, \"temperature\": temperature, \"budget\": budget, \"noise_cutoff_mg\": noise_cutoff_mg,\n \"calibration_statistics\": calibration_statistics}\n params = [\"temperature\", \"budget\", \"noise_cutoff_mg\", \"calibration_statistics\"]\n calibration_diagnostics = do_if_not_cached(\"calibrate\", calibrate_slave, args, params, get_calibrate, set_calibrate, hdf5_file)\n\n # Regardless of how we get the results, extract the offset and scales\n calibration_parameters = [calibration_diagnostics[var] for var in [\"x_offset\", \"x_scale\", \"y_offset\", \"y_scale\", \"z_offset\", \"z_scale\"]]\n\n if temperature is not None:\n calibration_parameters = [calibration_diagnostics[var] for var in [\"x_temp_offset\", \"y_temp_offset\", \"z_temp_offset\"]]\n\n # Apply the best calibration factors to the data\n do_calibration(x, y, z, temperature, calibration_parameters)\n\n return x, y, z, calibration_diagnostics","def eval_sparse(self, array_in, array_out, sp_matrix=None):\n if sp_matrix is None:\n sp_matrix = self.to_sparse_matrix(array_in.shape, \"csc\")\n # print(\"usually:\", sp_matrix.todense())\n array_out[:] = sp_matrix.dot(array_in.reshape(-1)).reshape(array_out.shape)","def calibrate(self, x, y) -> None:\n pass","def fit_model(self, matrix1, matrix2):\n #calculating A\n cov_matrix1 = np.cov(matrix1.T)\n cov_matrix2 = np.cov(matrix2.T)\n cov_inv_matrix1 = np.linalg.inv(cov_matrix1)\n cov_inv_matrix2 = np.linalg.inv(cov_matrix2)\n A = (np.subtract(cov_inv_matrix2, cov_inv_matrix1))/2\n\n #calculating B\n #mean\n mean1 = np.array(self.calculate_mean_vec(matrix1))\n mean2 = np.array(self.calculate_mean_vec(matrix2))\n B = np.matmul(mean1.T,cov_inv_matrix1) - np.matmul(mean2.T,cov_inv_matrix2)\n\n #Claculating C\n\n det_cov1 = np.linalg.det(cov_matrix1)\n det_cov2 = np.linalg.det(cov_matrix2)\n c1 = math.log(det_cov2/det_cov1)\n c2 = np.matmul(np.matmul(mean2.T,cov_inv_matrix2), mean2)\n c3 = np.matmul(np.matmul(mean1.T,cov_inv_matrix1), mean1)\n C = (c1+c2-c3)/2\n\n return A, B, C","def apply(self, data):\n print(\"this is morphism '{}'\".format(self.name))\n data = np.array(data)\n transformed_data = self.transf(data)\n return pd.DataFrame.from_dict({\"transf\": transformed_data.flatten()})","def _process(self, data: np.ndarray) -> np.ndarray:\n if not self.is_trained:\n raise DataProcessorError(\"SVD must be trained on data before it can be used.\")\n\n # IQ axis is reduced by projection\n if self._n_shots == 0:\n # level1 average mode\n dims = self._n_circs, self._n_slots\n else:\n # level1 single mode\n dims = self._n_circs, self._n_shots, self._n_slots\n\n projected_data = np.zeros(dims, dtype=object)\n\n for idx in range(self._n_slots):\n scale = self.parameters.scales[idx]\n axis = self.parameters.main_axes[idx]\n mean_i = self.parameters.i_means[idx]\n mean_q = self.parameters.q_means[idx]\n\n if self._n_shots != 0:\n # Single shot\n for circ_idx in range(self._n_circs):\n centered = [\n data[circ_idx, :, idx, 0] - mean_i,\n data[circ_idx, :, idx, 1] - mean_q,\n ]\n projected_data[circ_idx, :, idx] = axis @ np.array(centered) / scale\n else:\n # Averaged\n centered = [data[:, idx, 0] - mean_i, data[:, idx, 1] - mean_q]\n projected_data[:, idx] = axis @ np.array(centered) / scale\n\n return projected_data","def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:","def load_calibration(file_path=\"calibration_info\" ):\n info_file = Path(file_path)\n if info_file.is_file():\n with open(file_path, 'rb') as infile:\n payload = pickle.load(infile)\n mtx = payload['matrix']\n dist_coeff = payload['dist_coeff']\n return mtx, dist_coeff\n else:\n warnings.warn(\"File {} do not exist! Try to recalibrate\".format(file_path), UserWarning)\n mtx, dist_coeff = CalibrationUtils.calibrate()\n CalibrationUtils.save_calibration(mtx, dist_coeff, file_path)\n return mtx, dist_coeff","def __call__(self):\n #Check source type and sensor type, then call appripriate methods to \n #generate intermediate data, cascading all the way back to geometry \n #calculation if it wasn't already done.\n #Then return a projection matrix...\n\n # NOTE: returned projection_matrix is a numpy.ndarray\n if isinstance(self.sensors, sensors_module.SensorsEEG):\n projection_matrix = self.eeg_gain()\n elif isinstance(self.sensors, sensors_module.SensorsMEG):\n projection_matrix = self.meg_gain()\n\n return projection_matrix","def oracle(dataset: Dataset, conf: Namespace) -> np.ndarray:\n # Copy dataframe and set up test and score columns\n df = dataset.df.copy()\n df['test'] = df['fold'] == dataset.fold\n df['score'] = df[dataset.feature]\n\n # Compute calibrated score here, start as zeros\n calibrated_score = np.zeros_like(df['score'], dtype='float')\n\n # Get each combination of sensitive attributes (in this case only consider ethnicity)\n print(\"Computing results for subgroups...\")\n for subgroup in dataset.iterate_subgroups():\n\n # Set up select mask for left and right image, initialize as all True\n select = np.full_like(calibrated_score, True, dtype=bool) # TODO this can be cleaner\n\n # Iterate attributes of subgroup\n for attribute in subgroup:\n\n # Get columns of current attribute, is always only 2 (for left and right image)\n for col in dataset.consts['sensitive_attributes'][attribute]['cols']:\n # Update masks for both images of current attribute value\n select &= (df[col] == subgroup[attribute])\n\n # Mask to select the train data of the above select\n select_train = select & (df['test'] == False)\n\n # Set up calibrator on train set of current subgroup\n calibrator = BetaCalibration(df['score'][select_train], df['same'][select_train], score_min=-1, score_max=1)\n\n # Use calibrator on all data\n calibrated_score[select] = calibrator.predict(df['score'][select])\n\n return calibrated_score","def update(mat) -> np.ndarray:\n return mat","def calibrateCameraAruco(corners, ids, counter, board, imageSize, cameraMatrix, distCoeffs, rvecs=None, tvecs=None, flags=None, criteria=None):\n pass","def do_calibration(x,y,z,temperature,cp, optimal_t=25):\n # if temperature is used for calibration:\n if temperature is not None:\n # create an array of T - optimal_T (temperature minus the optimal temperature) i.e. the deviation in T from the optimum\n temp_dev = np.empty(len(temperature.data))\n for i in range(len(temperature.data)):\n temp_dev[i] = temperature.data[i] - optimal_t\n\n x.data = cp[\"x_offset\"] + (temp_dev * cp[\"x_temp_offset\"]) + (x.data * cp[\"x_scale\"])\n y.data = cp[\"y_offset\"] + (temp_dev * cp[\"y_temp_offset\"]) + (y.data * cp[\"y_scale\"])\n z.data = cp[\"z_offset\"] + (temp_dev * cp[\"z_temp_offset\"]) + (z.data * cp[\"z_scale\"])\n\n x.temp_offset = cp[\"x_temp_offset\"]\n y.temp_offset = cp[\"y_temp_offset\"]\n z.temp_offset = cp[\"z_temp_offset\"]\n\n # if temperature is not used for calibration:\n else:\n x.data = cp[\"x_offset\"] + (x.data * cp[\"x_scale\"])\n y.data = cp[\"y_offset\"] + (y.data * cp[\"y_scale\"])\n z.data = cp[\"z_offset\"] + (z.data * cp[\"z_scale\"])\n\n x.offset = cp[\"x_offset\"]\n x.scale = cp[\"x_scale\"]\n x.calibrated = True\n\n y.offset = cp[\"y_offset\"]\n y.scale = cp[\"y_scale\"]\n y.calibrated = True\n\n z.offset = cp[\"z_offset\"]\n z.scale = cp[\"z_scale\"]\n z.calibrated = True","def applyMtx(self, mtx: numpy.array) -> None:\n ...","def compute_camera_calib_distortion_params():\r\n nx = 9#number of inside corners in x\r\n ny = 6#number of inside corners in y\r\n # prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\r\n objp = np.zeros((ny*nx,3), np.float32)\r\n objp[:,:2] = np.mgrid[0:nx, 0:ny].T.reshape(-1,2)\r\n\r\n # Arrays to store object points and image points from all the images.\r\n objpoints = [] # 3d points in real world space\r\n imgpoints = [] # 2d points in image plane.\r\n\r\n # Read a particular image just to get image size (all images in the directory are same size)\r\n img = cv2.imread('./camera_cal/calibration3.jpg')\r\n img_size = (img.shape[1], img.shape[0])\r\n # Make a list of calibration images\r\n images = glob.glob('./camera_cal/calibration*.jpg')\r\n # Step through the list and search for chessboard corners\r\n for idx, fname in enumerate(images):\r\n img = cv2.imread(fname)\r\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\r\n\r\n # Find the chessboard corners\r\n ret, corners = cv2.findChessboardCorners(gray, (nx,ny), None)\r\n\r\n # If found, add object points, image points\r\n if ret == True:\r\n objpoints.append(objp)\r\n imgpoints.append(corners)\r\n # # Draw and display the corners\r\n # cv2.drawChessboardCorners(img, (nx,ny), corners, ret)\r\n # #write_name = 'corners_found'+str(idx)+'.jpg'\r\n # #cv2.imwrite(write_name, img)\r\n # cv2.imshow('img', img)\r\n # cv2.waitKey(500)\r\n\r\n # Do camera calibration given object points and image points\r\n ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, img_size,None,None)\r\n # Save the camera calibration result for later use (we won't worry about rvecs / tvecs)\r\n dist_pickle = {}\r\n dist_pickle[\"mtx\"] = mtx\r\n dist_pickle[\"dist\"] = dist\r\n pickle.dump( dist_pickle, open( \"data/cam_calib_pickle.p\", \"wb\" ) )\r\n print(\"Pickling done\")","def _transform(self, matrix):\n for x in list(self.keys()):\n ar = self[x]\n if len(ar.shape) == 2 and ar.shape[1] == 3:\n self[x] = np.dot(matrix, ar.transpose()).transpose()","def proj_to_velo(calib_data):\n rect = calib_data[\"R0_rect\"].reshape(3, 3)\n #to transform a point from Lidar framce to camera frame\n #reshape the flat line with 12 elements to 3X4 matrix\n velo_to_cam = calib_data[\"Tr_velo_to_cam\"].reshape(3, 4)\n#print('velo2cam', velo_to_cam)\n inv_rect = np.linalg.inv(rect)\n #select all rows and only first three columns\n#print('velo_to_cam[:, :3]', velo_to_cam[:, :3])\n #select all rows and only first three columns\n inv_velo_to_cam = np.linalg.pinv(velo_to_cam[:, :3])\n return np.dot(inv_velo_to_cam, inv_rect)","def fit_transform(self, raw_documents, y=None):\n #self.diccionario_fti.update({indice:fti})\n textos = raw_documents.iloc[:,0]\n X = super().fit_transform(textos)\n self.cal_term_fti(raw_documents)\n\n X2 = X.todense()\n for indice in list(self.diccionario_fti.keys()):\n fti = self.diccionario_fti.get(indice)\n #print('indice {0} valor')\n X2[:,indice]=np.transpose(np.apply_along_axis(lambda x :x * fti,0,X2[:,indice]))\n \n #print('matriz tras indice')\n #print (matriz[:,indice])\n matrizfinal = sp.csr_matrix(X2,X.shape)\n #aqui\n return matrizfinal","def camera_calibration_by_aruco_board(\n calibration_params_filename='calibration.pckl'):\n aruco_dict = aruco.Dictionary_get(aruco.DICT_5X5_1000)\n\n # Creating a theoretical board we'll use to calculate marker positions\n board = aruco.GridBoard_create(\n markersX=5,\n markersY=7,\n markerLength=0.04,\n markerSeparation=0.01,\n dictionary=aruco_dict)\n\n # Read an image or a video to calibrate your camera\n # I'm using a video and waiting until my entire gridboard is seen before\n # calibrating. The following code assumes you have a 5X7 Aruco gridboard\n # to calibrate with\n cam = cv2.VideoCapture(0)\n\n while (cam.isOpened()):\n # Capturing each frame of our video stream\n ret, img = cam.read()\n cv2.imshow('camera calibration', img)\n # retval is non-zero in the case of successful frame reading\n if ret == True:\n # grayscale image\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n parameters = aruco.DetectorParameters_create()\n\n # Detect Aruco markers\n corners, ids, rejectedImgPoints = aruco.detectMarkers(\n gray, aruco_dict, parameters=parameters)\n\n # Make sure markers were detected before continuing\n if (ids is not None and \n corners is not None and \n len(ids) > 0 and \n len(corners) > 0 and \n len(corners) == len(ids)):\n # The next if makes sure we see all matrixes in our gridboard\n if len(ids) == len(board.ids):\n # Calibrate the camera now using cv2 method\n ret, cameraMatrix, distCoeffs, _, _ = cv2.calibrateCamera(\n objectPoints=board.objPoints,\n imagePoints=corners,\n imageSize=gray.shape,\n cameraMatrix=None,\n distCoeffs=None)\n\n # Print matrix and distortion coefficient to the console\n print('Intrinsic calibration coefficients\\n', cameraMatrix)\n print('Distortion (extrinsic) coefficients\\n', distCoeffs)\n\n # Output values to be used where matrix+dist is required\n f = open(calibration_params_filename, 'wb')\n pickle.dump((cameraMatrix, distCoeffs), f)\n f.close()\n\n # PRint to console our success\n print('\\nCalibration successful!')\n\n break\n\n # Exit at the end of the video on the EOF key\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break","def camera_calibration_by_aruco_board(\n calibration_params_filename='calibration.pckl'):\n aruco_dict = aruco.Dictionary_get(aruco.DICT_5X5_1000)\n\n # Creating a theoretical board we'll use to calculate marker positions\n board = aruco.GridBoard_create(\n markersX=5,\n markersY=7,\n markerLength=0.04,\n markerSeparation=0.01,\n dictionary=aruco_dict)\n\n # Read an image or a video to calibrate your camera\n # I'm using a video and waiting until my entire gridboard is seen before\n # calibrating. The following code assumes you have a 5X7 Aruco gridboard\n # to calibrate with\n cam = cv2.VideoCapture(0)\n\n while (cam.isOpened()):\n # Capturing each frame of our video stream\n ret, img = cam.read()\n cv2.imshow('camera calibration', img)\n # retval is non-zero in the case of successful frame reading\n if ret == True:\n # grayscale image\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n parameters = aruco.DetectorParameters_create()\n\n # Detect Aruco markers\n corners, ids, rejectedImgPoints = aruco.detectMarkers(\n gray, aruco_dict, parameters=parameters)\n\n # Make sure markers were detected before continuing\n if (ids is not None and \n corners is not None and \n len(ids) > 0 and \n len(corners) > 0 and \n len(corners) == len(ids)):\n # The next if makes sure we see all matrixes in our gridboard\n if len(ids) == len(board.ids):\n # Calibrate the camera now using cv2 method\n ret, cameraMatrix, distCoeffs, _, _ = cv2.calibrateCamera(\n objectPoints=board.objPoints,\n imagePoints=corners,\n imageSize=gray.shape,\n cameraMatrix=None,\n distCoeffs=None)\n\n # Print matrix and distortion coefficient to the console\n print('Intrinsic calibration coefficients\\n', cameraMatrix)\n print('Distortion (extrinsic) coefficients\\n', distCoeffs)\n\n # Output values to be used where matrix+dist is required\n f = open(calibration_params_filename, 'wb')\n pickle.dump((cameraMatrix, distCoeffs), f)\n f.close()\n\n # PRint to console our success\n print('\\nCalibration successful!')\n\n break\n\n # Exit at the end of the video on the EOF key\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break","def fit(self, x, y=None):\n if self.method == 'svd' and x._sparse:\n raise NotImplementedError(\n \"SVD method not supported for sparse arrays.\")\n\n self.mean_ = x.mean(axis=0)\n norm_x = x - self.mean_\n\n if self.method == \"svd\":\n return self._fit_svd(norm_x)\n else:\n return self._fit_eig(norm_x)","def calibration(\n self,\n pulse_min: int,\n pulse_max: int,\n pulse_centre: int,\n pulse_angle_90: int,\n pulse_speed_100: int,\n /,\n ) -> None:","def resolves_matrix(self):\n self.P = np.linalg.solve(self.M, self.f)","def transform(self, data_matrix):\n if self.selected_instances is None:\n raise Exception('Error: attempt to use transform on non fit model')\n if self.selected_instances.shape[0] == 0:\n raise Exception('Error: attempt to use transform using 0 selectors')\n # TODO: the first instance is more important than others in a selector, so it should\n # receive a weight proportional to the rank e.g. 1/rank^p\n # the selector should return also a rank information for each feature, note: for the\n # composite selector it is important to distinguish the rank of multiple selectors\n data_matrix_out = pairwise_kernels(data_matrix,\n Y=self.selected_instances,\n metric=self.metric,\n **self.kwds)\n if self.scale:\n data_matrix_out = self.scaler.transform(data_matrix_out) * self.scaling_factor\n return data_matrix_out","def calibrateCamera(config,cbrow = 4,cbcol = 3,calibrate=False,alpha=0.4,manualPoints=False):\n\n # Termination criteria\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)\n # Prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\n objp = np.zeros((cbrow * cbcol, 3), np.float32)\n objp[:, :2] = np.mgrid[0:cbcol, 0:cbrow].T.reshape(-1, 2)\n \n # Read the config file\n cfg_3d = auxiliaryfunctions.read_config(config)\n img_path,path_corners,path_camera_matrix,path_undistort=caf.Foldernames3Dproject(cfg_3d)\n \n # Make sure that the folders are present (if not, make them)\n if not os.path.exists(img_path):\n os.makedirs(img_path)\n if not os.path.exists(path_corners):\n os.makedirs(path_corners)\n \n # Get images and camera names\n images = glob.glob(os.path.join(img_path,'*.jpg'))\n cam_names = cfg_3d['camera_names']\n \n ## It's not clear to me why I want to do this or what this number represents... I need to read further into it\n # # update the variable snapshot* in config file according to the name of the cameras\n # try:\n # for i in range(len(cam_names)):\n # cfg_3d[str('config_file_'+cam_names[i])] = cfg_3d.pop(str('config_file_camera-'+str(i+1)))\n # for i in range(len(cam_names)):\n # cfg_3d[str('shuffle_'+cam_names[i])] = cfg_3d.pop(str('shuffle_camera-'+str(i+1)))\n # except:\n # pass\n \n project_path = cfg_3d['project_path']\n projconfigfile=os.path.join(str(project_path),'config.yaml')\n auxiliaryfunctions.write_config_3d(projconfigfile,cfg_3d)\n\n # Initialize the dictionary \n img_shape = {}\n objpoints = {} # 3d point in real world space\n imgpoints = {} # 2d points in image plane.\n dist_pickle = {} ## I think this is the intrinsic parameter file that needs to be read in\n stereo_params= {}\n for cam in cam_names:\n objpoints.setdefault(cam, [])\n imgpoints.setdefault(cam, [])\n dist_pickle.setdefault(cam, [])\n\n # Sort the images.\n images.sort(key=lambda f: int(''.join(filter(str.isdigit, f))))\n if len(images)==0:\n raise Exception(\"No calibration images found. Make sure the calibration images are saved as .jpg and with prefix as the camera name as specified in the config.yaml file.\")\n direct_images = [img for img in images if 'direct' in img]\n mirror_images = [img for img in images if 'mirror' in img]\n\n if manualPoints:\n # This is where we read in the manually identified points and check them and stuff\n csvFiles = glob.glob(os.path.join(img_path,'*.csv'))\n for fname_csv in csvFiles:\n allPoints = caf.readCSV(fname_csv)\n for row in allPoints:\n continue\n # Start with mirror to figure out which BGR to use for direct\n for fname in mirror_images:\n \n filename=Path(fname).stem\n img = cv2.imread(fname)\n\n # Create a dictionary with all of the different image color conversions for testing\n img_colorConv = {\n \"BGR\":img,\n \"HSV\":cv2.cvtColor(img,40),\n \"Gray\":cv2.cvtColor(img,6)\n }\n\n thresh = 120\n ret = False\n for colorConv in img_colorConv:\n currImg = img_colorConv[colorConv]\n size = currImg.shape\n \n if len(size) == 2:\n \n ret, corners = cv2.findChessboardCorners(currImg, (cbcol,cbrow),None,)\n if ret == True: break\n\n currImg_bw = cv2.threshold(currImg,thresh,255,cv2.THRESH_BINARY)[1]\n ret, corners = cv2.findChessboardCorners(currImg_bw, (cbcol,cbrow),None,)\n if ret == True: break\n else: continue\n \n chanIdx = 0\n while (ret == False) and (chanIdx < size[2]):\n ret, corners = cv2.findChessboardCorners(currImg[:,:,chanIdx], (cbcol,cbrow),None,)\n if ret == True: break\n channel_bw = cv2.threshold(currImg[:,:,chanIdx],thresh,255,cv2.THRESH_BINARY)[1]\n ret, corners = cv2.findChessboardCorners(channel_bw, (cbcol,cbrow),None,)\n chanIdx += 1\n \n # If found, add object points, image points (after refining them)\n if ret == True:\n currImg = img_colorConv[\"Gray\"]\n img_shape[cam] = currImg.shape[::-1]\n objpoints[cam].append(objp)\n corners = cv2.cornerSubPix(currImg,corners,(11,11),(-1,-1),criteria)\n imgpoints[cam].append(corners)\n # Draw the corners and store the images\n img = cv2.drawChessboardCorners(currImg, (cbcol,cbrow), corners,ret)\n cv2.imwrite(os.path.join(str(path_corners),filename+'_corner.jpg'),img)\n else:\n print(\"Corners not found for the image %s\" %Path(fname).name)\n \n try:\n h, w = img.shape[:2]\n except:\n raise Exception(\"It seems that the name of calibration images does not match with the camera names in the config file. Please make sure that the calibration images are named with camera names as specified in the config.yaml file.\")\n\n # Perform calibration for each cameras and store the matrices as a pickle file\n if calibrate == True:\n \n # Read in the intrinsic parameters for each camera\n for cam in cam_names:\n dist_pickle[cam] = pickle.load(os.path.join(path_camera_matrix,cam+'_intrinsic_params.pickle'))\n\n # # Compute stereo calibration for each pair of cameras\n # camera_pair = [[cam_names[0], cam_names[1]]]\n # for pair in camera_pair:\n # print(\"Computing stereo calibration for \" %pair)\n # retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F = cv2.stereoCalibrate(objpoints[pair[0]],imgpoints[pair[0]],imgpoints[pair[1]],dist_pickle[pair[0]]['mtx'],dist_pickle[pair[0]]['dist'], dist_pickle[pair[1]]['mtx'], dist_pickle[pair[1]]['dist'],(h, w),flags = cv2.CALIB_FIX_INTRINSIC)\n\n # # Stereo Rectification\n # rectify_scale = alpha # Free scaling parameter check this https://docs.opencv.org/2.4/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html#fisheye-stereorectify\n # R1, R2, P1, P2, Q, roi1, roi2 = cv2.stereoRectify(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, (h, w), R, T, alpha = rectify_scale)\n \n # stereo_params[pair[0]+'-'+pair[1]] = {\"cameraMatrix1\": cameraMatrix1,\"cameraMatrix2\": cameraMatrix2,\"distCoeffs1\": distCoeffs1,\"distCoeffs2\": distCoeffs2,\"R\":R,\"T\":T,\"E\":E,\"F\":F,\n # \"R1\":R1,\n # \"R2\":R2,\n # \"P1\":P1,\n # \"P2\":P2,\n # \"roi1\":roi1,\n # \"roi2\":roi2,\n # \"Q\":Q,\n # \"image_shape\":[img_shape[pair[0]],img_shape[pair[1]]]}\n \n # print('Saving the stereo parameters for every pair of cameras as a pickle file in %s'%str(os.path.join(path_camera_matrix)))\n \n # auxiliaryfunctions.write_pickle(os.path.join(path_camera_matrix,'stereo_params.pickle'),stereo_params)\n # print(\"Camera calibration done! Use the function ``check_undistortion`` to check the check the calibration\")\n # else:\n # print(\"Corners extracted! You may check for the extracted corners in the directory %s and remove the pair of images where the corners are incorrectly detected. If all the corners are detected correctly with right order, then re-run the same function and use the flag ``calibrate=True``, to calbrate the camera.\"%str(path_corners))","def cal_dist_and_mtx(self, calibration_patterns, pattern_size, retain_calibration_patterns):\n # prepare object points, like (0,0,0), (1,0,0), (2,0,0), ....,(8,5,0)\n # use numpy mgrid function to generate the coordinates values for a given grid size.\n grid_x, grid_y = pattern_size[0], pattern_size[1]\n objp = np.zeros((grid_y * grid_x, 3), np.float32)\n objp[:,:2] = np.mgrid[:grid_x, :grid_y].T.reshape(-1,2)\n\n # Arrays to store object points and image points from all the sample images.\n objpoints = [] # 3d points in real world space\n imgpoints = [] # 2d points in image plane.\n \n # Step through the list and search for chessboard corners in distorted calibration images.\n for path in calibration_patterns:\n img = mpimg.imread(path)\n gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)\n\n # Find the chessboard's inner corners\n found, corners = cv2.findChessboardCorners(gray, pattern_size, None)\n\n # If found, add object points, image points\n if found:\n objpoints.append(objp)\n imgpoints.append(corners)\n \n # Draw and display the corners to see what was detected.\n if retain_calibration_patterns:\n cv2.drawChessboardCorners(img, pattern_size, corners, found)\n self.calibration_patterns_success.append(img)\n else:\n if retain_calibration_patterns:\n self.calibration_patterns_error.append(img)\n\n img_size = (img.shape[1], img.shape[0])\n\n if objpoints and imgpoints:\n _, self.camera_matrix, self.distortion_coef, _, _ = cv2.calibrateCamera(\n objpoints, imgpoints, img_size, None, None)","def fit_transform(self, x):\n self.fit(x)\n\n if self.method == \"svd\":\n return self._u * self._s\n else:\n return self._transform_eig(x)","def run(self, data):\n\t\treduced_data = PCA(n_components=2).fit_transform(data)\n\n\t\t# Run the algorithm\n\t\tself.estimator.fit_transform(reduced_data)\n\n\t\t# Save all relevent properties\n\t\tself.input_data = data\n\t\tself.centroids = self.estimator.cluster_centers_\n\t\tself.node_positions = reduced_data\n\t\tself.labels = self.estimator.labels_\n\n\t\t# Enable visualising when debugging\n\t\t# self.visualize(reduced_data)","def _init_model(self):\n self.A_inv = np.zeros(shape=(self.numUsers, self.d, self.d))\n self.b = np.zeros(shape=(self.numUsers, self.d))\n self.w = np.zeros(shape=(self.numUsers, self.d))\n for i, mat in enumerate(self.A_inv):\n self.A_inv[i] = np.eye(self.d)","def __init__(self, calibration_patterns, pattern_size=(9,6), retain_calibration_patterns=False):\n self.camera_matrix = None\n self.distortion_coef = None\n self.calibration_patterns_success = []\n self.calibration_patterns_error = []\n self.cal_dist_and_mtx(calibration_patterns, pattern_size, retain_calibration_patterns)","def fit_transform(self, X, y=None):\n X = np.asfortranarray(X, dtype=np.float64)\n Q = np.empty(\n (self.n_components, X.shape[1]), dtype=np.float64, order='F')\n U = np.empty(\n (X.shape[0], self.n_components), dtype=np.float64, order='F')\n w = np.empty(self.n_components, dtype=np.float64)\n explained_variance = np.empty(self.n_components, dtype=np.float64)\n explained_variance_ratio = np.empty(self.n_components, dtype=np.float64)\n mean = np.empty(X.shape[1], dtype=np.float64)\n param = parameters()\n param.X_m = X.shape[0]\n param.X_n = X.shape[1]\n param.k = self.n_components\n param.whiten = self.whiten\n\n lib = self._load_lib()\n lib.pca(\n _as_fptr(X), _as_fptr(Q), _as_fptr(w), _as_fptr(U),\n _as_fptr(explained_variance), _as_fptr(explained_variance_ratio),\n _as_fptr(mean), param)\n\n self._w = w\n self._U, self._Q = svd_flip(U, Q) # TODO Port to cuda?\n self._X = X\n n = X.shape[0]\n # To match sci-kit #TODO Port to cuda?\n self.explained_variance = self.singular_values_**2 / (n - 1)\n self.explained_variance_ratio = explained_variance_ratio\n self.mean_ = mean\n\n # TODO noise_variance_ calculation\n # can be done inside lib.pca if a bottleneck\n n_samples, n_features = X.shape\n total_var = np.var(X, ddof=1, axis=0)\n if self.n_components_ < min(n_features, n_samples):\n self.noise_variance_ = \\\n (total_var.sum() - self.explained_variance_.sum())\n self.noise_variance_ /= \\\n min(n_features, n_samples) - self.n_components\n else:\n self.noise_variance_ = 0.\n\n X_transformed = U * w\n return X_transformed","def _calibrate_with_loss(self, loss, metrics, calib_dataset, eval_dataset,\n verbose):\n self._calibrate_without_loss(calib_dataset, calib_batch_size, calib_steps)\n init_quantize_info = model_utils.get_quantize_info(self._qcbev_model)\n quantize_layers = model_utils.get_quantize_layers(self._qcb_model)\n\n def _recompile(model):\n \"\"\"Helper function to re-compile the model.\"\"\"\n # Must reset metrics to get accurate results\n for m in metrics:\n if not isinstance(m, str):\n m.reset_states()\n model.compile(loss=loss, metrics=metrics)\n\n def _evaluate(model):\n \"\"\"Helper function to evaluate model to get loss and accuracy.\"\"\"\n _recompile(model)\n if isinstance(eval_dataset, tuple):\n eval_images, eval_labels = eval_dataset\n return model.evaluate(\n eval_images, eval_labels, verbose=verbose, return_dict=True)\n else:\n return model.evaluate(eval_dataset, verbose=verbose, return_dict=True)\n\n def _print_results(results, title=''):\n \"\"\"Helper function to print evaluation results.\"\"\"\n pstr = '[' + title + ']: ' if title else ''\n for k, v in results.items():\n pstr += '\\t{}: {}'.format(k, v)\n print(pstr)\n\n # Get float results\n model_utils.set_layer_mode(self._qcb_model, 'ANALYSE')\n float_results = _evaluate(self._qcb_model)\n _print_results(float_results, 'float_results')\n\n # Get simple quantize calibrated results\n init_results = _evaluate(self._qcbev_model)\n _print_results(init_results, 'init_results')\n\n # Do quantize pos searching\n logger.info(\"Start Quantize Position Searching...\")\n model_utils.set_layer_mode(self._qcb_model, 'QCBEV')\n best_results = init_results\n best_quantize_info = copy.deepcopy(init_quantize_info)\n count = 0\n for name, layer in quantize_layers.items():\n count += 1\n logger.info('({}/{})Processing layer: {}'.format(count,\n len(quantize_layers),\n name))\n\n def _search_optimal_pos(init_quantize_info,\n init_results,\n layer_name,\n quantizer_name,\n delta=[-1, 1, 2]):\n new_best_results = init_results\n new_best_quantize_info = copy.deepcopy(init_quantize_info)\n\n tmp_quantize_info = copy.deepcopy(init_quantize_info)\n layer_info = tmp_quantize_info[layer_name]\n if quantizer_name == 'NoQuantizeActivation':\n return new_best_quantize_info, new_best_results\n elif quantizer_name == 'input':\n q_info = layer_info['info']\n else:\n q_info = layer_info[quantizer_name]['info']\n q_pos = q_info['quant_pos_var']\n\n for dt in delta:\n if verbose:\n logger.info('Try change {}.{}: {} -> {}'.format(\n layer_name, quantizer_name, q_pos, q_pos + dt))\n q_info['quant_pos_var'] = q_pos + dt\n model_utils.set_quantize_info(self._qcb_model, tmp_quantize_info)\n q_results = _evaluate(self._qcb_model)\n if q_results['loss'] < new_best_results['loss']:\n new_best_results = q_results\n new_best_quantize_info = copy.deepcopy(tmp_quantize_info)\n _print_results(new_best_results, 'Update Best Results')\n return new_best_quantize_info, new_best_results\n\n # Quantize Layer\n if isinstance(layer, vitis_quantize_layer.VitisQuantize):\n best_quantize_info, best_results = _search_optimal_pos(\n init_quantize_info=best_quantize_info,\n init_results=best_results,\n layer_name=layer.name,\n quantizer_name='input')\n # Quantize Wrappers\n elif isinstance(layer, vitis_quantize_wrapper.QuantizeWrapper):\n layer_info = best_quantize_info[layer.layer.name]\n for quantizer_name, q_info in layer_info.items():\n best_quantize_info, best_results = _search_optimal_pos(\n init_quantize_info=best_quantize_info,\n init_results=best_results,\n layer_name=layer.layer.name,\n quantizer_name=quantizer_name)\n\n logger.info(\"Quantize Position Searching Done.\")\n _print_results(best_results, 'Final Best Results')\n\n # Freeze the quantize info into the model, now using last_quantize_info\n self._freeze_quantize_info(best_quantize_info)","def testCalibrateImageNonConstant(self):\n npDim, maskedImage, image, mask, variance = self.setupImage()\n xIndex, yIndex = np.indices(npDim, dtype=np.float64)\n # y then x, as afw order and np order are flipped\n calibration = self.linearXCalibration.evaluate(yIndex.flatten(), xIndex.flatten()).reshape(npDim)\n outImage = maskedImage.image.getArray()*calibration # element-wise product, not matrix product\n expect = makeCalibratedMaskedImage(image, mask, variance, outImage, calibration, self.calibrationErr)\n\n photoCalib = lsst.afw.image.PhotoCalib(self.linearXCalibration, self.calibrationErr)\n result = photoCalib.calibrateImage(maskedImage)\n self.assertMaskedImagesAlmostEqual(expect, result)","def calibrateCameraArucoExtended(corners, ids, counter, board, imageSize, cameraMatrix, distCoeffs, rvecs=None, tvecs=None, stdDeviationsIntrinsics=None, stdDeviationsExtrinsics=None, perViewErrors=None, flags=None, criteria=None):\n pass","def fit_transform(self, X):\n self._method_calling = 2\n self.fit(X)\n\n # Transform - calculate kernel matrix\n # Output is always normalized\n return self._calculate_kernel_matrix()","def fit(self,X,y):\n\n d = X.shape[1]\n # 1. sketch the data\n self.B,a = self._sketch(X,method=self.fd_mode)\n #H = B.T@B + (self.alpha+a)*np.eye(d)\n #self.H = H\n self.H_inv = self._get_inv() #np.linalg.pinv(H)\n self.coef_ = self.H_inv@(X.T@y) #np.linalg.solve(H, X.T@y)\n self.is_fitted = True","def fit_data(self, data):\n delta_b, delta_q = self._fit_matrix\n return _slowadc_formula(data, delta_b, delta_q)","def generateMatrix():\n num_probes = 16\n\n # print(position_vectors)\n # Create the (48x4) calibration matrix:\n calibration_lookup= [[0] * 3 for i in range(num_probes)]\n calibration_matrix = [[0] * 9 for i in range(num_probes)]\n counter = 0\n\n # first populate with x-direction:\n shot_range = [17, 20] #x-direction\n dir = 0 #the direction of the orentation of the probe array\n position_vectors = get_probeLocs_calib_setup(dir)\n for probe_num in range(num_probes):\n position_vector = position_vectors[probe_num]\n ratio_Bx, ratio_By, ratio_Bz, norm_factor= getRatio(probe_num, position_vector, shot_range, dir)\n calibration_lookup[probe_num][dir] = ratio_Bx\n calibration_matrix[probe_num][(dir*3):(dir*3+1)] = [ratio_Bx, ratio_By, ratio_Bz]\n print(\"Progress: %d / %d\" %(counter+1,num_probes*3 ))\n counter +=1\n\n # Then populate with y-direction:\n shot_range = [21, 25] #y-direction\n dir = 1 #the direction of the orentation of the probe array\n position_vectors = get_probeLocs_calib_setup(dir)\n for probe_num in range(num_probes):\n position_vector = position_vectors[probe_num]\n ratio_Bx, ratio_By, ratio_Bz, norm_factor= getRatio(probe_num, position_vector, shot_range, dir)\n calibration_lookup[probe_num][dir] = ratio_By\n calibration_matrix[probe_num][(dir*3):(dir*3+1)] = [ratio_Bx, ratio_By, ratio_Bz]\n print(\"Progress: %d / %d\" %(counter+1,num_probes*3 ))\n counter +=1\n\n # Then populate with z-direction:\n shot_range = [11, 15] #z-direction\n dir = 2\n position_vectors = get_probeLocs_calib_setup(dir)\n for probe_num in range(num_probes):\n position_vector = position_vectors[probe_num]\n ratio_Bx, ratio_By, ratio_Bz, norm_factor= getRatio(probe_num, position_vector, shot_range, dir)\n calibration_lookup[probe_num][dir] = ratio_Bz\n calibration_matrix[probe_num][(dir*3):(dir*3+1)] = [ratio_Bx, ratio_By, ratio_Bz]\n print(\"Progress: %d / %d\" %(counter+1,num_probes*3 ))\n counter +=1\n\n pth = os.getcwd()\n date = '050119'\n print(\"Finished! File saved as calib-%s-4x4_lookup.txt and _3x3 in current working directory\" %(date))\n savetxt(os.path.join(pth, 'calib-%s-4x4_lookup_no_switch.txt' % (date)) , calibration_lookup)\n savetxt(os.path.join(pth, 'calib-%s-4x4_3x3_no_switch.txt' % (date)) , calibration_matrix)","def adjusted_matrix(self):\n mat = AlignerExtract().transform_matrix(self.aligned[\"matrix\"],\n self.aligned[\"size\"],\n self.aligned[\"padding\"])\n return mat","def run_calib(projector=OPTOMA_HD33()):\n w, h = (0.2160, 0.2794)\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\n [-w/2, 0, 0], [w/2, 0, 0],\n [-w/2, 0, h/2], [w/2, 0, h/2]])\n\n global img_points, going\n img_points = []\n\n try:\n window = Window()\n window.MoveXY(1600,0)\n window.ShowFullScreen(True)\n going = True\n\n @window.eventx\n def EVT_MOUSE_EVENTS(evt):\n global going, img_points\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\n img_points.append(evt.Position)\n print('Picked point %d of 6' % (len(img_points)))\n if len(img_points) == len(obj_points):\n print \"Done\"\n going = False\n\n print(\"\"\"[Extrinsic Calibration] \n\nThere should be 6 points marked on the table and backdrop. \nMoving the mouse over the projected display, click each of the points\nin order:\n (left top, on the backdrop),\n (right top, on the backdrop),\n (left center, on the crease),\n (right center, on the crease),\n (left bottom, on the table),\n (right bottom, on the table)\n\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\n\nClick the six points:\n\"\"\")\n\n while going: cv.WaitKey(10)\n\n finally:\n window.Close()\n\n img_points = np.array(img_points, 'f')\n projector.calibrate_extrinsic(img_points, obj_points)\n\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\n print('OK')","def calibrate_df(\n self,\n df: pd.DataFrame,\n acc_unit: Optional[str],\n gyr_unit: Optional[str],\n acc_cols: Iterable[str] = (\"acc_x\", \"acc_y\", \"acc_z\"),\n gyr_cols: Iterable[str] = (\"gyr_x\", \"gyr_y\", \"gyr_z\"),\n ) -> pd.DataFrame:\n acc_cols = list(acc_cols)\n gyr_cols = list(gyr_cols)\n acc = df[acc_cols].to_numpy()\n gyr = df[gyr_cols].to_numpy()\n cal_acc, cal_gyr = self.calibrate(acc=acc, gyr=gyr, acc_unit=acc_unit, gyr_unit=gyr_unit)\n\n cal_df = df.copy()\n cal_df[acc_cols] = cal_acc\n cal_df[gyr_cols] = cal_gyr\n\n return cal_df","def get_calib_data(self):\n\n accel_offset_read = self.con.receive(registers.ACCEL_OFFSET_X_LSB_ADDR, 6)\n accel_offset_read_x = (accel_offset_read[1] << 8) | accel_offset_read[\n 0] # Combine MSB and LSB registers into one decimal\n accel_offset_read_y = (accel_offset_read[3] << 8) | accel_offset_read[\n 2] # Combine MSB and LSB registers into one decimal\n accel_offset_read_z = (accel_offset_read[5] << 8) | accel_offset_read[\n 4] # Combine MSB and LSB registers into one decimal\n\n accel_radius_read = self.con.receive(registers.ACCEL_RADIUS_LSB_ADDR, 2)\n accel_radius_read_value = (accel_radius_read[1] << 8) | accel_radius_read[0]\n\n mag_offset_read = self.con.receive(registers.MAG_OFFSET_X_LSB_ADDR, 6)\n mag_offset_read_x = (mag_offset_read[1] << 8) | mag_offset_read[\n 0] # Combine MSB and LSB registers into one decimal\n mag_offset_read_y = (mag_offset_read[3] << 8) | mag_offset_read[\n 2] # Combine MSB and LSB registers into one decimal\n mag_offset_read_z = (mag_offset_read[5] << 8) | mag_offset_read[\n 4] # Combine MSB and LSB registers into one decimal\n\n mag_radius_read = self.con.receive(registers.MAG_RADIUS_LSB_ADDR, 2)\n mag_radius_read_value = (mag_radius_read[1] << 8) | mag_radius_read[0]\n\n gyro_offset_read = self.con.receive(registers.GYRO_OFFSET_X_LSB_ADDR, 6)\n gyro_offset_read_x = (gyro_offset_read[1] << 8) | gyro_offset_read[\n 0] # Combine MSB and LSB registers into one decimal\n gyro_offset_read_y = (gyro_offset_read[3] << 8) | gyro_offset_read[\n 2] # Combine MSB and LSB registers into one decimal\n gyro_offset_read_z = (gyro_offset_read[5] << 8) | gyro_offset_read[\n 4] # Combine MSB and LSB registers into one decimal\n\n calib_data = {'accel_offset': {'x': accel_offset_read_x, 'y': accel_offset_read_y, 'z': accel_offset_read_z}, 'accel_radius': accel_radius_read_value,\n 'mag_offset': {'x': mag_offset_read_x, 'y': mag_offset_read_y, 'z': mag_offset_read_z}, 'mag_radius': mag_radius_read_value,\n 'gyro_offset': {'x': gyro_offset_read_x, 'y': gyro_offset_read_y, 'z': gyro_offset_read_z}}\n\n return calib_data"],"string":"[\n \"def __call__(self, data):\\n cal = self.calc()\\n assert data.shape == cal.shape, \\\\\\n \\\"data shape does not match calibration ({} != {})\\\".format(data.shape, cal.shape)\\n return data * cal\",\n \"def _applyCalibration(self, ws, detPos):\\n alg = self.createChildAlgorithm('ApplyCalibration')\\n alg.setProperty('Workspace', ws)\\n alg.setProperty('PositionTable', detPos)\\n alg.execute()\",\n \"def _doCalibration(self):\\n self._cmdCalibration(2)\",\n \"def fit(self,data):\\n A = data[:,0:self.dim]\\n B = data[:,self.dim:]\\n\\n #Procrustean: CODE TO SOLVE FOR OPTIMAL (by least squares) EUCLIDEAN TRANSFORM (currently allows reflections):\\n bReflection = True\\n\\n muA = np.mean(A,axis=0)\\n muB = np.mean(B,axis=0)\\n A0 = A - np.tile(muA,[A.shape[0],1])\\n B0 = B - np.tile(muB,[B.shape[0],1])\\n\\n ssqA = np.sum(A0**2)\\n ssqB = np.sum(B0**2)\\n normA = np.sqrt(ssqA)\\n normB = np.sqrt(ssqB)\\n\\n A0 = A0 / normA\\n B0 = B0 / normB\\n\\n X = np.dot(A0.T,B0)\\n [L, D, M] = np.linalg.svd(X)\\n rotation = np.dot(M.T,L.T)\\n\\n traceTA = sum(D)\\n if self.bScale:\\n scale = traceTA * normA / normB\\n else:\\n scale = 1\\n translation = muA - np.dot(scale*muB,rotation); \\n\\n self.scale = scale\\n self.rot = rotation\\n self.trans = translation\\n return scale,rotation,translation\\n #A - (np.dot((scale * B),rotation) + translation)\",\n \"def calibrate(self, dataset: Iterable[Dict[str, np.ndarray]]) -> Dict[str, Tuple[float, float]]:\\n return calibrate(self.model, dataset)\",\n \"def apply_calibration(self, poses):\\n new_poses = []\\n for pose in poses:\\n T = pose.copy()\\n T[:3, :3] = np.eye(3)\\n new_poses.append(T)\\n return new_poses\",\n \"def calibrate(self, Otrain, Ftrain, Feval):\\n return Otrain[0] * np.ones(len(Feval))\",\n \"def load_calib(self):\\n # We'll build the calibration parameters as a dictionary, then\\n # convert it to a namedtuple to prevent it from being modified later\\n data = {}\\n\\n # Load the calibration file\\n calib_filepath = os.path.join(self.sequence_path, 'calib.txt')\\n filedata = utils.read_calib_file(calib_filepath)\\n\\n # Create 3x4 projection matrices\\n P_rect_00 = np.reshape(filedata['P0'], (3, 4))\\n P_rect_10 = np.reshape(filedata['P1'], (3, 4))\\n P_rect_20 = np.reshape(filedata['P2'], (3, 4))\\n P_rect_30 = np.reshape(filedata['P3'], (3, 4))\\n\\n # Compute the rectified extrinsics from cam0 to camN\\n T1 = np.eye(4)\\n T1[0, 3] = P_rect_10[0, 3] / P_rect_10[0, 0]\\n T2 = np.eye(4)\\n T2[0, 3] = P_rect_20[0, 3] / P_rect_20[0, 0]\\n T3 = np.eye(4)\\n T3[0, 3] = P_rect_30[0, 3] / P_rect_30[0, 0]\\n\\n # Compute the velodyne to rectified camera coordinate transforms\\n data['T_cam0_velo'] = np.reshape(filedata['Tr'], (3, 4))\\n data['T_cam0_velo'] = np.vstack([data['T_cam0_velo'], [0, 0, 0, 1]])\\n data['T_cam1_velo'] = T1.dot(data['T_cam0_velo'])\\n data['T_cam2_velo'] = T2.dot(data['T_cam0_velo'])\\n data['T_cam3_velo'] = T3.dot(data['T_cam0_velo'])\\n\\n # Compute the camera intrinsics\\n data['K_cam0'] = P_rect_00[0:3, 0:3]\\n data['K_cam1'] = P_rect_10[0:3, 0:3]\\n data['K_cam2'] = P_rect_20[0:3, 0:3]\\n data['K_cam3'] = P_rect_30[0:3, 0:3]\\n\\n # Compute the stereo baselines in meters by projecting the origin of\\n # each camera frame into the velodyne frame and computing the distances\\n # between them\\n p_cam = np.array([0, 0, 0, 1])\\n p_velo0 = np.linalg.inv(data['T_cam0_velo']).dot(p_cam)\\n p_velo1 = np.linalg.inv(data['T_cam1_velo']).dot(p_cam)\\n p_velo2 = np.linalg.inv(data['T_cam2_velo']).dot(p_cam)\\n p_velo3 = np.linalg.inv(data['T_cam3_velo']).dot(p_cam)\\n\\n data['b_gray'] = np.linalg.norm(p_velo1 - p_velo0) # gray baseline\\n data['b_rgb'] = np.linalg.norm(p_velo3 - p_velo2) # rgb baseline\\n\\n self.calib = namedtuple('CalibData', data.keys())(*data.values())\",\n \"def do_calibration(self):\\n goal = CalculateParametersGoal()\\n self.calibrate_client.send_goal(goal)\\n self.calibrate_client.wait_for_result()\\n result = self.calibrate_client.get_result()\\n rospy.loginfo('Received the calibration results')\\n if result.number_of_images is 0:\\n rospy.logerr('Failed to calibrate the camera.')\\n else:\\n rospy.loginfo('Number of pictures: {}, error: {}'.format(result.number_of_images, result.error))\\n self.save_calibration_parameters(result.intrinsics, result.error, result.number_of_images)\",\n \"def calibrate(self, calib_fns, calib_params, analytes=None, drift_correct=False):\\n # can have calibration function stored in self and pass *coefs?\\n if analytes is None:\\n analytes = self.analytes\\n\\n if 'calibrated' not in self.data.keys():\\n self.data['calibrated'] = {}\\n\\n for a in analytes:\\n if drift_correct:\\n P = self.drift_params(calib_params, a)\\n else:\\n P = calib_params[a].values[0]\\n\\n self.data['calibrated'][a] = \\\\\\n calib_fns[a](P,\\n self.data['ratios'][a])\\n\\n # coefs = calib_params[a]\\n # if len(coefs) == 1:\\n # self.data['calibrated'][a] = \\\\\\n # self.data['ratios'][a] * coefs\\n # else:\\n # self.data['calibrated'][a] = \\\\\\n # np.polyval(coefs, self.data['ratios'][a])\\n # self.data['ratios'][a] * coefs[0] + coefs[1]\\n self.setfocus('calibrated')\\n return\",\n \"def calibrate(cols=9, rows=6, path=\\\"./camera_cal/\\\", debug=False):\\n # termination criteria\\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)\\n\\n # prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\\n objp = np.zeros((cols*rows,3), np.float32)\\n objp[:,:2] = np.mgrid[0:cols,0:rows].T.reshape(-1,2)\\n\\n # Arrays to store object points and image points from all the images.\\n objpoints = [] # 3d point in real world space\\n imgpoints = [] # 2d points in image plane.\\n search_str = path+'*.jpg'\\n images = glob.glob(search_str)\\n print(\\\"Found {0} images for calibration.\\\".format(len(images)))\\n\\n for fname in images:\\n img = cv2.imread(fname)\\n gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\\n # Find the chess board corners\\n ret, corners = cv2.findChessboardCorners(gray, (cols,rows), None)\\n\\n # If found, add object points, image points (after refining them)\\n if ret == True:\\n objpoints.append(objp)\\n\\n cv2.cornerSubPix(gray,corners,(11,11),(-1,-1),criteria)\\n imgpoints.append(corners)\\n\\n if (debug):\\n # Draw and display the corners\\n cv2.drawChessboardCorners(img, (cols,rows), corners,ret)\\n window_name = \\\"calib image\\\"\\n cv2.imshow('calib image',img)\\n cv2.moveWindow(\\\"calib image\\\", 10, 50);\\n cv2.waitKey()\\n cv2.destroyAllWindows()\\n\\n else:\\n print(\\\"No chessboard corners in {0} found!!!\\\".format(fname))\\n\\n ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1],None,None)\\n return mtx, dist\",\n \"def fit_data(self, data):\\n return dot(data, self._fit_matrix.T)\",\n \"def apply_matrix(self, A):\\n assert self.is_vector(), 'Can only apply matrices to vector-valued functions'\\n C = np.matmul(A, self.coeffs[..., None])\\n assert C.shape[-1] == 1 # this should have created a new singleton axis\\n return BSplineFunc(self.kvs, np.squeeze(C, axis=-1))\",\n \"def calibrate():\\n if os.path.exists('calibration_data.pkl'):\\n with open('calibration_data.pkl', 'rb') as f:\\n return pickle.load(f)\\n\\n objp = np.zeros((6 * 9, 3), np.float32)\\n objp[:, :2] = np.mgrid[0:9, 0:6].T.reshape(-1, 2)\\n\\n # Arrays to store object points and image points from all the images.\\n objpoints = [] # 3d points in real world space\\n imgpoints = [] # 2d points in image plane.\\n\\n for fname in glob.glob('camera_cal/calibration*.jpg'):\\n img = cv2.imread(fname)\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n # print('{}: {}'.format(fname, gray.shape))\\n\\n # Find the chessboard corners\\n ret, corners = cv2.findChessboardCorners(gray, (9, 6), None)\\n\\n if ret:\\n objpoints.append(objp)\\n imgpoints.append(corners)\\n else:\\n print('Failed to detect corners for {}'.format(fname))\\n\\n ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, (1280, 720), None, None)\\n assert ret\\n\\n with open('calibration_data.pkl', 'wb') as f:\\n pickle.dump((mtx, dist), f)\\n\\n return mtx, dist\",\n \"def calibrate_camera(calib_path, display=True):\\r\\n assert path.exists(calib_path), '\\\"{}\\\" calibration images must be exist.'.format(calib_path)\\r\\n # prepare world points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\\r\\n # Set initial chessboard parameter matrix\\r\\n wdp = np.zeros((6 * 9, 3), np.float32)\\r\\n wdp[:, :2] = np.mgrid[0:9, 0:6].T.reshape(-1, 2)\\r\\n # Arrays to store object points and pixel points from all the images.\\r\\n worldpoints = [] # 3d points in real world space\\r\\n pixelpoints = [] # 2d points in pixel plane.\\r\\n # loads imgs into a list\\r\\n imgs = glob.glob(path.join(calib_path, 'calibration*.jpg'))\\r\\n # Step through the list and search for chessboard corners\\r\\n for filename in imgs:\\r\\n img = cv2.imread(filename)\\r\\n img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\r\\n # Find the chessboard corners\\r\\n pattern_flag, corners = cv2.findChessboardCorners(img_gray, (9, 6), None)\\r\\n if pattern_flag is True:\\r\\n worldpoints.append(wdp)\\r\\n pixelpoints.append(corners)\\r\\n # for display result of calibration\\r\\n if display:\\r\\n # Draw and display the corners\\r\\n img = cv2.drawChessboardCorners(img, (9, 6), corners, pattern_flag)\\r\\n cv2.imshow('img',img)\\r\\n print(\\\"Picture: \\\" + filename + ' calibrating ...')\\r\\n cv2.waitKey(300)\\r\\n if display:\\r\\n cv2.destroyAllWindows()\\r\\n ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(worldpoints, pixelpoints, img_gray.shape[::-1], None, None)\\r\\n # print(mtx,dist)\\r\\n return mtx, dist\",\n \"def calibration_matrix(resolution_px, diagonal_mm, focal_len_mm, skew=0.):\\n # Camera intrinsics parameters\\n resolution_x_px, resolution_y_px = resolution_px # image resolution in pixels\\n diagonal_px = np.sqrt(resolution_x_px**2 + resolution_y_px**2)\\n\\n resolution_x_mm = resolution_x_px / diagonal_px * diagonal_mm\\n resolution_y_mm = resolution_y_px / diagonal_px * diagonal_mm\\n\\n skew = skew # \\\"skew param will be zero for most normal cameras\\\" Hartley, Zisserman\\n\\n m_x = resolution_x_px / resolution_x_mm\\n m_y = resolution_y_px / resolution_y_mm\\n\\n alpha_x = focal_len_mm * m_x # focal length of the camera in pixels\\n alpha_y = focal_len_mm * m_y # focal length of the camera in pixels\\n\\n x_0 = resolution_x_px / 2\\n y_0 = resolution_y_px / 2\\n\\n return np.array([[alpha_x, skew, x_0], [0, alpha_y, y_0], [0, 0, 1]])\",\n \"def calibrate(self, Otrain, Ftrain, Feval):\\n I = np.where((np.isnan(Otrain) == 0) & (np.isnan(Ftrain) == 0))[0]\\n if len(I) == 0:\\n return np.nan*np.zeros(Feval.shape)\\n Ieval = np.where(np.isnan(Feval) == 0)[0]\\n x = np.nan*np.zeros(Feval.shape)\\n if len(Ieval) > 0:\\n x[Ieval] = self._calibrate(Otrain[I], Ftrain[I], Feval[Ieval])\\n return x\",\n \"def calibrate(self):\\n if self.iCAL_required:\\n logger.info(\\\"iCAL-sensitive registers were modified, performing calibration...\\\")\\n return self._run_ical()\\n else:\\n logger.info(\\\"iCAL-sensitive registers were not modified, skipping calibration...\\\")\\n return 0 # Still success\",\n \"def _calibrate(self, Otrain, Ftrain, Feval):\\n raise NotImplementedError()\",\n \"def fit(self, data):\\n x, y = np.asarray(data, dtype=float)\\n\\n # Quadratic part of design matrix [eqn. 15] from (*)\\n D1 = np.mat(np.vstack([x**2, x*y, y**2])).T\\n # Linear part of design matrix [eqn. 16] from (*)\\n D2 = np.mat(np.vstack([x, y, np.ones(len(x))])).T\\n\\n # forming scatter matrix [eqn. 17] from (*)\\n S1 = D1.T*D1\\n S2 = D1.T*D2\\n S3 = D2.T*D2\\n\\n # Constraint matrix [eqn. 18]\\n C1 = np.mat('0. 0. 2.; 0. -1. 0.; 2. 0. 0.')\\n\\n # Reduced scatter matrix [eqn. 29]\\n M = C1.I*(S1-S2*S3.I*S2.T)\\n\\n # M*|a b c >=l|a b c >. Find eigenvalues and eigenvectors from this equation [eqn. 28]\\n eval, evec = np.linalg.eig(M)\\n\\n # eigenvector must meet constraint 4ac - b^2 to be valid.\\n cond = 4*np.multiply(evec[0, :], evec[2, :]) - \\\\\\n np.power(evec[1, :], 2)\\n a1 = evec[:, np.nonzero(cond.A > 0)[1]]\\n\\n # |d f g> = -S3^(-1)*S2^(T)*|a b c> [eqn. 24]\\n a2 = -S3.I*S2.T*a1\\n\\n # eigenvectors |a b c d f g>\\n self.coef = np.vstack([a1, a2])\\n self._save_parameters()\",\n \"def calibrate_onc(data, path, model_name):\\n \\n #split test data (subsets 7-9) into new test (7-8)/train(9) sets\\n calibration_train_set = data[((data.subset==7)|(data.subset==8))].copy()\\n calibration_test_set = data[data.subset==9].copy()\\n\\n #define calibration model\\n ir = IsotonicRegression(out_of_bounds=\\\"clip\\\")\\n #fit the model to the probas from the training set\\n ir.fit(calibration_train_set.score, calibration_train_set.y )\\n \\n #evaluate with the test set and save\\n calibration_test_set.loc[:,'p_calibrated'] = ir.transform(calibration_test_set.score) \\n \\n #calibration_test_set.loc[:,'p_calibrated'] = p_calibrated\\n \\n #save\\n with open(path + 'model_calibrated_' + model_name + '.pickle', 'wb') as picklefile: \\n pickle.dump(ir,picklefile)\\n \\n with open(path + 'y_calibrated_' + model_name + '.pickle', 'wb') as picklefile: \\n pickle.dump(calibration_test_set, picklefile)\\n \\n print_calibrated_results(calibration_test_set.y, calibration_test_set.score, calibration_test_set.p_calibrated)\\n return calibration_test_set\",\n \"def calibrate(\\n model: onnx.ModelProto, dataset: List[Dict[str, np.ndarray]]\\n) -> Dict[str, Tuple[float, float]]:\\n augmented_model = ONNXCalibrator(model).build_calibration_model()\\n return calibrator.calibrate(augmented_model, dataset)\",\n \"def estimate(self, data):\\n\\n A = np.c_[data[:, 0], data[:, 1], np.ones(data.shape[0])]\\n C, _, _, _ = scipy.linalg.lstsq(A, data[:, 2]) # coefficients\\n\\n self.params = C\\n\\n return True\",\n \"def loadCameraCalibration(self, file_name=None):\\n\\n mat_str = []\\n if file_name == None:\\n file_str = \\\"/home/student/armlab-w20/util/calibration.cfg\\\"\\n else:\\n file_str = file_name\\n with open(file_str, 'r') as f:\\n for line in f:\\n line = line.replace('[', '')\\n line = line.replace(']', '')\\n line = line.replace('\\\\n', '')\\n mat_str.append(line)\\n cam_mat_str = mat_str[1:4]\\n dist_coeffs = mat_str[-2:]\\n dist_coeffs = \\\"\\\".join(dist_coeffs)\\n dist_coeffs = dist_coeffs.split()\\n dist_coeffs = [float(coeff) for coeff in dist_coeffs]\\n self.cam_int_mat = []\\n for row in cam_mat_str:\\n mat_row = []\\n mat_row = row.split()\\n mat_row = [float(i) for i in mat_row]\\n self.cam_int_mat.append(mat_row)\\n self.cam_int_mat = np.asarray(self.cam_int_mat)\\n self.dist_coeffs = np.asarray(dist_coeffs)\",\n \"def calibration(self, cal: int, /) -> None:\",\n \"def calibrate(self, cal=1.0, pol_eff=1.0):\\n \\n if self.ncomp == 1:\\n self.data *= cal\\n else:\\n self.data[0] *= cal\\n self.data[1] *= cal * pol_eff\\n self.data[2] *= cal * pol_eff\\n\\n return self\",\n \"def calib_raw(self, calib_func=\\\"kidsdata.kids_calib.get_calfact\\\", clean_raw=False, **kwargs):\\n\\n if getattr(self, \\\"__calib\\\", None) is None:\\n self.__log.debug(\\\"calibration using {}\\\".format(calib_func))\\n self.__check_attributes([\\\"I\\\", \\\"Q\\\"], read_missing=False)\\n\\n fmod = self.fmod\\n mod_mask = self.mod_mask\\n\\n # Check about the 3rd bit and the fix_masq keyword\\n if np.any(mod_mask & (1 << 2)) and kwargs.get(\\\"fix_masq\\\") is True:\\n self.__log.error(\\\"fix_masq should not be used when 3rd bit is set\\\")\\n\\n self.__log.info(\\\"Calibrating with fmod={} and {}\\\".format(fmod, kwargs))\\n calib_func = _import_from(calib_func)\\n self.__calib = calib_func(self.I, self.Q, mod_mask, fmod=fmod, **kwargs)\\n\\n else:\\n self.__log.error(\\\"calibrated data already present\\\")\\n\\n # Expand keys :\\n # Does not double memory, but it will not be possible to\\n # partially free memory : All attribute read at the same time\\n # must be deleted together\\n for ckey in self.__calib.keys():\\n self.__dict__[ckey] = self.__calib[ckey]\\n\\n if clean_raw:\\n self._clean_data(\\\"_KidsRawData__dataSd\\\")\",\n \"def matrix_transform(data, fun, *args, **kwargs):\\n if is_sparse_dataframe(data) or is_SparseDataFrame(data):\\n data = data.copy()\\n for col in data.columns:\\n data[col] = fun(data[col], *args, **kwargs)\\n elif sparse.issparse(data):\\n if isinstance(data, (sparse.lil_matrix, sparse.dok_matrix)):\\n data = data.tocsr()\\n else:\\n # avoid modifying in place\\n data = data.copy()\\n data.data = fun(data.data, *args, **kwargs)\\n else:\\n data = fun(data, *args, **kwargs)\\n return data\",\n \"def m(self) -> np.ndarray:\\n assert self._k is not None and self._r is not None and self._t is not None, \\\"camera must be calibrated\\\"\\n return forge_projective_matrix(self._k, r=self._r, t=self._t)\",\n \"def fit_transform(self, data_matrix, target=None):\\n self.fit(data_matrix, target)\\n return self.transform(data_matrix)\",\n \"def calculate_calibration(filename, nx=9, ny=6):\\n # Make a list of calibration images\\n img = cv2.imread(filename)\\n\\n # Convert to grayscale\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n\\n # Find the chessboard corners\\n objpoints = []\\n imgpoints = []\\n objp = np.zeros((ny*nx, 3), np.float32)\\n objp[:, :2] = np.mgrid[0:nx, 0:ny].T.reshape(-1, 2)\\n\\n ret, corners = cv2.findChessboardCorners(gray, (nx, ny), None)\\n if not ret:\\n return None\\n\\n imgpoints.append(corners)\\n objpoints.append(objp)\\n\\n ret, mtx, dist, a, b = cv2.calibrateCamera(\\n objpoints, imgpoints,\\n gray.shape[::-1], None, None\\n )\\n return img, corners, mtx, dist\",\n \"def matrix_map(self, bkg_reduction=True, data_correction=True):\\r\\n\\r\\n if bkg_reduction is True:\\r\\n if data_correction is True:\\r\\n data = self.df4\\r\\n \\r\\n else:\\r\\n data = self.df2\\r\\n\\r\\n else:\\r\\n if data_correction is True:\\r\\n data = self.df3\\r\\n \\r\\n else:\\r\\n data = self.df1\\r\\n\\r\\n return data\",\n \"def loadCameraCalibration(self):\\n\\n # Read calibration.csv\\n with open(\\\"util/calibration.csv\\\", 'rb') as csvfile:\\n csvreader = csv.reader(csvfile, delimiter=\\\",\\\", quotechar=\\\"|\\\")\\n tmp = []\\n intrinsic_matrix = []\\n distort_coef = []\\n i = 0\\n for row in csvreader:\\n for col in row:\\n try:\\n tmp.append(float(col))\\n except:\\n print(\\\"ERROR in calibration.csv intrinsic matrix\\\")\\n if(i!=3):\\n intrinsic_matrix.append(tmp)\\n i += 1\\n tmp = []\\n if(i==3):\\n distort_coef = tmp\\n tmp = []\\n \\n return intrinsic_matrix, distort_coef\",\n \"def build(self, data: np.ndarray):\\n ret = data.dot(self.eigenvectors)\\n self.pca_predictor_vars = ret\\n return ret\",\n \"def _RunCalibration(self, graph_key, gdef, input_data, config):\\n return self._RunGraph(graph_key, gdef, input_data, config, 30)\",\n \"def calibrate(self):\\n if not self._calibrate:\\n raise ValueError(\\\"calibrate parameter must be set\\\")\\n\\n if self.calibration_samples >= self._max_samples:\\n return self._camera\\n\\n frame = self.capture()\\n left = frame.images[0]\\n right = frame.images[1]\\n\\n ret_l, corners_l = left.features\\n ret_r, corners_r = right.features\\n\\n if self._last_timestamp is None:\\n self._last_timestamp = frame.timestamp\\n\\n if ret_l is True and ret_r is True and (frame.timestamp - self._last_timestamp).total_seconds() > self._frame_delay:\\n self.objpoints.append(self.objp)\\n self.imgpoints_l.append(corners_l)\\n self.imgpoints_r.append(corners_r)\\n\\n self.calibration_samples += 1\\n self._last_timestamp = frame.timestamp\\n\\n if self.calibration_samples >= self._max_samples:\\n img_shape = left.image.shape[::-1]\\n self._camera = self._finish_calibration(self.objpoints, self.imgpoints_l, self.imgpoints_r, img_shape)\\n return self._camera\",\n \"def calibrate_camera(path_to_images='../camera_cal/calibration*.jpg', pattern=(9, 6)):\\n # Prepare object points\\n objp = np.zeros((pattern[1]*pattern[0],3), np.float32)\\n objp[:,:2] = np.mgrid[0:pattern[0], 0:pattern[1]].T.reshape(-1,2)\\n\\n # Arrays to store object points and image points from all the images.\\n objpoints = [] # 3d points in real world space\\n imgpoints = [] # 2d points in image plane.\\n\\n # Make a list of calibration images\\n images = glob.glob(path_to_images)\\n img_w = 0\\n img_h = 0\\n\\n # Step through the list and search for chessboard corners\\n for idx, fname in enumerate(images):\\n img = cv2.imread(fname)\\n img_h, img_w, _ = img.shape\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n\\n # Find the chessboard corners\\n ret, corners = cv2.findChessboardCorners(gray, pattern, None)\\n\\n # If found, add object points, image points\\n if ret == True:\\n objpoints.append(objp)\\n imgpoints.append(corners)\\n \\n # Calibrate camera\\n ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, (img_w, img_h) ,None,None)\\n \\n # Return the camera matrix and distortion coefs\\n return mtx, dist\",\n \"def calibrate(self, chessboard_img_files, chessboard_size):\\n # Create placeholder lists\\n chess_rows, chess_cols = chessboard_size\\n chess_corners = np.zeros((chess_cols * chess_rows, 3), np.float32)\\n chess_corners[:, :2] = np.mgrid[0:chess_rows, 0:chess_cols].T.reshape(-1, 2)\\n objpoints = [] # 3d points in real world space\\n imgpoints = [] # 2d points in image plane.\\n\\n # Determine object point, image point pairs\\n for fname in chessboard_img_files:\\n # Load images\\n img = cv2.imread(fname)\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n\\n # Find the chessboard corners\\n found, img_corners = cv2.findChessboardCorners(gray, (chess_rows, chess_cols), None)\\n\\n # If found, save object points, image points\\n if found:\\n objpoints.append(chess_corners)\\n imgpoints.append(img_corners)\\n\\n # Perform calibration\\n success, camera_matrix, dist_coeffs, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, self.img_size,\\n None, None)\\n if not success:\\n raise Exception(\\\"Camera calibration unsuccessful.\\\")\\n return camera_matrix, dist_coeffs\",\n \"def project(self, new_expn):\\n \\\"\\\"\\\"\\n data = numpy.array(self.parent.serialisedArrayDataList)\\n import sklearn\\n skpca = sklearn.decomposition.PCA()\\n X_r = skpca.fit(data).transform(data)\\n \\n self.__v = X_r\\n \\\"\\\"\\\"\\n # old martrisx\\n matrix = numpy.array(self.parent.serialisedArrayDataList)\\n U, S, V = numpy.linalg.svd(matrix.T, full_matrices=False)\\n \\n print(\\\"matrix\\\", matrix.shape)\\n \\n # set-ups\\n self.parent = new_expn\\n if self.rowwise:\\n self.labels = new_expn[self.label_key]\\n else:\\n self.labels = new_expn.getConditionNames()\\n \\n matrix = numpy.array(self.parent.serialisedArrayDataList)\\n S = numpy.diag(S)\\n print(\\\"U\\\", U.shape)\\n print(\\\"V\\\", V.shape)\\n print(\\\"S\\\", S.shape)\\n print(\\\"matrix\\\", matrix.shape)\\n \\n #data = np.dot(U, np.dot(S, V))\\n #X_transformed = np.dot(X_transformed, self.V.T)\\n print(numpy.dot(S, V).shape)\\n\\n pr = numpy.dot(matrix, S)\\n print(\\\"pr\\\", pr.shape)\\n #y = x*W;\\n #y0 = Y(1,:);\\n #sum(abs(y0 - y)) %\\n \\n # I want a new v. U and D are the same.\\n \\n self.__v = pr\\n \\n print(U)\\n print()\\n print(pr)\\n \\n print(numpy.allclose(U, pr)) \\n print(numpy.allclose(matrix.T, numpy.dot(U, numpy.dot(S, V))))\\n return(True)\",\n \"def calibrate(): \\n \\n # Calibrate of the run using beam data. Creates a folder cal-files/caltag \\n # containing all calibration data. \\n CalObj = Calibration(steerfiles=steerfiles, name=localcaltag + '-cal') \\n\\n # Set Beam energy\\n CalObj.set_beam_momentum(beamenergy)\\n\\n # Get gearfile and set air as DUT material\\n localgearfile = CalObj.get_filename('gear.xml')\\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='thickness', value=0.0001)\\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='radLength', value=304000.0)\\n \\n # Create list of calibration steps \\n calpath = create_calibration_path(CalObj)\\n \\n # Run the calibration steps \\n CalObj.calibrate(path=calpath,ifile=rawfile_air,caltag=localcaltag)\",\n \"def calibrate(self, master):\\n if master.polyorder == 'linear':\\n self.fitfunction = \\\"A0 + A1 * D\\\"\\n self.fit_fkt = self.calc_lin\\n elif master.polyorder == 'quadratic':\\n self.fit_fkt = self.calc_quad\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2\\\"\\n elif master.polyorder == \\\"cubic\\\":\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2 + A3 * D**3\\\"\\n self.fit_fkt = self.calc_cubic\\n else:\\n print(\\\"Polynomgrad nicht definiert\\\")\\n \\n self.mw = np.asarray(self.mw)\\n if master.sensortype == \\\"Druck\\\":\\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\\n else:\\n print(\\\"Sensortyp noch nicht Hinterlegt\\\")\",\n \"def transform(self, X):\\n\\n t0 = time.perf_counter()\\n check_is_fitted(self)\\n self.check_external_components_modified()#[WARN] in d3m, primitives can \\\"restore\\\" private class variables...\\n X = self._validate_data(X, accept_sparse=[\\\"csr\\\", \\\"csc\\\"], reset=False)\\n t1 = time.perf_counter()\\n\\n if X.shape[1] != self.components_af_.shape[1]:\\n raise ValueError(\\n \\\"Impossible to perform projection:\\\"\\n \\\"X at fit stage had a different number of features. \\\"\\n \\\"(%s != %s)\\\" % (X.shape[1], self.components_af_.shape[1])\\n )\\n\\n #X_new = safe_sparse_dot(X, self.components_.T, dense_output=self.dense_output)\\n #import pdb; pdb.set_trace()\\n X_af = af.interop.from_ndarray(X).as_type(self.components_af_.dtype())\\n X_new = af.matmulNT(X_af, self.components_af_)\\n X_new = X_new.to_ndarray()\\n t2 = time.perf_counter()\\n return X_new\",\n \"def m_c(self) -> np.ndarray:\\n assert self._k is not None, \\\"camera must be calibrated\\\"\\n return forge_projective_matrix(self._k)\",\n \"def cam_calibration():\\n # read all calibration images in a folder with similar names\\n images = glob.glob('./camera_cal/calibration*.jpg')\\n\\n # calibrate camera and read object-points (3D), image points (2D) and image shape\\n objpoints, imgpoints, img_shape = calibrate_camera(images)\\n print(\\\"DONE: Camera calibration\\\")\\n # save calibration parameters' pickle file\\n save_calib_params(objpoints, imgpoints, img_shape)\\n print(\\\"Calibration parameters pickle file saved \\\")\",\n \"def calibrate(self):\\n\\n self.update_message('Calibrating platform...')\\n\\n self.calibrate_platform()\\n\\n self.update_message('Platform Calibrated.')\\n\\n # calibrate arm x axis\\n self.update_message('Calibrating x axis...')\\n calibrated = self.calibrate_arm(0)\\n\\n if not calibrated:\\n self.update_message('ERROR: Could not calibrate x axis.')\\n return 0\\n else:\\n self.update_message('x axis calibrated.')\\n\\n # calibrate arm y axis\\n self.update_message('Calibrating y axis...')\\n calibrated = self.calibrate_arm(1)\\n\\n if not calibrated:\\n self.update_message('ERROR: Could not calibrate y axis.')\\n return 0\\n else:\\n self.update_message('y axis calibrated.')\\n\\n # calibrate arm z axis\\n self.update_message('Calibrating z axis...')\\n calibrated = self.calibrate_arm(2)\\n\\n if not calibrated:\\n self.update_message('ERROR: Could not calibrate z axis.')\\n return 0\\n else:\\n self.update_message('z axis calibrated.\\\\n'\\n 'Autocalibration done.\\\\n'\\n 'Accuracy: {}'.format(self.matrix_accuracy()))\\n\\n # Getting the direction to withdraw pipette along x axis\\n self.get_withdraw_sign()\\n self.inv_mat = np.linalg.inv(self.mat)\\n self.calibrated = 1\\n self.cam.click_on_window = True\\n self.save_calibration()\\n return 1\",\n \"def _calibration(\\n name: str = CALIBRATION_NAME,\\n eval_config: Optional[config_pb2.EvalConfig] = None,\\n model_name: str = '',\\n output_name: str = '',\\n sub_key: Optional[metric_types.SubKey] = None,\\n aggregation_type: Optional[metric_types.AggregationType] = None,\\n class_weights: Optional[Dict[int, float]] = None,\\n example_weighted: bool = False) -> metric_types.MetricComputations:\\n key = metric_types.MetricKey(\\n name=name,\\n model_name=model_name,\\n output_name=output_name,\\n sub_key=sub_key,\\n example_weighted=example_weighted)\\n\\n # Make sure weighted_labels_predictions_examples are calculated.\\n computations = _weighted_labels_predictions_examples(\\n eval_config=eval_config,\\n model_name=model_name,\\n output_name=output_name,\\n sub_key=sub_key,\\n aggregation_type=aggregation_type,\\n class_weights=class_weights,\\n example_weighted=example_weighted)\\n weighted_labels_predictions_key = computations[-1].keys[-1]\\n\\n def result(\\n metrics: Dict[metric_types.MetricKey, Any]\\n ) -> Dict[metric_types.MetricKey, Any]:\\n \\\"\\\"\\\"Returns calibration.\\\"\\\"\\\"\\n metric = metrics[weighted_labels_predictions_key]\\n if np.isclose(metric.total_weighted_labels, 0.0):\\n value = float('nan')\\n else:\\n value = metric.total_weighted_predictions / metric.total_weighted_labels\\n\\n return {key: value}\\n\\n derived_computation = metric_types.DerivedMetricComputation(\\n keys=[key], result=result)\\n computations.append(derived_computation)\\n return computations\",\n \"def reconstruct(self,data):\\n k,d = self.w.shape\\n return dot(data,self.w)+self.mean.reshape(1,d)\",\n \"def _apply_correction(self):\\n np.copyto(self.network.weights, self.correction_matrix)\",\n \"def fit(self, X):\\n if self.n_components_ > X.shape[2]:\\n raise ValueError(\\\"n_components is greater than number of features in X.\\\")\\n\\n if len(X.shape) != 3:\\n raise ValueError(\\\"Data must be in 3 dimensions (conditions, time, features).\\\")\\n\\n if self.mean_subtract_:\\n self.cross_condition_mean_ = np.mean(X, axis=0, keepdims=True)\\n X = X - self.cross_condition_mean_\\n\\n X_flat = np.concatenate(X, axis=0)\\n self.pca_ = PCA(n_components=self.n_components_)\\n self.pca_.fit(X_flat)\\n\\n X_red = [self.pca_.transform(Xi) for Xi in X]\\n dX = np.concatenate([np.diff(Xi, axis=0) for Xi in X_red], axis=0)\\n X_prestate = np.concatenate([Xi[:-1] for Xi in X_red], axis=0)\\n M_skew = self._fit_skew(X_prestate, dX)\\n\\n self.eigen_vals_, self.eigen_vecs_ = self._get_jpcs(M_skew)\\n\\n self.proj_vectors_ = []\\n for i in range(len(self.eigen_vecs_) // 2):\\n v1 = self.eigen_vecs_[2 * i]\\n v2 = self.eigen_vecs_[2 * i + 1]\\n real_v1 = np.real(v1 + v2)\\n real_v1 /= np.linalg.norm(real_v1)\\n real_v2 = np.imag(v1 - v2)\\n real_v2 /= np.linalg.norm(real_v2)\\n self.proj_vectors_.append(real_v1)\\n self.proj_vectors_.append(real_v2)\\n self.proj_vectors_ = np.array(self.proj_vectors_)\\n return self\",\n \"def mca_transformer(transform_data):\\n M, dims, index, v0v1 = transform_data\\n def transform(dfp):\\n # dims, index, v0v1\\n P = np.zeros((len(dfp), dims), dtype=float)\\n print(\\\"transforming\\\")\\n for i, (_, row) in (enumerate(dfp.iterrows())):\\n ivec = np.zeros(M)\\n for col, val in zip(row.index, row):\\n if (col, val) in index:\\n ivec[index[col, val]] = 1\\n proj = ivec.dot(v0v1)\\n assert(all(proj.imag == 0))\\n P[i,:] = proj.real\\n return P\\n return transform\",\n \"def calibration(self) -> int:\",\n \"def transform(self,data):\\n n,d = data.shape\\n assert d==self.w.shape[1]\\n assert self.w is not None\\n k,d = self.w.shape\\n return dot(data-self.mean.reshape(1,d),self.w.T)\",\n \"def calibrate(self, calibration_dict=None):\\n if calibration_dict is not None:\\n for i in self.POSITIONS:\\n if self.version == \\\"standard\\\" and i.startswith(\\\"save_image__\\\"):\\n continue\\n self.POSITIONS[i] = calibration_dict[i]\\n else:\\n if os.path.isfile(GoogleEarthProCalibration.SETTINGS_FILE):\\n print \\\"Using config file\\\"\\n with open(GoogleEarthProCalibration.SETTINGS_FILE, \\\"r\\\") as gf:\\n for l in gf:\\n cd = l.split(\\\",\\\")\\n self.POSITIONS[cd[0]] = (int(cd[1]), int(cd[2]))\\n else:\\n to_offset = [i for i in self.POSITIONS \\\\\\n if i is not \\\"google_earth_pro_offset\\\"]\\n for i in to_offset:\\n self.POSITIONS[i] = self.offset(self.POSITIONS[i])\",\n \"def apply_observation_matrix(self, x, k, result=None):\\n\\n i = 0\\n\\n # vector case\\n ssm_indices = self.active_ssms(k)\\n if len(x.shape)==1:\\n r = 0\\n for j in ssm_indices:\\n ssm, scale = self.ssms[j], self.scales[j]\\n state_size = ssm.max_dimension\\n ri = ssm.apply_observation_matrix(x[i:i+state_size], k-self.ssm_starts[j])\\n if scale is not None:\\n r += ri * scale[k-self.ssm_starts[j]]\\n else:\\n r += ri\\n i += state_size\\n return r\\n\\n # matrix case\\n else:\\n assert(len(x.shape)==2)\\n\\n try:\\n rr = self.tmp_arrays[len(result)]\\n except KeyError:\\n rr = np.empty((len(result),))\\n self.tmp_arrays[len(result)] = rr\\n\\n result[:] = 0\\n for j in ssm_indices:\\n ssm, scale = self.ssms[j], self.scales[j]\\n state_size = ssm.max_dimension\\n ssm.apply_observation_matrix(x[i:i+state_size,:], k-self.ssm_starts[j], rr)\\n #print \\\"TSSM step %d applying obs matrix on ssm %d state_size %d n %d scale %f result[0] %f\\\\n\\\" % (k, j, state_size, len(result), scale[k-self.ssm_starts[j]] if scale is not None else 1.0, rr[0])\\n if scale is not None:\\n rr *= scale[k-self.ssm_starts[j]]\\n result += rr\\n i += state_size\",\n \"def calcIntrasec(self, gui):\\n count = len(self.points)\\n numpoints = (self.chessSize[0]*self.chessSize[1])\\n\\n #create matrices that are needed to compute calibration\\n mat = cv.CreateMat(3,3,cv.CV_32FC1)\\n distCoeffs = cv.CreateMat(4,1,cv.CV_32FC1)\\n p3d = cv.CreateMat(count,3,cv.CV_32FC1) #compute 3D points\\n p2d = cv.CreateMat(count,2,cv.CV_32FC1) #compute 2D points\\n pointCounts = cv.CreateMat( self.nframe ,1,cv.CV_32SC1) #give numpoints per images\\n cv.Set(pointCounts,numpoints)\\n rvecs = cv.CreateMat(self.nframe,3,cv.CV_32FC1)\\n tvecs = cv.CreateMat(self.nframe,3,cv.CV_32FC1)\\n\\n i = 0\\n row = 0\\n col = 0\\n cv.Set(p3d,0.0) #to set every values to 0.0... and not set Z value\\n\\n #this compute points in row and cols...\\n for p in self.points:\\n p2d[i,0] = p[0]\\n p2d[i,1] = p[1]\\n \\n p3d[i,0] = col\\n p3d[i,1] = row\\n col+=1\\n if col >= self.chessSize[0]: \\n row+=1\\n col=0\\n if row >= self.chessSize[1]:\\n row = 0\\n i+=1\\n\\n #and now, calibrate...\\n cv.CalibrateCamera2(p3d, p2d, pointCounts, self.framesize, mat, distCoeffs, rvecs, tvecs, flags=0)\\n gui.setMessage(\\\"Intrasinc camera parameters checked\\\")\\n\\n return (mat, distCoeffs)\",\n \"def fit_transform(self, x: Array2D) -> Array2D:\",\n \"def calibrate_camera(cal_images, nx, ny):\\n objpoints = [] # 3D points\\n imgpoints = [] # 2D points\\n\\n objp = np.zeros((nx*ny,3), np.float32)\\n objp[:,:2] = np.mgrid[0:nx,0:ny].T.reshape(-1, 2)\\n\\n for fname in cal_images:\\n img = cv2.imread(fname)\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n\\n ret, corners = cv2.findChessboardCorners(gray, (nx, ny), None)\\n if ret == True:\\n objpoints.append(objp)\\n imgpoints.append(corners)\\n\\n ret, mtx, dst, rvecs, tvecs = cv2.calibrateCamera(objpoints, \\n imgpoints, \\n gray.shape[::-1],\\n None, None)\\n\\n cam_cal = CameraCalibration(mtx=mtx, dst=dst, nx=nx, ny=ny, cal_images=cal_images)\\n return cam_cal\",\n \"def calibrate(self):\\n with completion_context(\\\"Estimating sensor offset\\\", color=\\\"c\\\", bright=True):\\n # Reset calibration\\n self._sens_offset = np.zeros(4) # last two entries are never calibrated but useful for broadcasting\\n self._wait_for_pole_at_rest()\\n\\n # Create parts of the calibration controller\\n go_right = QQubeGoToLimCtrl(positive=True, cnt_done=int(1.5 / self._dt))\\n go_left = QQubeGoToLimCtrl(positive=False, cnt_done=int(1.5 / self._dt))\\n go_center = QQubePDCtrl(self.spec)\\n\\n # Estimate alpha offset. Go to both limits for theta calibration.\\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\\n while not go_right.done:\\n meas = self._qsoc.snd_rcv(go_right(to.from_numpy(meas)))\\n while not go_left.done:\\n meas = self._qsoc.snd_rcv(go_left(to.from_numpy(meas)))\\n self._sens_offset[0] = (go_right.th_lim + go_left.th_lim) / 2\\n\\n # Estimate alpha offset\\n self._wait_for_pole_at_rest()\\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\\n self._sens_offset[1] = meas[1]\\n\\n print_cbt(\\n f\\\"Sensor offset: \\\"\\n f\\\"theta = {self._sens_offset[0]*180/np.pi:.3f} deg, \\\"\\n f\\\"alpha = {self._sens_offset[1]*180/np.pi:.3f} deg\\\",\\n \\\"g\\\",\\n )\\n\\n with completion_context(\\\"Centering cube\\\", color=\\\"c\\\", bright=True):\\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\\n while not go_center.done:\\n meas = self._qsoc.snd_rcv(go_center(to.from_numpy(meas - self._sens_offset)))\",\n \"def calibrate(x, y, z, temperature=None, budget=1000, noise_cutoff_mg=13, hdf5_file=None, calibration_statistics=False):\\n\\n args = {\\\"x\\\": x, \\\"y\\\": y, \\\"z\\\": z, \\\"temperature\\\": temperature, \\\"budget\\\": budget, \\\"noise_cutoff_mg\\\": noise_cutoff_mg,\\n \\\"calibration_statistics\\\": calibration_statistics}\\n params = [\\\"temperature\\\", \\\"budget\\\", \\\"noise_cutoff_mg\\\", \\\"calibration_statistics\\\"]\\n calibration_diagnostics = do_if_not_cached(\\\"calibrate\\\", calibrate_slave, args, params, get_calibrate, set_calibrate, hdf5_file)\\n\\n # Regardless of how we get the results, extract the offset and scales\\n calibration_parameters = [calibration_diagnostics[var] for var in [\\\"x_offset\\\", \\\"x_scale\\\", \\\"y_offset\\\", \\\"y_scale\\\", \\\"z_offset\\\", \\\"z_scale\\\"]]\\n\\n if temperature is not None:\\n calibration_parameters = [calibration_diagnostics[var] for var in [\\\"x_temp_offset\\\", \\\"y_temp_offset\\\", \\\"z_temp_offset\\\"]]\\n\\n # Apply the best calibration factors to the data\\n do_calibration(x, y, z, temperature, calibration_parameters)\\n\\n return x, y, z, calibration_diagnostics\",\n \"def eval_sparse(self, array_in, array_out, sp_matrix=None):\\n if sp_matrix is None:\\n sp_matrix = self.to_sparse_matrix(array_in.shape, \\\"csc\\\")\\n # print(\\\"usually:\\\", sp_matrix.todense())\\n array_out[:] = sp_matrix.dot(array_in.reshape(-1)).reshape(array_out.shape)\",\n \"def calibrate(self, x, y) -> None:\\n pass\",\n \"def fit_model(self, matrix1, matrix2):\\n #calculating A\\n cov_matrix1 = np.cov(matrix1.T)\\n cov_matrix2 = np.cov(matrix2.T)\\n cov_inv_matrix1 = np.linalg.inv(cov_matrix1)\\n cov_inv_matrix2 = np.linalg.inv(cov_matrix2)\\n A = (np.subtract(cov_inv_matrix2, cov_inv_matrix1))/2\\n\\n #calculating B\\n #mean\\n mean1 = np.array(self.calculate_mean_vec(matrix1))\\n mean2 = np.array(self.calculate_mean_vec(matrix2))\\n B = np.matmul(mean1.T,cov_inv_matrix1) - np.matmul(mean2.T,cov_inv_matrix2)\\n\\n #Claculating C\\n\\n det_cov1 = np.linalg.det(cov_matrix1)\\n det_cov2 = np.linalg.det(cov_matrix2)\\n c1 = math.log(det_cov2/det_cov1)\\n c2 = np.matmul(np.matmul(mean2.T,cov_inv_matrix2), mean2)\\n c3 = np.matmul(np.matmul(mean1.T,cov_inv_matrix1), mean1)\\n C = (c1+c2-c3)/2\\n\\n return A, B, C\",\n \"def apply(self, data):\\n print(\\\"this is morphism '{}'\\\".format(self.name))\\n data = np.array(data)\\n transformed_data = self.transf(data)\\n return pd.DataFrame.from_dict({\\\"transf\\\": transformed_data.flatten()})\",\n \"def _process(self, data: np.ndarray) -> np.ndarray:\\n if not self.is_trained:\\n raise DataProcessorError(\\\"SVD must be trained on data before it can be used.\\\")\\n\\n # IQ axis is reduced by projection\\n if self._n_shots == 0:\\n # level1 average mode\\n dims = self._n_circs, self._n_slots\\n else:\\n # level1 single mode\\n dims = self._n_circs, self._n_shots, self._n_slots\\n\\n projected_data = np.zeros(dims, dtype=object)\\n\\n for idx in range(self._n_slots):\\n scale = self.parameters.scales[idx]\\n axis = self.parameters.main_axes[idx]\\n mean_i = self.parameters.i_means[idx]\\n mean_q = self.parameters.q_means[idx]\\n\\n if self._n_shots != 0:\\n # Single shot\\n for circ_idx in range(self._n_circs):\\n centered = [\\n data[circ_idx, :, idx, 0] - mean_i,\\n data[circ_idx, :, idx, 1] - mean_q,\\n ]\\n projected_data[circ_idx, :, idx] = axis @ np.array(centered) / scale\\n else:\\n # Averaged\\n centered = [data[:, idx, 0] - mean_i, data[:, idx, 1] - mean_q]\\n projected_data[:, idx] = axis @ np.array(centered) / scale\\n\\n return projected_data\",\n \"def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:\",\n \"def load_calibration(file_path=\\\"calibration_info\\\" ):\\n info_file = Path(file_path)\\n if info_file.is_file():\\n with open(file_path, 'rb') as infile:\\n payload = pickle.load(infile)\\n mtx = payload['matrix']\\n dist_coeff = payload['dist_coeff']\\n return mtx, dist_coeff\\n else:\\n warnings.warn(\\\"File {} do not exist! Try to recalibrate\\\".format(file_path), UserWarning)\\n mtx, dist_coeff = CalibrationUtils.calibrate()\\n CalibrationUtils.save_calibration(mtx, dist_coeff, file_path)\\n return mtx, dist_coeff\",\n \"def __call__(self):\\n #Check source type and sensor type, then call appripriate methods to \\n #generate intermediate data, cascading all the way back to geometry \\n #calculation if it wasn't already done.\\n #Then return a projection matrix...\\n\\n # NOTE: returned projection_matrix is a numpy.ndarray\\n if isinstance(self.sensors, sensors_module.SensorsEEG):\\n projection_matrix = self.eeg_gain()\\n elif isinstance(self.sensors, sensors_module.SensorsMEG):\\n projection_matrix = self.meg_gain()\\n\\n return projection_matrix\",\n \"def oracle(dataset: Dataset, conf: Namespace) -> np.ndarray:\\n # Copy dataframe and set up test and score columns\\n df = dataset.df.copy()\\n df['test'] = df['fold'] == dataset.fold\\n df['score'] = df[dataset.feature]\\n\\n # Compute calibrated score here, start as zeros\\n calibrated_score = np.zeros_like(df['score'], dtype='float')\\n\\n # Get each combination of sensitive attributes (in this case only consider ethnicity)\\n print(\\\"Computing results for subgroups...\\\")\\n for subgroup in dataset.iterate_subgroups():\\n\\n # Set up select mask for left and right image, initialize as all True\\n select = np.full_like(calibrated_score, True, dtype=bool) # TODO this can be cleaner\\n\\n # Iterate attributes of subgroup\\n for attribute in subgroup:\\n\\n # Get columns of current attribute, is always only 2 (for left and right image)\\n for col in dataset.consts['sensitive_attributes'][attribute]['cols']:\\n # Update masks for both images of current attribute value\\n select &= (df[col] == subgroup[attribute])\\n\\n # Mask to select the train data of the above select\\n select_train = select & (df['test'] == False)\\n\\n # Set up calibrator on train set of current subgroup\\n calibrator = BetaCalibration(df['score'][select_train], df['same'][select_train], score_min=-1, score_max=1)\\n\\n # Use calibrator on all data\\n calibrated_score[select] = calibrator.predict(df['score'][select])\\n\\n return calibrated_score\",\n \"def update(mat) -> np.ndarray:\\n return mat\",\n \"def calibrateCameraAruco(corners, ids, counter, board, imageSize, cameraMatrix, distCoeffs, rvecs=None, tvecs=None, flags=None, criteria=None):\\n pass\",\n \"def do_calibration(x,y,z,temperature,cp, optimal_t=25):\\n # if temperature is used for calibration:\\n if temperature is not None:\\n # create an array of T - optimal_T (temperature minus the optimal temperature) i.e. the deviation in T from the optimum\\n temp_dev = np.empty(len(temperature.data))\\n for i in range(len(temperature.data)):\\n temp_dev[i] = temperature.data[i] - optimal_t\\n\\n x.data = cp[\\\"x_offset\\\"] + (temp_dev * cp[\\\"x_temp_offset\\\"]) + (x.data * cp[\\\"x_scale\\\"])\\n y.data = cp[\\\"y_offset\\\"] + (temp_dev * cp[\\\"y_temp_offset\\\"]) + (y.data * cp[\\\"y_scale\\\"])\\n z.data = cp[\\\"z_offset\\\"] + (temp_dev * cp[\\\"z_temp_offset\\\"]) + (z.data * cp[\\\"z_scale\\\"])\\n\\n x.temp_offset = cp[\\\"x_temp_offset\\\"]\\n y.temp_offset = cp[\\\"y_temp_offset\\\"]\\n z.temp_offset = cp[\\\"z_temp_offset\\\"]\\n\\n # if temperature is not used for calibration:\\n else:\\n x.data = cp[\\\"x_offset\\\"] + (x.data * cp[\\\"x_scale\\\"])\\n y.data = cp[\\\"y_offset\\\"] + (y.data * cp[\\\"y_scale\\\"])\\n z.data = cp[\\\"z_offset\\\"] + (z.data * cp[\\\"z_scale\\\"])\\n\\n x.offset = cp[\\\"x_offset\\\"]\\n x.scale = cp[\\\"x_scale\\\"]\\n x.calibrated = True\\n\\n y.offset = cp[\\\"y_offset\\\"]\\n y.scale = cp[\\\"y_scale\\\"]\\n y.calibrated = True\\n\\n z.offset = cp[\\\"z_offset\\\"]\\n z.scale = cp[\\\"z_scale\\\"]\\n z.calibrated = True\",\n \"def applyMtx(self, mtx: numpy.array) -> None:\\n ...\",\n \"def compute_camera_calib_distortion_params():\\r\\n nx = 9#number of inside corners in x\\r\\n ny = 6#number of inside corners in y\\r\\n # prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\\r\\n objp = np.zeros((ny*nx,3), np.float32)\\r\\n objp[:,:2] = np.mgrid[0:nx, 0:ny].T.reshape(-1,2)\\r\\n\\r\\n # Arrays to store object points and image points from all the images.\\r\\n objpoints = [] # 3d points in real world space\\r\\n imgpoints = [] # 2d points in image plane.\\r\\n\\r\\n # Read a particular image just to get image size (all images in the directory are same size)\\r\\n img = cv2.imread('./camera_cal/calibration3.jpg')\\r\\n img_size = (img.shape[1], img.shape[0])\\r\\n # Make a list of calibration images\\r\\n images = glob.glob('./camera_cal/calibration*.jpg')\\r\\n # Step through the list and search for chessboard corners\\r\\n for idx, fname in enumerate(images):\\r\\n img = cv2.imread(fname)\\r\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\r\\n\\r\\n # Find the chessboard corners\\r\\n ret, corners = cv2.findChessboardCorners(gray, (nx,ny), None)\\r\\n\\r\\n # If found, add object points, image points\\r\\n if ret == True:\\r\\n objpoints.append(objp)\\r\\n imgpoints.append(corners)\\r\\n # # Draw and display the corners\\r\\n # cv2.drawChessboardCorners(img, (nx,ny), corners, ret)\\r\\n # #write_name = 'corners_found'+str(idx)+'.jpg'\\r\\n # #cv2.imwrite(write_name, img)\\r\\n # cv2.imshow('img', img)\\r\\n # cv2.waitKey(500)\\r\\n\\r\\n # Do camera calibration given object points and image points\\r\\n ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, img_size,None,None)\\r\\n # Save the camera calibration result for later use (we won't worry about rvecs / tvecs)\\r\\n dist_pickle = {}\\r\\n dist_pickle[\\\"mtx\\\"] = mtx\\r\\n dist_pickle[\\\"dist\\\"] = dist\\r\\n pickle.dump( dist_pickle, open( \\\"data/cam_calib_pickle.p\\\", \\\"wb\\\" ) )\\r\\n print(\\\"Pickling done\\\")\",\n \"def _transform(self, matrix):\\n for x in list(self.keys()):\\n ar = self[x]\\n if len(ar.shape) == 2 and ar.shape[1] == 3:\\n self[x] = np.dot(matrix, ar.transpose()).transpose()\",\n \"def proj_to_velo(calib_data):\\n rect = calib_data[\\\"R0_rect\\\"].reshape(3, 3)\\n #to transform a point from Lidar framce to camera frame\\n #reshape the flat line with 12 elements to 3X4 matrix\\n velo_to_cam = calib_data[\\\"Tr_velo_to_cam\\\"].reshape(3, 4)\\n#print('velo2cam', velo_to_cam)\\n inv_rect = np.linalg.inv(rect)\\n #select all rows and only first three columns\\n#print('velo_to_cam[:, :3]', velo_to_cam[:, :3])\\n #select all rows and only first three columns\\n inv_velo_to_cam = np.linalg.pinv(velo_to_cam[:, :3])\\n return np.dot(inv_velo_to_cam, inv_rect)\",\n \"def fit_transform(self, raw_documents, y=None):\\n #self.diccionario_fti.update({indice:fti})\\n textos = raw_documents.iloc[:,0]\\n X = super().fit_transform(textos)\\n self.cal_term_fti(raw_documents)\\n\\n X2 = X.todense()\\n for indice in list(self.diccionario_fti.keys()):\\n fti = self.diccionario_fti.get(indice)\\n #print('indice {0} valor')\\n X2[:,indice]=np.transpose(np.apply_along_axis(lambda x :x * fti,0,X2[:,indice]))\\n \\n #print('matriz tras indice')\\n #print (matriz[:,indice])\\n matrizfinal = sp.csr_matrix(X2,X.shape)\\n #aqui\\n return matrizfinal\",\n \"def camera_calibration_by_aruco_board(\\n calibration_params_filename='calibration.pckl'):\\n aruco_dict = aruco.Dictionary_get(aruco.DICT_5X5_1000)\\n\\n # Creating a theoretical board we'll use to calculate marker positions\\n board = aruco.GridBoard_create(\\n markersX=5,\\n markersY=7,\\n markerLength=0.04,\\n markerSeparation=0.01,\\n dictionary=aruco_dict)\\n\\n # Read an image or a video to calibrate your camera\\n # I'm using a video and waiting until my entire gridboard is seen before\\n # calibrating. The following code assumes you have a 5X7 Aruco gridboard\\n # to calibrate with\\n cam = cv2.VideoCapture(0)\\n\\n while (cam.isOpened()):\\n # Capturing each frame of our video stream\\n ret, img = cam.read()\\n cv2.imshow('camera calibration', img)\\n # retval is non-zero in the case of successful frame reading\\n if ret == True:\\n # grayscale image\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n parameters = aruco.DetectorParameters_create()\\n\\n # Detect Aruco markers\\n corners, ids, rejectedImgPoints = aruco.detectMarkers(\\n gray, aruco_dict, parameters=parameters)\\n\\n # Make sure markers were detected before continuing\\n if (ids is not None and \\n corners is not None and \\n len(ids) > 0 and \\n len(corners) > 0 and \\n len(corners) == len(ids)):\\n # The next if makes sure we see all matrixes in our gridboard\\n if len(ids) == len(board.ids):\\n # Calibrate the camera now using cv2 method\\n ret, cameraMatrix, distCoeffs, _, _ = cv2.calibrateCamera(\\n objectPoints=board.objPoints,\\n imagePoints=corners,\\n imageSize=gray.shape,\\n cameraMatrix=None,\\n distCoeffs=None)\\n\\n # Print matrix and distortion coefficient to the console\\n print('Intrinsic calibration coefficients\\\\n', cameraMatrix)\\n print('Distortion (extrinsic) coefficients\\\\n', distCoeffs)\\n\\n # Output values to be used where matrix+dist is required\\n f = open(calibration_params_filename, 'wb')\\n pickle.dump((cameraMatrix, distCoeffs), f)\\n f.close()\\n\\n # PRint to console our success\\n print('\\\\nCalibration successful!')\\n\\n break\\n\\n # Exit at the end of the video on the EOF key\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n break\",\n \"def camera_calibration_by_aruco_board(\\n calibration_params_filename='calibration.pckl'):\\n aruco_dict = aruco.Dictionary_get(aruco.DICT_5X5_1000)\\n\\n # Creating a theoretical board we'll use to calculate marker positions\\n board = aruco.GridBoard_create(\\n markersX=5,\\n markersY=7,\\n markerLength=0.04,\\n markerSeparation=0.01,\\n dictionary=aruco_dict)\\n\\n # Read an image or a video to calibrate your camera\\n # I'm using a video and waiting until my entire gridboard is seen before\\n # calibrating. The following code assumes you have a 5X7 Aruco gridboard\\n # to calibrate with\\n cam = cv2.VideoCapture(0)\\n\\n while (cam.isOpened()):\\n # Capturing each frame of our video stream\\n ret, img = cam.read()\\n cv2.imshow('camera calibration', img)\\n # retval is non-zero in the case of successful frame reading\\n if ret == True:\\n # grayscale image\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n parameters = aruco.DetectorParameters_create()\\n\\n # Detect Aruco markers\\n corners, ids, rejectedImgPoints = aruco.detectMarkers(\\n gray, aruco_dict, parameters=parameters)\\n\\n # Make sure markers were detected before continuing\\n if (ids is not None and \\n corners is not None and \\n len(ids) > 0 and \\n len(corners) > 0 and \\n len(corners) == len(ids)):\\n # The next if makes sure we see all matrixes in our gridboard\\n if len(ids) == len(board.ids):\\n # Calibrate the camera now using cv2 method\\n ret, cameraMatrix, distCoeffs, _, _ = cv2.calibrateCamera(\\n objectPoints=board.objPoints,\\n imagePoints=corners,\\n imageSize=gray.shape,\\n cameraMatrix=None,\\n distCoeffs=None)\\n\\n # Print matrix and distortion coefficient to the console\\n print('Intrinsic calibration coefficients\\\\n', cameraMatrix)\\n print('Distortion (extrinsic) coefficients\\\\n', distCoeffs)\\n\\n # Output values to be used where matrix+dist is required\\n f = open(calibration_params_filename, 'wb')\\n pickle.dump((cameraMatrix, distCoeffs), f)\\n f.close()\\n\\n # PRint to console our success\\n print('\\\\nCalibration successful!')\\n\\n break\\n\\n # Exit at the end of the video on the EOF key\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n break\",\n \"def fit(self, x, y=None):\\n if self.method == 'svd' and x._sparse:\\n raise NotImplementedError(\\n \\\"SVD method not supported for sparse arrays.\\\")\\n\\n self.mean_ = x.mean(axis=0)\\n norm_x = x - self.mean_\\n\\n if self.method == \\\"svd\\\":\\n return self._fit_svd(norm_x)\\n else:\\n return self._fit_eig(norm_x)\",\n \"def calibration(\\n self,\\n pulse_min: int,\\n pulse_max: int,\\n pulse_centre: int,\\n pulse_angle_90: int,\\n pulse_speed_100: int,\\n /,\\n ) -> None:\",\n \"def resolves_matrix(self):\\n self.P = np.linalg.solve(self.M, self.f)\",\n \"def transform(self, data_matrix):\\n if self.selected_instances is None:\\n raise Exception('Error: attempt to use transform on non fit model')\\n if self.selected_instances.shape[0] == 0:\\n raise Exception('Error: attempt to use transform using 0 selectors')\\n # TODO: the first instance is more important than others in a selector, so it should\\n # receive a weight proportional to the rank e.g. 1/rank^p\\n # the selector should return also a rank information for each feature, note: for the\\n # composite selector it is important to distinguish the rank of multiple selectors\\n data_matrix_out = pairwise_kernels(data_matrix,\\n Y=self.selected_instances,\\n metric=self.metric,\\n **self.kwds)\\n if self.scale:\\n data_matrix_out = self.scaler.transform(data_matrix_out) * self.scaling_factor\\n return data_matrix_out\",\n \"def calibrateCamera(config,cbrow = 4,cbcol = 3,calibrate=False,alpha=0.4,manualPoints=False):\\n\\n # Termination criteria\\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)\\n # Prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)\\n objp = np.zeros((cbrow * cbcol, 3), np.float32)\\n objp[:, :2] = np.mgrid[0:cbcol, 0:cbrow].T.reshape(-1, 2)\\n \\n # Read the config file\\n cfg_3d = auxiliaryfunctions.read_config(config)\\n img_path,path_corners,path_camera_matrix,path_undistort=caf.Foldernames3Dproject(cfg_3d)\\n \\n # Make sure that the folders are present (if not, make them)\\n if not os.path.exists(img_path):\\n os.makedirs(img_path)\\n if not os.path.exists(path_corners):\\n os.makedirs(path_corners)\\n \\n # Get images and camera names\\n images = glob.glob(os.path.join(img_path,'*.jpg'))\\n cam_names = cfg_3d['camera_names']\\n \\n ## It's not clear to me why I want to do this or what this number represents... I need to read further into it\\n # # update the variable snapshot* in config file according to the name of the cameras\\n # try:\\n # for i in range(len(cam_names)):\\n # cfg_3d[str('config_file_'+cam_names[i])] = cfg_3d.pop(str('config_file_camera-'+str(i+1)))\\n # for i in range(len(cam_names)):\\n # cfg_3d[str('shuffle_'+cam_names[i])] = cfg_3d.pop(str('shuffle_camera-'+str(i+1)))\\n # except:\\n # pass\\n \\n project_path = cfg_3d['project_path']\\n projconfigfile=os.path.join(str(project_path),'config.yaml')\\n auxiliaryfunctions.write_config_3d(projconfigfile,cfg_3d)\\n\\n # Initialize the dictionary \\n img_shape = {}\\n objpoints = {} # 3d point in real world space\\n imgpoints = {} # 2d points in image plane.\\n dist_pickle = {} ## I think this is the intrinsic parameter file that needs to be read in\\n stereo_params= {}\\n for cam in cam_names:\\n objpoints.setdefault(cam, [])\\n imgpoints.setdefault(cam, [])\\n dist_pickle.setdefault(cam, [])\\n\\n # Sort the images.\\n images.sort(key=lambda f: int(''.join(filter(str.isdigit, f))))\\n if len(images)==0:\\n raise Exception(\\\"No calibration images found. Make sure the calibration images are saved as .jpg and with prefix as the camera name as specified in the config.yaml file.\\\")\\n direct_images = [img for img in images if 'direct' in img]\\n mirror_images = [img for img in images if 'mirror' in img]\\n\\n if manualPoints:\\n # This is where we read in the manually identified points and check them and stuff\\n csvFiles = glob.glob(os.path.join(img_path,'*.csv'))\\n for fname_csv in csvFiles:\\n allPoints = caf.readCSV(fname_csv)\\n for row in allPoints:\\n continue\\n # Start with mirror to figure out which BGR to use for direct\\n for fname in mirror_images:\\n \\n filename=Path(fname).stem\\n img = cv2.imread(fname)\\n\\n # Create a dictionary with all of the different image color conversions for testing\\n img_colorConv = {\\n \\\"BGR\\\":img,\\n \\\"HSV\\\":cv2.cvtColor(img,40),\\n \\\"Gray\\\":cv2.cvtColor(img,6)\\n }\\n\\n thresh = 120\\n ret = False\\n for colorConv in img_colorConv:\\n currImg = img_colorConv[colorConv]\\n size = currImg.shape\\n \\n if len(size) == 2:\\n \\n ret, corners = cv2.findChessboardCorners(currImg, (cbcol,cbrow),None,)\\n if ret == True: break\\n\\n currImg_bw = cv2.threshold(currImg,thresh,255,cv2.THRESH_BINARY)[1]\\n ret, corners = cv2.findChessboardCorners(currImg_bw, (cbcol,cbrow),None,)\\n if ret == True: break\\n else: continue\\n \\n chanIdx = 0\\n while (ret == False) and (chanIdx < size[2]):\\n ret, corners = cv2.findChessboardCorners(currImg[:,:,chanIdx], (cbcol,cbrow),None,)\\n if ret == True: break\\n channel_bw = cv2.threshold(currImg[:,:,chanIdx],thresh,255,cv2.THRESH_BINARY)[1]\\n ret, corners = cv2.findChessboardCorners(channel_bw, (cbcol,cbrow),None,)\\n chanIdx += 1\\n \\n # If found, add object points, image points (after refining them)\\n if ret == True:\\n currImg = img_colorConv[\\\"Gray\\\"]\\n img_shape[cam] = currImg.shape[::-1]\\n objpoints[cam].append(objp)\\n corners = cv2.cornerSubPix(currImg,corners,(11,11),(-1,-1),criteria)\\n imgpoints[cam].append(corners)\\n # Draw the corners and store the images\\n img = cv2.drawChessboardCorners(currImg, (cbcol,cbrow), corners,ret)\\n cv2.imwrite(os.path.join(str(path_corners),filename+'_corner.jpg'),img)\\n else:\\n print(\\\"Corners not found for the image %s\\\" %Path(fname).name)\\n \\n try:\\n h, w = img.shape[:2]\\n except:\\n raise Exception(\\\"It seems that the name of calibration images does not match with the camera names in the config file. Please make sure that the calibration images are named with camera names as specified in the config.yaml file.\\\")\\n\\n # Perform calibration for each cameras and store the matrices as a pickle file\\n if calibrate == True:\\n \\n # Read in the intrinsic parameters for each camera\\n for cam in cam_names:\\n dist_pickle[cam] = pickle.load(os.path.join(path_camera_matrix,cam+'_intrinsic_params.pickle'))\\n\\n # # Compute stereo calibration for each pair of cameras\\n # camera_pair = [[cam_names[0], cam_names[1]]]\\n # for pair in camera_pair:\\n # print(\\\"Computing stereo calibration for \\\" %pair)\\n # retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F = cv2.stereoCalibrate(objpoints[pair[0]],imgpoints[pair[0]],imgpoints[pair[1]],dist_pickle[pair[0]]['mtx'],dist_pickle[pair[0]]['dist'], dist_pickle[pair[1]]['mtx'], dist_pickle[pair[1]]['dist'],(h, w),flags = cv2.CALIB_FIX_INTRINSIC)\\n\\n # # Stereo Rectification\\n # rectify_scale = alpha # Free scaling parameter check this https://docs.opencv.org/2.4/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html#fisheye-stereorectify\\n # R1, R2, P1, P2, Q, roi1, roi2 = cv2.stereoRectify(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, (h, w), R, T, alpha = rectify_scale)\\n \\n # stereo_params[pair[0]+'-'+pair[1]] = {\\\"cameraMatrix1\\\": cameraMatrix1,\\\"cameraMatrix2\\\": cameraMatrix2,\\\"distCoeffs1\\\": distCoeffs1,\\\"distCoeffs2\\\": distCoeffs2,\\\"R\\\":R,\\\"T\\\":T,\\\"E\\\":E,\\\"F\\\":F,\\n # \\\"R1\\\":R1,\\n # \\\"R2\\\":R2,\\n # \\\"P1\\\":P1,\\n # \\\"P2\\\":P2,\\n # \\\"roi1\\\":roi1,\\n # \\\"roi2\\\":roi2,\\n # \\\"Q\\\":Q,\\n # \\\"image_shape\\\":[img_shape[pair[0]],img_shape[pair[1]]]}\\n \\n # print('Saving the stereo parameters for every pair of cameras as a pickle file in %s'%str(os.path.join(path_camera_matrix)))\\n \\n # auxiliaryfunctions.write_pickle(os.path.join(path_camera_matrix,'stereo_params.pickle'),stereo_params)\\n # print(\\\"Camera calibration done! Use the function ``check_undistortion`` to check the check the calibration\\\")\\n # else:\\n # print(\\\"Corners extracted! You may check for the extracted corners in the directory %s and remove the pair of images where the corners are incorrectly detected. If all the corners are detected correctly with right order, then re-run the same function and use the flag ``calibrate=True``, to calbrate the camera.\\\"%str(path_corners))\",\n \"def cal_dist_and_mtx(self, calibration_patterns, pattern_size, retain_calibration_patterns):\\n # prepare object points, like (0,0,0), (1,0,0), (2,0,0), ....,(8,5,0)\\n # use numpy mgrid function to generate the coordinates values for a given grid size.\\n grid_x, grid_y = pattern_size[0], pattern_size[1]\\n objp = np.zeros((grid_y * grid_x, 3), np.float32)\\n objp[:,:2] = np.mgrid[:grid_x, :grid_y].T.reshape(-1,2)\\n\\n # Arrays to store object points and image points from all the sample images.\\n objpoints = [] # 3d points in real world space\\n imgpoints = [] # 2d points in image plane.\\n \\n # Step through the list and search for chessboard corners in distorted calibration images.\\n for path in calibration_patterns:\\n img = mpimg.imread(path)\\n gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)\\n\\n # Find the chessboard's inner corners\\n found, corners = cv2.findChessboardCorners(gray, pattern_size, None)\\n\\n # If found, add object points, image points\\n if found:\\n objpoints.append(objp)\\n imgpoints.append(corners)\\n \\n # Draw and display the corners to see what was detected.\\n if retain_calibration_patterns:\\n cv2.drawChessboardCorners(img, pattern_size, corners, found)\\n self.calibration_patterns_success.append(img)\\n else:\\n if retain_calibration_patterns:\\n self.calibration_patterns_error.append(img)\\n\\n img_size = (img.shape[1], img.shape[0])\\n\\n if objpoints and imgpoints:\\n _, self.camera_matrix, self.distortion_coef, _, _ = cv2.calibrateCamera(\\n objpoints, imgpoints, img_size, None, None)\",\n \"def fit_transform(self, x):\\n self.fit(x)\\n\\n if self.method == \\\"svd\\\":\\n return self._u * self._s\\n else:\\n return self._transform_eig(x)\",\n \"def run(self, data):\\n\\t\\treduced_data = PCA(n_components=2).fit_transform(data)\\n\\n\\t\\t# Run the algorithm\\n\\t\\tself.estimator.fit_transform(reduced_data)\\n\\n\\t\\t# Save all relevent properties\\n\\t\\tself.input_data = data\\n\\t\\tself.centroids = self.estimator.cluster_centers_\\n\\t\\tself.node_positions = reduced_data\\n\\t\\tself.labels = self.estimator.labels_\\n\\n\\t\\t# Enable visualising when debugging\\n\\t\\t# self.visualize(reduced_data)\",\n \"def _init_model(self):\\n self.A_inv = np.zeros(shape=(self.numUsers, self.d, self.d))\\n self.b = np.zeros(shape=(self.numUsers, self.d))\\n self.w = np.zeros(shape=(self.numUsers, self.d))\\n for i, mat in enumerate(self.A_inv):\\n self.A_inv[i] = np.eye(self.d)\",\n \"def __init__(self, calibration_patterns, pattern_size=(9,6), retain_calibration_patterns=False):\\n self.camera_matrix = None\\n self.distortion_coef = None\\n self.calibration_patterns_success = []\\n self.calibration_patterns_error = []\\n self.cal_dist_and_mtx(calibration_patterns, pattern_size, retain_calibration_patterns)\",\n \"def fit_transform(self, X, y=None):\\n X = np.asfortranarray(X, dtype=np.float64)\\n Q = np.empty(\\n (self.n_components, X.shape[1]), dtype=np.float64, order='F')\\n U = np.empty(\\n (X.shape[0], self.n_components), dtype=np.float64, order='F')\\n w = np.empty(self.n_components, dtype=np.float64)\\n explained_variance = np.empty(self.n_components, dtype=np.float64)\\n explained_variance_ratio = np.empty(self.n_components, dtype=np.float64)\\n mean = np.empty(X.shape[1], dtype=np.float64)\\n param = parameters()\\n param.X_m = X.shape[0]\\n param.X_n = X.shape[1]\\n param.k = self.n_components\\n param.whiten = self.whiten\\n\\n lib = self._load_lib()\\n lib.pca(\\n _as_fptr(X), _as_fptr(Q), _as_fptr(w), _as_fptr(U),\\n _as_fptr(explained_variance), _as_fptr(explained_variance_ratio),\\n _as_fptr(mean), param)\\n\\n self._w = w\\n self._U, self._Q = svd_flip(U, Q) # TODO Port to cuda?\\n self._X = X\\n n = X.shape[0]\\n # To match sci-kit #TODO Port to cuda?\\n self.explained_variance = self.singular_values_**2 / (n - 1)\\n self.explained_variance_ratio = explained_variance_ratio\\n self.mean_ = mean\\n\\n # TODO noise_variance_ calculation\\n # can be done inside lib.pca if a bottleneck\\n n_samples, n_features = X.shape\\n total_var = np.var(X, ddof=1, axis=0)\\n if self.n_components_ < min(n_features, n_samples):\\n self.noise_variance_ = \\\\\\n (total_var.sum() - self.explained_variance_.sum())\\n self.noise_variance_ /= \\\\\\n min(n_features, n_samples) - self.n_components\\n else:\\n self.noise_variance_ = 0.\\n\\n X_transformed = U * w\\n return X_transformed\",\n \"def _calibrate_with_loss(self, loss, metrics, calib_dataset, eval_dataset,\\n verbose):\\n self._calibrate_without_loss(calib_dataset, calib_batch_size, calib_steps)\\n init_quantize_info = model_utils.get_quantize_info(self._qcbev_model)\\n quantize_layers = model_utils.get_quantize_layers(self._qcb_model)\\n\\n def _recompile(model):\\n \\\"\\\"\\\"Helper function to re-compile the model.\\\"\\\"\\\"\\n # Must reset metrics to get accurate results\\n for m in metrics:\\n if not isinstance(m, str):\\n m.reset_states()\\n model.compile(loss=loss, metrics=metrics)\\n\\n def _evaluate(model):\\n \\\"\\\"\\\"Helper function to evaluate model to get loss and accuracy.\\\"\\\"\\\"\\n _recompile(model)\\n if isinstance(eval_dataset, tuple):\\n eval_images, eval_labels = eval_dataset\\n return model.evaluate(\\n eval_images, eval_labels, verbose=verbose, return_dict=True)\\n else:\\n return model.evaluate(eval_dataset, verbose=verbose, return_dict=True)\\n\\n def _print_results(results, title=''):\\n \\\"\\\"\\\"Helper function to print evaluation results.\\\"\\\"\\\"\\n pstr = '[' + title + ']: ' if title else ''\\n for k, v in results.items():\\n pstr += '\\\\t{}: {}'.format(k, v)\\n print(pstr)\\n\\n # Get float results\\n model_utils.set_layer_mode(self._qcb_model, 'ANALYSE')\\n float_results = _evaluate(self._qcb_model)\\n _print_results(float_results, 'float_results')\\n\\n # Get simple quantize calibrated results\\n init_results = _evaluate(self._qcbev_model)\\n _print_results(init_results, 'init_results')\\n\\n # Do quantize pos searching\\n logger.info(\\\"Start Quantize Position Searching...\\\")\\n model_utils.set_layer_mode(self._qcb_model, 'QCBEV')\\n best_results = init_results\\n best_quantize_info = copy.deepcopy(init_quantize_info)\\n count = 0\\n for name, layer in quantize_layers.items():\\n count += 1\\n logger.info('({}/{})Processing layer: {}'.format(count,\\n len(quantize_layers),\\n name))\\n\\n def _search_optimal_pos(init_quantize_info,\\n init_results,\\n layer_name,\\n quantizer_name,\\n delta=[-1, 1, 2]):\\n new_best_results = init_results\\n new_best_quantize_info = copy.deepcopy(init_quantize_info)\\n\\n tmp_quantize_info = copy.deepcopy(init_quantize_info)\\n layer_info = tmp_quantize_info[layer_name]\\n if quantizer_name == 'NoQuantizeActivation':\\n return new_best_quantize_info, new_best_results\\n elif quantizer_name == 'input':\\n q_info = layer_info['info']\\n else:\\n q_info = layer_info[quantizer_name]['info']\\n q_pos = q_info['quant_pos_var']\\n\\n for dt in delta:\\n if verbose:\\n logger.info('Try change {}.{}: {} -> {}'.format(\\n layer_name, quantizer_name, q_pos, q_pos + dt))\\n q_info['quant_pos_var'] = q_pos + dt\\n model_utils.set_quantize_info(self._qcb_model, tmp_quantize_info)\\n q_results = _evaluate(self._qcb_model)\\n if q_results['loss'] < new_best_results['loss']:\\n new_best_results = q_results\\n new_best_quantize_info = copy.deepcopy(tmp_quantize_info)\\n _print_results(new_best_results, 'Update Best Results')\\n return new_best_quantize_info, new_best_results\\n\\n # Quantize Layer\\n if isinstance(layer, vitis_quantize_layer.VitisQuantize):\\n best_quantize_info, best_results = _search_optimal_pos(\\n init_quantize_info=best_quantize_info,\\n init_results=best_results,\\n layer_name=layer.name,\\n quantizer_name='input')\\n # Quantize Wrappers\\n elif isinstance(layer, vitis_quantize_wrapper.QuantizeWrapper):\\n layer_info = best_quantize_info[layer.layer.name]\\n for quantizer_name, q_info in layer_info.items():\\n best_quantize_info, best_results = _search_optimal_pos(\\n init_quantize_info=best_quantize_info,\\n init_results=best_results,\\n layer_name=layer.layer.name,\\n quantizer_name=quantizer_name)\\n\\n logger.info(\\\"Quantize Position Searching Done.\\\")\\n _print_results(best_results, 'Final Best Results')\\n\\n # Freeze the quantize info into the model, now using last_quantize_info\\n self._freeze_quantize_info(best_quantize_info)\",\n \"def testCalibrateImageNonConstant(self):\\n npDim, maskedImage, image, mask, variance = self.setupImage()\\n xIndex, yIndex = np.indices(npDim, dtype=np.float64)\\n # y then x, as afw order and np order are flipped\\n calibration = self.linearXCalibration.evaluate(yIndex.flatten(), xIndex.flatten()).reshape(npDim)\\n outImage = maskedImage.image.getArray()*calibration # element-wise product, not matrix product\\n expect = makeCalibratedMaskedImage(image, mask, variance, outImage, calibration, self.calibrationErr)\\n\\n photoCalib = lsst.afw.image.PhotoCalib(self.linearXCalibration, self.calibrationErr)\\n result = photoCalib.calibrateImage(maskedImage)\\n self.assertMaskedImagesAlmostEqual(expect, result)\",\n \"def calibrateCameraArucoExtended(corners, ids, counter, board, imageSize, cameraMatrix, distCoeffs, rvecs=None, tvecs=None, stdDeviationsIntrinsics=None, stdDeviationsExtrinsics=None, perViewErrors=None, flags=None, criteria=None):\\n pass\",\n \"def fit_transform(self, X):\\n self._method_calling = 2\\n self.fit(X)\\n\\n # Transform - calculate kernel matrix\\n # Output is always normalized\\n return self._calculate_kernel_matrix()\",\n \"def fit(self,X,y):\\n\\n d = X.shape[1]\\n # 1. sketch the data\\n self.B,a = self._sketch(X,method=self.fd_mode)\\n #H = B.T@B + (self.alpha+a)*np.eye(d)\\n #self.H = H\\n self.H_inv = self._get_inv() #np.linalg.pinv(H)\\n self.coef_ = self.H_inv@(X.T@y) #np.linalg.solve(H, X.T@y)\\n self.is_fitted = True\",\n \"def fit_data(self, data):\\n delta_b, delta_q = self._fit_matrix\\n return _slowadc_formula(data, delta_b, delta_q)\",\n \"def generateMatrix():\\n num_probes = 16\\n\\n # print(position_vectors)\\n # Create the (48x4) calibration matrix:\\n calibration_lookup= [[0] * 3 for i in range(num_probes)]\\n calibration_matrix = [[0] * 9 for i in range(num_probes)]\\n counter = 0\\n\\n # first populate with x-direction:\\n shot_range = [17, 20] #x-direction\\n dir = 0 #the direction of the orentation of the probe array\\n position_vectors = get_probeLocs_calib_setup(dir)\\n for probe_num in range(num_probes):\\n position_vector = position_vectors[probe_num]\\n ratio_Bx, ratio_By, ratio_Bz, norm_factor= getRatio(probe_num, position_vector, shot_range, dir)\\n calibration_lookup[probe_num][dir] = ratio_Bx\\n calibration_matrix[probe_num][(dir*3):(dir*3+1)] = [ratio_Bx, ratio_By, ratio_Bz]\\n print(\\\"Progress: %d / %d\\\" %(counter+1,num_probes*3 ))\\n counter +=1\\n\\n # Then populate with y-direction:\\n shot_range = [21, 25] #y-direction\\n dir = 1 #the direction of the orentation of the probe array\\n position_vectors = get_probeLocs_calib_setup(dir)\\n for probe_num in range(num_probes):\\n position_vector = position_vectors[probe_num]\\n ratio_Bx, ratio_By, ratio_Bz, norm_factor= getRatio(probe_num, position_vector, shot_range, dir)\\n calibration_lookup[probe_num][dir] = ratio_By\\n calibration_matrix[probe_num][(dir*3):(dir*3+1)] = [ratio_Bx, ratio_By, ratio_Bz]\\n print(\\\"Progress: %d / %d\\\" %(counter+1,num_probes*3 ))\\n counter +=1\\n\\n # Then populate with z-direction:\\n shot_range = [11, 15] #z-direction\\n dir = 2\\n position_vectors = get_probeLocs_calib_setup(dir)\\n for probe_num in range(num_probes):\\n position_vector = position_vectors[probe_num]\\n ratio_Bx, ratio_By, ratio_Bz, norm_factor= getRatio(probe_num, position_vector, shot_range, dir)\\n calibration_lookup[probe_num][dir] = ratio_Bz\\n calibration_matrix[probe_num][(dir*3):(dir*3+1)] = [ratio_Bx, ratio_By, ratio_Bz]\\n print(\\\"Progress: %d / %d\\\" %(counter+1,num_probes*3 ))\\n counter +=1\\n\\n pth = os.getcwd()\\n date = '050119'\\n print(\\\"Finished! File saved as calib-%s-4x4_lookup.txt and _3x3 in current working directory\\\" %(date))\\n savetxt(os.path.join(pth, 'calib-%s-4x4_lookup_no_switch.txt' % (date)) , calibration_lookup)\\n savetxt(os.path.join(pth, 'calib-%s-4x4_3x3_no_switch.txt' % (date)) , calibration_matrix)\",\n \"def adjusted_matrix(self):\\n mat = AlignerExtract().transform_matrix(self.aligned[\\\"matrix\\\"],\\n self.aligned[\\\"size\\\"],\\n self.aligned[\\\"padding\\\"])\\n return mat\",\n \"def run_calib(projector=OPTOMA_HD33()):\\n w, h = (0.2160, 0.2794)\\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\\n [-w/2, 0, 0], [w/2, 0, 0],\\n [-w/2, 0, h/2], [w/2, 0, h/2]])\\n\\n global img_points, going\\n img_points = []\\n\\n try:\\n window = Window()\\n window.MoveXY(1600,0)\\n window.ShowFullScreen(True)\\n going = True\\n\\n @window.eventx\\n def EVT_MOUSE_EVENTS(evt):\\n global going, img_points\\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\\n img_points.append(evt.Position)\\n print('Picked point %d of 6' % (len(img_points)))\\n if len(img_points) == len(obj_points):\\n print \\\"Done\\\"\\n going = False\\n\\n print(\\\"\\\"\\\"[Extrinsic Calibration] \\n\\nThere should be 6 points marked on the table and backdrop. \\nMoving the mouse over the projected display, click each of the points\\nin order:\\n (left top, on the backdrop),\\n (right top, on the backdrop),\\n (left center, on the crease),\\n (right center, on the crease),\\n (left bottom, on the table),\\n (right bottom, on the table)\\n\\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\\n\\nClick the six points:\\n\\\"\\\"\\\")\\n\\n while going: cv.WaitKey(10)\\n\\n finally:\\n window.Close()\\n\\n img_points = np.array(img_points, 'f')\\n projector.calibrate_extrinsic(img_points, obj_points)\\n\\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\\n print('OK')\",\n \"def calibrate_df(\\n self,\\n df: pd.DataFrame,\\n acc_unit: Optional[str],\\n gyr_unit: Optional[str],\\n acc_cols: Iterable[str] = (\\\"acc_x\\\", \\\"acc_y\\\", \\\"acc_z\\\"),\\n gyr_cols: Iterable[str] = (\\\"gyr_x\\\", \\\"gyr_y\\\", \\\"gyr_z\\\"),\\n ) -> pd.DataFrame:\\n acc_cols = list(acc_cols)\\n gyr_cols = list(gyr_cols)\\n acc = df[acc_cols].to_numpy()\\n gyr = df[gyr_cols].to_numpy()\\n cal_acc, cal_gyr = self.calibrate(acc=acc, gyr=gyr, acc_unit=acc_unit, gyr_unit=gyr_unit)\\n\\n cal_df = df.copy()\\n cal_df[acc_cols] = cal_acc\\n cal_df[gyr_cols] = cal_gyr\\n\\n return cal_df\",\n \"def get_calib_data(self):\\n\\n accel_offset_read = self.con.receive(registers.ACCEL_OFFSET_X_LSB_ADDR, 6)\\n accel_offset_read_x = (accel_offset_read[1] << 8) | accel_offset_read[\\n 0] # Combine MSB and LSB registers into one decimal\\n accel_offset_read_y = (accel_offset_read[3] << 8) | accel_offset_read[\\n 2] # Combine MSB and LSB registers into one decimal\\n accel_offset_read_z = (accel_offset_read[5] << 8) | accel_offset_read[\\n 4] # Combine MSB and LSB registers into one decimal\\n\\n accel_radius_read = self.con.receive(registers.ACCEL_RADIUS_LSB_ADDR, 2)\\n accel_radius_read_value = (accel_radius_read[1] << 8) | accel_radius_read[0]\\n\\n mag_offset_read = self.con.receive(registers.MAG_OFFSET_X_LSB_ADDR, 6)\\n mag_offset_read_x = (mag_offset_read[1] << 8) | mag_offset_read[\\n 0] # Combine MSB and LSB registers into one decimal\\n mag_offset_read_y = (mag_offset_read[3] << 8) | mag_offset_read[\\n 2] # Combine MSB and LSB registers into one decimal\\n mag_offset_read_z = (mag_offset_read[5] << 8) | mag_offset_read[\\n 4] # Combine MSB and LSB registers into one decimal\\n\\n mag_radius_read = self.con.receive(registers.MAG_RADIUS_LSB_ADDR, 2)\\n mag_radius_read_value = (mag_radius_read[1] << 8) | mag_radius_read[0]\\n\\n gyro_offset_read = self.con.receive(registers.GYRO_OFFSET_X_LSB_ADDR, 6)\\n gyro_offset_read_x = (gyro_offset_read[1] << 8) | gyro_offset_read[\\n 0] # Combine MSB and LSB registers into one decimal\\n gyro_offset_read_y = (gyro_offset_read[3] << 8) | gyro_offset_read[\\n 2] # Combine MSB and LSB registers into one decimal\\n gyro_offset_read_z = (gyro_offset_read[5] << 8) | gyro_offset_read[\\n 4] # Combine MSB and LSB registers into one decimal\\n\\n calib_data = {'accel_offset': {'x': accel_offset_read_x, 'y': accel_offset_read_y, 'z': accel_offset_read_z}, 'accel_radius': accel_radius_read_value,\\n 'mag_offset': {'x': mag_offset_read_x, 'y': mag_offset_read_y, 'z': mag_offset_read_z}, 'mag_radius': mag_radius_read_value,\\n 'gyro_offset': {'x': gyro_offset_read_x, 'y': gyro_offset_read_y, 'z': gyro_offset_read_z}}\\n\\n return calib_data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69434965","0.62040365","0.6035492","0.5958941","0.59398246","0.5786696","0.574981","0.57194704","0.55841017","0.5576397","0.55610746","0.5532381","0.5509009","0.5477683","0.5476905","0.54610693","0.5456806","0.5437726","0.5427076","0.5380523","0.5365716","0.5352096","0.534054","0.5323771","0.53008634","0.5292798","0.5290685","0.5273212","0.5272368","0.5260557","0.524219","0.52193886","0.52109563","0.520819","0.5202929","0.51907074","0.51894116","0.5187027","0.51745945","0.51668483","0.5166769","0.51652455","0.51590765","0.5145384","0.5123329","0.51185817","0.51039785","0.51002437","0.5093637","0.50756127","0.5071473","0.50353825","0.5031264","0.5025436","0.5024995","0.50187033","0.5014801","0.5007523","0.49838704","0.49812713","0.49728134","0.49708635","0.49693233","0.4963835","0.49611294","0.4956725","0.49464366","0.49458078","0.49366683","0.49326757","0.49280468","0.49214536","0.4892133","0.48916918","0.48915952","0.48717922","0.48707673","0.48707673","0.48684335","0.48681402","0.486642","0.48595127","0.4845485","0.48370123","0.4833647","0.48277792","0.48275793","0.4827446","0.48251522","0.48230937","0.48146152","0.48144194","0.48138478","0.48112923","0.48044974","0.4789157","0.47883916","0.47730467","0.47714597","0.47676077"],"string":"[\n \"0.69434965\",\n \"0.62040365\",\n \"0.6035492\",\n \"0.5958941\",\n \"0.59398246\",\n \"0.5786696\",\n \"0.574981\",\n \"0.57194704\",\n \"0.55841017\",\n \"0.5576397\",\n \"0.55610746\",\n \"0.5532381\",\n \"0.5509009\",\n \"0.5477683\",\n \"0.5476905\",\n \"0.54610693\",\n \"0.5456806\",\n \"0.5437726\",\n \"0.5427076\",\n \"0.5380523\",\n \"0.5365716\",\n \"0.5352096\",\n \"0.534054\",\n \"0.5323771\",\n \"0.53008634\",\n \"0.5292798\",\n \"0.5290685\",\n \"0.5273212\",\n \"0.5272368\",\n \"0.5260557\",\n \"0.524219\",\n \"0.52193886\",\n \"0.52109563\",\n \"0.520819\",\n \"0.5202929\",\n \"0.51907074\",\n \"0.51894116\",\n \"0.5187027\",\n \"0.51745945\",\n \"0.51668483\",\n \"0.5166769\",\n \"0.51652455\",\n \"0.51590765\",\n \"0.5145384\",\n \"0.5123329\",\n \"0.51185817\",\n \"0.51039785\",\n \"0.51002437\",\n \"0.5093637\",\n \"0.50756127\",\n \"0.5071473\",\n \"0.50353825\",\n \"0.5031264\",\n \"0.5025436\",\n \"0.5024995\",\n \"0.50187033\",\n \"0.5014801\",\n \"0.5007523\",\n \"0.49838704\",\n \"0.49812713\",\n \"0.49728134\",\n \"0.49708635\",\n \"0.49693233\",\n \"0.4963835\",\n \"0.49611294\",\n \"0.4956725\",\n \"0.49464366\",\n \"0.49458078\",\n \"0.49366683\",\n \"0.49326757\",\n \"0.49280468\",\n \"0.49214536\",\n \"0.4892133\",\n \"0.48916918\",\n \"0.48915952\",\n \"0.48717922\",\n \"0.48707673\",\n \"0.48707673\",\n \"0.48684335\",\n \"0.48681402\",\n \"0.486642\",\n \"0.48595127\",\n \"0.4845485\",\n \"0.48370123\",\n \"0.4833647\",\n \"0.48277792\",\n \"0.48275793\",\n \"0.4827446\",\n \"0.48251522\",\n \"0.48230937\",\n \"0.48146152\",\n \"0.48144194\",\n \"0.48138478\",\n \"0.48112923\",\n \"0.48044974\",\n \"0.4789157\",\n \"0.47883916\",\n \"0.47730467\",\n \"0.47714597\",\n \"0.47676077\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72663486"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84597,"cells":{"query":{"kind":"string","value":"update the signal processing parameters."},"document":{"kind":"string","value":"def update_signal_processing_parameters(self, **kwargs):\n for key, value in kwargs.items():\n if key in self.__dict__:\n self.__dict__[key] = value"},"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 update_parameters(self):\n # We update gamma, gamma0, lambda and nu in turn (Bottolo et al, 2011)\n self.update_gamma()\n self.update_gamma0()\n self.update_lambda()\n self.update_nu()\n if self.sample_xi:\n self.update_xi()","def updateSignals(self):\n self.parser.read(self.file)\n self.signalType = self.parser.get('Signals', 'signalType')\n if self.signalType == 'single':\n self.single = self.parser.get('Signals', 'single')\n elif self.signalType == 'dual':\n self.fast = self.parser.getint('Signals', 'fast')\n self.slow = self.parser.getint('Signals', 'slow')\n elif self.signalType == 'ribbon':\n self.ribbonStart = self.parser.get('Signals', 'ribbonStart')\n self.numRibbon = self.parser.get('Signals', 'numRibbon')\n self.ribbonSpacing = self.parser.get('Signals', 'ribbonSpacing')","def _update_parameter(self, dWxh, dbh, dWhy, dby):\n # Add code to update all the weights and biases here","def update_parameters(self):\n self.alignment_factor = rospy.get_param('/dyn_reconf/alignment_factor')\n self.cohesion_factor = rospy.get_param('/dyn_reconf/cohesion_factor')\n self.separation_factor = rospy.get_param('/dyn_reconf/separation_factor')\n self.avoid_factor = rospy.get_param('/dyn_reconf/avoid_factor')\n self.max_speed = rospy.get_param('/dyn_reconf/max_speed')\n self.max_force = rospy.get_param('/dyn_reconf/max_force')\n self.friction = rospy.get_param('/dyn_reconf/friction')\n self.crowd_radius = rospy.get_param('/dyn_reconf/crowd_radius')\n self.search_radius = rospy.get_param('/dyn_reconf/search_radius')\n\n rospy.loginfo(rospy.get_caller_id() + \" -> Parameters updated\")\n if DEBUG:\n print('alignment_factor: ', self.alignment_factor)\n print('cohesion_factor: ', self.cohesion_factor)\n print('separation_factor: ', self.separation_factor)\n print('avoid_factor: ', self.avoid_factor)\n print('max_speed: ', self.max_speed)\n print('max_force: ', self.max_force)\n print('friction: ', self.friction)\n print('crowd_radius: ', self.crowd_radius)\n print('search_radius: ', self.search_radius)","def update_filter_params(self, fh):\n (self.data_timestamp, self.framerate,\n self.l, self.d, self.gamma,\n self.eps, self.alex, self.traceswitch) = (fh.attrs['data_timestamp'], fh.attrs['framerate'],\n fh.attrs['l'], fh.attrs['d'], fh.attrs['gamma'],\n fh.attrs['eps'], fh.attrs['alex'], fh.attrs['traceswitch'])","def apply_parameters(self):\n n_bins = int(self.record_length / self.bin_width)\n time_bins = self.bin_width * np.arange(n_bins)\n \n\n self.tau = np.arange(self.tau_start, self.tau_end+self.tau_delta, self.tau_delta)\n sequence = self.generate_sequence()\n self.n_laser = find_laser_pulses(sequence)\n \n FC.Configure(self.record_length, self.bin_width, self.n_laser)\n\n if self.keep_data and sequence == self.sequence and np.all(time_bins == self.time_bins): # if the sequence and time_bins are the same as previous, keep existing data\n self.old_count_data = self.count_data.copy()\n else:\n self.old_count_data = np.zeros_like(FC.GetData())\n \n self.sequence = sequence\n self.time_bins = time_bins\n self.n_bins = n_bins\n \n self.MW_source = {'mw':mw, 'mw2':mw2}[self.mw_source]","def update(self, parameters):\n self.set_frequencies(parameters) # f_i\n self.set_coupling_weights(parameters) # w_ij\n self.set_phase_bias(parameters) # theta_i\n self.set_amplitudes_rate(parameters) # a_i\n self.set_nominal_amplitudes(parameters) # R_i","def update_params(self):\n pass","def _update_params(self):\n with self.sphere.sphere_lock:\n self._args_to_params(self.sphere.bai_1d_args, self.bai_1d_pars)\n self._args_to_params(self.sphere.bai_2d_args, self.bai_2d_pars)\n #self._args_to_params(self.sphere.mg_args, self.mg_pars)","def _update_params(self):\n _load = not self.san_interface.runmode\n params={}\n if ('iosched' in self._updatedattr or _load) and self.iosched<>IoSchedType.default:\n params['iosched']=str(self.iosched)\n if ('readahead' in self._updatedattr or _load) and self.readahead :\n params['readahead']=self.readahead\n if params:\n for pt in self.paths():\n pt.provider.set_dev_params(pt,params)","def __signal_settings_handler__(self, settings, debug):\n # Establish debug parameters...\n func_name = \"__signal_settings_handler__\";\n \n # Set up configurable parameters\n settings_delimiter = \";\"\n fields_delimiter = \"=\"\n \n \n if debug: print(\" -- DEBUG (%s) Incoming 'setting' string: %s\" %( func_name, settings ) )\n \n # Split line at delimiters\n line_split = settings.split(settings_delimiter)\n \n for item in line_split:\n # Remove all spaces\n item = item.replace(\" \", \"\"); \n if debug: print(\" -- DEBUG (%s) Item: %s\" %( func_name, item ) )\n \n # Split the field identifier and its value. \n field_identifier = item.split(fields_delimiter) \n if ( debug and len(field_identifier) is not 1 ): print(\" -- DEBUG (%s) Field: %s, Value: %s\" %( func_name, field_identifier[0], field_identifier[1] ) )\n \n \"\"\" Objective: Call processing function. \n \n - Check if the field is supported.\n - If so, call the respective process function. \n \"\"\"\n if field_identifier[0] in self.__process_field_opts__:\n self.__process_field_opts__[field_identifier[0]](self, field_identifier[1], debug)\n \n # TODO: All fields should be checked here....\n \n # ERROR If FT (tramission frequency) and FS (sampling frequency) are not provided.\n if self.FT is None:\n sys.exit(\"ERROR: The transmission frequncy (ft) was not defined. Please added necessary information to 'settings' for signal construction...\")\n\n\n # if FS not provided, base the interval on FT and cycles\n if self.FS is None: \n print(\"WARNING: No sampling frequency provided. \\n Will provide default values for plotting...\")\n if self.N is not (signal.default_samples_per_cycle * self.M):\n print(\"WARNING: Changing number of samples from %d to %d\" %(self.N, (signal.default_samples_per_cycle * self.M)))\n self.N = (signal.default_samples_per_cycle * self.M)\n self.nTs = np.linspace(start = 0, stop = self.M * (1/self.FT), num = self.N )\n self.FS = self.nTs[1] - self.nTs[0]\n print(\"WARNING: Setting sampling frequency to: %f\" %self.FS)\n self._signal = self.nTs\n else: \n self.nTs = np.linspace(0, (float(1)/self.FS)*self.N, self.N) \n self._signal = self.nTs","def update_parameters(self, timestamp, inputs):\n pass","def _update_params(self):\n pass","def update_params(self):\n \n # read parameters from context broker\n for attr in ['Kp', 'Ti', 'Td', 'lim_low', 'lim_high', 'setpoint']:\n self.params[attr] = float(self.ORION_CB.get_entity_attribute_value(entity_name=self.params['name'], attribute_name=attr))\n self.params['reverse_act'] = str(self.ORION_CB.get_entity_attribute_value(entity_name=self.params['name'], attribute_name='reverse_act')) \n \n # update PID parameters\n self.PID.Kp = self.params['Kp']\n self.PID.Ti = self.params['Ti']\n self.PID.Td = self.params['Td']\n self.PID.lim_low = self.params['lim_low']\n self.PID.lim_high = self.params['lim_high']\n self.PID.reverse_act = eval(eval(self.params['reverse_act']))","def update_values(self, to_update):\n for key, value in kwargs.iteritems():\n self.params[key] = value\n # update the possibly dependent parameters\n self.set_filenames()","def _update(self):\n self.all_params = {}\n self._update_experiment_params()\n self._update_preprocessing_params()\n self._update_model_params()","def updateParameters(self):\n\n return","def update_params(self):\n for layer in range(self.num_layers):\n for direction in range(self.num_directions):\n for param_name in self._get_param_names(direction, layer):\n param = getattr(self.module_to_quantize, param_name)\n param.data = getattr(self, param_name).data\n\n _logger.debug('Updated params for QcQuantizeRNN')","def updateParameters(self, parameters):","def updateData(self, *args):\n # if self.move_next_option == \"R\":\n # self.restSampling()\n # elif self.move_next_option == \"A\":\n # self.addExtra()\n # else:\n # self.continueReview()\n for name, value in self.parameter_inputs.items():\n self.parameters[name] = value.value\n # directly change the value of class variables\n logMsg((\"update settings: \", self.ml_classifier_cls, name, value.value))\n setattr(self.ml_classifier_cls, name, value.value)\n\n pass","def _update_params(self):\n raise NotImplementedException()","def update_total_fpsig_dict(self):\n for curr_CD in self.total_inputsr_dict.keys():\n self.total_fpsig_dict[curr_CD] = 0.0\n for c in self.source_connection_list:\n if(c.conn_type =='ShortRange'):\n self.total_fpsig_dict[c.connection_distribution] += (c.curr_firing_rate) * (c.weights**2) * c.nsyn\n\n # summation\n self.total_fp_sigv = 0.0\n for key,val in self.total_fpsig_dict.items():\n try:\n self.total_fp_sigv += val\n except:\n key.initialize()\n self.total_fp_sigv += val\n self.total_fp_sigv = self.total_fp_sigv * self.tau_m","def _set_params(self,x):\r\n self.k._set_params(x)","def _parameters_changed_notification(self, me, which=None):\n self._optimizer_copy_transformed = False # tells the optimizer array to update on next request\n self.parameters_changed()","def _update(self, var, channels, value):\n\n if type(channels) is int:\n channels = [channels]\n\n if var =='frequency':\n for channel in channels:\n self.frequencies[channel] = value\n elif var =='phase':\n for channel in channels:\n self.phases[channel] = value\n elif var == 'amplitude':\n for channel in channels:\n self.amplitudes[channel] = value","def pre_update(self, **values):\r\n pass","def _update_feedback(self):\n #First read in the current voltage (power)\n #Read in numReadsPerCycle signals (arb) to average\n #TODO: allow user to select reads per signal\n currSignal = self._ai_client.get_ai_voltage(self._ai_channel, self.numReadsPerCycle, max_range=self.max_input_voltage)\n\n #Add new data to the pid\n self.pid.set_pv(np.atleast_1d(np.mean(currSignal)))\n\n #Now compute the new control value and update the AO\n self.pid.set_cv()\n self._curr_output_voltage = self._curr_output_voltage + self.pid.cv\n if self._curr_output_voltage < self.min_voltage:\n self._curr_output_voltage = self.min_voltage\n elif self._curr_output_voltage > self.max_voltage:\n self._curr_output_voltage = self.max_voltage\n\n\n #Finally updating the analog output\n\n #Do a final check to make sure that if you are in hardware control mode that the voltage control is still HIGH\n #This is to avoid the potential error if the voltage control is toggled low between the last call of _check_hardware_control\n #and update_feedback, whcih would mean that currSignal would be 0 (assuming a pulsed experiment), and causing a garbage\n #feedback which could be an issue in the next pulse.\n if (~self._under_hardware_control or self.ai_client.get_ai_voltage(self._hwc_ai_channel)[-1] > self._hwc_thresh):\n self._ao_client.set_ao_voltage(self._ao_channel, self._curr_output_voltage)","def update_params(self, learning_rate):\n\t\t#######################################################################\n\t\t# ** START OF YOUR CODE **\n\t\t#######################################################################\n\t\tself._W = self._W - learning_rate * self._grad_W_current\n\t\tself._b = self._b - learning_rate * self._grad_b_current\n\t\t#######################################################################\n\t\t# ** END OF YOUR CODE **\n\t\t#######################################################################","def updateVariables(self) -> None:\n ...","def updatedata(self, force_update=False):\n\n self._update_counter = self._update_counter + 1\n logging.debug('ParameterViewer: update values')\n for instrument_name in self._instrumentnames:\n instr = self._instruments[self._instrumentnames.index(instrument_name)]\n parameters = {}\n\n try:\n parameters = instr.parameters\n except AttributeError as ex:\n # instrument was removed\n print('instrument was removed, stopping ParameterViewer')\n # logging.exception(ex)\n self._timer.stop()\n\n parameter_names = sorted(parameters.keys())\n\n si = sys.getswitchinterval()\n\n for parameter_name in parameter_names:\n # hack to make this semi thread-safe\n\n for field_name in self._fields:\n if field_name == 'Value':\n sys.setswitchinterval(100)\n value = parameters[parameter_name].get_latest()\n sys.setswitchinterval(si)\n self.update_field_signal.emit(instrument_name, parameter_name, field_name, value, force_update)\n else:\n if self._update_counter % 20 == 1 or 1:\n sys.setswitchinterval(100)\n value = getattr(parameters[parameter_name], field_name, '')\n sys.setswitchinterval(si)\n self.update_field_signal.emit(instrument_name, parameter_name,\n field_name, value, force_update)\n\n for callback_function in self.callbacklist:\n try:\n callback_function()\n except Exception as ex:\n logging.debug('update function failed')\n logging.exception(str(ex))","def updateInterface(self):\n p = self.cxn[self.selectedADR].packet()\n p.magnetv().pscurrent().psvoltage()\n p.time()\n p.temperatures()\n p.get_state_var('CompressorStatus')\n p.get_instrument_state()\n state = yield p.send()\n # change instrument statuses\n for name,status in state['get_instrument_state']:\n if status[0] == False: color = 'red3'\n elif status[1] == False: color = 'orange3'\n elif status[1] == True: color = 'green3'\n else: color = 'gray70'\n self.instrumentStatuses[name].config(bg=color)\n # change compressor button\n if state['get_state_var'] == True:\n self.compressorButton.configure(text='Stop Compressor',\n command=self.stopCompressor,\n state=Tkinter.NORMAL)\n elif state['get_state_var'] == False:\n self.compressorButton.configure(text='Start Compressor',\n command=self.startCompressor,\n state=Tkinter.NORMAL)\n else: self.compressorButton.configure(state=Tkinter.DISABLED)\n # update current, voltage fields\n temps = {}\n stages = ('T_60K','T_3K','T_GGG','T_FAA')\n for i in range(len(stages)):\n temps[stages[i]] = state['temperatures'][i]\n #if temps[stages[i]] == 'nan': temps[stages[i]] = numpy.nan\n if numpy.isnan(state['magnetv']['V']):\n emf = 'ERR'\n else:\n emf = \"{0:.3f}\".format(state['magnetv']['V'])\n if numpy.isnan(state['pscurrent']['A']):\n psI = 'PS OFF'\n else:\n psI = \"{0:.3f}\".format(state['pscurrent']['A'])\n if numpy.isnan(state['psvoltage']['V']):\n psV = 'PS OFF'\n else:\n psV = \"{0:.3f}\".format(state['psvoltage']['V'])\n self.currentBackEMF.set( emf )\n self.currentI.set( psI )\n self.currentV.set( psV )\n # update plot:\n # change data to plot\n self.stage60K.set_xdata(numpy.append(self.stage60K.get_xdata(),mpl.dates.date2num(state['time'])))\n self.stage60K.set_ydata(numpy.append(self.stage60K.get_ydata(),temps['T_60K']['K']))\n self.stage03K.set_xdata(numpy.append(self.stage03K.get_xdata(),mpl.dates.date2num(state['time'])))\n self.stage03K.set_ydata(numpy.append(self.stage03K.get_ydata(),temps['T_3K']['K']))\n self.stageGGG.set_xdata(numpy.append(self.stageGGG.get_xdata(),mpl.dates.date2num(state['time'])))\n self.stageGGG.set_ydata(numpy.append(self.stageGGG.get_ydata(),temps['T_GGG']['K']))\n self.stageFAA.set_xdata(numpy.append(self.stageFAA.get_xdata(),mpl.dates.date2num(state['time'])))\n self.stageFAA.set_ydata(numpy.append(self.stageFAA.get_ydata(),temps['T_FAA']['K']))\n #update plot\n self.updatePlot()\n # update legend\n labelOrder = ['T_60K','T_3K','T_GGG','T_FAA']\n lines = [self.stage60K,self.stage03K,self.stageGGG,self.stageFAA]\n labels = [l.strip('T_')+' ['+\"{0:.3f}\".format(temps[l]['K'])+'K]' for l in labelOrder]\n labels = [s.replace('1.#QOK','OoR') for s in labels]\n # legend on top (if not using this, delete \\n in title)\n self.ax.legend(lines,labels,bbox_to_anchor=(0., 1.02, 1., .102), loc=3,\n ncol=4, mode=\"expand\", borderaxespad=0.)","def update_parameters(self,like_params):\n\n # get current dictionary with parameters, update and setup again\n params=self.get_params()\n\n for par in like_params:\n if par.name in params:\n params[par.name]=par.value\n\n self._setup_from_parameters(params)\n return","def _update_parameters(self, curr_state, reward, next_state):\n phi = self._features.vector(curr_state)\n phi_dash = self._features.vector(next_state)\n\n self._A += np.outer(phi, (phi - self._gamma * phi_dash))\n self._b += reward * phi","def updateParameters(self, parameters):\r\n return","def updateParameters(self, parameters):\r\n return","def updateParameters(self, parameters):\r\n return","def updateParameters(self, parameters):\r\n return","def updateParameters(self, parameters):\r\n return","def updateParameters(self, parameters):\r\n return","def updateParameters(self, parameters):\r\n return","def updateParameters(self, parameters):\r\n return","def parameters_changed(self):\n pass","def update(self):\n\n self.pta_time[0] = 1 + Globals.clock.get_frame_time() * self.options.time_scale\n\n Globals.base.graphicsEngine.dispatch_compute(\n (self.options.size // 16, self.options.size // 16, 1),\n self.attr_update,\n Globals.base.win.get_gsg())\n\n self.fftX.execute()\n self.fftY.execute()\n self.fftZ.execute()\n\n # Execute the shader which combines the 3 displacement maps into\n # 1 displacement texture and 1 normal texture. We could use dFdx in\n # the fragment shader, however that gives no accurate results as\n # dFdx returns the same value for a 2x2 pixel block\n Globals.base.graphicsEngine.dispatch_compute(\n (self.options.size // 16, self.options.size // 16, 1),\n self.attr_combine,\n Globals.base.win.get_gsg())","def update(self, rxn_probs):\n pass","def setup(self):\n super().setup()\n self.ctx.restart_calc = None\n self.ctx.inputs = AttributeDict(self.exposed_inputs(XspectraCalculation, 'xspectra'))\n\n self.ctx.inputs.parameters = self.ctx.inputs.parameters.get_dict()","def updateParameters(self, parameters):\r\n #return\r\n parameters[2].enabled = 0\r\n parameters[3].enabled = 0\r\n parameters[4].enabled = 0","def updateParameters(self, parameters):\r\n #return\r\n parameters[2].enabled = 0\r\n parameters[3].enabled = 0\r\n parameters[4].enabled = 0","def _UpdateProcessingStatus(self, pid, process_status, used_memory):","def update_signal(self, event):\n if event.type == 'SIGNAL':\n order_event = self.generate_naive_order(event)\n self.events.put(order_event)","def update_signal(self, event):\n if event.type == 'SIGNAL':\n order_event = self.generate_naive_order(event)\n self.events.put(order_event)","def update_signal(self, event):\n if event.type == 'SIGNAL':\n order_event = self.generate_naive_order(event)\n self.events.put(order_event)","def update(self,update_flags):\n pass","def signalSetup(self):\n self.ui.b_info.clicked.connect(self.showInfo)\n self.ui.b_save.clicked.connect(self.openSave)\n self.ui.b_vid.clicked.connect(self.openVideo)\n self.ui.b_run.clicked.connect(self.startRun)\n self.ui.b_colour.clicked.connect(self.pickColour)\n self.ui.b_ground_truth.clicked.connect(self.openGroundTruth)\n\n self.ui.t_fps.textChanged.connect(self.changeFps)\n self.ui.t_low.editingFinished.connect(self.changeLow)\n self.ui.t_high.editingFinished.connect(self.changeHigh)\n self.ui.c_error_plot.stateChanged.connect(self.checkFiles)\n self.ui.c_speed_plot.stateChanged.connect(self.checkFiles)\n self.ui.c_crash_plot.stateChanged.connect(self.checkFiles)\n self.ui.combo_superpixel.currentIndexChanged.connect(\n self.changeSuperPixelMethod\n )\n self.ui.c_optimize.stateChanged.connect(self.checkFiles)\n self.ui.c_draw.stateChanged.connect(self.checkFiles)\n self.ui.c_velocity.stateChanged.connect(self.checkFiles)\n self.ui.c_object_detection.stateChanged.connect(self.checkFiles)","def update_synths(self, x, instrument):\n active_update = instrument.app.config().active_updates_enabled()\n for pm in self._maps.values():\n value = pm.map_value(x)\n param = pm.parameter\n instrument.x_param_change(param, value)\n if active_update: # and not self._transient:\n sed = instrument.synth_editor\n if sed:\n sed.set_aspect(param, value)","def _update_params(self, new_params):\n # update all the parameters\n for old_param, new_param in zip(self.model.parameters(), new_params):\n old_param.data += torch.from_numpy(new_param).to(old_param.device)","def _parse_args_consistent_with_mfd(self):\n super()._parse_args_consistent_with_mfd()\n\n # FIXME: There should be a smoother way to translate keys\n lal_required_signal_parameters = self.translate_keys_to_lal(\n dict(\n zip(\n self.required_signal_parameters,\n [0] * len(self.required_signal_parameters),\n )\n )\n )\n\n if any(\n key not in lal_required_signal_parameters for key in self.signal_parameters\n ):\n logger.warning(\n \"Injection of line artifacts only uses the following parameters:\\n\"\n f\"{self.required_signal_parameters}.\\n\"\n \"Any other parameter will be purged from this class now\"\n )\n params_to_purge = list(\n set(self.signal_parameters) - set(lal_required_signal_parameters)\n )\n logger.info(\n \"Purging input parameters that are not meaningful for LineWriter: {}\".format(\n params_to_purge\n )\n )\n for key in params_to_purge:\n self.signal_parameters.pop(key)\n\n if \"transientTau\" in self.signal_parameters:\n self.signal_parameters[\"transientTauDays\"] = (\n self.signal_parameters.pop(\"transientTau\") / 86400.0\n )\n self.signal_formats[\"transientTauDays\"] = self.signal_formats.pop(\n \"transientTau\"\n )","def update_recognize_params(self,inps,trgs,preds):\n batch_size = np.shape(trgs)[0]\n self.delta_weight_v_to_h = self.learning_rate/batch_size * np.transpose(trgs) @ (inps - preds)\n self.delta_bias_h = self.learning_rate * np.mean(inps - preds)\n\n self.weight_v_to_h += self.delta_weight_v_to_h\n self.bias_h += self.delta_bias_h\n \n return","def _update_params(self, *args, **kwargs):\n\n \n # Get old param dict config.\n old_config = self._param_dict.get_config()\n \n # Issue display commands and parse results.\n timeout = kwargs.get('timeout', SBE37_TIMEOUT)\n self._do_cmd_resp('ds',timeout=timeout)\n self._do_cmd_resp('dc',timeout=timeout)\n \n # Get new param dict config. If it differs from the old config,\n # tell driver superclass to publish a config change event.\n new_config = self._param_dict.get_config()\n if new_config != old_config:\n self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)","def updateParams(self, v,n,m, ii):\n \n inst = self.instruments[self.stringInsts.index(self.selInstsVar[ii].get())]\n params = inst.getQParams()\n self.paramBoxes[ii]['values'] = params[:]\n self.paramBoxes[ii].current(0)","def updateParameters(self):\n\n if self.params[1].value:\n if arcpy.Exists(self.params[1].value):\n try:\n min_value = arcpy.GetRasterProperties_management(self.params[1].value, \"MINIMUM\")[0]\n\n if str(self.params[8].value) != str(self.params[1].value):\n self.params[7].value = True\n self.params[8].value = str(self.params[1].value)\n else:\n self.params[7].value = False\n\n if str(min_value) == \"0\":\n if self.params[7].value == True:\n self.params[2].value = True\n self.params[3].enabled = True\n self.params[7].value = False\n else:\n self.params[2].value = False\n self.params[3].enabled = False\n\n except arcpy.ExecuteError:\n pass\n\n if self.params[2].value == True:\n self.params[3].enabled = True\n else:\n self.params[3].enabled = False","def update_param(self):\r\n # log('Video_object.update_param', log_level=3)\r\n # reset segments first\r\n self.segments.clear()\r\n self.total_size = 0\r\n\r\n # do some parameters updates\r\n stream = self.selected_stream\r\n self.extension = '.' + stream.extension\r\n self.name = self.title + self.extension\r\n self.eff_url = stream.url\r\n self.size = stream.size\r\n self.fragment_base_url = stream.fragment_base_url\r\n self.fragments = stream.fragments\r\n self.protocol = stream.protocol\r\n self.format_id = stream.format_id\r\n self.manifest_url = stream.manifest_url\r\n self.resolution = stream.resolution\r\n self.abr = stream.abr\r\n self.tbr = stream.tbr\r\n\r\n # set type ---------------------------------------------------------------------------------------\r\n self.type = 'audio' if stream.mediatype == 'audio' else 'video'\r\n\r\n # set subtype\r\n self.subtype_list.clear()\r\n\r\n if stream.mediatype in ('dash', 'normal'):\r\n self.subtype_list.append(stream.mediatype)\r\n\r\n if 'm3u8' in self.protocol:\r\n self.subtype_list.append('hls')\r\n\r\n if self.fragments:\r\n self.subtype_list.append('fragmented')\r\n\r\n if 'f4m' in self.protocol:\r\n self.subtype_list.append('f4m')\r\n\r\n if 'ism' in self.protocol:\r\n self.subtype_list.append('ism')\r\n\r\n self.select_audio()","def bayesian_update(self):\n for p in self.parameters:\n p.bayesian_update()","def _update_data(self):\n for attribute in [\"flow_rate\"]:\n self._data[attribute] = self._connection.measure","def change_parameters(self,params):\n no_of_params = 0\n for core_param in range(len(self.q)):\n for approx_param in range(self.q[core_param].param_no):\n self.q[core_param].vi_change_param(approx_param, params[no_of_params])\n no_of_params += 1","def update(self, **params):\n self.parameters.update(params)","def monkey_set_f_params(self):\n self._monkey_set_f_params_counter += 1","def monkey_set_f_params(self):\n self._monkey_set_f_params_counter += 1","def variational_update(self):\n with self.elbo_check('update_p_allele_swap'):\n self.model.update_p_allele_swap()\n\n with self.elbo_check('p_cn'):\n self.model.update_p_cn()\n\n with self.elbo_check('p_breakpoint'):\n self.model.update_p_breakpoint()\n\n with self.elbo_check('p_outlier_total'):\n self.model.update_p_outlier_total()\n\n with self.elbo_check('p_outlier_allele'):\n self.model.update_p_outlier_allele()","def _adjust(self):\n self.updateView()\n\n self.setDescription(\n f\"Smoothing Factor: x{self.smoothingFactor()}\\n\"\n f\"Method: {self.method()}\\n\"\n f\"Smoother type: {self.smoother_type_to_name[self.smootherType()]}\"\n )","def update_waveforms(self, key, _):\n if key == self.controls.Arrays.WAVEFORMS:\n self.trace_lines[0].set_ydata(self.pv_monitor.arrays[key][0])\n self.trace_lines[1].set_ydata(self.pv_monitor.arrays[key][1])\n self.draw()","def on_cam_base_param_adjust_btn_clicked(self):\n len = self.cam_processing_len_edit.text()\n wid = self.cam_processing_width_edit.text()\n self.baseCamThread.cam.set_cam_parameters(int(len), float(wid))\n # pitch, yaw = self.control1.device.cmd_cam_adjust(pitch, yaw)\n status = \"setting base cam param as: length \" + str(len) + \", width: \" + str(wid)\n self.cam_set_status_txt(status)","def update_parameters(self, event, gamma='2.4',\n gain=\"scale_default_value\"):\n print(\"gamma={}, gain={}\".format(gamma, gain))\n sys.stdout.flush()\n self.update_draw(gamma, gain)","def update_params(self, learning_rate=0.1):\n\n self.params['W'] = self.params['W'] - learning_rate * self.dW # update weights\n self.params['b'] = self.params['b'] - learning_rate * self.db # update bias(es)","def _update_plot(self, *args):\n # type: (dict, dict, dict, dict, dict) -> None\n if len(args) != 5 and not any([isinstance(arg, dict) for arg in args]):\n raise ValueError('Illegal arguments for _update_plot of %s' % self.__name__)\n desvars, responses, objectives, constraints, metadata = args\n\n data = self._compute_new_data(desvars, responses, objectives, constraints, metadata)\n self.cs[:, self.iter] = data[:]\n self.quad.set_array(self.cs.ravel())\n self.ax.set_xlim([-.5, self.iter+.5])\n self.iter += 1","def update_parameters(self, ob_no, hidden, ac_na, fixed_log_probs, q_n, adv_n):\n self.update_critic(ob_no, hidden, q_n)\n self.update_policy(ob_no, hidden, ac_na, fixed_log_probs, adv_n)","def update_value_parameters(self, vector):\n\n self.var_noise.set_value(np.array([vector[0]]))\n self.mean.set_value(np.array([vector[1]]))\n self.kernel.update_value_parameters(vector[2:])\n\n self.kernel_values = vector[2:]\n self.mean_value = vector[1:2]\n self.var_noise_value = vector[0:1]","def update_params(self, t, x, **kwargs):\n raise NotImplementedError","def _update_params(self):\n log.debug(\"Updating parameter dict\")\n old_config = self._param_dict.get_config()\n self._get_config()\n new_config = self._param_dict.get_config() \n if (new_config != old_config):\n self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)","def signal_vwap(self):\n pass","def params(self,new):\n self._params = new\n self._config_set()\n self._make_model()","def fit(self, signal):\n self.signal = signal","def _update_PID(self):\n self.pid = PID(p=self.paramP, i=self.paramI, d=self.paramD, setpoint=self.voltageSetpoint, memory=self.paramMemory)","def add_nfb_export_data(self, signal: dict):\n signal[\"fSmoothingFactor\"] = self.smoothingFactor()\n signal[\"method\"] = self.method()\n signal[\"sTemporalSmootherType\"] = self.smootherType()","def Process(self, in_signal): ###\n if not hasattr(self, \"_warned\"):\n self._warned = False\n if not self._warned:\n self._warned = True\n print()\n print()\n print(\"Hello, this is the BciGenericSignalProcessing superclass.\")\n print(\"You have not overshadowed Process(self, sig) inside a\")\n print(\"BciSignalProcessing subclass, or perhaps not defined \")\n print(\"a BciSignalProcessing subclass in the first place.\")\n print(\"Either way, the signal is not being processed.\")\n print()","def update_parameters(updates):\r\n for (key, val) in updates.items():\r\n par[key] = val\r\n print('Updating:', key, '-->', val)\r\n update_dependencies()","def _paramUpdate(self):\n\n # Update the database attributes accordingly.\n dt.utilities.DB_attrs_save(self.Database, self.newParam)","def prob_update(self):\n pass","def _parse_args_consistent_with_mfd(self):\n self.signal_parameters = self.translate_keys_to_lal(\n {\n key: self.__dict__[key]\n for key in self.signal_parameter_labels\n if self.__dict__.get(key, None) is not None\n }\n )\n\n self.signal_formats = {\n key: self.gps_time_and_string_formats_as_LAL.get(key, \":1.18e\")\n for key in self.signal_parameters\n }","def update(self, params):","def update(self, datain):\r\n self.arraydata = datain\r\n self.layoutChanged.emit()","def process_event(self, event):\n if not self.frozen:\n if event[\"event\"] == self.event:\n if self.what is None or event[\"target\"].startswith(self.what):\n self._varstate = event\n try:\n for key in self.subval:\n self._varstate = self._varstate[key]\n\n if bridgectl.log:\n bridgectl.log.debug(\n \"New value for {} is {}\".format(\n self.name,\n self._varstate))\n except Exception as e:\n if bridgectl.log:\n bridgectl.log.critical(\n \"Failed to process event for {}\".format(\n self.name),\n exc_info=(type(e),\n e,\n e.__traceback__))\n pass\n if event['event'] == 'time tick':\n if self.period in event[\"starts\"]:\n self._varstate = self.reset()","def _set_params(self,x):\r\n assert x.size==3\r\n self.variance = x[0]\r\n self.lengthscale = x[1]\r\n self.period = x[2]\r\n\r\n self.a = [1./self.lengthscale, 1.]\r\n self.b = [1]\r\n\r\n self.basis_alpha = np.ones((self.n_basis,))\r\n self.basis_omega = np.array(sum([[i*2*np.pi/self.period]*2 for i in range(1,self.n_freq+1)],[]))\r\n self.basis_phi = np.array(sum([[-np.pi/2, 0.] for i in range(1,self.n_freq+1)],[]))\r\n\r\n self.G = self.Gram_matrix()\r\n self.Gi = np.linalg.inv(self.G)","def _apply_params(self):\n config = self.get_startup_config()\n # Pass true to _set_params so we know these are startup values\n self._set_params(config, True)","def update_parameters(parameters, grads, learning_rate):\n pass","def _set_parameter(self):\n # Get parameter keys\n self.input_parameter = self.parameter_combobox.currentText()\n self.result_parameter = self.result_parameters[self.input_parameter]\n # Adjust axes labels\n self.ax.set_xlabel('{} steunpunt'.format(self.input_parameter))\n self.ax.set_ylabel('{} uitvoerlocatie'.format(self.input_parameter))\n # Set data\n self._set_data()","def updateParameters(self, parameters):\n\t\treturn","def set_parameters(self,params):\n K3Supervisor.set_parameters(self,params)\n self.blending.set_parameters(self.parameters)","def updateParms(self):\n self.p1text.setText(\"{0:g}\".format(self.parmVal[0]))\n if len(self.parmVal) > 1:\n self.p2text.setText(\"{0:g}\".format(self.parmVal[1]))\n if len(self.parmVal) > 2:\n self.p3text.setText(\"{0:g}\".format(self.parmVal[2]))\n if len(self.parmVal) > 3:\n self.p4text.setText(\"{0:g}\".format(self.parmVal[3]))","def em_update_params(self):\n for name in self.likelihood_params:\n with self.elbo_check(name):\n self.update_param(name)","def update_parameter(self, name, freq, value):\n if name not in self._parameters.keys():\n self.add_parameter(name, [freq], [value])\n else:\n param = self.get_parameter(name)\n param.update_value(freq, value)"],"string":"[\n \"def update_parameters(self):\\n # We update gamma, gamma0, lambda and nu in turn (Bottolo et al, 2011)\\n self.update_gamma()\\n self.update_gamma0()\\n self.update_lambda()\\n self.update_nu()\\n if self.sample_xi:\\n self.update_xi()\",\n \"def updateSignals(self):\\n self.parser.read(self.file)\\n self.signalType = self.parser.get('Signals', 'signalType')\\n if self.signalType == 'single':\\n self.single = self.parser.get('Signals', 'single')\\n elif self.signalType == 'dual':\\n self.fast = self.parser.getint('Signals', 'fast')\\n self.slow = self.parser.getint('Signals', 'slow')\\n elif self.signalType == 'ribbon':\\n self.ribbonStart = self.parser.get('Signals', 'ribbonStart')\\n self.numRibbon = self.parser.get('Signals', 'numRibbon')\\n self.ribbonSpacing = self.parser.get('Signals', 'ribbonSpacing')\",\n \"def _update_parameter(self, dWxh, dbh, dWhy, dby):\\n # Add code to update all the weights and biases here\",\n \"def update_parameters(self):\\n self.alignment_factor = rospy.get_param('/dyn_reconf/alignment_factor')\\n self.cohesion_factor = rospy.get_param('/dyn_reconf/cohesion_factor')\\n self.separation_factor = rospy.get_param('/dyn_reconf/separation_factor')\\n self.avoid_factor = rospy.get_param('/dyn_reconf/avoid_factor')\\n self.max_speed = rospy.get_param('/dyn_reconf/max_speed')\\n self.max_force = rospy.get_param('/dyn_reconf/max_force')\\n self.friction = rospy.get_param('/dyn_reconf/friction')\\n self.crowd_radius = rospy.get_param('/dyn_reconf/crowd_radius')\\n self.search_radius = rospy.get_param('/dyn_reconf/search_radius')\\n\\n rospy.loginfo(rospy.get_caller_id() + \\\" -> Parameters updated\\\")\\n if DEBUG:\\n print('alignment_factor: ', self.alignment_factor)\\n print('cohesion_factor: ', self.cohesion_factor)\\n print('separation_factor: ', self.separation_factor)\\n print('avoid_factor: ', self.avoid_factor)\\n print('max_speed: ', self.max_speed)\\n print('max_force: ', self.max_force)\\n print('friction: ', self.friction)\\n print('crowd_radius: ', self.crowd_radius)\\n print('search_radius: ', self.search_radius)\",\n \"def update_filter_params(self, fh):\\n (self.data_timestamp, self.framerate,\\n self.l, self.d, self.gamma,\\n self.eps, self.alex, self.traceswitch) = (fh.attrs['data_timestamp'], fh.attrs['framerate'],\\n fh.attrs['l'], fh.attrs['d'], fh.attrs['gamma'],\\n fh.attrs['eps'], fh.attrs['alex'], fh.attrs['traceswitch'])\",\n \"def apply_parameters(self):\\n n_bins = int(self.record_length / self.bin_width)\\n time_bins = self.bin_width * np.arange(n_bins)\\n \\n\\n self.tau = np.arange(self.tau_start, self.tau_end+self.tau_delta, self.tau_delta)\\n sequence = self.generate_sequence()\\n self.n_laser = find_laser_pulses(sequence)\\n \\n FC.Configure(self.record_length, self.bin_width, self.n_laser)\\n\\n if self.keep_data and sequence == self.sequence and np.all(time_bins == self.time_bins): # if the sequence and time_bins are the same as previous, keep existing data\\n self.old_count_data = self.count_data.copy()\\n else:\\n self.old_count_data = np.zeros_like(FC.GetData())\\n \\n self.sequence = sequence\\n self.time_bins = time_bins\\n self.n_bins = n_bins\\n \\n self.MW_source = {'mw':mw, 'mw2':mw2}[self.mw_source]\",\n \"def update(self, parameters):\\n self.set_frequencies(parameters) # f_i\\n self.set_coupling_weights(parameters) # w_ij\\n self.set_phase_bias(parameters) # theta_i\\n self.set_amplitudes_rate(parameters) # a_i\\n self.set_nominal_amplitudes(parameters) # R_i\",\n \"def update_params(self):\\n pass\",\n \"def _update_params(self):\\n with self.sphere.sphere_lock:\\n self._args_to_params(self.sphere.bai_1d_args, self.bai_1d_pars)\\n self._args_to_params(self.sphere.bai_2d_args, self.bai_2d_pars)\\n #self._args_to_params(self.sphere.mg_args, self.mg_pars)\",\n \"def _update_params(self):\\n _load = not self.san_interface.runmode\\n params={}\\n if ('iosched' in self._updatedattr or _load) and self.iosched<>IoSchedType.default:\\n params['iosched']=str(self.iosched)\\n if ('readahead' in self._updatedattr or _load) and self.readahead :\\n params['readahead']=self.readahead\\n if params:\\n for pt in self.paths():\\n pt.provider.set_dev_params(pt,params)\",\n \"def __signal_settings_handler__(self, settings, debug):\\n # Establish debug parameters...\\n func_name = \\\"__signal_settings_handler__\\\";\\n \\n # Set up configurable parameters\\n settings_delimiter = \\\";\\\"\\n fields_delimiter = \\\"=\\\"\\n \\n \\n if debug: print(\\\" -- DEBUG (%s) Incoming 'setting' string: %s\\\" %( func_name, settings ) )\\n \\n # Split line at delimiters\\n line_split = settings.split(settings_delimiter)\\n \\n for item in line_split:\\n # Remove all spaces\\n item = item.replace(\\\" \\\", \\\"\\\"); \\n if debug: print(\\\" -- DEBUG (%s) Item: %s\\\" %( func_name, item ) )\\n \\n # Split the field identifier and its value. \\n field_identifier = item.split(fields_delimiter) \\n if ( debug and len(field_identifier) is not 1 ): print(\\\" -- DEBUG (%s) Field: %s, Value: %s\\\" %( func_name, field_identifier[0], field_identifier[1] ) )\\n \\n \\\"\\\"\\\" Objective: Call processing function. \\n \\n - Check if the field is supported.\\n - If so, call the respective process function. \\n \\\"\\\"\\\"\\n if field_identifier[0] in self.__process_field_opts__:\\n self.__process_field_opts__[field_identifier[0]](self, field_identifier[1], debug)\\n \\n # TODO: All fields should be checked here....\\n \\n # ERROR If FT (tramission frequency) and FS (sampling frequency) are not provided.\\n if self.FT is None:\\n sys.exit(\\\"ERROR: The transmission frequncy (ft) was not defined. Please added necessary information to 'settings' for signal construction...\\\")\\n\\n\\n # if FS not provided, base the interval on FT and cycles\\n if self.FS is None: \\n print(\\\"WARNING: No sampling frequency provided. \\\\n Will provide default values for plotting...\\\")\\n if self.N is not (signal.default_samples_per_cycle * self.M):\\n print(\\\"WARNING: Changing number of samples from %d to %d\\\" %(self.N, (signal.default_samples_per_cycle * self.M)))\\n self.N = (signal.default_samples_per_cycle * self.M)\\n self.nTs = np.linspace(start = 0, stop = self.M * (1/self.FT), num = self.N )\\n self.FS = self.nTs[1] - self.nTs[0]\\n print(\\\"WARNING: Setting sampling frequency to: %f\\\" %self.FS)\\n self._signal = self.nTs\\n else: \\n self.nTs = np.linspace(0, (float(1)/self.FS)*self.N, self.N) \\n self._signal = self.nTs\",\n \"def update_parameters(self, timestamp, inputs):\\n pass\",\n \"def _update_params(self):\\n pass\",\n \"def update_params(self):\\n \\n # read parameters from context broker\\n for attr in ['Kp', 'Ti', 'Td', 'lim_low', 'lim_high', 'setpoint']:\\n self.params[attr] = float(self.ORION_CB.get_entity_attribute_value(entity_name=self.params['name'], attribute_name=attr))\\n self.params['reverse_act'] = str(self.ORION_CB.get_entity_attribute_value(entity_name=self.params['name'], attribute_name='reverse_act')) \\n \\n # update PID parameters\\n self.PID.Kp = self.params['Kp']\\n self.PID.Ti = self.params['Ti']\\n self.PID.Td = self.params['Td']\\n self.PID.lim_low = self.params['lim_low']\\n self.PID.lim_high = self.params['lim_high']\\n self.PID.reverse_act = eval(eval(self.params['reverse_act']))\",\n \"def update_values(self, to_update):\\n for key, value in kwargs.iteritems():\\n self.params[key] = value\\n # update the possibly dependent parameters\\n self.set_filenames()\",\n \"def _update(self):\\n self.all_params = {}\\n self._update_experiment_params()\\n self._update_preprocessing_params()\\n self._update_model_params()\",\n \"def updateParameters(self):\\n\\n return\",\n \"def update_params(self):\\n for layer in range(self.num_layers):\\n for direction in range(self.num_directions):\\n for param_name in self._get_param_names(direction, layer):\\n param = getattr(self.module_to_quantize, param_name)\\n param.data = getattr(self, param_name).data\\n\\n _logger.debug('Updated params for QcQuantizeRNN')\",\n \"def updateParameters(self, parameters):\",\n \"def updateData(self, *args):\\n # if self.move_next_option == \\\"R\\\":\\n # self.restSampling()\\n # elif self.move_next_option == \\\"A\\\":\\n # self.addExtra()\\n # else:\\n # self.continueReview()\\n for name, value in self.parameter_inputs.items():\\n self.parameters[name] = value.value\\n # directly change the value of class variables\\n logMsg((\\\"update settings: \\\", self.ml_classifier_cls, name, value.value))\\n setattr(self.ml_classifier_cls, name, value.value)\\n\\n pass\",\n \"def _update_params(self):\\n raise NotImplementedException()\",\n \"def update_total_fpsig_dict(self):\\n for curr_CD in self.total_inputsr_dict.keys():\\n self.total_fpsig_dict[curr_CD] = 0.0\\n for c in self.source_connection_list:\\n if(c.conn_type =='ShortRange'):\\n self.total_fpsig_dict[c.connection_distribution] += (c.curr_firing_rate) * (c.weights**2) * c.nsyn\\n\\n # summation\\n self.total_fp_sigv = 0.0\\n for key,val in self.total_fpsig_dict.items():\\n try:\\n self.total_fp_sigv += val\\n except:\\n key.initialize()\\n self.total_fp_sigv += val\\n self.total_fp_sigv = self.total_fp_sigv * self.tau_m\",\n \"def _set_params(self,x):\\r\\n self.k._set_params(x)\",\n \"def _parameters_changed_notification(self, me, which=None):\\n self._optimizer_copy_transformed = False # tells the optimizer array to update on next request\\n self.parameters_changed()\",\n \"def _update(self, var, channels, value):\\n\\n if type(channels) is int:\\n channels = [channels]\\n\\n if var =='frequency':\\n for channel in channels:\\n self.frequencies[channel] = value\\n elif var =='phase':\\n for channel in channels:\\n self.phases[channel] = value\\n elif var == 'amplitude':\\n for channel in channels:\\n self.amplitudes[channel] = value\",\n \"def pre_update(self, **values):\\r\\n pass\",\n \"def _update_feedback(self):\\n #First read in the current voltage (power)\\n #Read in numReadsPerCycle signals (arb) to average\\n #TODO: allow user to select reads per signal\\n currSignal = self._ai_client.get_ai_voltage(self._ai_channel, self.numReadsPerCycle, max_range=self.max_input_voltage)\\n\\n #Add new data to the pid\\n self.pid.set_pv(np.atleast_1d(np.mean(currSignal)))\\n\\n #Now compute the new control value and update the AO\\n self.pid.set_cv()\\n self._curr_output_voltage = self._curr_output_voltage + self.pid.cv\\n if self._curr_output_voltage < self.min_voltage:\\n self._curr_output_voltage = self.min_voltage\\n elif self._curr_output_voltage > self.max_voltage:\\n self._curr_output_voltage = self.max_voltage\\n\\n\\n #Finally updating the analog output\\n\\n #Do a final check to make sure that if you are in hardware control mode that the voltage control is still HIGH\\n #This is to avoid the potential error if the voltage control is toggled low between the last call of _check_hardware_control\\n #and update_feedback, whcih would mean that currSignal would be 0 (assuming a pulsed experiment), and causing a garbage\\n #feedback which could be an issue in the next pulse.\\n if (~self._under_hardware_control or self.ai_client.get_ai_voltage(self._hwc_ai_channel)[-1] > self._hwc_thresh):\\n self._ao_client.set_ao_voltage(self._ao_channel, self._curr_output_voltage)\",\n \"def update_params(self, learning_rate):\\n\\t\\t#######################################################################\\n\\t\\t# ** START OF YOUR CODE **\\n\\t\\t#######################################################################\\n\\t\\tself._W = self._W - learning_rate * self._grad_W_current\\n\\t\\tself._b = self._b - learning_rate * self._grad_b_current\\n\\t\\t#######################################################################\\n\\t\\t# ** END OF YOUR CODE **\\n\\t\\t#######################################################################\",\n \"def updateVariables(self) -> None:\\n ...\",\n \"def updatedata(self, force_update=False):\\n\\n self._update_counter = self._update_counter + 1\\n logging.debug('ParameterViewer: update values')\\n for instrument_name in self._instrumentnames:\\n instr = self._instruments[self._instrumentnames.index(instrument_name)]\\n parameters = {}\\n\\n try:\\n parameters = instr.parameters\\n except AttributeError as ex:\\n # instrument was removed\\n print('instrument was removed, stopping ParameterViewer')\\n # logging.exception(ex)\\n self._timer.stop()\\n\\n parameter_names = sorted(parameters.keys())\\n\\n si = sys.getswitchinterval()\\n\\n for parameter_name in parameter_names:\\n # hack to make this semi thread-safe\\n\\n for field_name in self._fields:\\n if field_name == 'Value':\\n sys.setswitchinterval(100)\\n value = parameters[parameter_name].get_latest()\\n sys.setswitchinterval(si)\\n self.update_field_signal.emit(instrument_name, parameter_name, field_name, value, force_update)\\n else:\\n if self._update_counter % 20 == 1 or 1:\\n sys.setswitchinterval(100)\\n value = getattr(parameters[parameter_name], field_name, '')\\n sys.setswitchinterval(si)\\n self.update_field_signal.emit(instrument_name, parameter_name,\\n field_name, value, force_update)\\n\\n for callback_function in self.callbacklist:\\n try:\\n callback_function()\\n except Exception as ex:\\n logging.debug('update function failed')\\n logging.exception(str(ex))\",\n \"def updateInterface(self):\\n p = self.cxn[self.selectedADR].packet()\\n p.magnetv().pscurrent().psvoltage()\\n p.time()\\n p.temperatures()\\n p.get_state_var('CompressorStatus')\\n p.get_instrument_state()\\n state = yield p.send()\\n # change instrument statuses\\n for name,status in state['get_instrument_state']:\\n if status[0] == False: color = 'red3'\\n elif status[1] == False: color = 'orange3'\\n elif status[1] == True: color = 'green3'\\n else: color = 'gray70'\\n self.instrumentStatuses[name].config(bg=color)\\n # change compressor button\\n if state['get_state_var'] == True:\\n self.compressorButton.configure(text='Stop Compressor',\\n command=self.stopCompressor,\\n state=Tkinter.NORMAL)\\n elif state['get_state_var'] == False:\\n self.compressorButton.configure(text='Start Compressor',\\n command=self.startCompressor,\\n state=Tkinter.NORMAL)\\n else: self.compressorButton.configure(state=Tkinter.DISABLED)\\n # update current, voltage fields\\n temps = {}\\n stages = ('T_60K','T_3K','T_GGG','T_FAA')\\n for i in range(len(stages)):\\n temps[stages[i]] = state['temperatures'][i]\\n #if temps[stages[i]] == 'nan': temps[stages[i]] = numpy.nan\\n if numpy.isnan(state['magnetv']['V']):\\n emf = 'ERR'\\n else:\\n emf = \\\"{0:.3f}\\\".format(state['magnetv']['V'])\\n if numpy.isnan(state['pscurrent']['A']):\\n psI = 'PS OFF'\\n else:\\n psI = \\\"{0:.3f}\\\".format(state['pscurrent']['A'])\\n if numpy.isnan(state['psvoltage']['V']):\\n psV = 'PS OFF'\\n else:\\n psV = \\\"{0:.3f}\\\".format(state['psvoltage']['V'])\\n self.currentBackEMF.set( emf )\\n self.currentI.set( psI )\\n self.currentV.set( psV )\\n # update plot:\\n # change data to plot\\n self.stage60K.set_xdata(numpy.append(self.stage60K.get_xdata(),mpl.dates.date2num(state['time'])))\\n self.stage60K.set_ydata(numpy.append(self.stage60K.get_ydata(),temps['T_60K']['K']))\\n self.stage03K.set_xdata(numpy.append(self.stage03K.get_xdata(),mpl.dates.date2num(state['time'])))\\n self.stage03K.set_ydata(numpy.append(self.stage03K.get_ydata(),temps['T_3K']['K']))\\n self.stageGGG.set_xdata(numpy.append(self.stageGGG.get_xdata(),mpl.dates.date2num(state['time'])))\\n self.stageGGG.set_ydata(numpy.append(self.stageGGG.get_ydata(),temps['T_GGG']['K']))\\n self.stageFAA.set_xdata(numpy.append(self.stageFAA.get_xdata(),mpl.dates.date2num(state['time'])))\\n self.stageFAA.set_ydata(numpy.append(self.stageFAA.get_ydata(),temps['T_FAA']['K']))\\n #update plot\\n self.updatePlot()\\n # update legend\\n labelOrder = ['T_60K','T_3K','T_GGG','T_FAA']\\n lines = [self.stage60K,self.stage03K,self.stageGGG,self.stageFAA]\\n labels = [l.strip('T_')+' ['+\\\"{0:.3f}\\\".format(temps[l]['K'])+'K]' for l in labelOrder]\\n labels = [s.replace('1.#QOK','OoR') for s in labels]\\n # legend on top (if not using this, delete \\\\n in title)\\n self.ax.legend(lines,labels,bbox_to_anchor=(0., 1.02, 1., .102), loc=3,\\n ncol=4, mode=\\\"expand\\\", borderaxespad=0.)\",\n \"def update_parameters(self,like_params):\\n\\n # get current dictionary with parameters, update and setup again\\n params=self.get_params()\\n\\n for par in like_params:\\n if par.name in params:\\n params[par.name]=par.value\\n\\n self._setup_from_parameters(params)\\n return\",\n \"def _update_parameters(self, curr_state, reward, next_state):\\n phi = self._features.vector(curr_state)\\n phi_dash = self._features.vector(next_state)\\n\\n self._A += np.outer(phi, (phi - self._gamma * phi_dash))\\n self._b += reward * phi\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def updateParameters(self, parameters):\\r\\n return\",\n \"def parameters_changed(self):\\n pass\",\n \"def update(self):\\n\\n self.pta_time[0] = 1 + Globals.clock.get_frame_time() * self.options.time_scale\\n\\n Globals.base.graphicsEngine.dispatch_compute(\\n (self.options.size // 16, self.options.size // 16, 1),\\n self.attr_update,\\n Globals.base.win.get_gsg())\\n\\n self.fftX.execute()\\n self.fftY.execute()\\n self.fftZ.execute()\\n\\n # Execute the shader which combines the 3 displacement maps into\\n # 1 displacement texture and 1 normal texture. We could use dFdx in\\n # the fragment shader, however that gives no accurate results as\\n # dFdx returns the same value for a 2x2 pixel block\\n Globals.base.graphicsEngine.dispatch_compute(\\n (self.options.size // 16, self.options.size // 16, 1),\\n self.attr_combine,\\n Globals.base.win.get_gsg())\",\n \"def update(self, rxn_probs):\\n pass\",\n \"def setup(self):\\n super().setup()\\n self.ctx.restart_calc = None\\n self.ctx.inputs = AttributeDict(self.exposed_inputs(XspectraCalculation, 'xspectra'))\\n\\n self.ctx.inputs.parameters = self.ctx.inputs.parameters.get_dict()\",\n \"def updateParameters(self, parameters):\\r\\n #return\\r\\n parameters[2].enabled = 0\\r\\n parameters[3].enabled = 0\\r\\n parameters[4].enabled = 0\",\n \"def updateParameters(self, parameters):\\r\\n #return\\r\\n parameters[2].enabled = 0\\r\\n parameters[3].enabled = 0\\r\\n parameters[4].enabled = 0\",\n \"def _UpdateProcessingStatus(self, pid, process_status, used_memory):\",\n \"def update_signal(self, event):\\n if event.type == 'SIGNAL':\\n order_event = self.generate_naive_order(event)\\n self.events.put(order_event)\",\n \"def update_signal(self, event):\\n if event.type == 'SIGNAL':\\n order_event = self.generate_naive_order(event)\\n self.events.put(order_event)\",\n \"def update_signal(self, event):\\n if event.type == 'SIGNAL':\\n order_event = self.generate_naive_order(event)\\n self.events.put(order_event)\",\n \"def update(self,update_flags):\\n pass\",\n \"def signalSetup(self):\\n self.ui.b_info.clicked.connect(self.showInfo)\\n self.ui.b_save.clicked.connect(self.openSave)\\n self.ui.b_vid.clicked.connect(self.openVideo)\\n self.ui.b_run.clicked.connect(self.startRun)\\n self.ui.b_colour.clicked.connect(self.pickColour)\\n self.ui.b_ground_truth.clicked.connect(self.openGroundTruth)\\n\\n self.ui.t_fps.textChanged.connect(self.changeFps)\\n self.ui.t_low.editingFinished.connect(self.changeLow)\\n self.ui.t_high.editingFinished.connect(self.changeHigh)\\n self.ui.c_error_plot.stateChanged.connect(self.checkFiles)\\n self.ui.c_speed_plot.stateChanged.connect(self.checkFiles)\\n self.ui.c_crash_plot.stateChanged.connect(self.checkFiles)\\n self.ui.combo_superpixel.currentIndexChanged.connect(\\n self.changeSuperPixelMethod\\n )\\n self.ui.c_optimize.stateChanged.connect(self.checkFiles)\\n self.ui.c_draw.stateChanged.connect(self.checkFiles)\\n self.ui.c_velocity.stateChanged.connect(self.checkFiles)\\n self.ui.c_object_detection.stateChanged.connect(self.checkFiles)\",\n \"def update_synths(self, x, instrument):\\n active_update = instrument.app.config().active_updates_enabled()\\n for pm in self._maps.values():\\n value = pm.map_value(x)\\n param = pm.parameter\\n instrument.x_param_change(param, value)\\n if active_update: # and not self._transient:\\n sed = instrument.synth_editor\\n if sed:\\n sed.set_aspect(param, value)\",\n \"def _update_params(self, new_params):\\n # update all the parameters\\n for old_param, new_param in zip(self.model.parameters(), new_params):\\n old_param.data += torch.from_numpy(new_param).to(old_param.device)\",\n \"def _parse_args_consistent_with_mfd(self):\\n super()._parse_args_consistent_with_mfd()\\n\\n # FIXME: There should be a smoother way to translate keys\\n lal_required_signal_parameters = self.translate_keys_to_lal(\\n dict(\\n zip(\\n self.required_signal_parameters,\\n [0] * len(self.required_signal_parameters),\\n )\\n )\\n )\\n\\n if any(\\n key not in lal_required_signal_parameters for key in self.signal_parameters\\n ):\\n logger.warning(\\n \\\"Injection of line artifacts only uses the following parameters:\\\\n\\\"\\n f\\\"{self.required_signal_parameters}.\\\\n\\\"\\n \\\"Any other parameter will be purged from this class now\\\"\\n )\\n params_to_purge = list(\\n set(self.signal_parameters) - set(lal_required_signal_parameters)\\n )\\n logger.info(\\n \\\"Purging input parameters that are not meaningful for LineWriter: {}\\\".format(\\n params_to_purge\\n )\\n )\\n for key in params_to_purge:\\n self.signal_parameters.pop(key)\\n\\n if \\\"transientTau\\\" in self.signal_parameters:\\n self.signal_parameters[\\\"transientTauDays\\\"] = (\\n self.signal_parameters.pop(\\\"transientTau\\\") / 86400.0\\n )\\n self.signal_formats[\\\"transientTauDays\\\"] = self.signal_formats.pop(\\n \\\"transientTau\\\"\\n )\",\n \"def update_recognize_params(self,inps,trgs,preds):\\n batch_size = np.shape(trgs)[0]\\n self.delta_weight_v_to_h = self.learning_rate/batch_size * np.transpose(trgs) @ (inps - preds)\\n self.delta_bias_h = self.learning_rate * np.mean(inps - preds)\\n\\n self.weight_v_to_h += self.delta_weight_v_to_h\\n self.bias_h += self.delta_bias_h\\n \\n return\",\n \"def _update_params(self, *args, **kwargs):\\n\\n \\n # Get old param dict config.\\n old_config = self._param_dict.get_config()\\n \\n # Issue display commands and parse results.\\n timeout = kwargs.get('timeout', SBE37_TIMEOUT)\\n self._do_cmd_resp('ds',timeout=timeout)\\n self._do_cmd_resp('dc',timeout=timeout)\\n \\n # Get new param dict config. If it differs from the old config,\\n # tell driver superclass to publish a config change event.\\n new_config = self._param_dict.get_config()\\n if new_config != old_config:\\n self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)\",\n \"def updateParams(self, v,n,m, ii):\\n \\n inst = self.instruments[self.stringInsts.index(self.selInstsVar[ii].get())]\\n params = inst.getQParams()\\n self.paramBoxes[ii]['values'] = params[:]\\n self.paramBoxes[ii].current(0)\",\n \"def updateParameters(self):\\n\\n if self.params[1].value:\\n if arcpy.Exists(self.params[1].value):\\n try:\\n min_value = arcpy.GetRasterProperties_management(self.params[1].value, \\\"MINIMUM\\\")[0]\\n\\n if str(self.params[8].value) != str(self.params[1].value):\\n self.params[7].value = True\\n self.params[8].value = str(self.params[1].value)\\n else:\\n self.params[7].value = False\\n\\n if str(min_value) == \\\"0\\\":\\n if self.params[7].value == True:\\n self.params[2].value = True\\n self.params[3].enabled = True\\n self.params[7].value = False\\n else:\\n self.params[2].value = False\\n self.params[3].enabled = False\\n\\n except arcpy.ExecuteError:\\n pass\\n\\n if self.params[2].value == True:\\n self.params[3].enabled = True\\n else:\\n self.params[3].enabled = False\",\n \"def update_param(self):\\r\\n # log('Video_object.update_param', log_level=3)\\r\\n # reset segments first\\r\\n self.segments.clear()\\r\\n self.total_size = 0\\r\\n\\r\\n # do some parameters updates\\r\\n stream = self.selected_stream\\r\\n self.extension = '.' + stream.extension\\r\\n self.name = self.title + self.extension\\r\\n self.eff_url = stream.url\\r\\n self.size = stream.size\\r\\n self.fragment_base_url = stream.fragment_base_url\\r\\n self.fragments = stream.fragments\\r\\n self.protocol = stream.protocol\\r\\n self.format_id = stream.format_id\\r\\n self.manifest_url = stream.manifest_url\\r\\n self.resolution = stream.resolution\\r\\n self.abr = stream.abr\\r\\n self.tbr = stream.tbr\\r\\n\\r\\n # set type ---------------------------------------------------------------------------------------\\r\\n self.type = 'audio' if stream.mediatype == 'audio' else 'video'\\r\\n\\r\\n # set subtype\\r\\n self.subtype_list.clear()\\r\\n\\r\\n if stream.mediatype in ('dash', 'normal'):\\r\\n self.subtype_list.append(stream.mediatype)\\r\\n\\r\\n if 'm3u8' in self.protocol:\\r\\n self.subtype_list.append('hls')\\r\\n\\r\\n if self.fragments:\\r\\n self.subtype_list.append('fragmented')\\r\\n\\r\\n if 'f4m' in self.protocol:\\r\\n self.subtype_list.append('f4m')\\r\\n\\r\\n if 'ism' in self.protocol:\\r\\n self.subtype_list.append('ism')\\r\\n\\r\\n self.select_audio()\",\n \"def bayesian_update(self):\\n for p in self.parameters:\\n p.bayesian_update()\",\n \"def _update_data(self):\\n for attribute in [\\\"flow_rate\\\"]:\\n self._data[attribute] = self._connection.measure\",\n \"def change_parameters(self,params):\\n no_of_params = 0\\n for core_param in range(len(self.q)):\\n for approx_param in range(self.q[core_param].param_no):\\n self.q[core_param].vi_change_param(approx_param, params[no_of_params])\\n no_of_params += 1\",\n \"def update(self, **params):\\n self.parameters.update(params)\",\n \"def monkey_set_f_params(self):\\n self._monkey_set_f_params_counter += 1\",\n \"def monkey_set_f_params(self):\\n self._monkey_set_f_params_counter += 1\",\n \"def variational_update(self):\\n with self.elbo_check('update_p_allele_swap'):\\n self.model.update_p_allele_swap()\\n\\n with self.elbo_check('p_cn'):\\n self.model.update_p_cn()\\n\\n with self.elbo_check('p_breakpoint'):\\n self.model.update_p_breakpoint()\\n\\n with self.elbo_check('p_outlier_total'):\\n self.model.update_p_outlier_total()\\n\\n with self.elbo_check('p_outlier_allele'):\\n self.model.update_p_outlier_allele()\",\n \"def _adjust(self):\\n self.updateView()\\n\\n self.setDescription(\\n f\\\"Smoothing Factor: x{self.smoothingFactor()}\\\\n\\\"\\n f\\\"Method: {self.method()}\\\\n\\\"\\n f\\\"Smoother type: {self.smoother_type_to_name[self.smootherType()]}\\\"\\n )\",\n \"def update_waveforms(self, key, _):\\n if key == self.controls.Arrays.WAVEFORMS:\\n self.trace_lines[0].set_ydata(self.pv_monitor.arrays[key][0])\\n self.trace_lines[1].set_ydata(self.pv_monitor.arrays[key][1])\\n self.draw()\",\n \"def on_cam_base_param_adjust_btn_clicked(self):\\n len = self.cam_processing_len_edit.text()\\n wid = self.cam_processing_width_edit.text()\\n self.baseCamThread.cam.set_cam_parameters(int(len), float(wid))\\n # pitch, yaw = self.control1.device.cmd_cam_adjust(pitch, yaw)\\n status = \\\"setting base cam param as: length \\\" + str(len) + \\\", width: \\\" + str(wid)\\n self.cam_set_status_txt(status)\",\n \"def update_parameters(self, event, gamma='2.4',\\n gain=\\\"scale_default_value\\\"):\\n print(\\\"gamma={}, gain={}\\\".format(gamma, gain))\\n sys.stdout.flush()\\n self.update_draw(gamma, gain)\",\n \"def update_params(self, learning_rate=0.1):\\n\\n self.params['W'] = self.params['W'] - learning_rate * self.dW # update weights\\n self.params['b'] = self.params['b'] - learning_rate * self.db # update bias(es)\",\n \"def _update_plot(self, *args):\\n # type: (dict, dict, dict, dict, dict) -> None\\n if len(args) != 5 and not any([isinstance(arg, dict) for arg in args]):\\n raise ValueError('Illegal arguments for _update_plot of %s' % self.__name__)\\n desvars, responses, objectives, constraints, metadata = args\\n\\n data = self._compute_new_data(desvars, responses, objectives, constraints, metadata)\\n self.cs[:, self.iter] = data[:]\\n self.quad.set_array(self.cs.ravel())\\n self.ax.set_xlim([-.5, self.iter+.5])\\n self.iter += 1\",\n \"def update_parameters(self, ob_no, hidden, ac_na, fixed_log_probs, q_n, adv_n):\\n self.update_critic(ob_no, hidden, q_n)\\n self.update_policy(ob_no, hidden, ac_na, fixed_log_probs, adv_n)\",\n \"def update_value_parameters(self, vector):\\n\\n self.var_noise.set_value(np.array([vector[0]]))\\n self.mean.set_value(np.array([vector[1]]))\\n self.kernel.update_value_parameters(vector[2:])\\n\\n self.kernel_values = vector[2:]\\n self.mean_value = vector[1:2]\\n self.var_noise_value = vector[0:1]\",\n \"def update_params(self, t, x, **kwargs):\\n raise NotImplementedError\",\n \"def _update_params(self):\\n log.debug(\\\"Updating parameter dict\\\")\\n old_config = self._param_dict.get_config()\\n self._get_config()\\n new_config = self._param_dict.get_config() \\n if (new_config != old_config):\\n self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)\",\n \"def signal_vwap(self):\\n pass\",\n \"def params(self,new):\\n self._params = new\\n self._config_set()\\n self._make_model()\",\n \"def fit(self, signal):\\n self.signal = signal\",\n \"def _update_PID(self):\\n self.pid = PID(p=self.paramP, i=self.paramI, d=self.paramD, setpoint=self.voltageSetpoint, memory=self.paramMemory)\",\n \"def add_nfb_export_data(self, signal: dict):\\n signal[\\\"fSmoothingFactor\\\"] = self.smoothingFactor()\\n signal[\\\"method\\\"] = self.method()\\n signal[\\\"sTemporalSmootherType\\\"] = self.smootherType()\",\n \"def Process(self, in_signal): ###\\n if not hasattr(self, \\\"_warned\\\"):\\n self._warned = False\\n if not self._warned:\\n self._warned = True\\n print()\\n print()\\n print(\\\"Hello, this is the BciGenericSignalProcessing superclass.\\\")\\n print(\\\"You have not overshadowed Process(self, sig) inside a\\\")\\n print(\\\"BciSignalProcessing subclass, or perhaps not defined \\\")\\n print(\\\"a BciSignalProcessing subclass in the first place.\\\")\\n print(\\\"Either way, the signal is not being processed.\\\")\\n print()\",\n \"def update_parameters(updates):\\r\\n for (key, val) in updates.items():\\r\\n par[key] = val\\r\\n print('Updating:', key, '-->', val)\\r\\n update_dependencies()\",\n \"def _paramUpdate(self):\\n\\n # Update the database attributes accordingly.\\n dt.utilities.DB_attrs_save(self.Database, self.newParam)\",\n \"def prob_update(self):\\n pass\",\n \"def _parse_args_consistent_with_mfd(self):\\n self.signal_parameters = self.translate_keys_to_lal(\\n {\\n key: self.__dict__[key]\\n for key in self.signal_parameter_labels\\n if self.__dict__.get(key, None) is not None\\n }\\n )\\n\\n self.signal_formats = {\\n key: self.gps_time_and_string_formats_as_LAL.get(key, \\\":1.18e\\\")\\n for key in self.signal_parameters\\n }\",\n \"def update(self, params):\",\n \"def update(self, datain):\\r\\n self.arraydata = datain\\r\\n self.layoutChanged.emit()\",\n \"def process_event(self, event):\\n if not self.frozen:\\n if event[\\\"event\\\"] == self.event:\\n if self.what is None or event[\\\"target\\\"].startswith(self.what):\\n self._varstate = event\\n try:\\n for key in self.subval:\\n self._varstate = self._varstate[key]\\n\\n if bridgectl.log:\\n bridgectl.log.debug(\\n \\\"New value for {} is {}\\\".format(\\n self.name,\\n self._varstate))\\n except Exception as e:\\n if bridgectl.log:\\n bridgectl.log.critical(\\n \\\"Failed to process event for {}\\\".format(\\n self.name),\\n exc_info=(type(e),\\n e,\\n e.__traceback__))\\n pass\\n if event['event'] == 'time tick':\\n if self.period in event[\\\"starts\\\"]:\\n self._varstate = self.reset()\",\n \"def _set_params(self,x):\\r\\n assert x.size==3\\r\\n self.variance = x[0]\\r\\n self.lengthscale = x[1]\\r\\n self.period = x[2]\\r\\n\\r\\n self.a = [1./self.lengthscale, 1.]\\r\\n self.b = [1]\\r\\n\\r\\n self.basis_alpha = np.ones((self.n_basis,))\\r\\n self.basis_omega = np.array(sum([[i*2*np.pi/self.period]*2 for i in range(1,self.n_freq+1)],[]))\\r\\n self.basis_phi = np.array(sum([[-np.pi/2, 0.] for i in range(1,self.n_freq+1)],[]))\\r\\n\\r\\n self.G = self.Gram_matrix()\\r\\n self.Gi = np.linalg.inv(self.G)\",\n \"def _apply_params(self):\\n config = self.get_startup_config()\\n # Pass true to _set_params so we know these are startup values\\n self._set_params(config, True)\",\n \"def update_parameters(parameters, grads, learning_rate):\\n pass\",\n \"def _set_parameter(self):\\n # Get parameter keys\\n self.input_parameter = self.parameter_combobox.currentText()\\n self.result_parameter = self.result_parameters[self.input_parameter]\\n # Adjust axes labels\\n self.ax.set_xlabel('{} steunpunt'.format(self.input_parameter))\\n self.ax.set_ylabel('{} uitvoerlocatie'.format(self.input_parameter))\\n # Set data\\n self._set_data()\",\n \"def updateParameters(self, parameters):\\n\\t\\treturn\",\n \"def set_parameters(self,params):\\n K3Supervisor.set_parameters(self,params)\\n self.blending.set_parameters(self.parameters)\",\n \"def updateParms(self):\\n self.p1text.setText(\\\"{0:g}\\\".format(self.parmVal[0]))\\n if len(self.parmVal) > 1:\\n self.p2text.setText(\\\"{0:g}\\\".format(self.parmVal[1]))\\n if len(self.parmVal) > 2:\\n self.p3text.setText(\\\"{0:g}\\\".format(self.parmVal[2]))\\n if len(self.parmVal) > 3:\\n self.p4text.setText(\\\"{0:g}\\\".format(self.parmVal[3]))\",\n \"def em_update_params(self):\\n for name in self.likelihood_params:\\n with self.elbo_check(name):\\n self.update_param(name)\",\n \"def update_parameter(self, name, freq, value):\\n if name not in self._parameters.keys():\\n self.add_parameter(name, [freq], [value])\\n else:\\n param = self.get_parameter(name)\\n param.update_value(freq, value)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6584715","0.6542431","0.62621695","0.6258087","0.62553895","0.62539536","0.61550564","0.6127215","0.60999376","0.60887265","0.60854816","0.6067803","0.60374635","0.6030319","0.5960224","0.5955644","0.5927045","0.5896254","0.57902694","0.57900864","0.5787434","0.5704172","0.57001895","0.5672998","0.56431484","0.5640971","0.563882","0.5637197","0.56106585","0.559716","0.55864733","0.55333877","0.552276","0.5520245","0.5520245","0.5520245","0.5520245","0.5520245","0.5520245","0.5520245","0.5520245","0.55173767","0.5516853","0.54899126","0.54814166","0.54723203","0.54723203","0.54533947","0.54477215","0.54477215","0.54477215","0.54314077","0.54309565","0.5422611","0.54161114","0.54112124","0.53878015","0.53866875","0.538485","0.5372699","0.53709704","0.5368628","0.53639823","0.53635854","0.5359206","0.5357293","0.5357293","0.5355747","0.5355205","0.5353949","0.5353485","0.53394943","0.5329501","0.532011","0.531725","0.53141236","0.53056663","0.5303428","0.5300104","0.5294837","0.52879107","0.52853763","0.528375","0.52813643","0.52786785","0.5262654","0.5259481","0.52589816","0.5247797","0.52356416","0.523223","0.52270526","0.5225662","0.5223719","0.5219303","0.5218997","0.52145636","0.52098334","0.5208813","0.52075887"],"string":"[\n \"0.6584715\",\n \"0.6542431\",\n \"0.62621695\",\n \"0.6258087\",\n \"0.62553895\",\n \"0.62539536\",\n \"0.61550564\",\n \"0.6127215\",\n \"0.60999376\",\n \"0.60887265\",\n \"0.60854816\",\n \"0.6067803\",\n \"0.60374635\",\n \"0.6030319\",\n \"0.5960224\",\n \"0.5955644\",\n \"0.5927045\",\n \"0.5896254\",\n \"0.57902694\",\n \"0.57900864\",\n \"0.5787434\",\n \"0.5704172\",\n \"0.57001895\",\n \"0.5672998\",\n \"0.56431484\",\n \"0.5640971\",\n \"0.563882\",\n \"0.5637197\",\n \"0.56106585\",\n \"0.559716\",\n \"0.55864733\",\n \"0.55333877\",\n \"0.552276\",\n \"0.5520245\",\n \"0.5520245\",\n \"0.5520245\",\n \"0.5520245\",\n \"0.5520245\",\n \"0.5520245\",\n \"0.5520245\",\n \"0.5520245\",\n \"0.55173767\",\n \"0.5516853\",\n \"0.54899126\",\n \"0.54814166\",\n \"0.54723203\",\n \"0.54723203\",\n \"0.54533947\",\n \"0.54477215\",\n \"0.54477215\",\n \"0.54477215\",\n \"0.54314077\",\n \"0.54309565\",\n \"0.5422611\",\n \"0.54161114\",\n \"0.54112124\",\n \"0.53878015\",\n \"0.53866875\",\n \"0.538485\",\n \"0.5372699\",\n \"0.53709704\",\n \"0.5368628\",\n \"0.53639823\",\n \"0.53635854\",\n \"0.5359206\",\n \"0.5357293\",\n \"0.5357293\",\n \"0.5355747\",\n \"0.5355205\",\n \"0.5353949\",\n \"0.5353485\",\n \"0.53394943\",\n \"0.5329501\",\n \"0.532011\",\n \"0.531725\",\n \"0.53141236\",\n \"0.53056663\",\n \"0.5303428\",\n \"0.5300104\",\n \"0.5294837\",\n \"0.52879107\",\n \"0.52853763\",\n \"0.528375\",\n \"0.52813643\",\n \"0.52786785\",\n \"0.5262654\",\n \"0.5259481\",\n \"0.52589816\",\n \"0.5247797\",\n \"0.52356416\",\n \"0.523223\",\n \"0.52270526\",\n \"0.5225662\",\n \"0.5223719\",\n \"0.5219303\",\n \"0.5218997\",\n \"0.52145636\",\n \"0.52098334\",\n \"0.5208813\",\n \"0.52075887\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.79885525"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84598,"cells":{"query":{"kind":"string","value":"Initialize the class for real time processing."},"document":{"kind":"string","value":"def __init__(self, data_rate: Union[int, float], processing_window: int = None):\n super().__init__()\n self.data_rate = data_rate\n self.processing_window = processing_window if processing_window else data_rate\n self.raw_data_buffer = []\n self.processed_data_buffer = []\n self._is_one = None"},"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 initialize(self):\n self._start = time.time()","def initialize(self):\n self._startTime = time.time()","def __init__(self):\n\t\tself._logger = None\n\t\tself._instanciate_logger()\n\t\tself._video_manager = VideoManager(self, self._logger)\n\t\tself._video_thread = None\n\t\tself._audio_manager = AudioManager(self, self._logger)\n\t\tself._audio_thread = None\n\t\tself._input_thread = None\n\t\tself._trigger_manager = None\n\t\tself.is_running = False","def __init__(self):\n self._clock = pg.time.Clock()","def __init__(self):\n self._start = None\n self._end = None\n self._num_frames = 0","def __init__(self):\n # zu Beginn ist noch kein Modus gesetzt\n self.mode = None\n # zu Beginn sind noch keine Channels/ Pins konfiguriert\n self.channels = {}\n # es sind zu Beginn auch noch keine callbacks fuer events hinzugefuegt\n self.events = []","def _init(self) -> None:\n now = time()\n\n # Timestamps for tracking compute durations by task group.\n # Start with length 2 so that we always can compute a valid dt later.\n self.time = [now] * 2\n # The amount of compute since the last timestamp\n self.compute = {}\n # The number of threads at the time\n self.nthreads = [self.scheduler.total_nthreads] * 2","def __init__(self):\n self.buienradar_rpc = {\"rain_at\": self.rain_at,\n \"rain_max\": self.rain_max\n }\n\n multiprocessing.Process.__init__(self)\n self.name = 'buienradar'\n self.shutdown = False\n self._sched = None\n self._rain = []","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def initialize(self):\r\n pass","def initialize(self):\r\n pass","def __init__(self) -> None:\n self.simulation = None\n self.update_time = 0.1\n self.time = None\n self.config = None","def __init__(self):\n self._initialized = False\n self.init()","def __init__(self):\n self._initialized = False\n self.init()","def _initialize(self):\n pass","def _initialize(self):\n pass","def _initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def _init(self):\n pass","def __init__(self):\n\n super(Scheduler, self).__init__()\n self.num_steps = 0\n self.current_time = 0.0\n self.components = []","def __init__(self):\n\n self.elapsed_time = 0","def __init__(self):\n\n super().__init__()\n self._run_flag = True","def initialize(self):\n\t\tpass","def __init__(self):\n game_engine = get_gameengine()\n if game_engine is not None:\n self = game_engine\n else:\n ## The targeted frames per second\n self.target_fps = 200\n\n ## The start time\n self.time = time.time()\n\n ## A list of all registered game objects\n self.game_objects = list()\n\n ## A list of colliders\n self.colliders = list()\n\n ## Manage the user inputs\n self.input_manager = InputManager(self)\n\n ## Determines the state of the Game Engine\n self.running = False\n\n ## Variable to pause the Game Engine\n self.paused = False\n\n self.time_node = pm.PyNode('time1')\n # end if","def init(self) -> None:\n ...","async def initialize(self):","def initialize(cls):","def __init__(self, loop=None):\n object.__setattr__(self, '_loop', loop or get_event_loop())","def __init__(self):\n self.started = Event()","def initialize(self) -> None:\n pass","def init(self) -> None:","def __init__(self):\n\n super(VirtualTimeScheduler, self).__init__()\n self.event_queue = Queue.PriorityQueue()","def __init__(self):\n self._update_scheduled = False","def initialize(self):\n watch_tv = self.args['watch_tv']\n cleaning = self.args['cleaning']\n self.sensor_living = self.get_app('globals').sensor_living # type: Sensor\n self.sensor_bedroom = self.get_app('globals').sensor_bedroom # type: Sensor\n self.sensor_spare = self.get_app('globals').sensor_spare # type: Sensor\n self.listen_state(self.watching_tv, watch_tv, new=\"on\")\n self.listen_state(self.stop_watching, watch_tv, new=\"off\")\n self.listen_state(self.clean_on, cleaning, new='on')\n self.listen_state(self.clean_off, cleaning, new='off')","def __init__(self):\n super().__init__('node_name')\n self.create_timer(0.2, self.timer_callback)\n\n self.count = 1","def _initialise_run(self) -> None:","def __init__(self):\n self._done = True\n self._listeners = []\n self._data = None\n self._started_daemon = False","def __init__(self):\n self._read_calibration_data()\n self.set_oversamplings_and_mode(\n HumidityOversampling.x08,\n TemperatureOversampling.x08,\n PressureOversampling.x16,\n SensorMode.Normal)\n self.set_config(\n InactiveDuration.ms1000,\n FilterCoefficient.fc04)","def __init__(self):\n\t\tself.interrupt = False\n\t\tself.direction = OUTPUT.MOTOR_DOWN\n\t\tself.moving = False\n\t\tself.currentFloor = -1\n\n\t\tself.orderQueue = OrderQueue.load_from_file()\n\t\tself.callbackQueue = Queue()\n\t\tself.newOrderQueue = Queue()\n\t\tself.startedOrderQueue = Queue()\n\t\tself.signalPoller = SignalPoller(self.callbackQueue)\n\t\tself.doorTimer = DoorTimer(self.close_door, self.callbackQueue)\n\t\tself.initialize_lights()\n\t\tself.initialize_networkHandler()\n\t\tself.update_and_send_elevator_info()\n\t\tself.set_callbacks()\n\t\tself.networkHandler.start()\n\t\tself.signalPoller.start()\n\t\tself.drive()\n\t\tself.run()","def init(self):\n\t\tsp_addcallback(self.sp_callback)\n\t\tself.downloader.start()","def __init__(self):\n\n self.frameCount = 0\n self._initScreen()\n self._initObjects()\n self._initControls()\n self._initLevel()\n self._start()\n print \"DEBUG: Initializing Game\"\n pass","def initialize(self):","def initialize(self):","def initialize(self):","def initialize(self):","def init(self, **kwargs):\n self._d = {}\n self._th = None\n self._run = True\n self.load()","def __init__(self):\n super().__init__()\n self._active = False\n # Counter, used in the animation\n self._time = 0\n # Store the current image id, initially it's 'default'\n self._image = 'default'","def initialize(self): \r\n pass","def init(self):","def init(self):","async def init(self) -> None:","async def init(self) -> None:","def __init__(self):\n\n super().__init__()\n\n self.active = True\n self.driver = Driver.instance()\n self.camera = Camera.instance()\n\n # define directories and file paths\n date_str = datetime.today().strftime(\"%Y-%m-%d-%H-%M-%S\")\n self.log_dir = f\"{const.Storage.DATA}/{date_str}\"\n self.img_dir = f\"{self.log_dir}/img/\"\n self.log_path = f\"{self.log_dir}/log.csv\"\n self.img_extension = \"npy\"\n\n # ensure that the necessary directories exist\n os.mkdir(self.log_dir)\n os.mkdir(self.img_dir)\n assert os.path.isdir(self.log_dir), \"data directory could not be created\"\n assert os.path.isdir(self.img_dir), \"image directory could not be created\"","def __init__(self, time):\n pass","def initialize(self, *args, **kwargs):\n pass","def initialize(self):\n pass # pragma: no cover","def init(self):\n raise NotImplementedError","def init(self):\n raise NotImplementedError","def do_init(self):\n\n pass","def __init__(self):\n Thread.__init__(self)\n self.start() # start the thread","def initialize(self):\n return","def __init__(self):\n print(\"Initializing\")","def __init__(self):\n print(\"Initializing\")","def init(self, start):\r\n\t\tself.start = start\r\n\t\tself.time = 0\r\n\t\tself.t = []\r\n\t\tself.ch = []","def __init__(self):\n # load files\n self.init_bin_start_time = load_last_bin_time()\n self.prev_value_cache = load_prev_val_cache()\n self.init_job_vals_dict = load_job_init_vals()\n\n config = load_config()\n self.database_domain = config[ConfigFields.DATABASE_DOMAIN]\n self.metrics = config[ConfigFields.METRICS]\n self.bin_duration = config[ConfigFields.BIN_DURATION]\n\n \"to be overwritten when server time is found in a job\"\n self.current_time = int(time.time())\n self.bin_start_times = None # updated below\n self.final_bin_end_time = None # updated below\n self.update_bin_times() # updates","def initialize(self):\n self.initilize_multiply_array() # m\n self.initialize_cameras()\n self.initialize_electronics()\n self.logger.info('Starting free runs and continuous reads')\n self.camera_microscope.start_free_run()\n self.camera_microscope.continuous_reads()\n self.camera_fiber.start_free_run()\n self.camera_fiber.continuous_reads()\n self.servo_off()\n\n time.sleep(1) #m Without the sleep below initialize_multiply_array does not work","def __init__(self, loop):\n super().__init__()\n self.loop = loop\n self.pending = set()","def __init__(self) -> None:\n self.metrics = {}\n self.current = None\n self.run = None","def __init__(self, config, loop):\n self.config = config\n self.loop = loop","def __init__(self):\n\t\tprint(\"Class initilised\")","def __init__(self):\n self.initialized = False","def __init__(self):\n self.initialized = False","def __init__(self):\n # A lock/condition to protected _time. It is notified whenever _time is changed.\n self._time_condition = threading.Condition()\n # The current time in seconds past epoch.\n self._time = 0.0\n # A lock/condition to protect _waiting_threads. It is notified whenever _waiting_threads is changed.\n self._waiting_condition = threading.Condition()\n # The number of threads that are blocking in `simulate_waiting`.\n self._waiting_threads = 0","def __init__(self):\r\n\r\n self.Helpers = Helpers(\"Movidius\")\r\n self.confs = self.Helpers.confs\r\n\r\n self.classes = []\r\n self.ncsGraph = None\r\n self.ncsDevice = None\r\n self.reqsize = None\r\n\r\n self.mean = 128\r\n self.std = 1 / 128\r\n\r\n #mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2)\r\n\r\n self.Helpers.logger.info(\"Movidius class initialization complete.\")","def _init(self):\n # A string of the last image taken\n self.last_image = None\n\n # Number of images captured\n self.image_count = 0\n\n # Duration tracking. Set high to cause capture on first load\n self._duration_start = -(60 * 60 * 24)","def __init__(self):\n self._events = collections.deque()\n self._alarms = 0\n self._alarm_active = True\n self._kq = select.kqueue()\n self._kq_events = {}\n self.traceback = ()\n self.event_count = 0\n self._no_tb = False","def __init__(self):\n self._data = None\n self._result = None\n self._error = None\n self.complete = False\n self.cancelled = False\n self._running = False\n self._callback = None\n self._joiners = list()","def initialize(self, *args, **kwargs):\n self.initialized = True","def __init__(self):\n self.ts = dict()\n self.cache = dict()","def on_start(self):\n self.init()","def _initialize(self):\n self.send_init_command()","def __init__(self, clock=proctime):\n self._clock = clock","def init(self):\n self.dispatcher.start()\n self.replyer.start()","def __init__(self) -> None:\n # TODO: Provide the complete constructor for this object","def __init__(self):\n self._pub = rospy.Publisher(self.TOPIC, MarkerArray, queue_size=10)\n loc_sub = message_filters.Subscriber('/object_analytics/localization', ObjectsInBoxes3D)\n det_sub = message_filters.Subscriber('/object_analytics/detection', ObjectsInBoxes)\n tra_sub = message_filters.Subscriber('/object_analytics/tracking', TrackedObjects)\n\n ts = message_filters.TimeSynchronizer([det_sub, loc_sub, tra_sub], 10)\n ts.registerCallback(self._callback)","def on_load(self):\n self.__init__()","def autonomousInit(self):\n #self.timer.reset()\n #self.timer.start()\n pass","def __init__(self, interval=1.0):\n\n self.last_input_time = -1.0\n self.last_output_time = -1.0\n self.last_spent = -1.0\n self.last_dt = -1.0\n\n super(RealTimeSyncScheduler, self).__init__()\n self.set_interval(interval)","def __init__(self):\n \n self.load_PSF_data()","def __init__(self, **kwargs):\n self.is_initialized = False\n self.delta = 1"],"string":"[\n \"def initialize(self):\\n self._start = time.time()\",\n \"def initialize(self):\\n self._startTime = time.time()\",\n \"def __init__(self):\\n\\t\\tself._logger = None\\n\\t\\tself._instanciate_logger()\\n\\t\\tself._video_manager = VideoManager(self, self._logger)\\n\\t\\tself._video_thread = None\\n\\t\\tself._audio_manager = AudioManager(self, self._logger)\\n\\t\\tself._audio_thread = None\\n\\t\\tself._input_thread = None\\n\\t\\tself._trigger_manager = None\\n\\t\\tself.is_running = False\",\n \"def __init__(self):\\n self._clock = pg.time.Clock()\",\n \"def __init__(self):\\n self._start = None\\n self._end = None\\n self._num_frames = 0\",\n \"def __init__(self):\\n # zu Beginn ist noch kein Modus gesetzt\\n self.mode = None\\n # zu Beginn sind noch keine Channels/ Pins konfiguriert\\n self.channels = {}\\n # es sind zu Beginn auch noch keine callbacks fuer events hinzugefuegt\\n self.events = []\",\n \"def _init(self) -> None:\\n now = time()\\n\\n # Timestamps for tracking compute durations by task group.\\n # Start with length 2 so that we always can compute a valid dt later.\\n self.time = [now] * 2\\n # The amount of compute since the last timestamp\\n self.compute = {}\\n # The number of threads at the time\\n self.nthreads = [self.scheduler.total_nthreads] * 2\",\n \"def __init__(self):\\n self.buienradar_rpc = {\\\"rain_at\\\": self.rain_at,\\n \\\"rain_max\\\": self.rain_max\\n }\\n\\n multiprocessing.Process.__init__(self)\\n self.name = 'buienradar'\\n self.shutdown = False\\n self._sched = None\\n self._rain = []\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def initialize(self):\\r\\n pass\",\n \"def initialize(self):\\r\\n pass\",\n \"def __init__(self) -> None:\\n self.simulation = None\\n self.update_time = 0.1\\n self.time = None\\n self.config = None\",\n \"def __init__(self):\\n self._initialized = False\\n self.init()\",\n \"def __init__(self):\\n self._initialized = False\\n self.init()\",\n \"def _initialize(self):\\n pass\",\n \"def _initialize(self):\\n pass\",\n \"def _initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def _init(self):\\n pass\",\n \"def __init__(self):\\n\\n super(Scheduler, self).__init__()\\n self.num_steps = 0\\n self.current_time = 0.0\\n self.components = []\",\n \"def __init__(self):\\n\\n self.elapsed_time = 0\",\n \"def __init__(self):\\n\\n super().__init__()\\n self._run_flag = True\",\n \"def initialize(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n game_engine = get_gameengine()\\n if game_engine is not None:\\n self = game_engine\\n else:\\n ## The targeted frames per second\\n self.target_fps = 200\\n\\n ## The start time\\n self.time = time.time()\\n\\n ## A list of all registered game objects\\n self.game_objects = list()\\n\\n ## A list of colliders\\n self.colliders = list()\\n\\n ## Manage the user inputs\\n self.input_manager = InputManager(self)\\n\\n ## Determines the state of the Game Engine\\n self.running = False\\n\\n ## Variable to pause the Game Engine\\n self.paused = False\\n\\n self.time_node = pm.PyNode('time1')\\n # end if\",\n \"def init(self) -> None:\\n ...\",\n \"async def initialize(self):\",\n \"def initialize(cls):\",\n \"def __init__(self, loop=None):\\n object.__setattr__(self, '_loop', loop or get_event_loop())\",\n \"def __init__(self):\\n self.started = Event()\",\n \"def initialize(self) -> None:\\n pass\",\n \"def init(self) -> None:\",\n \"def __init__(self):\\n\\n super(VirtualTimeScheduler, self).__init__()\\n self.event_queue = Queue.PriorityQueue()\",\n \"def __init__(self):\\n self._update_scheduled = False\",\n \"def initialize(self):\\n watch_tv = self.args['watch_tv']\\n cleaning = self.args['cleaning']\\n self.sensor_living = self.get_app('globals').sensor_living # type: Sensor\\n self.sensor_bedroom = self.get_app('globals').sensor_bedroom # type: Sensor\\n self.sensor_spare = self.get_app('globals').sensor_spare # type: Sensor\\n self.listen_state(self.watching_tv, watch_tv, new=\\\"on\\\")\\n self.listen_state(self.stop_watching, watch_tv, new=\\\"off\\\")\\n self.listen_state(self.clean_on, cleaning, new='on')\\n self.listen_state(self.clean_off, cleaning, new='off')\",\n \"def __init__(self):\\n super().__init__('node_name')\\n self.create_timer(0.2, self.timer_callback)\\n\\n self.count = 1\",\n \"def _initialise_run(self) -> None:\",\n \"def __init__(self):\\n self._done = True\\n self._listeners = []\\n self._data = None\\n self._started_daemon = False\",\n \"def __init__(self):\\n self._read_calibration_data()\\n self.set_oversamplings_and_mode(\\n HumidityOversampling.x08,\\n TemperatureOversampling.x08,\\n PressureOversampling.x16,\\n SensorMode.Normal)\\n self.set_config(\\n InactiveDuration.ms1000,\\n FilterCoefficient.fc04)\",\n \"def __init__(self):\\n\\t\\tself.interrupt = False\\n\\t\\tself.direction = OUTPUT.MOTOR_DOWN\\n\\t\\tself.moving = False\\n\\t\\tself.currentFloor = -1\\n\\n\\t\\tself.orderQueue = OrderQueue.load_from_file()\\n\\t\\tself.callbackQueue = Queue()\\n\\t\\tself.newOrderQueue = Queue()\\n\\t\\tself.startedOrderQueue = Queue()\\n\\t\\tself.signalPoller = SignalPoller(self.callbackQueue)\\n\\t\\tself.doorTimer = DoorTimer(self.close_door, self.callbackQueue)\\n\\t\\tself.initialize_lights()\\n\\t\\tself.initialize_networkHandler()\\n\\t\\tself.update_and_send_elevator_info()\\n\\t\\tself.set_callbacks()\\n\\t\\tself.networkHandler.start()\\n\\t\\tself.signalPoller.start()\\n\\t\\tself.drive()\\n\\t\\tself.run()\",\n \"def init(self):\\n\\t\\tsp_addcallback(self.sp_callback)\\n\\t\\tself.downloader.start()\",\n \"def __init__(self):\\n\\n self.frameCount = 0\\n self._initScreen()\\n self._initObjects()\\n self._initControls()\\n self._initLevel()\\n self._start()\\n print \\\"DEBUG: Initializing Game\\\"\\n pass\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def init(self, **kwargs):\\n self._d = {}\\n self._th = None\\n self._run = True\\n self.load()\",\n \"def __init__(self):\\n super().__init__()\\n self._active = False\\n # Counter, used in the animation\\n self._time = 0\\n # Store the current image id, initially it's 'default'\\n self._image = 'default'\",\n \"def initialize(self): \\r\\n pass\",\n \"def init(self):\",\n \"def init(self):\",\n \"async def init(self) -> None:\",\n \"async def init(self) -> None:\",\n \"def __init__(self):\\n\\n super().__init__()\\n\\n self.active = True\\n self.driver = Driver.instance()\\n self.camera = Camera.instance()\\n\\n # define directories and file paths\\n date_str = datetime.today().strftime(\\\"%Y-%m-%d-%H-%M-%S\\\")\\n self.log_dir = f\\\"{const.Storage.DATA}/{date_str}\\\"\\n self.img_dir = f\\\"{self.log_dir}/img/\\\"\\n self.log_path = f\\\"{self.log_dir}/log.csv\\\"\\n self.img_extension = \\\"npy\\\"\\n\\n # ensure that the necessary directories exist\\n os.mkdir(self.log_dir)\\n os.mkdir(self.img_dir)\\n assert os.path.isdir(self.log_dir), \\\"data directory could not be created\\\"\\n assert os.path.isdir(self.img_dir), \\\"image directory could not be created\\\"\",\n \"def __init__(self, time):\\n pass\",\n \"def initialize(self, *args, **kwargs):\\n pass\",\n \"def initialize(self):\\n pass # pragma: no cover\",\n \"def init(self):\\n raise NotImplementedError\",\n \"def init(self):\\n raise NotImplementedError\",\n \"def do_init(self):\\n\\n pass\",\n \"def __init__(self):\\n Thread.__init__(self)\\n self.start() # start the thread\",\n \"def initialize(self):\\n return\",\n \"def __init__(self):\\n print(\\\"Initializing\\\")\",\n \"def __init__(self):\\n print(\\\"Initializing\\\")\",\n \"def init(self, start):\\r\\n\\t\\tself.start = start\\r\\n\\t\\tself.time = 0\\r\\n\\t\\tself.t = []\\r\\n\\t\\tself.ch = []\",\n \"def __init__(self):\\n # load files\\n self.init_bin_start_time = load_last_bin_time()\\n self.prev_value_cache = load_prev_val_cache()\\n self.init_job_vals_dict = load_job_init_vals()\\n\\n config = load_config()\\n self.database_domain = config[ConfigFields.DATABASE_DOMAIN]\\n self.metrics = config[ConfigFields.METRICS]\\n self.bin_duration = config[ConfigFields.BIN_DURATION]\\n\\n \\\"to be overwritten when server time is found in a job\\\"\\n self.current_time = int(time.time())\\n self.bin_start_times = None # updated below\\n self.final_bin_end_time = None # updated below\\n self.update_bin_times() # updates\",\n \"def initialize(self):\\n self.initilize_multiply_array() # m\\n self.initialize_cameras()\\n self.initialize_electronics()\\n self.logger.info('Starting free runs and continuous reads')\\n self.camera_microscope.start_free_run()\\n self.camera_microscope.continuous_reads()\\n self.camera_fiber.start_free_run()\\n self.camera_fiber.continuous_reads()\\n self.servo_off()\\n\\n time.sleep(1) #m Without the sleep below initialize_multiply_array does not work\",\n \"def __init__(self, loop):\\n super().__init__()\\n self.loop = loop\\n self.pending = set()\",\n \"def __init__(self) -> None:\\n self.metrics = {}\\n self.current = None\\n self.run = None\",\n \"def __init__(self, config, loop):\\n self.config = config\\n self.loop = loop\",\n \"def __init__(self):\\n\\t\\tprint(\\\"Class initilised\\\")\",\n \"def __init__(self):\\n self.initialized = False\",\n \"def __init__(self):\\n self.initialized = False\",\n \"def __init__(self):\\n # A lock/condition to protected _time. It is notified whenever _time is changed.\\n self._time_condition = threading.Condition()\\n # The current time in seconds past epoch.\\n self._time = 0.0\\n # A lock/condition to protect _waiting_threads. It is notified whenever _waiting_threads is changed.\\n self._waiting_condition = threading.Condition()\\n # The number of threads that are blocking in `simulate_waiting`.\\n self._waiting_threads = 0\",\n \"def __init__(self):\\r\\n\\r\\n self.Helpers = Helpers(\\\"Movidius\\\")\\r\\n self.confs = self.Helpers.confs\\r\\n\\r\\n self.classes = []\\r\\n self.ncsGraph = None\\r\\n self.ncsDevice = None\\r\\n self.reqsize = None\\r\\n\\r\\n self.mean = 128\\r\\n self.std = 1 / 128\\r\\n\\r\\n #mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2)\\r\\n\\r\\n self.Helpers.logger.info(\\\"Movidius class initialization complete.\\\")\",\n \"def _init(self):\\n # A string of the last image taken\\n self.last_image = None\\n\\n # Number of images captured\\n self.image_count = 0\\n\\n # Duration tracking. Set high to cause capture on first load\\n self._duration_start = -(60 * 60 * 24)\",\n \"def __init__(self):\\n self._events = collections.deque()\\n self._alarms = 0\\n self._alarm_active = True\\n self._kq = select.kqueue()\\n self._kq_events = {}\\n self.traceback = ()\\n self.event_count = 0\\n self._no_tb = False\",\n \"def __init__(self):\\n self._data = None\\n self._result = None\\n self._error = None\\n self.complete = False\\n self.cancelled = False\\n self._running = False\\n self._callback = None\\n self._joiners = list()\",\n \"def initialize(self, *args, **kwargs):\\n self.initialized = True\",\n \"def __init__(self):\\n self.ts = dict()\\n self.cache = dict()\",\n \"def on_start(self):\\n self.init()\",\n \"def _initialize(self):\\n self.send_init_command()\",\n \"def __init__(self, clock=proctime):\\n self._clock = clock\",\n \"def init(self):\\n self.dispatcher.start()\\n self.replyer.start()\",\n \"def __init__(self) -> None:\\n # TODO: Provide the complete constructor for this object\",\n \"def __init__(self):\\n self._pub = rospy.Publisher(self.TOPIC, MarkerArray, queue_size=10)\\n loc_sub = message_filters.Subscriber('/object_analytics/localization', ObjectsInBoxes3D)\\n det_sub = message_filters.Subscriber('/object_analytics/detection', ObjectsInBoxes)\\n tra_sub = message_filters.Subscriber('/object_analytics/tracking', TrackedObjects)\\n\\n ts = message_filters.TimeSynchronizer([det_sub, loc_sub, tra_sub], 10)\\n ts.registerCallback(self._callback)\",\n \"def on_load(self):\\n self.__init__()\",\n \"def autonomousInit(self):\\n #self.timer.reset()\\n #self.timer.start()\\n pass\",\n \"def __init__(self, interval=1.0):\\n\\n self.last_input_time = -1.0\\n self.last_output_time = -1.0\\n self.last_spent = -1.0\\n self.last_dt = -1.0\\n\\n super(RealTimeSyncScheduler, self).__init__()\\n self.set_interval(interval)\",\n \"def __init__(self):\\n \\n self.load_PSF_data()\",\n \"def __init__(self, **kwargs):\\n self.is_initialized = False\\n self.delta = 1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7711892","0.76289284","0.73504174","0.7244866","0.7172699","0.71558505","0.7131929","0.7114648","0.71031666","0.71031666","0.71031666","0.71031666","0.71031666","0.71031666","0.71031666","0.71031666","0.70616686","0.70616686","0.7052515","0.7051719","0.7051719","0.7040977","0.7040977","0.7040977","0.7018033","0.7018033","0.7018033","0.7018033","0.7018033","0.7017691","0.7006126","0.7004176","0.69982165","0.6976638","0.6974979","0.6971698","0.69701564","0.6956352","0.69530964","0.6946451","0.6935173","0.6921663","0.69011444","0.6894571","0.689358","0.68759334","0.68750316","0.68704796","0.68491","0.6846664","0.6841676","0.68273443","0.6816626","0.6816626","0.6816626","0.6816626","0.68135625","0.68053156","0.67981774","0.6797127","0.6797127","0.6784058","0.6784058","0.67832154","0.67788196","0.677466","0.6770357","0.6759755","0.6759755","0.6750706","0.67476285","0.6742477","0.673694","0.673694","0.67260873","0.6722885","0.6722014","0.6713804","0.6704185","0.67027795","0.66988564","0.66983145","0.66983145","0.6692173","0.66896725","0.66893375","0.6679526","0.6678245","0.6676761","0.66721636","0.6667922","0.66679066","0.666707","0.6664892","0.66633487","0.66602856","0.6656706","0.6653553","0.66491723","0.6647641","0.6642695"],"string":"[\n \"0.7711892\",\n \"0.76289284\",\n \"0.73504174\",\n \"0.7244866\",\n \"0.7172699\",\n \"0.71558505\",\n \"0.7131929\",\n \"0.7114648\",\n \"0.71031666\",\n \"0.71031666\",\n \"0.71031666\",\n \"0.71031666\",\n \"0.71031666\",\n \"0.71031666\",\n \"0.71031666\",\n \"0.71031666\",\n \"0.70616686\",\n \"0.70616686\",\n \"0.7052515\",\n \"0.7051719\",\n \"0.7051719\",\n \"0.7040977\",\n \"0.7040977\",\n \"0.7040977\",\n \"0.7018033\",\n \"0.7018033\",\n \"0.7018033\",\n \"0.7018033\",\n \"0.7018033\",\n \"0.7017691\",\n \"0.7006126\",\n \"0.7004176\",\n \"0.69982165\",\n \"0.6976638\",\n \"0.6974979\",\n \"0.6971698\",\n \"0.69701564\",\n \"0.6956352\",\n \"0.69530964\",\n \"0.6946451\",\n \"0.6935173\",\n \"0.6921663\",\n \"0.69011444\",\n \"0.6894571\",\n \"0.689358\",\n \"0.68759334\",\n \"0.68750316\",\n \"0.68704796\",\n \"0.68491\",\n \"0.6846664\",\n \"0.6841676\",\n \"0.68273443\",\n \"0.6816626\",\n \"0.6816626\",\n \"0.6816626\",\n \"0.6816626\",\n \"0.68135625\",\n \"0.68053156\",\n \"0.67981774\",\n \"0.6797127\",\n \"0.6797127\",\n \"0.6784058\",\n \"0.6784058\",\n \"0.67832154\",\n \"0.67788196\",\n \"0.677466\",\n \"0.6770357\",\n \"0.6759755\",\n \"0.6759755\",\n \"0.6750706\",\n \"0.67476285\",\n \"0.6742477\",\n \"0.673694\",\n \"0.673694\",\n \"0.67260873\",\n \"0.6722885\",\n \"0.6722014\",\n \"0.6713804\",\n \"0.6704185\",\n \"0.67027795\",\n \"0.66988564\",\n \"0.66983145\",\n \"0.66983145\",\n \"0.6692173\",\n \"0.66896725\",\n \"0.66893375\",\n \"0.6679526\",\n \"0.6678245\",\n \"0.6676761\",\n \"0.66721636\",\n \"0.6667922\",\n \"0.66679066\",\n \"0.666707\",\n \"0.6664892\",\n \"0.66633487\",\n \"0.66602856\",\n \"0.6656706\",\n \"0.6653553\",\n \"0.66491723\",\n \"0.6647641\",\n \"0.6642695\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84599,"cells":{"query":{"kind":"string","value":"Process EMG data in realtime."},"document":{"kind":"string","value":"def process_emg(\n self,\n emg_data: np.ndarray,\n mvc_list: Union[list, tuple] = None,\n band_pass_filter=True,\n low_pass_filter=False,\n moving_average=True,\n centering=True,\n absolute_value=True,\n normalization=False,\n moving_average_window=200,\n **kwargs,\n ) -> np.ndarray:\n self.update_signal_processing_parameters(**kwargs)\n tic = time.time()\n if low_pass_filter and moving_average:\n raise RuntimeError(\"Please choose between low-pass filter and moving average.\")\n ma_win = moving_average_window\n if ma_win > self.processing_window:\n raise RuntimeError(f\"Moving average windows ({ma_win}) higher than emg windows ({self.processing_window}).\")\n emg_sample = emg_data.shape[1]\n if emg_sample == 0:\n raise RuntimeError(\"EMG data are empty.\")\n\n if normalization:\n if not mvc_list:\n raise RuntimeError(\"Please give a list of mvc to normalize the emg signal.\")\n if isinstance(mvc_list, np.ndarray) is True:\n if len(mvc_list.shape) == 1:\n quot = mvc_list.reshape(-1, 1)\n else:\n quot = mvc_list\n else:\n quot = np.array(mvc_list).reshape(-1, 1)\n else:\n quot = [1]\n\n if len(self.raw_data_buffer) == 0:\n self.raw_data_buffer = emg_data\n processed_shape = self.raw_data_buffer.shape[1] if not moving_average else 1\n self.processed_data_buffer = np.zeros((emg_data.shape[0], processed_shape))\n\n elif self.raw_data_buffer.shape[1] < self.processing_window:\n self.raw_data_buffer = np.append(self.raw_data_buffer, emg_data, axis=1)\n if not moving_average:\n self.processed_data_buffer = np.append(\n self.processed_data_buffer, np.zeros((emg_data.shape[0], emg_sample)), axis=1\n )\n else:\n self.processed_data_buffer = np.append(\n self.processed_data_buffer, np.zeros((emg_data.shape[0], 1)), axis=1\n )\n\n else:\n self.raw_data_buffer = np.append(\n self.raw_data_buffer[:, -self.processing_window + emg_sample :], emg_data, axis=1\n )\n emg_proc_tmp = self.process_generic_signal(\n self.raw_data_buffer,\n band_pass_filter=band_pass_filter,\n centering=centering,\n absolute_value=absolute_value,\n low_pass_filter=False,\n moving_average=False,\n normalization=False,\n )\n self.processed_data_buffer = emg_proc_tmp / quot\n if low_pass_filter:\n self.processed_data_buffer = (\n self.butter_lowpass_filter(emg_proc_tmp, self.lpf_lcut, self.data_rate, order=self.lp_butter_order)\n / quot\n )\n elif moving_average:\n average = np.median(emg_proc_tmp[:, -ma_win:], axis=1).reshape(-1, 1)\n self.processed_data_buffer = np.append(self.processed_data_buffer[:, 1:], average / quot, axis=1)\n self.process_time.append(time.time() - tic)\n return self.processed_data_buffer"},"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 run(self):\r\n self.collect_data()","def process():","def run(self):\n while(not self.stop_event.is_set()):\n # read values until stop is sent\n response1 = _read_once(1,self.serial)\n response2 = _read_once(2,self.serial)\n #print(response)\n self.data1[\"d\"].append(response1) # Push response to the data list for later\n self.data2[\"d\"].append(response2) # Push response to the data list for later\n curTime = time.time()\n self.data1[\"t\"].append(curTime)\n self.data2[\"t\"].append(curTime)\n #sleep(0.0001) # I need to be small enough to capture peaks.\n return","def handle_event(self):\n self.done = False\n while not self.done:\n try:\n callback_item = self.eventq.get(timeout=1)\n if callback_item == 'finish':\n print ('done')\n self.done = True\n else:\n current_ctr = callback_item\n if current_ctr > self.current_counter + 1:\n self.event('missing frames')\n self.current_counter = current_ctr + 1\n\n try:\n print ('current cntr', self.current_counter)\n pv_pairs = {}\n slice = np.array(caget(self.get_data_pv_name()))\n print ('pvname', self.get_data_pv_name())\n # read other pvs\n for pv in self.pvs:\n pv_pairs[pv] = (self.pvs[pv], caget(self.pvs[pv]))\n print ('pv pairs', pv_pairs)\n if slice is None:\n self.done = True\n self.event('reading image times out, possibly the detector exposure time is too small')\n else:\n slice.resize(self.sizex, self.sizey)\n data = ut.Data(slice, pv_pairs)\n # deliver data to monitor\n self.deliver_data(data)\n except:\n self.done = True\n self.event('reading image raises exception, possibly the detector exposure time is too small')\n except tqueue.Empty:\n continue\n\n self.finish()","def collect_data(self):\r\n self.vcp.read(self.vcp.inWaiting())\r\n while True:\r\n data = self.vcp.readline()\r\n data = data.decode(\"ASCII\")\r\n timestamp = \",\" + datetime.datetime.now().strftime(\"%H:%M:%S\")\r\n data_timestamp = data + timestamp\r\n if not self.data_pause:\r\n self.update_anemometer_log.emit(data_timestamp)\r\n if self.stop_timer:\r\n break","def _process(self):\n while True:\n with Timer() as data_timer:\n frame = self._frames_q.get()\n\n with Timer() as agent_timer:\n s, frame_metadata = self._unwrap_frame(frame)\n s = np.expand_dims(s, 0) # batch\n act = self.pred(s)[0][0].argmax()\n put_overwrite(self._actions_q, self._wrap_action(act, frame_metadata))\n\n print('.', end='', flush=True)\n if self.verbose:\n print('Avg data wait time: %.3f' % data_timer.time())\n print('Avg agent neural net eval time: %.3f' % agent_timer.time())","def data_process():\n global localtime\n global value_dict\n sensor_types = sEtting.sensor_types\n sensor_values = []\n msg = None\n value_dict = collections.OrderedDict.fromkeys(sEtting.payload_header)\n value_dict[\"ver_format\"] = sEtting.ver_format\n value_dict[\"FAKE_GPS\"] = sEtting.fake_gps\n value_dict[\"app\"] = sEtting.app\n value_dict[\"ver_app\"] = sEtting.ver_app\n value_dict[\"device_id\"] = sEtting.device_id\n value_dict[\"date\"] = localtime.strftime(\"%Y-%m-%d\")\n value_dict[\"time\"] = localtime.strftime(\"%H:%M:%S\")\n value_dict[\"device\"] = sEtting.device\n\n for sensor in sensor_types:\n if sensor == 'pm25-at':\n value_dict[\"s_d0\"] = get_reading_csv(sensor)\n elif sensor == 'temperature':\n value_dict[\"s_t0\"] = get_reading_csv(sensor)\n elif sensor == 'humidity':\n value_dict[\"s_h0\"] = get_reading_csv(sensor)\n elif sensor == 'pm10-at':\n value_dict[\"s_d1\"] = get_reading_csv(sensor)\n else:\n print 'Not support sensor type.'\n if sEtting.fake_gps == 1:\n value_dict[\"gps_lat\"] = sEtting.fgps_lat\n value_dict[\"gps_lon\"] = sEtting.fgps_lon\n value_dict[\"gps_alt\"] = sEtting.fgps_alt\n value_dict[\"gps_fix\"] = 0\n else:\n value_dict[\"gps_lat\"] = get_gps()[0]\n value_dict[\"gps_lon\"] = get_gps()[1]\n value_dict[\"gps_alt\"] = get_gps()[2]\n value_dict[\"gps_fix\"] = gpsd.fix.mode\n value_dict[\"gps_num\"] = 0\n #if debug_enable == '0':\n msg = \"|\" + \"|\".join([\"=\".join([key, str(val)])\n for key, val in value_dict.items()])\n return msg\n #elif debug_enable == '1':\n # msg_debug = \",\".join([\"=\".join([key, str(val)]) for key, val in value_dict.items()])\n # return msg_debug","def _async_process_data(self):\n raise NotImplementedError","def collect_data(self):\n self.logger.info(\"Waiting for incoming data ...\")\n while True:\n item = self.in_queue.get()\n self.logger.info(\"Received data!\")\n self.collector_process_data(item)","def process_amqp_events(self):\n self.connection.process_data_events()","def process_data(request):\n mongodb = get_db() \n start_time = time.time()\n record_segments(mongodb)\n record_heatmaps(mongodb)\n result = sys._getframe().f_code.co_name, \"COMPLETED\", (time.time() - start_time), \"seconds\"\n print result\n return result","def receive_data(self):\n while True:\n\n data = self.recv_end()\n\n if len(data) > 0:\n\n try:\n self.current_data = json.loads(data)\n self.current_3D_points = base64.b64decode(self.current_data['points'])\n self.is_new_data = True\n\n except:\n # print('cannot load DepthCamera data')\n pass","def process(self):\n pass","def event_loop(self):\n self.timer.blockSignals(True) # prevent runaway condition if timer adds more events to loop during processing\n QCoreApplication.processEvents() # process all incoming signals before going onto next image\n \"\"\" \n During the processEvents call, all incoming signals will be processed \n before moving onto the next image. Events processed here include:\n - updating the new ROIs with self.update_roi_coords()\n - recieving new images and adding them to the process queue with self.recieve_image()\n - updating the number of ROI groups with self.update_num_roi_groups()\n - updating the number of ROIs per group with self.update_num_rois_per_group()\n \"\"\"\n\n self.process_next_image() # processes one image from the queue if it is not empty\n self.save() # only saves data if queue is empty and self.should_save = True\n\n self.timer.blockSignals(False) # allow the timer to trigger the event loop again","def _async_process_data(self):\n data = self._api.get_device_data(self._dev_id)\n\n if not data:\n _LOGGER.error(\"Received no data for device %s\", self._name)\n self.async_write_ha_state()\n return\n\n if \"relay\" in data:\n self._is_on = data[\"relay\"]\n\n self.async_write_ha_state()","def simulateCore(self):\n while len(self.event_q) > 0:\n evts = self.nextEvents()\n self.handleEvents(evts)\n self.gatherSystemStatistics(self.scheduler.system)\n self.dumpEventQueue()","def collect_data(self):\n self.lines = []\n\n while True:\n self._process_serial_data()","def run(self):\n while True:\n try:\n data = self._read()\n except IOError:\n break\n\n if len(data) == 0:\n self.finalize(\"Connection closed.\")\n break\n\n gevent.spawn(self.process_data, data)","def run(self):\n while True:\n try:\n data = self._read()\n except IOError:\n break\n\n if len(data) == 0:\n self.finalize(\"Connection closed.\")\n break\n\n gevent.spawn(self.process_data, data)","def process(self):","def process(self):","def process(self):","def data_received(self, data):\n if self.session is not None:\n size = len(data)\n self.logger.debug('process_data(%r, %d)', data, size)\n self.session.process_data(data, size)","def processor(self, data):\n streaming_data = self.decoder.decodeData(data)\n # Add Your code here to process data and handle transport/storage","def processor(self, data):\n streaming_data = self.decoder.decodeData(data)\n # Add Your code here to process data and handle transport/storage","def processor(self, data):\n streaming_data = self.decoder.decodeData(data)\n # Add Your code here to process data and handle transport/storage","def processor(self, data):\n streaming_data = self.decoder.decodeData(data)\n # Add Your code here to process data and handle transport/storage","def processor(self, data):\n streaming_data = self.decoder.decodeData(data)\n # Add Your code here to process data and handle transport/storage","def processor(self, data):\n streaming_data = self.decoder.decodeData(data)\n # Add Your code here to process data and handle transport/storage","def run(self):\n\n while not self.shutdownEvent.is_set():\n gpsData = self.__getGPSData()\n\n # Broadcast GPS data\n if gpsData:\n msgData = json.dumps(gpsData)\n\n self._msgQueue.put((msgData, MessageType.GPS_MESSAGE))\n\n time.sleep(self._readPeriod)\n\n # Cleanup\n self.__shutdown()","def run():\n\twrite_fuel_data()","def recive_data(self):\n # read all available data\n while self.ser.inWaiting() > self.INPUT_DATA_SIZE+1:\n data = array.array('c')\n # search the header\n data.append(self.ser.read(1))\n while data[0] != chr(1):\n data[0] = self.ser.read(1)\n \n # wait for all available data\n while self.ser.inWaiting() < (self.INPUT_DATA_SIZE-1):\n time.sleep(0.03);\n \n # recives data\n data = self.ser.read(self.INPUT_DATA_SIZE-1)\n \n # prove if you want graphical data\n if self.pushButton_monitor.isChecked():\n # decodes the data\n t = struct.unpack('I', data[3]+data[2]+data[1]+data[0])\n r = struct.unpack('f', data[4]+data[5]+data[6]+data[7])\n x0 = struct.unpack('f', data[8]+data[9]+data[10]+data[11])\n x1 = struct.unpack('f', data[12]+data[13]+data[14]+data[15])\n u = struct.unpack('f', data[16]+data[17]+data[18]+data[19])\n \n self.time = t[0]*25e-9\n \n # prepare the string output\n aux_str = \" t = \"+str(self.time)+\"\\t\"\n aux_str += \" r = \"+str(r[0])+\"\\t\"\n aux_str += \" u = \"+str(u[0])+\"\\t\"\n aux_str += \" x1 = \"+str(x1[0])+\"\\t\"\n aux_str += \" x0 = \"+str(x0[0])+\"\\n\"\n # print string output\n self.textBrowser.insertPlainText(aux_str)\n \n # append data to the arrays\n self.graf_t.append(self.time)\n self.graf_r.append(r[0])\n self.graf_x0.append(x0[0])\n self.graf_x1.append(x1[0])\n self.graf_u.append(u[0])\n \n # remove one value if the arrays have maximum length\n if self.graf_t.buffer_info()[1] >= NUM_SAMPLES:\n self.graf_t.pop(0)\n self.graf_r.pop(0)\n self.graf_x0.pop(0)\n self.graf_x1.pop(0)\n self.graf_u.pop(0)\n \n # reload number of samples lavel\n self.label_samples_value.setText(str(self.graf_t.buffer_info()[1]))\n # reload number of waiting chars in serial rx buffer\n self.label_rx_buff_value.setText(str(self.ser.inWaiting()))\n\n # reload mutex area\n self.updated_data = 1\n \n # prove if there are available id's\n if (self.actionPC_Monitor.isChecked() and data[20] == chr(2)):\n # if it is true, looks how much id's\n i = struct.unpack('B', data[21])\n\n if i[0] < STACK_SIZE:\n for z in range(i[0]):\n new_device = struct.unpack('B', data[z+22])\n new_string = str(new_device[0])\n \n llista = self.listWidget_link.findItems(new_string, QtCore.Qt.MatchExactly)\n if len(llista) == 0:\n self.listWidget_link.addItem(new_string)","def processIncoming(self):\r\n while self.queue.qsize():\r\n try:\r\n volume_T101 = self.queue.get(0)\r\n self.var_pb_progress.set(volume_T101/100) #scale to 100\r\n self.var_T101.set(\"T101: \" + str(round(volume_T101,4)))\r\n self.var_LIT101.set(self.take_reading(volume_T101))\r\n self.update_physical(volume_T101)\r\n self.PLC_command()\r\n self.check_attack(volume_T101)\r\n self.output_results()\r\n self.master.update_idletasks()\r\n except queue.Empty:\r\n pass","def data_collection():\n global PAUSED\n print(\"Detecting nodes\")\n while True:\n data = SOCK.recvfrom(1024)[0] # buffer size is 1024 bytes\n message = data.decode()\n try:\n message_function = message[0]\n message = message[1:]\n \n if message_function == \"t\":\n loc, temp, hum = message.split(\", \")\n temp = (float(temp) * 1.8) + 32 # convert from C to F\n\n # Checks if location is alreay in the rolling_X dictionarys. If not, it creates an entry\n # in the dictionary and populates it with the defaults\n if loc not in ROLLING_TEMPS:\n ROLLING_TEMPS[loc] = copy(TEMPDEQUEDEFAULT)\n print(loc, \"has connected\")\n if loc not in ROLLING_HUMS:\n ROLLING_HUMS[loc] = copy(HUMDEQUEDEFAULT)\n\n # Append new temp and humidity to appropriate deque in dictionaries\n ROLLING_TEMPS[loc].appendleft(temp)\n ROLLING_HUMS[loc].appendleft(hum)\n LAST_RECEIVED[loc] = datetime.datetime.utcnow()\n \n elif message_function == \"c\":\n if message == \"pause\":\n PAUSED = True\n print(\"pausing\")\n elif message == \"unpause\":\n PAUSED = False\n print(\"unpausing\")\n else:\n print(\"unknown command function\")\n elif message_function == \"i\":\n if message == \"status\":\n print(\"Paused:\", PAUSED)\n else:\n print(\"unknown info function\")\n except:\n print(\"malformed data\")","def process_queue(self):\n while self.input_processing_running:\n\n # Process everything in the queue.\n while self.input_queue.qsize() > 0:\n try:\n _telem = self.input_queue.get_nowait()\n self.process_telemetry(_telem)\n\n except Exception as e:\n self.log_error(\"Error processing telemetry dict - %s\" % str(e))\n\n # Sleep while waiting for some new data.\n time.sleep(0.5)","def start_recording_and_saving_data(self, eeg_file_path):\n # set up variables\n self.e_event, self.e_state, user_id, n_samples, n_sam, composer_port, secs, state = self.setup_var()\n # pointers\n n_samples_taken = ct.pointer(n_samples)\n data = ct.pointer(ct.c_double(0))\n user = ct.pointer(user_id)\n ready_to_collect = False\n # start connection\n print \"Connecting...\"\n if self.libEDK.EE_EngineConnect(\"Emotiv Systems-5\") != 0: # connection failed\n print \"Emotiv Engine start up failed.\"\n self.stop_connection()\n sys.exit(1)\n print \"Connected! Start receiving data...\"\n self._recording = True\n # write data to file\n self.f = open(eeg_file_path, 'w')\n # write header\n for header in Constants.HEADER:\n # last one in header\n if header != \"TIMESTAMP\" and not self.f.closed:\n self.f.write(header + \",\")\n elif not self.f.closed:\n self.f.write(header + \"\\n\")\n h_data = self.libEDK.EE_DataCreate()\n self.libEDK.EE_DataSetBufferSizeInSec(secs)\n # start recording\n while self._recording:\n state = self.libEDK.EE_EngineGetNextEvent(self.e_event)\n if state == 0:\n event_type = self.libEDK.EE_EmoEngineEventGetType(self.e_event)\n self.libEDK.EE_EmoEngineEventGetUserId(self.e_event, user)\n # add user\n if event_type == 16:\n print \"User added\"\n self.libEDK.EE_DataAcquisitionEnable(user_id, True)\n ready_to_collect = True\n if ready_to_collect:\n self.libEDK.EE_DataUpdateHandle(0, h_data)\n self.libEDK.EE_DataGetNumberOfSample(h_data,n_samples_taken)\n # print \"Updated :\", n_samples_taken[0]\n if n_samples_taken[0] != 0:\n n_sam = n_samples_taken[0]\n arr = (ct.c_double*n_samples_taken[0])()\n ct.cast(arr, ct.POINTER(ct.c_double))\n # self.libEDK.EE_DataGet(h_data, 3,byref(arr), nSam)\n data = np.array('d') # zeros(n_samples_taken[0],double)\n for sampleIdx in range(n_samples_taken[0]):\n # channel 14 + loc data 6 + timestamp 1 = 23\n data = np.zeros(23)\n for i in range(22):\n self.libEDK.EE_DataGet(h_data, Constants.TARGET_CHANNEL_LIST[i], ct.byref(arr), n_sam)\n if not self.f.closed:\n print >>self.f,arr[sampleIdx],\",\",\n data[i] = arr[sampleIdx]\n # write our own time stamp\n t = time.time()\n data[-1] = t\n if not self.f.closed:\n print >>self.f,t,\n # put data onto out buffer queue\n self.out_buffer_queue.put(data)\n # switch line\n if not self.f.closed:\n print >>self.f,'\\n',\n self.f.flush()\n # not sure the use of this in the original program...\n self.libEDK.EE_DataFree(h_data)","def on_timer(self):\n self.read_serial_data()\n # self.update_monitor()","def data_received(self, data):\n self.log.debug('data_received: {!r}'.format(data))\n self._last_received = datetime.datetime.now()\n for byte in (bytes([value]) for value in data):\n\n try:\n self.stream.feed_byte(byte)\n except (ValueError, AssertionError):\n e_type, e_value, _ = sys.exc_info()\n map(self.log.warn,\n traceback.format_exception_only(e_type, e_value))\n continue\n\n if self.stream.is_oob:\n continue\n\n # self.reader.feed_byte()\n self.shell.feed_byte(byte)","def process(self):\n raise NotImplementedError","def realtime(self):","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def run(self):\n while True:\n if self.job_q.empty():\n self.message_q.put(False)\n return\n try:\n smolecule = self.job_q.get()\n self.data_pointer[smolecule].get_adp(self.Temp)\n except IndexError:\n self.message_q.put((smolecule, None))\n try:\n self.message_q.put((smolecule, [j.adp['cart_int'] for j in self.data_pointer[smolecule].atoms]))\n except KeyError:\n # =======================================================\n # self.message_q.put((molecule,[0 for i in self.data_pointer[molecule].atoms]))\n #=======================================================\n pass","def refresh(self, _loop, data):\n try:\n if(self.model.mode == 'live'):\n self.updateGraphs()\n self.model.memory = int(self.dataClient.recv())\n self.model.cpu = float(self.dataClient.recv())\n except EOFError:\n pass\n except Exception as e:\n self.logger.error(e)\n\n self.view.refresh()\n _loop.set_alarm_in(guiRefreshTimer, self.refresh)","def _parseData(self, payload):\n out=[]\n bytesParsed = 0\n while bytesParsed < len(payload):\n\n #check for the extended Code Level, code and length\n #count the number of EXCODE_BYTE\n #extendedCodeLevel = sum([1 for x in data if x == EXCODE_BYTE] )\n #bytesParsed += extendedCodeLevel\n\n #identify the length of the expected bytes in the payload\n code = payload[bytesParsed]\n bytesParsed +=1\n if code > 0x7F:\n # multi-byte code, length > 1\n length = payload[bytesParsed]\n bytesParsed +=1\n else:\n length = 1\n\n if code == SENSOR_STATUS:\n # value of 0==no contact, 200==contact\n #print \"leadoff: %i\" % payload[bytesParsed]\n out.append( {'timestamp': self.curtime, 'leadoff': payload[bytesParsed] } )\n bytesParsed +=1\n\n elif code == HEART_RATE:\n #print \"HR: %i\" % payload[bytesParsed]\n out.append( {'timestamp': self.curtime, 'HR': payload[bytesParsed:] } )\n bytesParsed +=1\n\n elif code == CONFIG_BYTE:\n #print \"config: %i\" % payload[bytesParsed]\n out.append( {'timestamp': self.curtime, 'config': payload[bytesParsed:] } )\n bytesParsed +=1\n\n elif code == RAW_ECG:\n # raw value is between -32768 and 32767, in twos compliment form\n # if the raw value is higher than 32768, it should be rolled around to allow for negative values\n raw = payload[bytesParsed]*256 + payload[bytesParsed]\n if raw >= 32768: \n raw = raw - 65536\n #print \"ecg: %i\" % ecg\n\n # create the timestamp on each ECG sample, starting from the first\n if self.starttime is None:\n self.starttime = time.time()\n self.curtime = self.starttime\n else:\n self.curtime = self.curtime + 1./self.Fs\n\n out.append( {'timestamp': self.curtime, 'ecg_raw': raw } )\n bytesParsed += length\n\n elif code == DEBUG_1:\n #print \"debug1: \" + str(payload[bytesParsed:]).strip('[]')\n out.append( {'timestamp': self.curtime, 'debug1': payload[bytesParsed:] } )\n bytesParsed += length\n\n elif code == DEBUG_2:\n #print \"debug2: \" + str(payload[bytesParsed:]).strip('[]')\n out.append( {'timestamp': self.curtime, 'debug2': payload[bytesParsed:] } )\n bytesParsed += length\n\n else:\n print \"unknown code: %i\" % code\n\n return out","def collector_process_data(self, data):\n for c in clients:\n c.on_message(json.dumps(data))","def got_data(self, data):\n if self.get_current_state() == SBE37ProtocolState.DIRECT_ACCESS:\n # direct access mode\n if len(data) > 0:\n mi_logger.debug(\"SBE37Protocol._got_data(): <\" + data + \">\") \n if self._driver_event:\n self._driver_event(DriverAsyncEvent.DIRECT_ACCESS, data)\n # TODO: what about logging this as an event?\n return\n \n if len(data)>0:\n # Call the superclass to update line and prompt buffers.\n CommandResponseInstrumentProtocol.got_data(self, data)\n \n # If in streaming mode, process the buffer for samples to publish.\n cur_state = self.get_current_state()\n if cur_state == SBE37ProtocolState.AUTOSAMPLE:\n if SBE37_NEWLINE in self._linebuf:\n lines = self._linebuf.split(SBE37_NEWLINE)\n self._linebuf = lines[-1]\n for line in lines:\n self._extract_sample(line)","def processIncoming(self):\n try:\n msg = self.guiqueue.get(False)\n (PK, XERRO, tt) = getDataFromString(msg)\n self.PK0.append(PK[0])\n self.PK1.append(PK[1])\n self.PK2.append(PK[2])\n self.PK3.append(PK[3])\n self.PK4.append(PK[4])\n self.PK5.append(PK[5])\n self.PK6.append(PK[6])\n self.PK7.append(PK[7])\n self.XERRO0.append(XERRO[0])\n self.XERRO1.append(XERRO[1])\n self.XERRO2.append(XERRO[2])\n self.XERRO3.append(XERRO[3])\n self.XERRO4.append(XERRO[4])\n self.XERRO5.append(XERRO[5])\n self.XERRO6.append(XERRO[6])\n self.XERRO7.append(XERRO[7])\n self.t.append(tt)\n \n \n #replota a cada dado novo\n self.updatePlot()\n \n except queue.Empty:\n #print(\"Fila Vazia\")\n pass\n\n self.root.after(25, self.processIncoming)","def _process(self, data: np.ndarray) -> np.ndarray:","def _process(self, data: np.ndarray) -> np.ndarray:","def processData(pipe, event, pulses):\n logging.info(\"Started processData\")\n start_time = time.time()\n for pulse in range(pulses):\n samples = pipe.get()\n# time.sleep(0.001)\n end_time = time.time()\n elapsed = end_time - start_time\n samplesProcessed = (pulses * len(samples[0]) * len(samples))\n logging.info(\"processData processed %d Msamples in %.3f s\",\n samplesProcessed / 1e6,\n elapsed)\n logging.info(\"processData rate: %.3f Msa/s in lumps of %d samples\",\n samplesProcessed / elapsed / 1e6,\n dig.pointsPerCycle)","def on_message(client, userdata, msg):\n # Bring all the global variables to this scope otherwise python makes new local copies\n global currentFileTime\n global lastDataFrameArrivalTime\n global storeData\n # If this is first instance then make a new file with current time and start placing the data in that file\n if storeData is False:\n storeData = True\n currentFileTime = datetime.now()\n print(\"Opening a new file and storing data in : \" + str(currentFileTime.strftime(\"%Y_%m_%d_%H_%M_%S\"))+\"...\")\n # Store the incoming msg.payload of data to the file\n msg.payload = msg.payload.decode(\"utf-8\")\n dataslice = str(msg.payload)[0:10]\n print(\"Channel::accelarationData:\" + str(dataslice).replace(\"\\n\", \" \") + \"...\")\n lastDataFrameArrivalTime = time.time()\n fileName = currentFileTime.strftime(\"%Y_%m_%d_%H_%M_%S\")\n store_data(fileName, msg.payload)","def eeg_handler(self, unused_addr, args, ch1, ch2, ch3, ch4, ch5, ch6):\n\n\t\tself.data[0, self.eegcount] = ch2\n\t\tself.data[1, self.eegcount] = ch3\n\n\t\tself.eegcount += 1\n\n\t\tif self.eegcount >= self.settings.buffer_size - 1:\n\n\t\t\tself.eegcount = 0\n\t\t\told_data = self.data\n\t\t\tfor i in range(self.settings.num_channels):\n\t\t\t\tself.output_data[i] = self.eeg_to_tones(old_data[i])\n\n\t\t\tself.stream.start_stream()\n\n\t\t\twhile self.stream.is_active():\n\t\t\t\ttime.sleep(self.settings.buffer_size /\n\t\t\t\t\t\t self.settings.playback_rate)\n\n\t\t\tself.stream.stop_stream()\n\t\t\told_data = []","def on_eot(self, data):\n logger.debug('on_eot: %r', data)\n if self.in_transfer_state:\n # put the records together to a message\n if self.messages:\n message = b\"\".join(self.messages)\n self.queue.put_nowait(message)\n self.discard_env()\n else:\n raise InvalidState('Server is not ready to accept EOT message.')","def on_data(self, data):\n if data is not None:\n # Send the data to the parent process\n logging.debug('Received raw data : ' + str(data))\n self.mp_queue.put(data)","def data_received(self, data):\n pass","def process(self, event):\n pass","def run(self):\n\n if self.transport == 'any':\n devs = kromek.discover()\n else:\n devs = kromek.discover(self.transport)\n\n print('Discovered %s' % devs)\n\n if len(devs) <= 0:\n return\n\n filtered = []\n\n for dev in devs:\n if self.device == 'all' or dev[0] in self.device:\n filtered.append(dev)\n\n devs = filtered\n if len(devs) <= 0:\n return\n\n done_devices = set()\n try:\n while self.running:\n print(\"Plot_manager.run: getting data\")\n with kromek.Controller(devs, self.interval) as controller:\n for reading in controller.read():\n if self.create_structures:\n self.total = np.array(reading[4])\n self.lst = np.array([reading[4]])\n self.create_structures = False\n else:\n self.total += np.array(reading[4])\n self.lst = np.concatenate(\n (self.lst, [np.array(reading[4])]))\n serial = reading[0]\n dev_count = reading[1]\n if serial not in done_devices:\n this_start, this_end = self.get_interval(\n time.time() - self.interval)\n\n self.handle_spectra(\n this_start, this_end, reading[4])\n if dev_count >= self.count > 0:\n done_devices.add(serial)\n controller.stop_collector(serial)\n if len(done_devices) >= len(devs):\n break\n except KeyboardInterrupt:\n self.vprint(1, '\\nKeyboardInterrupt: stopping Manager run')\n self.takedown()\n except SystemExit:\n self.vprint(1, '\\nSystemExit: taking down Manager')\n self.takedown()","def monitorMessages(m, rate):\n\n _send_data_request(m, rate)\n\n data_flags = {}\n flight_data = {}\n while continue_messages:\n msg = m.recv_match(blocking=True)\n if not msg or msg.get_type() == \"BAD_DATA\":\n continue\n\n if msg.get_type() == \"ATTITUDE\":\n flight_data['yaw'] = msg.yaw\n flight_data['roll'] = msg.roll\n flight_data['pitch'] = msg.pitch\n flight_data['src_att'] = SRC_PIXHAWK\n # elif msg.get_type() == \"SYSTEM_TIME\": \"\"\"not important: checking timestamp- 08.06\"\"\"\n # flight_data['pixhawktime'] = msg.time_unix_usec\n elif msg.get_type() == \"GLOBAL_POSITION_INT\":\n t = datetime.now()\n flight_data['fd_timestamp'] = t.strftime(TIMESTAMP_SIGNATURE)\n flight_data['timestamp'] = flight_data['fd_timestamp']\n flight_data['lon'] = msg.lon\n flight_data['lat'] = msg.lat\n flight_data['relative_alt'] = msg.relative_alt\n flight_data['hdg'] = msg.hdg\n flight_data['src_hdg'] = SRC_PIXHAWK\n flight_data['src_gps'] = SRC_PIXHAWK\n\n elif msg.get_type() == \"GPS_RAW_INT\":\n flight_data['cog'] = msg.cog\n flight_data['src_cog'] = SRC_PIXHAWK\n\n if 'yaw' in flight_data and 'lon' in flight_data \\\n and 'cog' in flight_data:\n flight_data['src'] = SRC_PIXHAWK\n path = os.path.join(gs.FLIGHT_DATA_FOLDER, \"{timestamp}.json\".format(timestamp=flight_data['timestamp']))\n with open(path, 'wb') as f:\n json.dump(flight_data, f)\n\n reactor.callFromThread(addPHdata, flight_data)\n flight_data = {}","def process(self, data) :\n rData = Core.Processlib.Data()\n rData.frameNumber = data.frameNumber\n rData.buffer = self._worker.process(data.buffer)\n if self._writer: #optional HDF5 writer\n self._writer.write(rData.buffer, rData.frameNumber)","def process_thread(self):","def run(self):\n operation_manager = self._core.get_operation_manager()\n while True:\n while operation_manager.process_next():\n pass\n sleep(2)","def process_data(self):\n timer_start = time.time()\n # ensure self.df_events and self.df_locations are not None\n if self.df_events is None or self.df_locations is None:\n print(\"Missing data: either df_events or df_locations is None\")\n return\n # set start and end based on self.df_events if not already set\n if not self.start:\n self.start = self.df_events['event_time'].min()\n if not self.end:\n self.end = self.df_events['event_time'].max()\n print(f\"date range for events data is from {self.start} to {self.end}\")\n # create Grid object before processing any data\n grid = self.compute_grid_cells(self.df_locations)\n # clean and combine events and locations data\n df_data = self.combine_events_and_locations(grid)\n print(df_data.shape)\n # df_data.to_csv('../../../data_files/20210506_cleanedInputDataCumSum.csv', index=False)\n # df_data = pd.read_csv('../../../data_files/20210415_cleanedInputDataAprilCumSum.csv')\n # process data within grid class\n df_processed = grid.process_data(df_data, 'weekly')\n # df_processed = self.calculate_demand(df_processed)\n # df_processed.to_csv('../../../data_files/20210506_processedGridCellData.csv')\n # set df_demand to be df_processed\n df_processed.reset_index(inplace=True)\n df_processed = df_processed.astype({'date': 'str', 'avail_count': 'float', 'avail_mins': 'float', 'prob_scooter_avail': 'float', 'trips': 'float', 'adj_trips': 'float'})\n # make sure dates are within start and end dates\n start_date = str(iso8601.parse_date(self.start).date())\n end_date = str(iso8601.parse_date(self.end).date())\n df_processed = df_processed[(df_processed['date'] >= start_date) & (df_processed['date'] <= end_date)]\n self.set_demand(df_processed)\n timer_end = time.time()\n print('Elapsed time to process data:', (timer_end - timer_start)/60.0, 'minutes')","def run(self, data):\n\t\t# no processing here\n\t\treturn data","def loop(self):\n data_received = 0\n data = ''\n start_time = time.time()\n current_start_time = time.time()\n current_frames_received = 0\n while not self.halt:\n # Collect data until we have a full frame.\n tmp_data = self.sock.recv(self.chunk_length)\n data += tmp_data\n if tmp_data.startswith(self.sync_start):\n # Reset data variables, to prepare for a new frame.\n data = ''\n data_received = 0\n switch = self.switch_resolution(tmp_data)\n if switch:\n current_start_time = time.time()\n current_frames_received = 0\n elif tmp_data.startswith(self.sync_kill):\n # The server is closing the connection.\n print 'Received kill frame...'\n self.halt = True\n elif self.width != 0 and self.height != 0:\n data_received += self.chunk_length\n # When we've received a frame or more (because of zero padding), \n # then we can finally show it.\n if data_received >= self.full_frame_length():\n data = data[:self.full_frame_length()]\n frame = self.data_to_frame(data)\n if self.output_file is None:\n self.show_video_image(frame)\n else:\n self.write_video_image(frame)\n # Update statistics\n self.received_frames += 1\n current_frames_received += 1\n self.output_statistics_during(start_time, \n current_start_time, \n current_frames_received\n )\n # Reset the values after we've received the whole frame.\n data_received = 0\n data = ''","def stremingData(self):\n ports = com_select()\n self.comport = None\n if not ports:\n QMessageBox.warning(self, 'No Connection',\n \"No unit found please verify that the IMU is connected\")\n else:\n for port in ports:\n if test_con(port):\n self.comport = port\n break\n if self.comport:\n if self.ui.qtBStream.text() == 'Stream':\n self.ui.qtBStream.setText('Stop')\n self.streamData = GetValue(self.comport)\n self.streamData.start()\n iter(self.streamData)\n self.timer = QTimer()\n self.timer.timeout.connect(self.graphupdate)\n self.i = 0\n self.__x = []\n if self.recF:\n if self.ui.qtBrowse.text() == '':\n self.file_select()\n if self.ui.qtBrowse.text() == '':\n QMessageBox.warning(self,\n 'No file',\n 'No file selected')\n self.stremingData()\n return 0\n self.timer.start()\n elif self.ui.qtBStream.text() == 'Stop':\n self.ui.qtBStream.setText('Stream')\n self.timer.stop()\n self.streamData.stop()\n self.data = [[] for i in range(8)]\n else:\n QMessageBox.warning(self, 'No Connection com search',\n \"No unit found please verify that the IMU is connected\")","def ecgalgAnalyzeRaw(self, D, nHRV=30): #, dataqueue):\n #D = self.popBuffer()\n self.analyze.tg_ecg_update(D['ecg_raw'])\n #ecg_filt = self.analyze.tg_ecg_get_raw_filtered() #delayed against raw by 211 samples\n ecg_filt = self.analyze.tg_ecg_get_raw_smoothed() #delayed against raw by 450 samples, if 60Hz powerline\n D['ecg_filt'] = ecg_filt\n\n if self.analyze.tg_ecg_is_r_peak():\n #print \"found peak\"\n num_rri = self.analyze.tg_ecg_get_total_rri_count() \n rri = self.analyze.tg_ecg_get_rri()\n hr = self.analyze.tg_ecg_compute_hr_now()\n D['rri']= rri\n D['hr'] = hr\n print \"%i HR: %i (rri: %i)\" % (num_rri, 60000* 1/rri, rri)\n\n if num_rri>=15 and num_rri < nHRV:\n # slowly increase number of RRIs in HRV calculation until we reach nHRV\n # This is equivalen to starting with a window of 15 RRIs and increasing the window length to max=nHRV\n nHRV = num_rri\n if num_rri >= nHRV and (num_rri+2) % self.HRV_UPDATE == 0: \n #calculate every HRV_UPDATE heartbeats, starting at nHRV (window increases from 15 to 30)\n hrv = self.analyze.tg_ecg_compute_hrv(nHRV)\n D['hrv'] = hrv\n print \"hrv: \" + str(hrv)\n\n return D","def processEvents(self):\n if not self.getIsConnected():\n return\n\n # Loop until there is no more data in the receive buffer.\n while True:\n if not self._socketPoller.isReady():\n # There is no data waiting.\n return\n\n nBytesRead, _ = self._socket.recvfrom_into(self._buffer)\n if nBytesRead <= 0:\n # Since we checked for data ready, we don't expect this.\n return\n\n # _bufferView is a memoryview, so we can slice efficienty.\n self._elementReader.onReceivedData(self._bufferView[0:nBytesRead])","def processEvent(self):\n\t\tself.dataPolarity=float(np.sign(np.mean(self.eventData)))\n\n\t\tself._processEvent()\n\n\t\tif not self.saveTS:\n\t\t\tself.eventData=[]\n\n\t\tself.writeEvent()","def go(self):\n # ipdb.set_trace()\n self.ang_data = np.zeros(int(self.avg.get()))\n self.amp_a2 = np.zeros(int(self.avg.get()))\n self.amp_b2 = np.zeros(int(self.avg.get()))\n self.ab_re = np.zeros(int(self.avg.get()))\n self.ab_im = np.zeros(int(self.avg.get()))\n df = bw*1.0/channels\n self.index = trunc(float(self.freq2meas.get())/df)\n self.index_offset = trunc(int(self.chann_span.get()))\n self.enabler = 1\n #self.t = threading.Thread(target=self.obtain_data, name='data_thread')\n print(enabler)\n self.t.start()\n return 1","def handle(self):\n while True:\n try:\n chunk = self.connection.recv(4)\n if len(chunk) < 4:\n break\n slen = struct.unpack(\">L\", chunk)[0]\n chunk = self.connection.recv(slen)\n while len(chunk) < slen:\n chunk = chunk + self.connection.recv(slen - len(chunk))\n obj = self.unPickle(chunk)\n msg = obj['msg']\n if type(msg) is str:\n record = logging.makeLogRecord(obj)\n self.handleLogRecord(record)\n else:\n self.statsThread.addRecord(msg)\n timeDict = msg['time'] \n if timeDict['total'] > LOG_THRESHOLD: \n #obj['msg'] = 'Processed ' + msg['request'] + ' on ' + msg['file'] + ' in ' + ('%.3f' % msg['time']['total']) + ' seconds'\n logMsg = 'Processed ' + msg['request'] + ' on ' + msg['file'] + '. Timing entries in seconds: '\n addComma=False\n for SECTION in self.SECTION_KEYS:\n timeKey=SECTION.strip()\n if timeDict.has_key(timeKey):\n if addComma:\n logMsg += ','\n else:\n addComma = True\n logMsg += ' ' + timeKey + ' ' + ('%.3f' % timeDict[timeKey])\n \n obj['msg'] = logMsg\n record = logging.makeLogRecord(obj)\n self.handleLogRecord(record)\n except Exception, e:\n import sys, traceback, string\n t, v, tb = sys.exc_info()\n print string.join(traceback.format_exception(t, v, tb))","def process(self):\n\n self.wsRms.connect()\n\n self.scheduler = Scheduler(self)\n self.scheduler.setDaemon(True)\n self.scheduler.start()\n\n while not self.stop:\n json = self.wsEngine.receive()\n if json == None:\n time.sleep(1)\n continue\n print \"------->Receive from lib: %s\" %json\n message = Message().restore(json)\n\n if message.getCmd() == Message.CMD_REGISTER:\n self.waitingQueue.append(message)\n\n elif message.getCmd() == Message.CMD_RELEASE:\n self.wsRms.release(message.getRes())\n self.runningQueue.remove(message)\n\n self.scheduler.stop()","def main_loop(self):\n # main loop...don't ever exit\n while True:\n # collect data\n # get the time...the local clock is set with NTP regularly\n self._get_time()\n \n # get the latest metar data from the closest location\n self._get_metar()\n \n # get the latest fence station data\n self._get_fence_station()\n \n # get the lastest roof station data\n #METAR self._get_roof_station()\n \n # publish the data to our data file\n self.write_data_files()\n \n # show the user we are running\n print(\"{:s}\".format(datetime.datetime.now(pytz.UTC).strftime(\"%Y-%m-%d %H:%M:%S.%f\")), end=\"\\r\", flush=True)\n \n # wait a bit for the next loop\n time.sleep(3.0)\n \n return","def recive_data(self, data_waveformreceived):\r\n self.adcollector.save_as_binary(self.savedirectory)\r\n self.channel_number = len(data_waveformreceived)\r\n if self.channel_number == 1: \r\n if 'Vp' in self.readinchan:\r\n self.data_collected_0 = data_waveformreceived[0]\r\n \r\n self.PlotDataItem_patch_voltage = PlotDataItem(self.xlabelhere_all, self.data_collected_0)\r\n #use the same color as before, taking advantages of employing same keys in dictionary\r\n self.PlotDataItem_patch_voltage.setPen('w')\r\n self.pw_data.addItem(self.PlotDataItem_patch_voltage)\r\n \r\n self.textitem_patch_voltage = pg.TextItem(('Vp'), color=('w'), anchor=(1, 1))\r\n self.textitem_patch_voltage.setPos(0, 1)\r\n self.pw_data.addItem(self.textitem_patch_voltage)\r\n elif 'Ip' in self.readinchan:\r\n self.data_collected_0 = data_waveformreceived[0]\r\n \r\n self.PlotDataItem_patch_current = PlotDataItem(self.xlabelhere_all, self.data_collected_0)\r\n #use the same color as before, taking advantages of employing same keys in dictionary\r\n self.PlotDataItem_patch_current.setPen('c')\r\n self.pw_data.addItem(self.PlotDataItem_patch_current)\r\n \r\n self.textitem_patch_current = pg.TextItem(('Ip'), color=('w'), anchor=(1, 1))\r\n self.textitem_patch_current.setPos(0, 1)\r\n self.pw_data.addItem(self.textitem_patch_current) \r\n elif 'PMT' in self.readinchan: # repeatnum, PMT_data_index_array, averagenum, ScanArrayXnum\r\n self.data_collected_0 = data_waveformreceived[0]*-1\r\n self.data_collected_0 = self.data_collected_0[0:len(self.data_collected_0)-1]\r\n \r\n # pmt data could come from raster scanning mode or from contour scanning mode.\r\n try:\r\n for i in range(self.repeatnum):\r\n self.PMT_image_reconstructed_array = self.data_collected_0[np.where(self.PMT_data_index_array_repeated == i+1)]\r\n Dataholder_average = np.mean(self.PMT_image_reconstructed_array.reshape(self.averagenum, -1), axis=0)\r\n Value_yPixels = int(len(self.samples_1)/self.ScanArrayXnum)\r\n self.PMT_image_reconstructed = np.reshape(Dataholder_average, (Value_yPixels, self.ScanArrayXnum))\r\n \r\n # Stack the arrays into a 3d array\r\n if i == 0:\r\n self.PMT_image_reconstructed_stack = self.PMT_image_reconstructed\r\n else:\r\n self.PMT_image_reconstructed_stack = np.concatenate((self.PMT_image_reconstructed_stack, self.PMT_image_reconstructed), axis=0)\r\n \r\n Localimg = Image.fromarray(self.PMT_image_reconstructed) #generate an image object\r\n Localimg.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+str(i)+'.tif')) #save as tif\r\n \r\n plt.figure()\r\n plt.imshow(self.PMT_image_reconstructed, cmap = plt.cm.gray)\r\n plt.show()\r\n except:\r\n np.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+'flatten'), self.data_collected_0)\r\n \r\n elif self.channel_number == 2: \r\n if 'PMT' not in self.readinchan:\r\n self.data_collected_0 = data_waveformreceived[0]\r\n \r\n self.PlotDataItem_patch_voltage = PlotDataItem(self.xlabelhere_all, self.data_collected_0)\r\n #use the same color as before, taking advantages of employing same keys in dictionary\r\n self.PlotDataItem_patch_voltage.setPen('w')\r\n self.pw_data.addItem(self.PlotDataItem_patch_voltage)\r\n \r\n self.textitem_patch_voltage = pg.TextItem(('Vp'), color=('w'), anchor=(1, 1))\r\n self.textitem_patch_voltage.setPos(0, 1)\r\n self.pw_data.addItem(self.textitem_patch_voltage) \r\n \r\n self.data_collected_1 = data_waveformreceived[1]\r\n \r\n self.PlotDataItem_patch_current = PlotDataItem(self.xlabelhere_all, self.data_collected_1)\r\n #use the same color as before, taking advantages of employing same keys in dictionary\r\n self.PlotDataItem_patch_current.setPen('c')\r\n self.pw_data.addItem(self.PlotDataItem_patch_current)\r\n \r\n self.textitem_patch_current = pg.TextItem(('Ip'), color=('w'), anchor=(1, 1))\r\n self.textitem_patch_current.setPos(0, 1)\r\n self.pw_data.addItem(self.textitem_patch_current) \r\n elif 'PMT' in self.readinchan:\r\n self.data_collected_0 = data_waveformreceived[0]*-1\r\n self.data_collected_0 = self.data_collected_0[0:len(self.data_collected_0)-1]\r\n \r\n try:\r\n for i in range(self.repeatnum):\r\n self.PMT_image_reconstructed_array = self.data_collected_0[np.where(self.PMT_data_index_array_repeated == i+1)]\r\n Dataholder_average = np.mean(self.PMT_image_reconstructed_array.reshape(self.averagenum, -1), axis=0)\r\n Value_yPixels = int(len(self.samples_1)/self.ScanArrayXnum)\r\n self.PMT_image_reconstructed = np.reshape(Dataholder_average, (Value_yPixels, self.ScanArrayXnum))\r\n \r\n # Stack the arrays into a 3d array\r\n if i == 0:\r\n self.PMT_image_reconstructed_stack = self.PMT_image_reconstructed\r\n else:\r\n self.PMT_image_reconstructed_stack = np.concatenate((self.PMT_image_reconstructed_stack, self.PMT_image_reconstructed), axis=0)\r\n \r\n Localimg = Image.fromarray(self.PMT_image_reconstructed) #generate an image object\r\n Localimg.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+str(i)+'.tif')) #save as tif\r\n \r\n plt.figure()\r\n plt.imshow(self.PMT_image_reconstructed, cmap = plt.cm.gray)\r\n plt.show()\r\n except:\r\n np.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+'contourscanning'), self.data_collected_0)\r\n \r\n if 'Vp' in self.readinchan:\r\n self.data_collected_1 = data_waveformreceived[1]\r\n \r\n self.PlotDataItem_patch_voltage = PlotDataItem(self.xlabelhere_all, self.data_collected_1)\r\n #use the same color as before, taking advantages of employing same keys in dictionary\r\n self.PlotDataItem_patch_voltage.setPen('w')\r\n self.pw_data.addItem(self.PlotDataItem_patch_voltage)\r\n \r\n self.textitem_patch_voltage = pg.TextItem(('Vp'), color=('w'), anchor=(1, 1))\r\n self.textitem_patch_voltage.setPos(0, 1)\r\n self.pw_data.addItem(self.textitem_patch_voltage)\r\n elif 'Ip' in self.readinchan:\r\n self.data_collected_1 = data_waveformreceived[1]\r\n \r\n self.PlotDataItem_patch_current = PlotDataItem(self.xlabelhere_all, self.data_collected_1)\r\n #use the same color as before, taking advantages of employing same keys in dictionary\r\n self.PlotDataItem_patch_current.setPen('c')\r\n self.pw_data.addItem(self.PlotDataItem_patch_current)\r\n \r\n self.textitem_patch_current = pg.TextItem(('Ip'), color=('w'), anchor=(1, 1))\r\n self.textitem_patch_current.setPos(0, 1)\r\n self.pw_data.addItem(self.textitem_patch_current)","def run(self):\n # Define our components entry point\n while True:\n\n # for each packet waiting on our input port\n for packet in self.receive_all('in'):\n try:\n image = packet.get(\"data\")\n log.debug(\"%s received %s %s\",\n self.__class__.__name__, image.shape, image)\n mask = np.zeros_like(image, dtype=np.bool)\n for i, line in enumerate(image):\n minimum = np.min(image[i])\n factor = 1.1\n threshold = factor * minimum\n mask[i] = image[i] < threshold\n packet.set(\"data\", mask)\n except:\n log.error('Component Failed: %s',\n self.__class__.__name__, exc_info=True)\n\n # send the packet to the next component\n self.send('out', packet)\n\n # yield the CPU, allowing another component to run\n self.yield_ctrl()","def run(self):\n while True: # make sure to run at least once before exiting\n with self._lock:\n self._update(self._data)\n if self._done:\n break\n time.sleep(1)","def process_data(self):\n # If both queues are empty, just wait\n if self.prs_q.empty() and self.flw_q.empty():\n time.sleep(0.01)\n return\n\n # while the pressure queue is not empty, get the data and append\n new_prs_data = False\n while not self.prs_q.empty():\n t, pressure = self.prs_q.get()\n # Puts the same data on the queue that is read by the piston control thread\n self.prs_lifo_q.put([t, pressure])\n # Rolls the array\n self.prs_data = np.roll(self.prs_data, 1)\n # inserts the new data in the current i position\n self.prs_data[:, 0] = (t, pressure - self.prs_tare, pressure)\n new_prs_data = True\n if new_prs_data:\n # Signals that it got all the data from the queue and the sensors can continue to put\n # new data in the queue\n self.prs_q.task_done()\n\n # while the flow queue is not empty, get the data and append\n new_flw_data = False\n while not self.flw_q.empty():\n t, flow = self.flw_q.get()\n self.flw_lifo_q.put([t, flow])\n # Rolls the array\n self.flw_data = np.roll(self.flw_data, 1)\n # inserts the new data in the current i position\n self.flw_data[:, 0] = (t, flow - self.flw_tare, flow)\n new_flw_data = True\n if new_flw_data:\n # Signals that it got all the data from the queue and the sensors can continue to put\n # new data in the queue\n self.flw_q.task_done()\n\n # Calculating volume from the flow\n now = time.time()\n try:\n last_inhale = now - self.cd[\"inhale_instant\"]\n except:\n last_inhale = 3\n # Gets the indexes of the data since the last breath\n i_li = np.where(now - self.flw_data[0, :] < last_inhale)[0]\n # volume = np.sum(self.flw_data[1, i_li]) / (60 * last_inhale)\n # Integrating the flow with trapz to get accurate results, considering the dt is not \n # constant between samples. The time is negative, so needs to invert the signal\n volume = -integrate.trapz(self.flw_data[1, i_li], self.flw_data[0, i_li])\n # Converting the volume from L to mL and time from minute to second\n volume = 1000 * volume / 60\n # Calibration factor\n calib = 5\n volume = volume * calib\n self.vol_lifo_q.put([t, volume])\n self.vol_data = np.roll(self.vol_data, 1)\n self.vol_data[:, 0] = (t, volume)\n\n\n # Gets the tare of the pressure and flow sensors and updates the data \n if self.get_tare and self.worker_piston.mode == 0:\n idxs_flw_tare = np.where(time.time() - self.flw_data[0, :] < self.tare_duration)[0]\n self.flw_tare = np.mean(self.flw_data[2, idxs_flw_tare])\n self.flw_data[1, :] = self.flw_data[2, :] - self.flw_tare\n idxs_prs_tare = np.where(time.time() - self.prs_data[0, :] < self.tare_duration)[0]\n self.prs_tare = np.mean(self.prs_data[2, idxs_prs_tare])\n self.prs_data[1, :] = self.prs_data[2, :] - self.prs_tare\n self.get_tare = False\n if self.get_tare and self.worker_piston.mode != 0:\n print(\"The respirator must be stopped before adjusting the tare.\")\n self.get_tare = False","def xbee_data_callback(msg):\n sender = str(msg.remote_device.get_64bit_addr())\n\n # Parse the received JSON.\n try:\n json_items = json.loads(msg.data.decode())\n except (JSONDecodeError, UnicodeDecodeError):\n return\n\n # If the sender is not in the auto-irrigation dictionary, add it with the default value.\n if sender not in auto_irrigation_dict:\n auto_irrigation_dict[sender] = auto_irrigation\n\n if msg.is_broadcast or json_items[ITEM_OP] != OP_STATUS:\n return\n\n print_log(\"Sensor data received from '{}' with payload '{}'\".format(sender, msg.data.decode()))\n\n properties = json_items[ITEM_PROP]\n\n # Update the valve position and last moisture in the dictionaries.\n if STAT_VALVE in properties:\n station_valve_dict[sender] = True if properties[STAT_VALVE] == 1 else False\n if STAT_MOISTURE in properties:\n station_moisture_dict[sender] = float(properties[STAT_MOISTURE])\n\n # Parse the configurations contained in the message and upload them to DRM.\n upload_configurations_drm(parse_configurations(properties), sender)","def run(self):\n while True:\n lines = self.process(date_generator=self.date_generator).split('\\n')\n for line in lines:\n if self.probability():\n if not self.simulation:\n self.engine.send(tag=self.tag, msg=str(line))\n now = datetime.utcnow().ctime()\n print('{0} => {1}'.format(now, str(line)))\n else:\n now = datetime.utcnow().ctime()\n print('{0} => Skipped by prob.'.format(now))\n\n if self.interactive:\n input(\"» Press Enter for next iteration «\")\n else:\n self.wait()","def feed_data(self):\n test = True\n\n sizex_pv = self.detector + ':image1:ArraySize0_RBV'\n sizey_pv = self.detector + ':image1:ArraySize1_RBV'\n acquire_pv_name = self.get_acquire_pv_name()\n while test:\n self.sizex = caget(sizex_pv)\n self.sizey = caget(sizey_pv)\n ack = caget(acquire_pv_name)\n if ack == 1:\n test = False\n self.start_processes()\n else:\n time.sleep(.005)\n\n # # start the infinit loop so the feed does not stop after this init\n # if True:\n # time.sleep(10)\n #\n return caget(acquire_pv_name)","def _collect_data(self) -> None:\n self.set_websocket_data()\n self.set_stratum_data()\n self.set_cache_data()\n self.collect_peer_connection_metrics()\n self.set_tx_storage_data()","def run(self):\n # Get data objects (in a dict) from the controller process \n dataDict = self.controller.recv()\n self.orderedStreams = dataDict['orderedStreams']\n\n ID = None\n data = None\n while self.clients:\n result = self.resultQ.get()\n if result is None:\n self.clients -= 1\n continue\n ID, data = result\n # Data sequence is unimportant, simply write it out and proceed\n self.writePairs(data)\n\n # Send updated data (stats mainly) via the pipe directly back to\n # the MPController object, close filehandles and finish up.\n self.updateObjectsToController()\n self.closeFileHandles()","def run(self):\n while True:\n time.sleep(RTM_READ_DELAY)\n for event in self._slack_client.rtm_read():\n self.handle_event(event)","def update(self):\n # pull all available chunks\n c, t = self.inlet.pull_chunk(timeout=0.0)\n new_c = []\n new_t = []\n while c:\n new_c += c\n new_t += t\n c, t = self.inlet.pull_chunk(timeout=0.0)\n\n # add samples to buffer\n if any(new_c):\n # add samples\n data_v = [item for sublist in new_c for item in sublist]\n self.gbuffer = np.roll(self.gbuffer, -len(data_v))\n self.gbuffer[-len(data_v):] = data_v\n # add timestamps\n if new_t:\n self.gtimes = np.roll(self.gtimes, -len(new_t))\n self.gtimes[-len(new_t):] = new_t\n\n # update graph handles\n if self.gbuffer.any():\n for k in range(0, self.channel_count):\n self.handles[k].setData(self.gtimes,\n self.gbuffer[k::self.channel_count])","def _one_loop(self):\n frame, processed_data = super()._one_loop()\n\n if processed_data:\n segments = self._process_boxes(processed_data)\n if len(segments):\n self._draw_segments(frame, segments)\n self._notifications.append({\n \"kind\": \"distancing\"\n })\n if self.config.streaming_output:\n self._notifications.append({\n \"kind\": \"frame\"\n })\n return frame, processed_data","def process(self):\n main_thread_exited = False\n\n while True:\n if not main_thread_exited and not threading.main_thread().is_alive():\n log.info(\"%s exited\", threading.main_thread().name)\n main_thread_exited = True\n self.finish()\n\n try:\n with self._lock:\n span = self._queue.get(block=False)\n if span is None:\n self._sender.close()\n log.info(\"Processing has been finished\")\n return\n\n for data in span.get_data():\n self._sender.emit_with_time(\n label=data['label'],\n timestamp=data['timestamp'],\n data=data['data']\n )\n except Empty:\n time.sleep(0.1)","def start_monitor_loop(self):\n read_file = read_config_file.ConfigFileReader()\n\n communication_time = read_file.get_send_communication_time()\n metrics_array = read_file.get_metrics()\n\n self.add_metrics_to_monitor_object(communication_time, metrics_array)","def run(self):\n self.read_from_serial()","def run(self):\n while True:\n # Do something\n print('Doing something imporant in the background')\n\n self.loadData()\n time.sleep(self.interval)","def _main_loop(self):\n while not rospy.is_shutdown():\n # Check for reconfiguration data\n if self._transfer_reconfigure_data is not None:\n # Copy reconfigure data from shared memory\n with self._transfer_reconfigure_data_mutex:\n reconfigure_data = deepcopy(self._transfer_reconfigure_data)\n self._transfer_reconfigure_data = None\n # Run vision reconfiguration\n self._configure_vision(*reconfigure_data)\n # Check for new image\n elif self._transfer_image_msg is not None:\n # Copy image from shared memory\n with self._transfer_image_msg_mutex:\n image_msg = self._transfer_image_msg\n self._transfer_image_msg = None\n # Run the vision pipeline\n self._handle_image(image_msg)\n # Now the first image has been processed\n self._first_image_callback = False\n else:\n try:\n self._rate.sleep()\n except rospy.exceptions.ROSTimeMovedBackwardsException:\n pass","def on_update(self):\n\n t_start = time.time()\n\n # get input audio if desired\n if self.input_stream:\n try:\n num_frames = self.input_stream.get_read_available() # number of frames to ask for\n if num_frames:\n data_str = self.input_stream.read(num_frames, False)\n data_np = np.fromstring(data_str, dtype=np.float32)\n self.input_func(data_np, self.num_input_channels)\n except IOError as e:\n print('got error', e)\n\n # Ask the generator to generate some audio samples.\n num_frames = self.stream.get_write_available() # number of frames to supply\n if self.generator and num_frames != 0:\n (data, continue_flag) = self.generator.generate(num_frames, self.num_channels)\n\n # make sure we got the correct number of frames that we requested\n assert len(data) == num_frames * self.num_channels, \\\n \"asked for (%d * %d) frames but got %d\" % (num_frames, self.num_channels, len(data))\n\n # convert type if needed and write to stream\n if data.dtype != np.float32:\n data = data.astype(np.float32)\n self.stream.write(data.tostring())\n\n # send data to listener as well\n if self.listen_func:\n self.listen_func(data, self.num_channels)\n\n # continue flag\n if not continue_flag:\n self.generator = None\n\n # how long this all took\n dt = time.time() - t_start\n a = 0.9\n self.cpu_time = a * self.cpu_time + (1-a) * dt","def process(self, data, channel = None):\n\t\traise NotImplementException()","async def _monitor_recv(self):\n\n while True:\n await RisingEdge(self.clock)\n await ReadOnly()\n if self.bus.valid.value:\n self._recv(int(self.bus.data.value))","def obtain_data(self):\n ##MODIFY THIS\n #ipdb.set_trace()\n print('obtain_data')\n print(self.enabler)\n print(self.index)\n helper = '>'+str(1+int(self.chann_span.get()))+'Q'\n print('helper='+helper)\n while(self.enabler):\n #print('size'+str(1+int(self.chann_span.get())))\n #print('offset'+str(self.index-self.index_offset))\n A2 = struct.unpack(helper, fpga.read('A2', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8))) \n #print(A2)\n #print(str(10*np.log10(A2))+'dB')\n self.amp_a2[0] = np.mean(A2)\n self.amp_a2 = np.roll(self.amp_a2, -1)\n B2 = struct.unpack(helper, fpga.read('B2', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8)))\n self.amp_b2[0] = np.mean(B2)\n self.amp_b2 = np.roll(self.amp_b2, -1)\n AB_re = struct.unpack(helper, fpga.read('AB_re', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8)))\n self.ab_re[0] = np.mean(AB_re)\n self.ab_re = np.roll(self.ab_re, -1)\n AB_im = struct.unpack(helper, fpga.read('AB_im', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8)))\n self.ab_im[0] = np.mean(AB_im)\n self.ab_im = np.roll(self.ab_im, -1) \n # print('RE:' + str(self.ab_re)+ '\\t IM:' +str(self.ab_im))\n log_a = 10*np.log10(np.mean(self.amp_a2)+1.0)\n log_b = 10*np.log10(np.mean(self.amp_b2)+1.0) \n ang = np.rad2deg(np.arctan2(np.mean(self.ab_im), np.mean(self.ab_re))) #review the way of avg this... i dont know if its the most correct way to do it...\n self.a2.set(log_a)\n self.b2.set(log_b)\n self.ang.set(ang)\n self.amp_rel.set(log_a-log_b)\n return 1","def sync(self):\n self._start_slow_sync()\n self._ask_for_all_records()\n self._process_events()\n self._process_reminders()\n self._process_recurrences()\n #self._write_events()","async def run(self):\n\n\t\tawait asyncio.sleep(self.delay)\n\t\tR_load = self.lock.mag/(self.sense - self.lock.mag)*self.R_ref\n\t\tawait self.resistance.push(R_load)\n\t\tawait self.current.push(self.lock.dc/(self.R_ref+R_load))\n\t\tawait self.voltage.push(self.lock.dc*R_load/(self.R_ref+R_load))\n\n\t\tlogger.debug(\"Stream has filled {} of {} points\".format(self.resistance.points_taken,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tself.resistance.num_points() ))\n\n\t\t#await asyncio.sleep(2*self.integration_time) # Give the filters some time to catch up?","def generate_data(self):\n print(\"generate_data - init\")\n with open(self.input_file, \"r\") as f:\n\n # read JSON data from input file\n data = json.loads(f.read())\n\n for idx, row in enumerate(data): \n # serialize Python dict to string\n msg = self.serialize_json(row)\n #print(f\"Linha: {row}\")\n self.send(self.topic, msg)\n self.flush()\n #print(\"Sleeping\")\n time.sleep(1)"],"string":"[\n \"def run(self):\\r\\n self.collect_data()\",\n \"def process():\",\n \"def run(self):\\n while(not self.stop_event.is_set()):\\n # read values until stop is sent\\n response1 = _read_once(1,self.serial)\\n response2 = _read_once(2,self.serial)\\n #print(response)\\n self.data1[\\\"d\\\"].append(response1) # Push response to the data list for later\\n self.data2[\\\"d\\\"].append(response2) # Push response to the data list for later\\n curTime = time.time()\\n self.data1[\\\"t\\\"].append(curTime)\\n self.data2[\\\"t\\\"].append(curTime)\\n #sleep(0.0001) # I need to be small enough to capture peaks.\\n return\",\n \"def handle_event(self):\\n self.done = False\\n while not self.done:\\n try:\\n callback_item = self.eventq.get(timeout=1)\\n if callback_item == 'finish':\\n print ('done')\\n self.done = True\\n else:\\n current_ctr = callback_item\\n if current_ctr > self.current_counter + 1:\\n self.event('missing frames')\\n self.current_counter = current_ctr + 1\\n\\n try:\\n print ('current cntr', self.current_counter)\\n pv_pairs = {}\\n slice = np.array(caget(self.get_data_pv_name()))\\n print ('pvname', self.get_data_pv_name())\\n # read other pvs\\n for pv in self.pvs:\\n pv_pairs[pv] = (self.pvs[pv], caget(self.pvs[pv]))\\n print ('pv pairs', pv_pairs)\\n if slice is None:\\n self.done = True\\n self.event('reading image times out, possibly the detector exposure time is too small')\\n else:\\n slice.resize(self.sizex, self.sizey)\\n data = ut.Data(slice, pv_pairs)\\n # deliver data to monitor\\n self.deliver_data(data)\\n except:\\n self.done = True\\n self.event('reading image raises exception, possibly the detector exposure time is too small')\\n except tqueue.Empty:\\n continue\\n\\n self.finish()\",\n \"def collect_data(self):\\r\\n self.vcp.read(self.vcp.inWaiting())\\r\\n while True:\\r\\n data = self.vcp.readline()\\r\\n data = data.decode(\\\"ASCII\\\")\\r\\n timestamp = \\\",\\\" + datetime.datetime.now().strftime(\\\"%H:%M:%S\\\")\\r\\n data_timestamp = data + timestamp\\r\\n if not self.data_pause:\\r\\n self.update_anemometer_log.emit(data_timestamp)\\r\\n if self.stop_timer:\\r\\n break\",\n \"def _process(self):\\n while True:\\n with Timer() as data_timer:\\n frame = self._frames_q.get()\\n\\n with Timer() as agent_timer:\\n s, frame_metadata = self._unwrap_frame(frame)\\n s = np.expand_dims(s, 0) # batch\\n act = self.pred(s)[0][0].argmax()\\n put_overwrite(self._actions_q, self._wrap_action(act, frame_metadata))\\n\\n print('.', end='', flush=True)\\n if self.verbose:\\n print('Avg data wait time: %.3f' % data_timer.time())\\n print('Avg agent neural net eval time: %.3f' % agent_timer.time())\",\n \"def data_process():\\n global localtime\\n global value_dict\\n sensor_types = sEtting.sensor_types\\n sensor_values = []\\n msg = None\\n value_dict = collections.OrderedDict.fromkeys(sEtting.payload_header)\\n value_dict[\\\"ver_format\\\"] = sEtting.ver_format\\n value_dict[\\\"FAKE_GPS\\\"] = sEtting.fake_gps\\n value_dict[\\\"app\\\"] = sEtting.app\\n value_dict[\\\"ver_app\\\"] = sEtting.ver_app\\n value_dict[\\\"device_id\\\"] = sEtting.device_id\\n value_dict[\\\"date\\\"] = localtime.strftime(\\\"%Y-%m-%d\\\")\\n value_dict[\\\"time\\\"] = localtime.strftime(\\\"%H:%M:%S\\\")\\n value_dict[\\\"device\\\"] = sEtting.device\\n\\n for sensor in sensor_types:\\n if sensor == 'pm25-at':\\n value_dict[\\\"s_d0\\\"] = get_reading_csv(sensor)\\n elif sensor == 'temperature':\\n value_dict[\\\"s_t0\\\"] = get_reading_csv(sensor)\\n elif sensor == 'humidity':\\n value_dict[\\\"s_h0\\\"] = get_reading_csv(sensor)\\n elif sensor == 'pm10-at':\\n value_dict[\\\"s_d1\\\"] = get_reading_csv(sensor)\\n else:\\n print 'Not support sensor type.'\\n if sEtting.fake_gps == 1:\\n value_dict[\\\"gps_lat\\\"] = sEtting.fgps_lat\\n value_dict[\\\"gps_lon\\\"] = sEtting.fgps_lon\\n value_dict[\\\"gps_alt\\\"] = sEtting.fgps_alt\\n value_dict[\\\"gps_fix\\\"] = 0\\n else:\\n value_dict[\\\"gps_lat\\\"] = get_gps()[0]\\n value_dict[\\\"gps_lon\\\"] = get_gps()[1]\\n value_dict[\\\"gps_alt\\\"] = get_gps()[2]\\n value_dict[\\\"gps_fix\\\"] = gpsd.fix.mode\\n value_dict[\\\"gps_num\\\"] = 0\\n #if debug_enable == '0':\\n msg = \\\"|\\\" + \\\"|\\\".join([\\\"=\\\".join([key, str(val)])\\n for key, val in value_dict.items()])\\n return msg\\n #elif debug_enable == '1':\\n # msg_debug = \\\",\\\".join([\\\"=\\\".join([key, str(val)]) for key, val in value_dict.items()])\\n # return msg_debug\",\n \"def _async_process_data(self):\\n raise NotImplementedError\",\n \"def collect_data(self):\\n self.logger.info(\\\"Waiting for incoming data ...\\\")\\n while True:\\n item = self.in_queue.get()\\n self.logger.info(\\\"Received data!\\\")\\n self.collector_process_data(item)\",\n \"def process_amqp_events(self):\\n self.connection.process_data_events()\",\n \"def process_data(request):\\n mongodb = get_db() \\n start_time = time.time()\\n record_segments(mongodb)\\n record_heatmaps(mongodb)\\n result = sys._getframe().f_code.co_name, \\\"COMPLETED\\\", (time.time() - start_time), \\\"seconds\\\"\\n print result\\n return result\",\n \"def receive_data(self):\\n while True:\\n\\n data = self.recv_end()\\n\\n if len(data) > 0:\\n\\n try:\\n self.current_data = json.loads(data)\\n self.current_3D_points = base64.b64decode(self.current_data['points'])\\n self.is_new_data = True\\n\\n except:\\n # print('cannot load DepthCamera data')\\n pass\",\n \"def process(self):\\n pass\",\n \"def event_loop(self):\\n self.timer.blockSignals(True) # prevent runaway condition if timer adds more events to loop during processing\\n QCoreApplication.processEvents() # process all incoming signals before going onto next image\\n \\\"\\\"\\\" \\n During the processEvents call, all incoming signals will be processed \\n before moving onto the next image. Events processed here include:\\n - updating the new ROIs with self.update_roi_coords()\\n - recieving new images and adding them to the process queue with self.recieve_image()\\n - updating the number of ROI groups with self.update_num_roi_groups()\\n - updating the number of ROIs per group with self.update_num_rois_per_group()\\n \\\"\\\"\\\"\\n\\n self.process_next_image() # processes one image from the queue if it is not empty\\n self.save() # only saves data if queue is empty and self.should_save = True\\n\\n self.timer.blockSignals(False) # allow the timer to trigger the event loop again\",\n \"def _async_process_data(self):\\n data = self._api.get_device_data(self._dev_id)\\n\\n if not data:\\n _LOGGER.error(\\\"Received no data for device %s\\\", self._name)\\n self.async_write_ha_state()\\n return\\n\\n if \\\"relay\\\" in data:\\n self._is_on = data[\\\"relay\\\"]\\n\\n self.async_write_ha_state()\",\n \"def simulateCore(self):\\n while len(self.event_q) > 0:\\n evts = self.nextEvents()\\n self.handleEvents(evts)\\n self.gatherSystemStatistics(self.scheduler.system)\\n self.dumpEventQueue()\",\n \"def collect_data(self):\\n self.lines = []\\n\\n while True:\\n self._process_serial_data()\",\n \"def run(self):\\n while True:\\n try:\\n data = self._read()\\n except IOError:\\n break\\n\\n if len(data) == 0:\\n self.finalize(\\\"Connection closed.\\\")\\n break\\n\\n gevent.spawn(self.process_data, data)\",\n \"def run(self):\\n while True:\\n try:\\n data = self._read()\\n except IOError:\\n break\\n\\n if len(data) == 0:\\n self.finalize(\\\"Connection closed.\\\")\\n break\\n\\n gevent.spawn(self.process_data, data)\",\n \"def process(self):\",\n \"def process(self):\",\n \"def process(self):\",\n \"def data_received(self, data):\\n if self.session is not None:\\n size = len(data)\\n self.logger.debug('process_data(%r, %d)', data, size)\\n self.session.process_data(data, size)\",\n \"def processor(self, data):\\n streaming_data = self.decoder.decodeData(data)\\n # Add Your code here to process data and handle transport/storage\",\n \"def processor(self, data):\\n streaming_data = self.decoder.decodeData(data)\\n # Add Your code here to process data and handle transport/storage\",\n \"def processor(self, data):\\n streaming_data = self.decoder.decodeData(data)\\n # Add Your code here to process data and handle transport/storage\",\n \"def processor(self, data):\\n streaming_data = self.decoder.decodeData(data)\\n # Add Your code here to process data and handle transport/storage\",\n \"def processor(self, data):\\n streaming_data = self.decoder.decodeData(data)\\n # Add Your code here to process data and handle transport/storage\",\n \"def processor(self, data):\\n streaming_data = self.decoder.decodeData(data)\\n # Add Your code here to process data and handle transport/storage\",\n \"def run(self):\\n\\n while not self.shutdownEvent.is_set():\\n gpsData = self.__getGPSData()\\n\\n # Broadcast GPS data\\n if gpsData:\\n msgData = json.dumps(gpsData)\\n\\n self._msgQueue.put((msgData, MessageType.GPS_MESSAGE))\\n\\n time.sleep(self._readPeriod)\\n\\n # Cleanup\\n self.__shutdown()\",\n \"def run():\\n\\twrite_fuel_data()\",\n \"def recive_data(self):\\n # read all available data\\n while self.ser.inWaiting() > self.INPUT_DATA_SIZE+1:\\n data = array.array('c')\\n # search the header\\n data.append(self.ser.read(1))\\n while data[0] != chr(1):\\n data[0] = self.ser.read(1)\\n \\n # wait for all available data\\n while self.ser.inWaiting() < (self.INPUT_DATA_SIZE-1):\\n time.sleep(0.03);\\n \\n # recives data\\n data = self.ser.read(self.INPUT_DATA_SIZE-1)\\n \\n # prove if you want graphical data\\n if self.pushButton_monitor.isChecked():\\n # decodes the data\\n t = struct.unpack('I', data[3]+data[2]+data[1]+data[0])\\n r = struct.unpack('f', data[4]+data[5]+data[6]+data[7])\\n x0 = struct.unpack('f', data[8]+data[9]+data[10]+data[11])\\n x1 = struct.unpack('f', data[12]+data[13]+data[14]+data[15])\\n u = struct.unpack('f', data[16]+data[17]+data[18]+data[19])\\n \\n self.time = t[0]*25e-9\\n \\n # prepare the string output\\n aux_str = \\\" t = \\\"+str(self.time)+\\\"\\\\t\\\"\\n aux_str += \\\" r = \\\"+str(r[0])+\\\"\\\\t\\\"\\n aux_str += \\\" u = \\\"+str(u[0])+\\\"\\\\t\\\"\\n aux_str += \\\" x1 = \\\"+str(x1[0])+\\\"\\\\t\\\"\\n aux_str += \\\" x0 = \\\"+str(x0[0])+\\\"\\\\n\\\"\\n # print string output\\n self.textBrowser.insertPlainText(aux_str)\\n \\n # append data to the arrays\\n self.graf_t.append(self.time)\\n self.graf_r.append(r[0])\\n self.graf_x0.append(x0[0])\\n self.graf_x1.append(x1[0])\\n self.graf_u.append(u[0])\\n \\n # remove one value if the arrays have maximum length\\n if self.graf_t.buffer_info()[1] >= NUM_SAMPLES:\\n self.graf_t.pop(0)\\n self.graf_r.pop(0)\\n self.graf_x0.pop(0)\\n self.graf_x1.pop(0)\\n self.graf_u.pop(0)\\n \\n # reload number of samples lavel\\n self.label_samples_value.setText(str(self.graf_t.buffer_info()[1]))\\n # reload number of waiting chars in serial rx buffer\\n self.label_rx_buff_value.setText(str(self.ser.inWaiting()))\\n\\n # reload mutex area\\n self.updated_data = 1\\n \\n # prove if there are available id's\\n if (self.actionPC_Monitor.isChecked() and data[20] == chr(2)):\\n # if it is true, looks how much id's\\n i = struct.unpack('B', data[21])\\n\\n if i[0] < STACK_SIZE:\\n for z in range(i[0]):\\n new_device = struct.unpack('B', data[z+22])\\n new_string = str(new_device[0])\\n \\n llista = self.listWidget_link.findItems(new_string, QtCore.Qt.MatchExactly)\\n if len(llista) == 0:\\n self.listWidget_link.addItem(new_string)\",\n \"def processIncoming(self):\\r\\n while self.queue.qsize():\\r\\n try:\\r\\n volume_T101 = self.queue.get(0)\\r\\n self.var_pb_progress.set(volume_T101/100) #scale to 100\\r\\n self.var_T101.set(\\\"T101: \\\" + str(round(volume_T101,4)))\\r\\n self.var_LIT101.set(self.take_reading(volume_T101))\\r\\n self.update_physical(volume_T101)\\r\\n self.PLC_command()\\r\\n self.check_attack(volume_T101)\\r\\n self.output_results()\\r\\n self.master.update_idletasks()\\r\\n except queue.Empty:\\r\\n pass\",\n \"def data_collection():\\n global PAUSED\\n print(\\\"Detecting nodes\\\")\\n while True:\\n data = SOCK.recvfrom(1024)[0] # buffer size is 1024 bytes\\n message = data.decode()\\n try:\\n message_function = message[0]\\n message = message[1:]\\n \\n if message_function == \\\"t\\\":\\n loc, temp, hum = message.split(\\\", \\\")\\n temp = (float(temp) * 1.8) + 32 # convert from C to F\\n\\n # Checks if location is alreay in the rolling_X dictionarys. If not, it creates an entry\\n # in the dictionary and populates it with the defaults\\n if loc not in ROLLING_TEMPS:\\n ROLLING_TEMPS[loc] = copy(TEMPDEQUEDEFAULT)\\n print(loc, \\\"has connected\\\")\\n if loc not in ROLLING_HUMS:\\n ROLLING_HUMS[loc] = copy(HUMDEQUEDEFAULT)\\n\\n # Append new temp and humidity to appropriate deque in dictionaries\\n ROLLING_TEMPS[loc].appendleft(temp)\\n ROLLING_HUMS[loc].appendleft(hum)\\n LAST_RECEIVED[loc] = datetime.datetime.utcnow()\\n \\n elif message_function == \\\"c\\\":\\n if message == \\\"pause\\\":\\n PAUSED = True\\n print(\\\"pausing\\\")\\n elif message == \\\"unpause\\\":\\n PAUSED = False\\n print(\\\"unpausing\\\")\\n else:\\n print(\\\"unknown command function\\\")\\n elif message_function == \\\"i\\\":\\n if message == \\\"status\\\":\\n print(\\\"Paused:\\\", PAUSED)\\n else:\\n print(\\\"unknown info function\\\")\\n except:\\n print(\\\"malformed data\\\")\",\n \"def process_queue(self):\\n while self.input_processing_running:\\n\\n # Process everything in the queue.\\n while self.input_queue.qsize() > 0:\\n try:\\n _telem = self.input_queue.get_nowait()\\n self.process_telemetry(_telem)\\n\\n except Exception as e:\\n self.log_error(\\\"Error processing telemetry dict - %s\\\" % str(e))\\n\\n # Sleep while waiting for some new data.\\n time.sleep(0.5)\",\n \"def start_recording_and_saving_data(self, eeg_file_path):\\n # set up variables\\n self.e_event, self.e_state, user_id, n_samples, n_sam, composer_port, secs, state = self.setup_var()\\n # pointers\\n n_samples_taken = ct.pointer(n_samples)\\n data = ct.pointer(ct.c_double(0))\\n user = ct.pointer(user_id)\\n ready_to_collect = False\\n # start connection\\n print \\\"Connecting...\\\"\\n if self.libEDK.EE_EngineConnect(\\\"Emotiv Systems-5\\\") != 0: # connection failed\\n print \\\"Emotiv Engine start up failed.\\\"\\n self.stop_connection()\\n sys.exit(1)\\n print \\\"Connected! Start receiving data...\\\"\\n self._recording = True\\n # write data to file\\n self.f = open(eeg_file_path, 'w')\\n # write header\\n for header in Constants.HEADER:\\n # last one in header\\n if header != \\\"TIMESTAMP\\\" and not self.f.closed:\\n self.f.write(header + \\\",\\\")\\n elif not self.f.closed:\\n self.f.write(header + \\\"\\\\n\\\")\\n h_data = self.libEDK.EE_DataCreate()\\n self.libEDK.EE_DataSetBufferSizeInSec(secs)\\n # start recording\\n while self._recording:\\n state = self.libEDK.EE_EngineGetNextEvent(self.e_event)\\n if state == 0:\\n event_type = self.libEDK.EE_EmoEngineEventGetType(self.e_event)\\n self.libEDK.EE_EmoEngineEventGetUserId(self.e_event, user)\\n # add user\\n if event_type == 16:\\n print \\\"User added\\\"\\n self.libEDK.EE_DataAcquisitionEnable(user_id, True)\\n ready_to_collect = True\\n if ready_to_collect:\\n self.libEDK.EE_DataUpdateHandle(0, h_data)\\n self.libEDK.EE_DataGetNumberOfSample(h_data,n_samples_taken)\\n # print \\\"Updated :\\\", n_samples_taken[0]\\n if n_samples_taken[0] != 0:\\n n_sam = n_samples_taken[0]\\n arr = (ct.c_double*n_samples_taken[0])()\\n ct.cast(arr, ct.POINTER(ct.c_double))\\n # self.libEDK.EE_DataGet(h_data, 3,byref(arr), nSam)\\n data = np.array('d') # zeros(n_samples_taken[0],double)\\n for sampleIdx in range(n_samples_taken[0]):\\n # channel 14 + loc data 6 + timestamp 1 = 23\\n data = np.zeros(23)\\n for i in range(22):\\n self.libEDK.EE_DataGet(h_data, Constants.TARGET_CHANNEL_LIST[i], ct.byref(arr), n_sam)\\n if not self.f.closed:\\n print >>self.f,arr[sampleIdx],\\\",\\\",\\n data[i] = arr[sampleIdx]\\n # write our own time stamp\\n t = time.time()\\n data[-1] = t\\n if not self.f.closed:\\n print >>self.f,t,\\n # put data onto out buffer queue\\n self.out_buffer_queue.put(data)\\n # switch line\\n if not self.f.closed:\\n print >>self.f,'\\\\n',\\n self.f.flush()\\n # not sure the use of this in the original program...\\n self.libEDK.EE_DataFree(h_data)\",\n \"def on_timer(self):\\n self.read_serial_data()\\n # self.update_monitor()\",\n \"def data_received(self, data):\\n self.log.debug('data_received: {!r}'.format(data))\\n self._last_received = datetime.datetime.now()\\n for byte in (bytes([value]) for value in data):\\n\\n try:\\n self.stream.feed_byte(byte)\\n except (ValueError, AssertionError):\\n e_type, e_value, _ = sys.exc_info()\\n map(self.log.warn,\\n traceback.format_exception_only(e_type, e_value))\\n continue\\n\\n if self.stream.is_oob:\\n continue\\n\\n # self.reader.feed_byte()\\n self.shell.feed_byte(byte)\",\n \"def process(self):\\n raise NotImplementedError\",\n \"def realtime(self):\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def run(self):\\n while True:\\n if self.job_q.empty():\\n self.message_q.put(False)\\n return\\n try:\\n smolecule = self.job_q.get()\\n self.data_pointer[smolecule].get_adp(self.Temp)\\n except IndexError:\\n self.message_q.put((smolecule, None))\\n try:\\n self.message_q.put((smolecule, [j.adp['cart_int'] for j in self.data_pointer[smolecule].atoms]))\\n except KeyError:\\n # =======================================================\\n # self.message_q.put((molecule,[0 for i in self.data_pointer[molecule].atoms]))\\n #=======================================================\\n pass\",\n \"def refresh(self, _loop, data):\\n try:\\n if(self.model.mode == 'live'):\\n self.updateGraphs()\\n self.model.memory = int(self.dataClient.recv())\\n self.model.cpu = float(self.dataClient.recv())\\n except EOFError:\\n pass\\n except Exception as e:\\n self.logger.error(e)\\n\\n self.view.refresh()\\n _loop.set_alarm_in(guiRefreshTimer, self.refresh)\",\n \"def _parseData(self, payload):\\n out=[]\\n bytesParsed = 0\\n while bytesParsed < len(payload):\\n\\n #check for the extended Code Level, code and length\\n #count the number of EXCODE_BYTE\\n #extendedCodeLevel = sum([1 for x in data if x == EXCODE_BYTE] )\\n #bytesParsed += extendedCodeLevel\\n\\n #identify the length of the expected bytes in the payload\\n code = payload[bytesParsed]\\n bytesParsed +=1\\n if code > 0x7F:\\n # multi-byte code, length > 1\\n length = payload[bytesParsed]\\n bytesParsed +=1\\n else:\\n length = 1\\n\\n if code == SENSOR_STATUS:\\n # value of 0==no contact, 200==contact\\n #print \\\"leadoff: %i\\\" % payload[bytesParsed]\\n out.append( {'timestamp': self.curtime, 'leadoff': payload[bytesParsed] } )\\n bytesParsed +=1\\n\\n elif code == HEART_RATE:\\n #print \\\"HR: %i\\\" % payload[bytesParsed]\\n out.append( {'timestamp': self.curtime, 'HR': payload[bytesParsed:] } )\\n bytesParsed +=1\\n\\n elif code == CONFIG_BYTE:\\n #print \\\"config: %i\\\" % payload[bytesParsed]\\n out.append( {'timestamp': self.curtime, 'config': payload[bytesParsed:] } )\\n bytesParsed +=1\\n\\n elif code == RAW_ECG:\\n # raw value is between -32768 and 32767, in twos compliment form\\n # if the raw value is higher than 32768, it should be rolled around to allow for negative values\\n raw = payload[bytesParsed]*256 + payload[bytesParsed]\\n if raw >= 32768: \\n raw = raw - 65536\\n #print \\\"ecg: %i\\\" % ecg\\n\\n # create the timestamp on each ECG sample, starting from the first\\n if self.starttime is None:\\n self.starttime = time.time()\\n self.curtime = self.starttime\\n else:\\n self.curtime = self.curtime + 1./self.Fs\\n\\n out.append( {'timestamp': self.curtime, 'ecg_raw': raw } )\\n bytesParsed += length\\n\\n elif code == DEBUG_1:\\n #print \\\"debug1: \\\" + str(payload[bytesParsed:]).strip('[]')\\n out.append( {'timestamp': self.curtime, 'debug1': payload[bytesParsed:] } )\\n bytesParsed += length\\n\\n elif code == DEBUG_2:\\n #print \\\"debug2: \\\" + str(payload[bytesParsed:]).strip('[]')\\n out.append( {'timestamp': self.curtime, 'debug2': payload[bytesParsed:] } )\\n bytesParsed += length\\n\\n else:\\n print \\\"unknown code: %i\\\" % code\\n\\n return out\",\n \"def collector_process_data(self, data):\\n for c in clients:\\n c.on_message(json.dumps(data))\",\n \"def got_data(self, data):\\n if self.get_current_state() == SBE37ProtocolState.DIRECT_ACCESS:\\n # direct access mode\\n if len(data) > 0:\\n mi_logger.debug(\\\"SBE37Protocol._got_data(): <\\\" + data + \\\">\\\") \\n if self._driver_event:\\n self._driver_event(DriverAsyncEvent.DIRECT_ACCESS, data)\\n # TODO: what about logging this as an event?\\n return\\n \\n if len(data)>0:\\n # Call the superclass to update line and prompt buffers.\\n CommandResponseInstrumentProtocol.got_data(self, data)\\n \\n # If in streaming mode, process the buffer for samples to publish.\\n cur_state = self.get_current_state()\\n if cur_state == SBE37ProtocolState.AUTOSAMPLE:\\n if SBE37_NEWLINE in self._linebuf:\\n lines = self._linebuf.split(SBE37_NEWLINE)\\n self._linebuf = lines[-1]\\n for line in lines:\\n self._extract_sample(line)\",\n \"def processIncoming(self):\\n try:\\n msg = self.guiqueue.get(False)\\n (PK, XERRO, tt) = getDataFromString(msg)\\n self.PK0.append(PK[0])\\n self.PK1.append(PK[1])\\n self.PK2.append(PK[2])\\n self.PK3.append(PK[3])\\n self.PK4.append(PK[4])\\n self.PK5.append(PK[5])\\n self.PK6.append(PK[6])\\n self.PK7.append(PK[7])\\n self.XERRO0.append(XERRO[0])\\n self.XERRO1.append(XERRO[1])\\n self.XERRO2.append(XERRO[2])\\n self.XERRO3.append(XERRO[3])\\n self.XERRO4.append(XERRO[4])\\n self.XERRO5.append(XERRO[5])\\n self.XERRO6.append(XERRO[6])\\n self.XERRO7.append(XERRO[7])\\n self.t.append(tt)\\n \\n \\n #replota a cada dado novo\\n self.updatePlot()\\n \\n except queue.Empty:\\n #print(\\\"Fila Vazia\\\")\\n pass\\n\\n self.root.after(25, self.processIncoming)\",\n \"def _process(self, data: np.ndarray) -> np.ndarray:\",\n \"def _process(self, data: np.ndarray) -> np.ndarray:\",\n \"def processData(pipe, event, pulses):\\n logging.info(\\\"Started processData\\\")\\n start_time = time.time()\\n for pulse in range(pulses):\\n samples = pipe.get()\\n# time.sleep(0.001)\\n end_time = time.time()\\n elapsed = end_time - start_time\\n samplesProcessed = (pulses * len(samples[0]) * len(samples))\\n logging.info(\\\"processData processed %d Msamples in %.3f s\\\",\\n samplesProcessed / 1e6,\\n elapsed)\\n logging.info(\\\"processData rate: %.3f Msa/s in lumps of %d samples\\\",\\n samplesProcessed / elapsed / 1e6,\\n dig.pointsPerCycle)\",\n \"def on_message(client, userdata, msg):\\n # Bring all the global variables to this scope otherwise python makes new local copies\\n global currentFileTime\\n global lastDataFrameArrivalTime\\n global storeData\\n # If this is first instance then make a new file with current time and start placing the data in that file\\n if storeData is False:\\n storeData = True\\n currentFileTime = datetime.now()\\n print(\\\"Opening a new file and storing data in : \\\" + str(currentFileTime.strftime(\\\"%Y_%m_%d_%H_%M_%S\\\"))+\\\"...\\\")\\n # Store the incoming msg.payload of data to the file\\n msg.payload = msg.payload.decode(\\\"utf-8\\\")\\n dataslice = str(msg.payload)[0:10]\\n print(\\\"Channel::accelarationData:\\\" + str(dataslice).replace(\\\"\\\\n\\\", \\\" \\\") + \\\"...\\\")\\n lastDataFrameArrivalTime = time.time()\\n fileName = currentFileTime.strftime(\\\"%Y_%m_%d_%H_%M_%S\\\")\\n store_data(fileName, msg.payload)\",\n \"def eeg_handler(self, unused_addr, args, ch1, ch2, ch3, ch4, ch5, ch6):\\n\\n\\t\\tself.data[0, self.eegcount] = ch2\\n\\t\\tself.data[1, self.eegcount] = ch3\\n\\n\\t\\tself.eegcount += 1\\n\\n\\t\\tif self.eegcount >= self.settings.buffer_size - 1:\\n\\n\\t\\t\\tself.eegcount = 0\\n\\t\\t\\told_data = self.data\\n\\t\\t\\tfor i in range(self.settings.num_channels):\\n\\t\\t\\t\\tself.output_data[i] = self.eeg_to_tones(old_data[i])\\n\\n\\t\\t\\tself.stream.start_stream()\\n\\n\\t\\t\\twhile self.stream.is_active():\\n\\t\\t\\t\\ttime.sleep(self.settings.buffer_size /\\n\\t\\t\\t\\t\\t\\t self.settings.playback_rate)\\n\\n\\t\\t\\tself.stream.stop_stream()\\n\\t\\t\\told_data = []\",\n \"def on_eot(self, data):\\n logger.debug('on_eot: %r', data)\\n if self.in_transfer_state:\\n # put the records together to a message\\n if self.messages:\\n message = b\\\"\\\".join(self.messages)\\n self.queue.put_nowait(message)\\n self.discard_env()\\n else:\\n raise InvalidState('Server is not ready to accept EOT message.')\",\n \"def on_data(self, data):\\n if data is not None:\\n # Send the data to the parent process\\n logging.debug('Received raw data : ' + str(data))\\n self.mp_queue.put(data)\",\n \"def data_received(self, data):\\n pass\",\n \"def process(self, event):\\n pass\",\n \"def run(self):\\n\\n if self.transport == 'any':\\n devs = kromek.discover()\\n else:\\n devs = kromek.discover(self.transport)\\n\\n print('Discovered %s' % devs)\\n\\n if len(devs) <= 0:\\n return\\n\\n filtered = []\\n\\n for dev in devs:\\n if self.device == 'all' or dev[0] in self.device:\\n filtered.append(dev)\\n\\n devs = filtered\\n if len(devs) <= 0:\\n return\\n\\n done_devices = set()\\n try:\\n while self.running:\\n print(\\\"Plot_manager.run: getting data\\\")\\n with kromek.Controller(devs, self.interval) as controller:\\n for reading in controller.read():\\n if self.create_structures:\\n self.total = np.array(reading[4])\\n self.lst = np.array([reading[4]])\\n self.create_structures = False\\n else:\\n self.total += np.array(reading[4])\\n self.lst = np.concatenate(\\n (self.lst, [np.array(reading[4])]))\\n serial = reading[0]\\n dev_count = reading[1]\\n if serial not in done_devices:\\n this_start, this_end = self.get_interval(\\n time.time() - self.interval)\\n\\n self.handle_spectra(\\n this_start, this_end, reading[4])\\n if dev_count >= self.count > 0:\\n done_devices.add(serial)\\n controller.stop_collector(serial)\\n if len(done_devices) >= len(devs):\\n break\\n except KeyboardInterrupt:\\n self.vprint(1, '\\\\nKeyboardInterrupt: stopping Manager run')\\n self.takedown()\\n except SystemExit:\\n self.vprint(1, '\\\\nSystemExit: taking down Manager')\\n self.takedown()\",\n \"def monitorMessages(m, rate):\\n\\n _send_data_request(m, rate)\\n\\n data_flags = {}\\n flight_data = {}\\n while continue_messages:\\n msg = m.recv_match(blocking=True)\\n if not msg or msg.get_type() == \\\"BAD_DATA\\\":\\n continue\\n\\n if msg.get_type() == \\\"ATTITUDE\\\":\\n flight_data['yaw'] = msg.yaw\\n flight_data['roll'] = msg.roll\\n flight_data['pitch'] = msg.pitch\\n flight_data['src_att'] = SRC_PIXHAWK\\n # elif msg.get_type() == \\\"SYSTEM_TIME\\\": \\\"\\\"\\\"not important: checking timestamp- 08.06\\\"\\\"\\\"\\n # flight_data['pixhawktime'] = msg.time_unix_usec\\n elif msg.get_type() == \\\"GLOBAL_POSITION_INT\\\":\\n t = datetime.now()\\n flight_data['fd_timestamp'] = t.strftime(TIMESTAMP_SIGNATURE)\\n flight_data['timestamp'] = flight_data['fd_timestamp']\\n flight_data['lon'] = msg.lon\\n flight_data['lat'] = msg.lat\\n flight_data['relative_alt'] = msg.relative_alt\\n flight_data['hdg'] = msg.hdg\\n flight_data['src_hdg'] = SRC_PIXHAWK\\n flight_data['src_gps'] = SRC_PIXHAWK\\n\\n elif msg.get_type() == \\\"GPS_RAW_INT\\\":\\n flight_data['cog'] = msg.cog\\n flight_data['src_cog'] = SRC_PIXHAWK\\n\\n if 'yaw' in flight_data and 'lon' in flight_data \\\\\\n and 'cog' in flight_data:\\n flight_data['src'] = SRC_PIXHAWK\\n path = os.path.join(gs.FLIGHT_DATA_FOLDER, \\\"{timestamp}.json\\\".format(timestamp=flight_data['timestamp']))\\n with open(path, 'wb') as f:\\n json.dump(flight_data, f)\\n\\n reactor.callFromThread(addPHdata, flight_data)\\n flight_data = {}\",\n \"def process(self, data) :\\n rData = Core.Processlib.Data()\\n rData.frameNumber = data.frameNumber\\n rData.buffer = self._worker.process(data.buffer)\\n if self._writer: #optional HDF5 writer\\n self._writer.write(rData.buffer, rData.frameNumber)\",\n \"def process_thread(self):\",\n \"def run(self):\\n operation_manager = self._core.get_operation_manager()\\n while True:\\n while operation_manager.process_next():\\n pass\\n sleep(2)\",\n \"def process_data(self):\\n timer_start = time.time()\\n # ensure self.df_events and self.df_locations are not None\\n if self.df_events is None or self.df_locations is None:\\n print(\\\"Missing data: either df_events or df_locations is None\\\")\\n return\\n # set start and end based on self.df_events if not already set\\n if not self.start:\\n self.start = self.df_events['event_time'].min()\\n if not self.end:\\n self.end = self.df_events['event_time'].max()\\n print(f\\\"date range for events data is from {self.start} to {self.end}\\\")\\n # create Grid object before processing any data\\n grid = self.compute_grid_cells(self.df_locations)\\n # clean and combine events and locations data\\n df_data = self.combine_events_and_locations(grid)\\n print(df_data.shape)\\n # df_data.to_csv('../../../data_files/20210506_cleanedInputDataCumSum.csv', index=False)\\n # df_data = pd.read_csv('../../../data_files/20210415_cleanedInputDataAprilCumSum.csv')\\n # process data within grid class\\n df_processed = grid.process_data(df_data, 'weekly')\\n # df_processed = self.calculate_demand(df_processed)\\n # df_processed.to_csv('../../../data_files/20210506_processedGridCellData.csv')\\n # set df_demand to be df_processed\\n df_processed.reset_index(inplace=True)\\n df_processed = df_processed.astype({'date': 'str', 'avail_count': 'float', 'avail_mins': 'float', 'prob_scooter_avail': 'float', 'trips': 'float', 'adj_trips': 'float'})\\n # make sure dates are within start and end dates\\n start_date = str(iso8601.parse_date(self.start).date())\\n end_date = str(iso8601.parse_date(self.end).date())\\n df_processed = df_processed[(df_processed['date'] >= start_date) & (df_processed['date'] <= end_date)]\\n self.set_demand(df_processed)\\n timer_end = time.time()\\n print('Elapsed time to process data:', (timer_end - timer_start)/60.0, 'minutes')\",\n \"def run(self, data):\\n\\t\\t# no processing here\\n\\t\\treturn data\",\n \"def loop(self):\\n data_received = 0\\n data = ''\\n start_time = time.time()\\n current_start_time = time.time()\\n current_frames_received = 0\\n while not self.halt:\\n # Collect data until we have a full frame.\\n tmp_data = self.sock.recv(self.chunk_length)\\n data += tmp_data\\n if tmp_data.startswith(self.sync_start):\\n # Reset data variables, to prepare for a new frame.\\n data = ''\\n data_received = 0\\n switch = self.switch_resolution(tmp_data)\\n if switch:\\n current_start_time = time.time()\\n current_frames_received = 0\\n elif tmp_data.startswith(self.sync_kill):\\n # The server is closing the connection.\\n print 'Received kill frame...'\\n self.halt = True\\n elif self.width != 0 and self.height != 0:\\n data_received += self.chunk_length\\n # When we've received a frame or more (because of zero padding), \\n # then we can finally show it.\\n if data_received >= self.full_frame_length():\\n data = data[:self.full_frame_length()]\\n frame = self.data_to_frame(data)\\n if self.output_file is None:\\n self.show_video_image(frame)\\n else:\\n self.write_video_image(frame)\\n # Update statistics\\n self.received_frames += 1\\n current_frames_received += 1\\n self.output_statistics_during(start_time, \\n current_start_time, \\n current_frames_received\\n )\\n # Reset the values after we've received the whole frame.\\n data_received = 0\\n data = ''\",\n \"def stremingData(self):\\n ports = com_select()\\n self.comport = None\\n if not ports:\\n QMessageBox.warning(self, 'No Connection',\\n \\\"No unit found please verify that the IMU is connected\\\")\\n else:\\n for port in ports:\\n if test_con(port):\\n self.comport = port\\n break\\n if self.comport:\\n if self.ui.qtBStream.text() == 'Stream':\\n self.ui.qtBStream.setText('Stop')\\n self.streamData = GetValue(self.comport)\\n self.streamData.start()\\n iter(self.streamData)\\n self.timer = QTimer()\\n self.timer.timeout.connect(self.graphupdate)\\n self.i = 0\\n self.__x = []\\n if self.recF:\\n if self.ui.qtBrowse.text() == '':\\n self.file_select()\\n if self.ui.qtBrowse.text() == '':\\n QMessageBox.warning(self,\\n 'No file',\\n 'No file selected')\\n self.stremingData()\\n return 0\\n self.timer.start()\\n elif self.ui.qtBStream.text() == 'Stop':\\n self.ui.qtBStream.setText('Stream')\\n self.timer.stop()\\n self.streamData.stop()\\n self.data = [[] for i in range(8)]\\n else:\\n QMessageBox.warning(self, 'No Connection com search',\\n \\\"No unit found please verify that the IMU is connected\\\")\",\n \"def ecgalgAnalyzeRaw(self, D, nHRV=30): #, dataqueue):\\n #D = self.popBuffer()\\n self.analyze.tg_ecg_update(D['ecg_raw'])\\n #ecg_filt = self.analyze.tg_ecg_get_raw_filtered() #delayed against raw by 211 samples\\n ecg_filt = self.analyze.tg_ecg_get_raw_smoothed() #delayed against raw by 450 samples, if 60Hz powerline\\n D['ecg_filt'] = ecg_filt\\n\\n if self.analyze.tg_ecg_is_r_peak():\\n #print \\\"found peak\\\"\\n num_rri = self.analyze.tg_ecg_get_total_rri_count() \\n rri = self.analyze.tg_ecg_get_rri()\\n hr = self.analyze.tg_ecg_compute_hr_now()\\n D['rri']= rri\\n D['hr'] = hr\\n print \\\"%i HR: %i (rri: %i)\\\" % (num_rri, 60000* 1/rri, rri)\\n\\n if num_rri>=15 and num_rri < nHRV:\\n # slowly increase number of RRIs in HRV calculation until we reach nHRV\\n # This is equivalen to starting with a window of 15 RRIs and increasing the window length to max=nHRV\\n nHRV = num_rri\\n if num_rri >= nHRV and (num_rri+2) % self.HRV_UPDATE == 0: \\n #calculate every HRV_UPDATE heartbeats, starting at nHRV (window increases from 15 to 30)\\n hrv = self.analyze.tg_ecg_compute_hrv(nHRV)\\n D['hrv'] = hrv\\n print \\\"hrv: \\\" + str(hrv)\\n\\n return D\",\n \"def processEvents(self):\\n if not self.getIsConnected():\\n return\\n\\n # Loop until there is no more data in the receive buffer.\\n while True:\\n if not self._socketPoller.isReady():\\n # There is no data waiting.\\n return\\n\\n nBytesRead, _ = self._socket.recvfrom_into(self._buffer)\\n if nBytesRead <= 0:\\n # Since we checked for data ready, we don't expect this.\\n return\\n\\n # _bufferView is a memoryview, so we can slice efficienty.\\n self._elementReader.onReceivedData(self._bufferView[0:nBytesRead])\",\n \"def processEvent(self):\\n\\t\\tself.dataPolarity=float(np.sign(np.mean(self.eventData)))\\n\\n\\t\\tself._processEvent()\\n\\n\\t\\tif not self.saveTS:\\n\\t\\t\\tself.eventData=[]\\n\\n\\t\\tself.writeEvent()\",\n \"def go(self):\\n # ipdb.set_trace()\\n self.ang_data = np.zeros(int(self.avg.get()))\\n self.amp_a2 = np.zeros(int(self.avg.get()))\\n self.amp_b2 = np.zeros(int(self.avg.get()))\\n self.ab_re = np.zeros(int(self.avg.get()))\\n self.ab_im = np.zeros(int(self.avg.get()))\\n df = bw*1.0/channels\\n self.index = trunc(float(self.freq2meas.get())/df)\\n self.index_offset = trunc(int(self.chann_span.get()))\\n self.enabler = 1\\n #self.t = threading.Thread(target=self.obtain_data, name='data_thread')\\n print(enabler)\\n self.t.start()\\n return 1\",\n \"def handle(self):\\n while True:\\n try:\\n chunk = self.connection.recv(4)\\n if len(chunk) < 4:\\n break\\n slen = struct.unpack(\\\">L\\\", chunk)[0]\\n chunk = self.connection.recv(slen)\\n while len(chunk) < slen:\\n chunk = chunk + self.connection.recv(slen - len(chunk))\\n obj = self.unPickle(chunk)\\n msg = obj['msg']\\n if type(msg) is str:\\n record = logging.makeLogRecord(obj)\\n self.handleLogRecord(record)\\n else:\\n self.statsThread.addRecord(msg)\\n timeDict = msg['time'] \\n if timeDict['total'] > LOG_THRESHOLD: \\n #obj['msg'] = 'Processed ' + msg['request'] + ' on ' + msg['file'] + ' in ' + ('%.3f' % msg['time']['total']) + ' seconds'\\n logMsg = 'Processed ' + msg['request'] + ' on ' + msg['file'] + '. Timing entries in seconds: '\\n addComma=False\\n for SECTION in self.SECTION_KEYS:\\n timeKey=SECTION.strip()\\n if timeDict.has_key(timeKey):\\n if addComma:\\n logMsg += ','\\n else:\\n addComma = True\\n logMsg += ' ' + timeKey + ' ' + ('%.3f' % timeDict[timeKey])\\n \\n obj['msg'] = logMsg\\n record = logging.makeLogRecord(obj)\\n self.handleLogRecord(record)\\n except Exception, e:\\n import sys, traceback, string\\n t, v, tb = sys.exc_info()\\n print string.join(traceback.format_exception(t, v, tb))\",\n \"def process(self):\\n\\n self.wsRms.connect()\\n\\n self.scheduler = Scheduler(self)\\n self.scheduler.setDaemon(True)\\n self.scheduler.start()\\n\\n while not self.stop:\\n json = self.wsEngine.receive()\\n if json == None:\\n time.sleep(1)\\n continue\\n print \\\"------->Receive from lib: %s\\\" %json\\n message = Message().restore(json)\\n\\n if message.getCmd() == Message.CMD_REGISTER:\\n self.waitingQueue.append(message)\\n\\n elif message.getCmd() == Message.CMD_RELEASE:\\n self.wsRms.release(message.getRes())\\n self.runningQueue.remove(message)\\n\\n self.scheduler.stop()\",\n \"def main_loop(self):\\n # main loop...don't ever exit\\n while True:\\n # collect data\\n # get the time...the local clock is set with NTP regularly\\n self._get_time()\\n \\n # get the latest metar data from the closest location\\n self._get_metar()\\n \\n # get the latest fence station data\\n self._get_fence_station()\\n \\n # get the lastest roof station data\\n #METAR self._get_roof_station()\\n \\n # publish the data to our data file\\n self.write_data_files()\\n \\n # show the user we are running\\n print(\\\"{:s}\\\".format(datetime.datetime.now(pytz.UTC).strftime(\\\"%Y-%m-%d %H:%M:%S.%f\\\")), end=\\\"\\\\r\\\", flush=True)\\n \\n # wait a bit for the next loop\\n time.sleep(3.0)\\n \\n return\",\n \"def recive_data(self, data_waveformreceived):\\r\\n self.adcollector.save_as_binary(self.savedirectory)\\r\\n self.channel_number = len(data_waveformreceived)\\r\\n if self.channel_number == 1: \\r\\n if 'Vp' in self.readinchan:\\r\\n self.data_collected_0 = data_waveformreceived[0]\\r\\n \\r\\n self.PlotDataItem_patch_voltage = PlotDataItem(self.xlabelhere_all, self.data_collected_0)\\r\\n #use the same color as before, taking advantages of employing same keys in dictionary\\r\\n self.PlotDataItem_patch_voltage.setPen('w')\\r\\n self.pw_data.addItem(self.PlotDataItem_patch_voltage)\\r\\n \\r\\n self.textitem_patch_voltage = pg.TextItem(('Vp'), color=('w'), anchor=(1, 1))\\r\\n self.textitem_patch_voltage.setPos(0, 1)\\r\\n self.pw_data.addItem(self.textitem_patch_voltage)\\r\\n elif 'Ip' in self.readinchan:\\r\\n self.data_collected_0 = data_waveformreceived[0]\\r\\n \\r\\n self.PlotDataItem_patch_current = PlotDataItem(self.xlabelhere_all, self.data_collected_0)\\r\\n #use the same color as before, taking advantages of employing same keys in dictionary\\r\\n self.PlotDataItem_patch_current.setPen('c')\\r\\n self.pw_data.addItem(self.PlotDataItem_patch_current)\\r\\n \\r\\n self.textitem_patch_current = pg.TextItem(('Ip'), color=('w'), anchor=(1, 1))\\r\\n self.textitem_patch_current.setPos(0, 1)\\r\\n self.pw_data.addItem(self.textitem_patch_current) \\r\\n elif 'PMT' in self.readinchan: # repeatnum, PMT_data_index_array, averagenum, ScanArrayXnum\\r\\n self.data_collected_0 = data_waveformreceived[0]*-1\\r\\n self.data_collected_0 = self.data_collected_0[0:len(self.data_collected_0)-1]\\r\\n \\r\\n # pmt data could come from raster scanning mode or from contour scanning mode.\\r\\n try:\\r\\n for i in range(self.repeatnum):\\r\\n self.PMT_image_reconstructed_array = self.data_collected_0[np.where(self.PMT_data_index_array_repeated == i+1)]\\r\\n Dataholder_average = np.mean(self.PMT_image_reconstructed_array.reshape(self.averagenum, -1), axis=0)\\r\\n Value_yPixels = int(len(self.samples_1)/self.ScanArrayXnum)\\r\\n self.PMT_image_reconstructed = np.reshape(Dataholder_average, (Value_yPixels, self.ScanArrayXnum))\\r\\n \\r\\n # Stack the arrays into a 3d array\\r\\n if i == 0:\\r\\n self.PMT_image_reconstructed_stack = self.PMT_image_reconstructed\\r\\n else:\\r\\n self.PMT_image_reconstructed_stack = np.concatenate((self.PMT_image_reconstructed_stack, self.PMT_image_reconstructed), axis=0)\\r\\n \\r\\n Localimg = Image.fromarray(self.PMT_image_reconstructed) #generate an image object\\r\\n Localimg.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+str(i)+'.tif')) #save as tif\\r\\n \\r\\n plt.figure()\\r\\n plt.imshow(self.PMT_image_reconstructed, cmap = plt.cm.gray)\\r\\n plt.show()\\r\\n except:\\r\\n np.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+'flatten'), self.data_collected_0)\\r\\n \\r\\n elif self.channel_number == 2: \\r\\n if 'PMT' not in self.readinchan:\\r\\n self.data_collected_0 = data_waveformreceived[0]\\r\\n \\r\\n self.PlotDataItem_patch_voltage = PlotDataItem(self.xlabelhere_all, self.data_collected_0)\\r\\n #use the same color as before, taking advantages of employing same keys in dictionary\\r\\n self.PlotDataItem_patch_voltage.setPen('w')\\r\\n self.pw_data.addItem(self.PlotDataItem_patch_voltage)\\r\\n \\r\\n self.textitem_patch_voltage = pg.TextItem(('Vp'), color=('w'), anchor=(1, 1))\\r\\n self.textitem_patch_voltage.setPos(0, 1)\\r\\n self.pw_data.addItem(self.textitem_patch_voltage) \\r\\n \\r\\n self.data_collected_1 = data_waveformreceived[1]\\r\\n \\r\\n self.PlotDataItem_patch_current = PlotDataItem(self.xlabelhere_all, self.data_collected_1)\\r\\n #use the same color as before, taking advantages of employing same keys in dictionary\\r\\n self.PlotDataItem_patch_current.setPen('c')\\r\\n self.pw_data.addItem(self.PlotDataItem_patch_current)\\r\\n \\r\\n self.textitem_patch_current = pg.TextItem(('Ip'), color=('w'), anchor=(1, 1))\\r\\n self.textitem_patch_current.setPos(0, 1)\\r\\n self.pw_data.addItem(self.textitem_patch_current) \\r\\n elif 'PMT' in self.readinchan:\\r\\n self.data_collected_0 = data_waveformreceived[0]*-1\\r\\n self.data_collected_0 = self.data_collected_0[0:len(self.data_collected_0)-1]\\r\\n \\r\\n try:\\r\\n for i in range(self.repeatnum):\\r\\n self.PMT_image_reconstructed_array = self.data_collected_0[np.where(self.PMT_data_index_array_repeated == i+1)]\\r\\n Dataholder_average = np.mean(self.PMT_image_reconstructed_array.reshape(self.averagenum, -1), axis=0)\\r\\n Value_yPixels = int(len(self.samples_1)/self.ScanArrayXnum)\\r\\n self.PMT_image_reconstructed = np.reshape(Dataholder_average, (Value_yPixels, self.ScanArrayXnum))\\r\\n \\r\\n # Stack the arrays into a 3d array\\r\\n if i == 0:\\r\\n self.PMT_image_reconstructed_stack = self.PMT_image_reconstructed\\r\\n else:\\r\\n self.PMT_image_reconstructed_stack = np.concatenate((self.PMT_image_reconstructed_stack, self.PMT_image_reconstructed), axis=0)\\r\\n \\r\\n Localimg = Image.fromarray(self.PMT_image_reconstructed) #generate an image object\\r\\n Localimg.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+str(i)+'.tif')) #save as tif\\r\\n \\r\\n plt.figure()\\r\\n plt.imshow(self.PMT_image_reconstructed, cmap = plt.cm.gray)\\r\\n plt.show()\\r\\n except:\\r\\n np.save(os.path.join(self.savedirectory, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')+'_PMT_'+self.saving_prefix+'_'+'contourscanning'), self.data_collected_0)\\r\\n \\r\\n if 'Vp' in self.readinchan:\\r\\n self.data_collected_1 = data_waveformreceived[1]\\r\\n \\r\\n self.PlotDataItem_patch_voltage = PlotDataItem(self.xlabelhere_all, self.data_collected_1)\\r\\n #use the same color as before, taking advantages of employing same keys in dictionary\\r\\n self.PlotDataItem_patch_voltage.setPen('w')\\r\\n self.pw_data.addItem(self.PlotDataItem_patch_voltage)\\r\\n \\r\\n self.textitem_patch_voltage = pg.TextItem(('Vp'), color=('w'), anchor=(1, 1))\\r\\n self.textitem_patch_voltage.setPos(0, 1)\\r\\n self.pw_data.addItem(self.textitem_patch_voltage)\\r\\n elif 'Ip' in self.readinchan:\\r\\n self.data_collected_1 = data_waveformreceived[1]\\r\\n \\r\\n self.PlotDataItem_patch_current = PlotDataItem(self.xlabelhere_all, self.data_collected_1)\\r\\n #use the same color as before, taking advantages of employing same keys in dictionary\\r\\n self.PlotDataItem_patch_current.setPen('c')\\r\\n self.pw_data.addItem(self.PlotDataItem_patch_current)\\r\\n \\r\\n self.textitem_patch_current = pg.TextItem(('Ip'), color=('w'), anchor=(1, 1))\\r\\n self.textitem_patch_current.setPos(0, 1)\\r\\n self.pw_data.addItem(self.textitem_patch_current)\",\n \"def run(self):\\n # Define our components entry point\\n while True:\\n\\n # for each packet waiting on our input port\\n for packet in self.receive_all('in'):\\n try:\\n image = packet.get(\\\"data\\\")\\n log.debug(\\\"%s received %s %s\\\",\\n self.__class__.__name__, image.shape, image)\\n mask = np.zeros_like(image, dtype=np.bool)\\n for i, line in enumerate(image):\\n minimum = np.min(image[i])\\n factor = 1.1\\n threshold = factor * minimum\\n mask[i] = image[i] < threshold\\n packet.set(\\\"data\\\", mask)\\n except:\\n log.error('Component Failed: %s',\\n self.__class__.__name__, exc_info=True)\\n\\n # send the packet to the next component\\n self.send('out', packet)\\n\\n # yield the CPU, allowing another component to run\\n self.yield_ctrl()\",\n \"def run(self):\\n while True: # make sure to run at least once before exiting\\n with self._lock:\\n self._update(self._data)\\n if self._done:\\n break\\n time.sleep(1)\",\n \"def process_data(self):\\n # If both queues are empty, just wait\\n if self.prs_q.empty() and self.flw_q.empty():\\n time.sleep(0.01)\\n return\\n\\n # while the pressure queue is not empty, get the data and append\\n new_prs_data = False\\n while not self.prs_q.empty():\\n t, pressure = self.prs_q.get()\\n # Puts the same data on the queue that is read by the piston control thread\\n self.prs_lifo_q.put([t, pressure])\\n # Rolls the array\\n self.prs_data = np.roll(self.prs_data, 1)\\n # inserts the new data in the current i position\\n self.prs_data[:, 0] = (t, pressure - self.prs_tare, pressure)\\n new_prs_data = True\\n if new_prs_data:\\n # Signals that it got all the data from the queue and the sensors can continue to put\\n # new data in the queue\\n self.prs_q.task_done()\\n\\n # while the flow queue is not empty, get the data and append\\n new_flw_data = False\\n while not self.flw_q.empty():\\n t, flow = self.flw_q.get()\\n self.flw_lifo_q.put([t, flow])\\n # Rolls the array\\n self.flw_data = np.roll(self.flw_data, 1)\\n # inserts the new data in the current i position\\n self.flw_data[:, 0] = (t, flow - self.flw_tare, flow)\\n new_flw_data = True\\n if new_flw_data:\\n # Signals that it got all the data from the queue and the sensors can continue to put\\n # new data in the queue\\n self.flw_q.task_done()\\n\\n # Calculating volume from the flow\\n now = time.time()\\n try:\\n last_inhale = now - self.cd[\\\"inhale_instant\\\"]\\n except:\\n last_inhale = 3\\n # Gets the indexes of the data since the last breath\\n i_li = np.where(now - self.flw_data[0, :] < last_inhale)[0]\\n # volume = np.sum(self.flw_data[1, i_li]) / (60 * last_inhale)\\n # Integrating the flow with trapz to get accurate results, considering the dt is not \\n # constant between samples. The time is negative, so needs to invert the signal\\n volume = -integrate.trapz(self.flw_data[1, i_li], self.flw_data[0, i_li])\\n # Converting the volume from L to mL and time from minute to second\\n volume = 1000 * volume / 60\\n # Calibration factor\\n calib = 5\\n volume = volume * calib\\n self.vol_lifo_q.put([t, volume])\\n self.vol_data = np.roll(self.vol_data, 1)\\n self.vol_data[:, 0] = (t, volume)\\n\\n\\n # Gets the tare of the pressure and flow sensors and updates the data \\n if self.get_tare and self.worker_piston.mode == 0:\\n idxs_flw_tare = np.where(time.time() - self.flw_data[0, :] < self.tare_duration)[0]\\n self.flw_tare = np.mean(self.flw_data[2, idxs_flw_tare])\\n self.flw_data[1, :] = self.flw_data[2, :] - self.flw_tare\\n idxs_prs_tare = np.where(time.time() - self.prs_data[0, :] < self.tare_duration)[0]\\n self.prs_tare = np.mean(self.prs_data[2, idxs_prs_tare])\\n self.prs_data[1, :] = self.prs_data[2, :] - self.prs_tare\\n self.get_tare = False\\n if self.get_tare and self.worker_piston.mode != 0:\\n print(\\\"The respirator must be stopped before adjusting the tare.\\\")\\n self.get_tare = False\",\n \"def xbee_data_callback(msg):\\n sender = str(msg.remote_device.get_64bit_addr())\\n\\n # Parse the received JSON.\\n try:\\n json_items = json.loads(msg.data.decode())\\n except (JSONDecodeError, UnicodeDecodeError):\\n return\\n\\n # If the sender is not in the auto-irrigation dictionary, add it with the default value.\\n if sender not in auto_irrigation_dict:\\n auto_irrigation_dict[sender] = auto_irrigation\\n\\n if msg.is_broadcast or json_items[ITEM_OP] != OP_STATUS:\\n return\\n\\n print_log(\\\"Sensor data received from '{}' with payload '{}'\\\".format(sender, msg.data.decode()))\\n\\n properties = json_items[ITEM_PROP]\\n\\n # Update the valve position and last moisture in the dictionaries.\\n if STAT_VALVE in properties:\\n station_valve_dict[sender] = True if properties[STAT_VALVE] == 1 else False\\n if STAT_MOISTURE in properties:\\n station_moisture_dict[sender] = float(properties[STAT_MOISTURE])\\n\\n # Parse the configurations contained in the message and upload them to DRM.\\n upload_configurations_drm(parse_configurations(properties), sender)\",\n \"def run(self):\\n while True:\\n lines = self.process(date_generator=self.date_generator).split('\\\\n')\\n for line in lines:\\n if self.probability():\\n if not self.simulation:\\n self.engine.send(tag=self.tag, msg=str(line))\\n now = datetime.utcnow().ctime()\\n print('{0} => {1}'.format(now, str(line)))\\n else:\\n now = datetime.utcnow().ctime()\\n print('{0} => Skipped by prob.'.format(now))\\n\\n if self.interactive:\\n input(\\\"» Press Enter for next iteration «\\\")\\n else:\\n self.wait()\",\n \"def feed_data(self):\\n test = True\\n\\n sizex_pv = self.detector + ':image1:ArraySize0_RBV'\\n sizey_pv = self.detector + ':image1:ArraySize1_RBV'\\n acquire_pv_name = self.get_acquire_pv_name()\\n while test:\\n self.sizex = caget(sizex_pv)\\n self.sizey = caget(sizey_pv)\\n ack = caget(acquire_pv_name)\\n if ack == 1:\\n test = False\\n self.start_processes()\\n else:\\n time.sleep(.005)\\n\\n # # start the infinit loop so the feed does not stop after this init\\n # if True:\\n # time.sleep(10)\\n #\\n return caget(acquire_pv_name)\",\n \"def _collect_data(self) -> None:\\n self.set_websocket_data()\\n self.set_stratum_data()\\n self.set_cache_data()\\n self.collect_peer_connection_metrics()\\n self.set_tx_storage_data()\",\n \"def run(self):\\n # Get data objects (in a dict) from the controller process \\n dataDict = self.controller.recv()\\n self.orderedStreams = dataDict['orderedStreams']\\n\\n ID = None\\n data = None\\n while self.clients:\\n result = self.resultQ.get()\\n if result is None:\\n self.clients -= 1\\n continue\\n ID, data = result\\n # Data sequence is unimportant, simply write it out and proceed\\n self.writePairs(data)\\n\\n # Send updated data (stats mainly) via the pipe directly back to\\n # the MPController object, close filehandles and finish up.\\n self.updateObjectsToController()\\n self.closeFileHandles()\",\n \"def run(self):\\n while True:\\n time.sleep(RTM_READ_DELAY)\\n for event in self._slack_client.rtm_read():\\n self.handle_event(event)\",\n \"def update(self):\\n # pull all available chunks\\n c, t = self.inlet.pull_chunk(timeout=0.0)\\n new_c = []\\n new_t = []\\n while c:\\n new_c += c\\n new_t += t\\n c, t = self.inlet.pull_chunk(timeout=0.0)\\n\\n # add samples to buffer\\n if any(new_c):\\n # add samples\\n data_v = [item for sublist in new_c for item in sublist]\\n self.gbuffer = np.roll(self.gbuffer, -len(data_v))\\n self.gbuffer[-len(data_v):] = data_v\\n # add timestamps\\n if new_t:\\n self.gtimes = np.roll(self.gtimes, -len(new_t))\\n self.gtimes[-len(new_t):] = new_t\\n\\n # update graph handles\\n if self.gbuffer.any():\\n for k in range(0, self.channel_count):\\n self.handles[k].setData(self.gtimes,\\n self.gbuffer[k::self.channel_count])\",\n \"def _one_loop(self):\\n frame, processed_data = super()._one_loop()\\n\\n if processed_data:\\n segments = self._process_boxes(processed_data)\\n if len(segments):\\n self._draw_segments(frame, segments)\\n self._notifications.append({\\n \\\"kind\\\": \\\"distancing\\\"\\n })\\n if self.config.streaming_output:\\n self._notifications.append({\\n \\\"kind\\\": \\\"frame\\\"\\n })\\n return frame, processed_data\",\n \"def process(self):\\n main_thread_exited = False\\n\\n while True:\\n if not main_thread_exited and not threading.main_thread().is_alive():\\n log.info(\\\"%s exited\\\", threading.main_thread().name)\\n main_thread_exited = True\\n self.finish()\\n\\n try:\\n with self._lock:\\n span = self._queue.get(block=False)\\n if span is None:\\n self._sender.close()\\n log.info(\\\"Processing has been finished\\\")\\n return\\n\\n for data in span.get_data():\\n self._sender.emit_with_time(\\n label=data['label'],\\n timestamp=data['timestamp'],\\n data=data['data']\\n )\\n except Empty:\\n time.sleep(0.1)\",\n \"def start_monitor_loop(self):\\n read_file = read_config_file.ConfigFileReader()\\n\\n communication_time = read_file.get_send_communication_time()\\n metrics_array = read_file.get_metrics()\\n\\n self.add_metrics_to_monitor_object(communication_time, metrics_array)\",\n \"def run(self):\\n self.read_from_serial()\",\n \"def run(self):\\n while True:\\n # Do something\\n print('Doing something imporant in the background')\\n\\n self.loadData()\\n time.sleep(self.interval)\",\n \"def _main_loop(self):\\n while not rospy.is_shutdown():\\n # Check for reconfiguration data\\n if self._transfer_reconfigure_data is not None:\\n # Copy reconfigure data from shared memory\\n with self._transfer_reconfigure_data_mutex:\\n reconfigure_data = deepcopy(self._transfer_reconfigure_data)\\n self._transfer_reconfigure_data = None\\n # Run vision reconfiguration\\n self._configure_vision(*reconfigure_data)\\n # Check for new image\\n elif self._transfer_image_msg is not None:\\n # Copy image from shared memory\\n with self._transfer_image_msg_mutex:\\n image_msg = self._transfer_image_msg\\n self._transfer_image_msg = None\\n # Run the vision pipeline\\n self._handle_image(image_msg)\\n # Now the first image has been processed\\n self._first_image_callback = False\\n else:\\n try:\\n self._rate.sleep()\\n except rospy.exceptions.ROSTimeMovedBackwardsException:\\n pass\",\n \"def on_update(self):\\n\\n t_start = time.time()\\n\\n # get input audio if desired\\n if self.input_stream:\\n try:\\n num_frames = self.input_stream.get_read_available() # number of frames to ask for\\n if num_frames:\\n data_str = self.input_stream.read(num_frames, False)\\n data_np = np.fromstring(data_str, dtype=np.float32)\\n self.input_func(data_np, self.num_input_channels)\\n except IOError as e:\\n print('got error', e)\\n\\n # Ask the generator to generate some audio samples.\\n num_frames = self.stream.get_write_available() # number of frames to supply\\n if self.generator and num_frames != 0:\\n (data, continue_flag) = self.generator.generate(num_frames, self.num_channels)\\n\\n # make sure we got the correct number of frames that we requested\\n assert len(data) == num_frames * self.num_channels, \\\\\\n \\\"asked for (%d * %d) frames but got %d\\\" % (num_frames, self.num_channels, len(data))\\n\\n # convert type if needed and write to stream\\n if data.dtype != np.float32:\\n data = data.astype(np.float32)\\n self.stream.write(data.tostring())\\n\\n # send data to listener as well\\n if self.listen_func:\\n self.listen_func(data, self.num_channels)\\n\\n # continue flag\\n if not continue_flag:\\n self.generator = None\\n\\n # how long this all took\\n dt = time.time() - t_start\\n a = 0.9\\n self.cpu_time = a * self.cpu_time + (1-a) * dt\",\n \"def process(self, data, channel = None):\\n\\t\\traise NotImplementException()\",\n \"async def _monitor_recv(self):\\n\\n while True:\\n await RisingEdge(self.clock)\\n await ReadOnly()\\n if self.bus.valid.value:\\n self._recv(int(self.bus.data.value))\",\n \"def obtain_data(self):\\n ##MODIFY THIS\\n #ipdb.set_trace()\\n print('obtain_data')\\n print(self.enabler)\\n print(self.index)\\n helper = '>'+str(1+int(self.chann_span.get()))+'Q'\\n print('helper='+helper)\\n while(self.enabler):\\n #print('size'+str(1+int(self.chann_span.get())))\\n #print('offset'+str(self.index-self.index_offset))\\n A2 = struct.unpack(helper, fpga.read('A2', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8))) \\n #print(A2)\\n #print(str(10*np.log10(A2))+'dB')\\n self.amp_a2[0] = np.mean(A2)\\n self.amp_a2 = np.roll(self.amp_a2, -1)\\n B2 = struct.unpack(helper, fpga.read('B2', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8)))\\n self.amp_b2[0] = np.mean(B2)\\n self.amp_b2 = np.roll(self.amp_b2, -1)\\n AB_re = struct.unpack(helper, fpga.read('AB_re', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8)))\\n self.ab_re[0] = np.mean(AB_re)\\n self.ab_re = np.roll(self.ab_re, -1)\\n AB_im = struct.unpack(helper, fpga.read('AB_im', (1+int(self.chann_span.get()))*8, ((self.index-self.index_offset)*8)))\\n self.ab_im[0] = np.mean(AB_im)\\n self.ab_im = np.roll(self.ab_im, -1) \\n # print('RE:' + str(self.ab_re)+ '\\\\t IM:' +str(self.ab_im))\\n log_a = 10*np.log10(np.mean(self.amp_a2)+1.0)\\n log_b = 10*np.log10(np.mean(self.amp_b2)+1.0) \\n ang = np.rad2deg(np.arctan2(np.mean(self.ab_im), np.mean(self.ab_re))) #review the way of avg this... i dont know if its the most correct way to do it...\\n self.a2.set(log_a)\\n self.b2.set(log_b)\\n self.ang.set(ang)\\n self.amp_rel.set(log_a-log_b)\\n return 1\",\n \"def sync(self):\\n self._start_slow_sync()\\n self._ask_for_all_records()\\n self._process_events()\\n self._process_reminders()\\n self._process_recurrences()\\n #self._write_events()\",\n \"async def run(self):\\n\\n\\t\\tawait asyncio.sleep(self.delay)\\n\\t\\tR_load = self.lock.mag/(self.sense - self.lock.mag)*self.R_ref\\n\\t\\tawait self.resistance.push(R_load)\\n\\t\\tawait self.current.push(self.lock.dc/(self.R_ref+R_load))\\n\\t\\tawait self.voltage.push(self.lock.dc*R_load/(self.R_ref+R_load))\\n\\n\\t\\tlogger.debug(\\\"Stream has filled {} of {} points\\\".format(self.resistance.points_taken,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tself.resistance.num_points() ))\\n\\n\\t\\t#await asyncio.sleep(2*self.integration_time) # Give the filters some time to catch up?\",\n \"def generate_data(self):\\n print(\\\"generate_data - init\\\")\\n with open(self.input_file, \\\"r\\\") as f:\\n\\n # read JSON data from input file\\n data = json.loads(f.read())\\n\\n for idx, row in enumerate(data): \\n # serialize Python dict to string\\n msg = self.serialize_json(row)\\n #print(f\\\"Linha: {row}\\\")\\n self.send(self.topic, msg)\\n self.flush()\\n #print(\\\"Sleeping\\\")\\n time.sleep(1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6334594","0.62554085","0.6160218","0.6159584","0.6151509","0.6107726","0.6082145","0.5994185","0.59724444","0.59122896","0.5894136","0.5888195","0.5872895","0.58719957","0.5846285","0.5831141","0.58255845","0.58187026","0.58187026","0.57989854","0.57989854","0.57989854","0.5796255","0.57851565","0.57851565","0.57851565","0.57851565","0.57851565","0.57851565","0.5772342","0.5771454","0.577043","0.57229537","0.5719781","0.57048696","0.5702638","0.56901366","0.56879175","0.5677235","0.5634566","0.5634534","0.5634534","0.5634534","0.5634534","0.5634534","0.56315947","0.5631336","0.56309545","0.5629524","0.5626405","0.5597844","0.5576698","0.5576698","0.5567772","0.55644846","0.5559144","0.5549949","0.5544434","0.55323493","0.5530343","0.5526232","0.55113196","0.5508437","0.55029273","0.54975444","0.5494098","0.549391","0.5483065","0.54767454","0.5461642","0.545303","0.5445476","0.54450554","0.544475","0.54367816","0.543315","0.5429846","0.54256856","0.5423934","0.5423785","0.5400941","0.5392577","0.5387491","0.5384168","0.53804094","0.53777575","0.53708285","0.53698623","0.53688514","0.53654","0.5363845","0.5354627","0.53451216","0.534395","0.5340496","0.53395486","0.53368556","0.5336633","0.53336555","0.53319323"],"string":"[\n \"0.6334594\",\n \"0.62554085\",\n \"0.6160218\",\n \"0.6159584\",\n \"0.6151509\",\n \"0.6107726\",\n \"0.6082145\",\n \"0.5994185\",\n \"0.59724444\",\n \"0.59122896\",\n \"0.5894136\",\n \"0.5888195\",\n \"0.5872895\",\n \"0.58719957\",\n \"0.5846285\",\n \"0.5831141\",\n \"0.58255845\",\n \"0.58187026\",\n \"0.58187026\",\n \"0.57989854\",\n \"0.57989854\",\n \"0.57989854\",\n \"0.5796255\",\n \"0.57851565\",\n \"0.57851565\",\n \"0.57851565\",\n \"0.57851565\",\n \"0.57851565\",\n \"0.57851565\",\n \"0.5772342\",\n \"0.5771454\",\n \"0.577043\",\n \"0.57229537\",\n \"0.5719781\",\n \"0.57048696\",\n \"0.5702638\",\n \"0.56901366\",\n \"0.56879175\",\n \"0.5677235\",\n \"0.5634566\",\n \"0.5634534\",\n \"0.5634534\",\n \"0.5634534\",\n \"0.5634534\",\n \"0.5634534\",\n \"0.56315947\",\n \"0.5631336\",\n \"0.56309545\",\n \"0.5629524\",\n \"0.5626405\",\n \"0.5597844\",\n \"0.5576698\",\n \"0.5576698\",\n \"0.5567772\",\n \"0.55644846\",\n \"0.5559144\",\n \"0.5549949\",\n \"0.5544434\",\n \"0.55323493\",\n \"0.5530343\",\n \"0.5526232\",\n \"0.55113196\",\n \"0.5508437\",\n \"0.55029273\",\n \"0.54975444\",\n \"0.5494098\",\n \"0.549391\",\n \"0.5483065\",\n \"0.54767454\",\n \"0.5461642\",\n \"0.545303\",\n \"0.5445476\",\n \"0.54450554\",\n \"0.544475\",\n \"0.54367816\",\n \"0.543315\",\n \"0.5429846\",\n \"0.54256856\",\n \"0.5423934\",\n \"0.5423785\",\n \"0.5400941\",\n \"0.5392577\",\n \"0.5387491\",\n \"0.5384168\",\n \"0.53804094\",\n \"0.53777575\",\n \"0.53708285\",\n \"0.53698623\",\n \"0.53688514\",\n \"0.53654\",\n \"0.5363845\",\n \"0.5354627\",\n \"0.53451216\",\n \"0.534395\",\n \"0.5340496\",\n \"0.53395486\",\n \"0.53368556\",\n \"0.5336633\",\n \"0.53336555\",\n \"0.53319323\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59569275"},"document_rank":{"kind":"string","value":"9"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":845,"numItemsPerPage":100,"numTotalItems":95772,"offset":84500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjAxMjE4MiwianRpIjoiZDVhOGE3OGMtOGIwYi00OTg4LWEzNTgtZmI1ZjhhYjJlMmJhIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwMTU3ODIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.ZXBWbvj4s5rlJPJ0szEfbF-n-RH96ilbPu-Yei64VFNTXstqlKT0cnNPYiXjqwUcW65fSLpAorElXNvVMu5XDQ","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 |
|---|---|---|---|---|---|---|
the function makes a game of "7 Boom" it replace every number that contains "7" or divides by 7. | def seven_boom(end_number):
all_nums = []
for n in range(1, end_number + 1):
if n % 7 == 0 or "7" in str(n):
all_nums.append("Boom")
else:
all_nums.append(n)
return all_nums | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def problem():\n # First prime number>2 ends only with (1, 3, 5, 7, 9). Last digit cannot be\n # replaced.\n # Number of digits that need to be replaced are 3.\n\n masks = (\n \"{1}{2}{0}{0}{0}{3}\",\n \"{1}{0}{2}{0}{0}{3}\",\n \"{1}{0}{0}{2}{0}{3}\",\n \"{1}{0}{0}{0}{2}{3}\... | [
"0.6820968",
"0.65721613",
"0.59408474",
"0.57117885",
"0.57012874",
"0.5686959",
"0.56695634",
"0.5645862",
"0.562656",
"0.55166095",
"0.549958",
"0.54770386",
"0.54770386",
"0.54770386",
"0.54343045",
"0.54297036",
"0.5426893",
"0.54231066",
"0.5422682",
"0.5420768",
"0.541... | 0.6623458 | 1 |
Valid response with next action to be followed by the JS | def json_to_response(self, action=None, json_status=None, success_url=None,
json_data=None, **response_kwargs):
data = {
"status": self.get_status(json_status),
"action": self.get_action(action),
"extra_data": self.get_json_data(json_data or {})
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_response(self, response):\n pass",
"def user_should_get_an_ok_response():\n assert web_app.validate_reponse()",
"def validate(self, response):\n return response[\"status_code\"] == 1",
"def post_validate_flow(\n self, response: flow.FlowValidationResult\n ) -> flow.Flo... | [
"0.66249514",
"0.62555987",
"0.6251725",
"0.61860937",
"0.61699665",
"0.61699665",
"0.6126522",
"0.6126522",
"0.6123501",
"0.5934643",
"0.59199834",
"0.58912086",
"0.584448",
"0.584448",
"0.5806025",
"0.5805762",
"0.5803021",
"0.57740223",
"0.5767923",
"0.5762147",
"0.5740651... | 0.0 | -1 |
Returns action to take after call | def get_action(self, action=None):
if action:
self.action = action
if self.action not in AjaxResponseAction.choices:
raise ValueError(
"Invalid action selected: '{}'".format(self.action))
return self.action | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def call_action(self, action):\n pass",
"def action_done(self):",
"def take_action(self, *args, **kwargs):\r\n pass",
"def action_done(self):\n pass",
"def _do_action(self):\n pass",
"def _do_action(self):\n pass",
"def do_after(self):\r\n pass",
"def act(sel... | [
"0.69445664",
"0.6943001",
"0.6942204",
"0.68721336",
"0.6834246",
"0.6834246",
"0.6597721",
"0.6511799",
"0.645936",
"0.64292854",
"0.64245814",
"0.6415862",
"0.63407004",
"0.63407004",
"0.6297166",
"0.6296422",
"0.6282538",
"0.6266559",
"0.6254029",
"0.62444353",
"0.6218164... | 0.0 | -1 |
Returns status of for json | def get_status(self, json_status=None):
if json_status:
self.json_status = json_status
if self.json_status not in AjaxResponseStatus.choices:
raise ValueError(
"Invalid status selected: '{}'".format(self.json_status))
return self.json_status | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def status():\n return jsonify({\"status\": \"OK\"})",
"def status():\n return jsonify({\"Status\": \"Ok\"})",
"def json_status():\n return jsonify({\"status\": \"OK\"})",
"def getStatus():\n return json.dumps({'camera': Camera.status(), 'rover': rover.status()}), 200",
"def get_status():\n ... | [
"0.80390227",
"0.79501057",
"0.79491484",
"0.78886074",
"0.7840176",
"0.76253086",
"0.7582878",
"0.7577055",
"0.7507282",
"0.7502897",
"0.7459544",
"0.7423667",
"0.73184675",
"0.7257667",
"0.7207916",
"0.71479875",
"0.71447736",
"0.71276903",
"0.7103936",
"0.7063255",
"0.7037... | 0.6963305 | 23 |
Returns any extra data to add to json | def get_json_data(self, json_data=None):
return json_data or {} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hydrate_extra_info(self, bundle):\n extra_info = bundle.data[\"extra_info\"]\n bundle.data[\"extra_info\"] = json.dumps(extra_info)\n return bundle",
"def extra(self) -> Dict[str, Any]:\n extra = self.extras.copy()\n if isinstance(self.author, str):\n extra['Auth... | [
"0.7136737",
"0.6971354",
"0.6882013",
"0.6691394",
"0.6650121",
"0.662635",
"0.662635",
"0.661754",
"0.6543825",
"0.65356535",
"0.64480144",
"0.6437633",
"0.63862795",
"0.6352075",
"0.6335709",
"0.6330153",
"0.6306599",
"0.62786764",
"0.6273986",
"0.6263539",
"0.6244206",
... | 0.61241674 | 36 |
If form invalid return error list in JSON response | def form_invalid(self, form, prefix=None):
response = super(FormAjaxMixin, self).form_invalid(form)
if self.request.is_ajax():
data = {
"errors_list": self.add_prefix(form.errors, prefix),
}
return self.json_to_response(status=400, json_data=data,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def form_invalid(self, form):\n response = super().form_invalid(form)\n if self.is_ajax():\n return JsonResponse(form.errors, status=400)\n else:\n return response",
"def form_invalid(self, form):\n response = super(AjaxableResponseMixin, self).form_invalid(form)... | [
"0.7665663",
"0.75349003",
"0.7339613",
"0.71741205",
"0.7158141",
"0.7126791",
"0.7107218",
"0.6952973",
"0.6897809",
"0.6629777",
"0.6626728",
"0.6606772",
"0.6513617",
"0.64996225",
"0.64490724",
"0.6420252",
"0.63936806",
"0.63936806",
"0.6303919",
"0.6296751",
"0.6293436... | 0.7219318 | 3 |
If form valid return response with action | def form_valid(self, form):
response = super(FormAjaxMixin, self).form_valid(form)
if self.request.is_ajax():
return self.json_to_response()
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(self, request, *args, **kwargs):\n form = self.get_form()\n if form.validate():\n return self.form_valid(form)\n else:\n return self.form_invalid(form)",
"def post(self, request, *args, **kwargs):\n form = self.get_form()\n if form.is_valid():\n ... | [
"0.6804317",
"0.6632513",
"0.6586356",
"0.6526392",
"0.6373733",
"0.6342913",
"0.63415116",
"0.61759424",
"0.6175222",
"0.61239624",
"0.61119753",
"0.61110294",
"0.60705644",
"0.6056116",
"0.60451347",
"0.6035517",
"0.6014968",
"0.60106874",
"0.59802735",
"0.5964109",
"0.5911... | 0.56068015 | 62 |
Add form prefix to errors | def add_prefix(self, errors, prefix):
if not prefix:
prefix = self.get_prefix()
if prefix:
return {"%s-%s" % (prefix, k): v for k, v in errors.items()}
return errors | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _post_clean(self):\r\n super(NgModelFormMixin, self)._post_clean()\r\n if self._errors and self.prefix:\r\n self._errors = ErrorDict((self.add_prefix(name), value) for name, value in self._errors.items())",
"def render_errors(form):\n return {\n \"form\": form\n }",
"d... | [
"0.7038696",
"0.6208197",
"0.6115108",
"0.5996022",
"0.5964648",
"0.58308095",
"0.5824564",
"0.57793695",
"0.57664406",
"0.57629406",
"0.5701787",
"0.5659007",
"0.5616956",
"0.56133205",
"0.56133205",
"0.55535233",
"0.5502182",
"0.545413",
"0.5441139",
"0.542132",
"0.52813584... | 0.7227966 | 0 |
Returns the rendered template in JSON format | def render_to_response(self, context, **response_kwargs):
if self.request.is_ajax():
data = {
"content": render_to_string(
self.get_template_names(), context, request=self.request)
}
return JsonResponse(data)
if settings.DEBUG:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render(self):\n self.run()\n return [{'dest' : self.dest,\n 'text' : self.tmpl.render(**self.data)}]",
"def render_application_template(self):\n self.pipeline_config['instance_links'] = self.retrieve_instance_links()\n jsondata = get_template(\n template... | [
"0.7579928",
"0.7063285",
"0.68811625",
"0.6820729",
"0.67492795",
"0.673821",
"0.6679588",
"0.6661849",
"0.65768874",
"0.6514327",
"0.6481385",
"0.64696205",
"0.64591503",
"0.6450817",
"0.6443299",
"0.6396994",
"0.6315381",
"0.6302424",
"0.6277436",
"0.6257746",
"0.6257746",... | 0.59789956 | 53 |
Initialize the overarching program and allow for threading. | def __init__(self):
super().__init__()
self.init_ui() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init ():\n freeze_support () # for specific uses of the program on Windows",
"def _initialise_run(self) -> None:",
"def init(self):\r\n self._parse_options(self._force_args)\r\n self._maybe_daemonize()\r\n self._setup_modules()\r\n self._state = self.INITIALIZED",
"def startup(self):\n ... | [
"0.7048484",
"0.6891471",
"0.6890817",
"0.6824575",
"0.67827064",
"0.676735",
"0.6756139",
"0.66983837",
"0.66682756",
"0.6659636",
"0.6567239",
"0.65514654",
"0.6450136",
"0.6402179",
"0.6348086",
"0.6328023",
"0.63192403",
"0.63087535",
"0.6293216",
"0.62915957",
"0.6284138... | 0.0 | -1 |
Build the UI and set up the initial parameters for the system. build the user interface and connect signals from the UI to methods defined below. This is inherited from PyQt5 and pyqtgraph (for antialiasing). ADD MORE OF WHAT THE METHOD DOES HERE. | def init_ui(self, parent=None):
super(dIdVGui, self).__init__(parent)
self.setupUi(self)
#pg.setConfigOptions(antialias=True)
#%% Initial Differential Conductance Variables
self.dIdV_rate = self.dIdVRate.value()
self.dIdV_start = self.dIdVStartCurr.value()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initUI(self):\n self.logger.debug('Setting up the Measurement GUI')\n self.setWindowTitle(self.title)\n\n self.show()\n\n self.make_combobox_scanner()\n self.make_combobox_movements()\n self.make_combobox_configurate()\n self.make_combobox_basic()",
"def _init... | [
"0.7934318",
"0.7619701",
"0.7533222",
"0.7496077",
"0.7448796",
"0.74145854",
"0.7398438",
"0.73087925",
"0.73002166",
"0.7296921",
"0.72742283",
"0.72733223",
"0.72610986",
"0.72468096",
"0.7227707",
"0.7221966",
"0.72207093",
"0.7216277",
"0.7216277",
"0.718057",
"0.717609... | 0.6574674 | 92 |
Open a dialog box and create a compliance list for a custom sweep. Will save the list so that it may be passed to the instruments. SLIGHTLY BUGGY BUT OK | def create_compliance_list(self):
self.compliance_list = None
self.list_label = ("Enter a list of compliance voltages (V) separated "
"by commas (e.g. 1, 2, 3). Range is 0.1 to 105. Must "
"have same number of points as current list or be "
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_to_current_designs_callback(self, ListTypesFull, check_button_ckList):\n\n if not self.check_for_residue_existance():\n return\n\n self.current_chainFull = self.current_residue.get().split(\":\")\n if len(self.current_chainFull) > 1:\n ResStart = int(self.current_... | [
"0.53039885",
"0.5272541",
"0.5164381",
"0.5153914",
"0.51034915",
"0.507512",
"0.5046017",
"0.5033432",
"0.5007332",
"0.49825966",
"0.49568945",
"0.49487162",
"0.49321654",
"0.49084106",
"0.490425",
"0.4867304",
"0.4857254",
"0.48513114",
"0.48159236",
"0.4812841",
"0.480814... | 0.70281583 | 0 |
Open a dialog box and create a current list for a custom sweep. Will return the list as a string so that it may be passed to the instruments. SLIGHTLY BUGGY BUT OK | def create_I_list(self):
self.I_list = ['0']
self.list_label = ("Enter a list of source currents (A) separated by "
"commas (e.g., 1e-3, 2e-6, 3e-4). Range is -0.105 "
"to 0.105. If empty list, sets 1-point list with "
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_compliance_list(self):\r\n self.compliance_list = None\r\n self.list_label = (\"Enter a list of compliance voltages (V) separated \"\r\n \"by commas (e.g. 1, 2, 3). Range is 0.1 to 105. Must \"\r\n \"have same number of points as current list or be... | [
"0.6108962",
"0.55942416",
"0.5566351",
"0.5345901",
"0.5332031",
"0.53211814",
"0.5315982",
"0.5270236",
"0.5257532",
"0.5217911",
"0.51774496",
"0.51343507",
"0.5105398",
"0.51048917",
"0.50571436",
"0.5004678",
"0.50045633",
"0.50009185",
"0.499991",
"0.49909893",
"0.49825... | 0.58283496 | 1 |
Open a dialog box and create a cycle interval list for a custom sweep. Will return the list as a string so that it may be passed to the instruments. SLIGHTLY BUGGY BUT OK | def create_cycle_list(self):
self.cycle_list = None
self.list_label = ("Enter a list of cycle times (in integer PLC) "
"separated by commas (e.g., 1, 5, 7). Must "
"have same number of points as current list or be "
"e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_I_list(self):\r\n self.I_list = ['0']\r\n self.list_label = (\"Enter a list of source currents (A) separated by \"\r\n \"commas (e.g., 1e-3, 2e-6, 3e-4). Range is -0.105 \"\r\n \"to 0.105. If empty list, sets 1-point list with \"\r\n ... | [
"0.5815914",
"0.54718876",
"0.5277732",
"0.5244302",
"0.5012473",
"0.5012194",
"0.5010573",
"0.48528308",
"0.47787085",
"0.47195724",
"0.46868253",
"0.4671984",
"0.4651609",
"0.4645154",
"0.46232212",
"0.46119052",
"0.45586553",
"0.4554039",
"0.45474464",
"0.45366964",
"0.453... | 0.71184677 | 0 |
Calculate the number of points in a sweep. | def num_points_sweep(self, start, stop, step):
return(abs((stop - start)//step) + 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def n_sweep(self):\n return self._n_sweep",
"def n_points(self):\n\n if self.data_reduced:\n return len(self.data_reduced[0])\n else:\n return 0",
"def numberOfPoints(self):\n return 20000",
"def nr_points(self):\n return len(self.x)",
"def GetNumber... | [
"0.67116016",
"0.6710413",
"0.64373267",
"0.64242",
"0.63951397",
"0.6383078",
"0.6207242",
"0.617462",
"0.617306",
"0.61665",
"0.6122303",
"0.6066918",
"0.60630375",
"0.6040785",
"0.6001944",
"0.5952431",
"0.5930012",
"0.5926737",
"0.58931786",
"0.58931786",
"0.58803296",
... | 0.7976391 | 0 |
If instruments are connected, set the source range type based on the combo box selection and the measurement type. The function inside get() returns unique keys for all nondifferential conductance measurements. Since differential conductance automatically has 'best' ranging, its keys don't matter. WORKING | def update_source_range_type(self):
self.source_range_type_index = self.SourceRangeType.currentIndex()
self.cmd = None
if self.current_tab:
self.cmd = self.source_range_type_switch.get(
self.current_tab + 3*self.source_range_type_index, None)
if self... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_default_tuner_range():\n return {65.41: 'C2',\n 69.30: 'C2#',\n 73.42: 'D2',\n 77.78: 'E2b',\n 82.41: 'E2',\n 87.31: 'F2',\n 92.50: 'F2#',\n 98.00: 'G2',\n 103.80: 'G2#',\n 110.00: 'A2',\n 116... | [
"0.56911653",
"0.52945167",
"0.51720303",
"0.4946854",
"0.4937591",
"0.4891812",
"0.4796071",
"0.4778892",
"0.47767597",
"0.47518268",
"0.47423512",
"0.4717272",
"0.47147053",
"0.4697422",
"0.46531144",
"0.46339667",
"0.46199188",
"0.45852423",
"0.45715055",
"0.4561549",
"0.4... | 0.5822572 | 0 |
If instruments are connected and 'fixed' ranging is selected for the source, set the range for the current source. WORKING | def update_source_range(self):
self.source_range_index = self.SourceRangeValue.currentIndex()
self.cmd = None
if self.source_range_type_index and self.connected:
self.cmd = self.source_range_switch.get(
self.source_range_index, None)
self.I_sourc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def updateRange(self):\n if self.autoFollow:\n self.xrange = self.param.activeRange()\n self.xrange = self.xrange # call getter & setter again to verify limits",
"def update_source_range_type(self):\r\n self.source_range_type_index = self.SourceRangeType.currentIndex()\r\n ... | [
"0.6363817",
"0.60023093",
"0.5866444",
"0.582724",
"0.5760188",
"0.57191896",
"0.5687571",
"0.56715",
"0.56542695",
"0.55636144",
"0.55159867",
"0.5506243",
"0.5476146",
"0.5476146",
"0.54492867",
"0.54370373",
"0.54271984",
"0.54124457",
"0.5391282",
"0.53891414",
"0.536108... | 0.6765496 | 0 |
If instruments connected and the voltmeter is set to manual ranging, update the value of the voltmeter range. WORKING | def update_volt_range(self):
self.volt_range_index = self.VoltmeterRangeValue.currentIndex()
self.cmd = self.volt_range_switch.get(self.volt_range_index, None)
if self.connected:
self.I_source.write(self.cmd) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_volt_rate(self):\r\n self.cmd = None\r\n if self.connected:\r\n self.cmd = (\"SYST:COMM:SER:SEND ':SENS:VOLT:NPLC \"\r\n + (str(self.DeltaRate.value()) if self.current_tab\r\n else str(self.dIdVRate.value())) + \"'\")\r\n ... | [
"0.6594569",
"0.6531825",
"0.6392429",
"0.6377812",
"0.6198045",
"0.6152024",
"0.6146791",
"0.61040014",
"0.6015494",
"0.59889895",
"0.5960682",
"0.5886433",
"0.58780557",
"0.58434933",
"0.5833829",
"0.5824948",
"0.58067364",
"0.57977766",
"0.5794106",
"0.5776705",
"0.576475"... | 0.7757934 | 0 |
If instruments connected, update voltmeter rate. Only functional for dIdV and delta measurements. WORKING | def update_volt_rate(self):
self.cmd = None
if self.connected:
self.cmd = ("SYST:COMM:SER:SEND ':SENS:VOLT:NPLC "
+ (str(self.DeltaRate.value()) if self.current_tab
else str(self.dIdVRate.value())) + "'")
self.voltmeter_rat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _measurement_update(self):\n pass",
"def update_volt_range(self):\r\n self.volt_range_index = self.VoltmeterRangeValue.currentIndex()\r\n self.cmd = self.volt_range_switch.get(self.volt_range_index, None)\r\n if self.connected:\r\n self.I_source.write(self.cmd)",
"def ... | [
"0.63179785",
"0.622544",
"0.60588276",
"0.5962366",
"0.589405",
"0.5797333",
"0.5788367",
"0.57867223",
"0.57157326",
"0.57095784",
"0.57080036",
"0.5685928",
"0.56754315",
"0.5664005",
"0.56250376",
"0.5614799",
"0.55972266",
"0.55874556",
"0.55782706",
"0.55688703",
"0.556... | 0.7804134 | 0 |
If the instruments are connected and the user alters the compliance voltage, send a command to update the instruments. WORKING | def update_compliance(self):
self.compliance_voltage = str(self.ComplianceVoltage.value())
#self.cmd = None
if self.connected:
self.cmd = "CURR:COMP " + self.compliance_voltage
self.I_source.write(self.cmd) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_volt_range(self):\r\n self.volt_range_index = self.VoltmeterRangeValue.currentIndex()\r\n self.cmd = self.volt_range_switch.get(self.volt_range_index, None)\r\n if self.connected:\r\n self.I_source.write(self.cmd)",
"def update_volt_rate(self):\r\n self.cmd = None... | [
"0.6727535",
"0.66885936",
"0.6580229",
"0.62153286",
"0.6068523",
"0.6049526",
"0.6044076",
"0.60218334",
"0.60006726",
"0.5878938",
"0.5873626",
"0.5801125",
"0.5755011",
"0.5741827",
"0.5732976",
"0.57316613",
"0.57288504",
"0.56651706",
"0.56286997",
"0.56208044",
"0.5619... | 0.74610525 | 0 |
If instruments connected and the user alters the specified units in the dropdown menu, send a command to update the unit type. WORKING | def update_units(self):
self.units_index = self.UnitsComboBox.currentIndex()
self.cmd = None
if self.connected:
self.cmd = self.unit_switch.get(self.units_index, None)
self.I_source.write(self.cmd)
self.update_header_string() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unitUpdate(self):\n newText = self.unitGroup.unitString()\n cursorPos = len(newText) - self.text().length() + self.cursorPosition()\n if cursorPos < 0: # cursor set to same distance from right end\n cursorPos = 0\n self.blockSignals(True)\n self.setText(newTex... | [
"0.6152118",
"0.61117256",
"0.6045749",
"0.5959084",
"0.58111477",
"0.57802886",
"0.5717387",
"0.570346",
"0.56736743",
"0.56634337",
"0.56476676",
"0.56463736",
"0.5617639",
"0.56117994",
"0.5536073",
"0.5527987",
"0.55072844",
"0.54589546",
"0.54367155",
"0.53979075",
"0.53... | 0.7398374 | 0 |
FIGURE OUT HOW TO DO PROPERLY | def clear_buffer(self):
self.cmd = "TRAC:CLE"
self.I_source.write(self.cmd)
self.in_buffer = int(self.I_source.query("TRAC:POIN:ACT?")) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transform(self):",
"def apply(self):",
"def preprocess(self):",
"def apply(self) -> None:",
"def apply(self) -> None:",
"def transform():",
"def scale(self):",
"def substantiate():",
"def transform(self, x):",
"def solvate(self):\n\n pass",
"def exo2():",
"def othersn(ax):",
"def... | [
"0.60599005",
"0.58336335",
"0.57831174",
"0.578261",
"0.578261",
"0.5730147",
"0.56879497",
"0.5623188",
"0.56141365",
"0.5584145",
"0.5570487",
"0.5546733",
"0.55165327",
"0.5394322",
"0.5368094",
"0.53645474",
"0.5340135",
"0.53302324",
"0.5329223",
"0.5323773",
"0.5292836... | 0.0 | -1 |
FIGURE OUT HOW TO DO PROPERLY self.cmd = None | def calibrate_meter(self):
print("meter calibrated") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cmd(self):",
"def __init__(self, cmd):\r\n self._cmd = cmd",
"def __init__(self, cmd):\n self._cmd = cmd",
"def cmd(self, cmd):\n return cmd",
"def __init__(self, cmd):\n # Build command + options \n self.cmd = cmd \n setattr(self, 'command', \"%s\" % (cmd))",
"def _... | [
"0.7856441",
"0.76452756",
"0.7426194",
"0.7417791",
"0.7231597",
"0.7196737",
"0.7139473",
"0.7066071",
"0.69000655",
"0.68417186",
"0.68273544",
"0.67683977",
"0.67374516",
"0.6641619",
"0.6626947",
"0.657753",
"0.65712225",
"0.652236",
"0.64832443",
"0.64673394",
"0.646055... | 0.0 | -1 |
If the user selects a different measurement type from the tab menu, update the variables and the ranging. WORKING | def update_tab(self):
self.current_tab = self.TabWidget.currentIndex()
# print("Tab = " + str(self.current_tab))
self.update_source_range_type()
self.update_variables_switch[self.current_tab]()
self.update_header_string()
self.update_filter_on() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_units(self):\n unit_var_value = self.view.vars['unit'].get()\n if unit_var_value == 'm3ph':\n self.minran_u_label.config(text='m³/h')\n self.maxran_u_label.config(text='m³/h')\n self.points_tview.heading('vflow', text='Przepływ [m³/h]', anchor=tk.CENTER)\n ... | [
"0.6636531",
"0.6625855",
"0.65011966",
"0.63680774",
"0.61108446",
"0.60962576",
"0.59827435",
"0.5895908",
"0.5879142",
"0.5857627",
"0.5799572",
"0.578058",
"0.57690614",
"0.57404363",
"0.57372797",
"0.56927246",
"0.56882066",
"0.5685359",
"0.5659598",
"0.56448346",
"0.563... | 0.57343465 | 15 |
Check GPIB address of current source and initialize if valid. If the usergiven GPIB address for the 6221 is in the list of resources, then assign it to self.I_source and send the following | def update_GPIB(self):
self.check_errors(False, False)
#self.I_source_list = [
# x for x in self.resources
# if (str(self.GPIB.value()) and 'GPIB') in x
# ]
if not self.errors_exist:
self.I_source = self.rm.open_resource(self.I_so... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n import visa\n\n rm = visa.ResourceManager()\n target = 'Agilent Technologies,8163B,MY48208514,V5.25(72637)'\n\n for dev in rm.list_resources():\n try:\n inst = rm.open_resource(dev)\n name = inst.query('*IDN?') # Agilent Te... | [
"0.58488786",
"0.5460564",
"0.54244834",
"0.53689754",
"0.52629423",
"0.5229564",
"0.5226817",
"0.5191806",
"0.5149981",
"0.5125633",
"0.50626856",
"0.50484693",
"0.5043974",
"0.50175875",
"0.501238",
"0.49967742",
"0.49922526",
"0.4991907",
"0.49915245",
"0.49810675",
"0.497... | 0.5940608 | 0 |
Create/overwrite a new save file and write a standard header. Open a dialog box that allows the user to name the .txt file the program will write measurements to. Record the name of this file, open it for writing (overwrite all previous data), and write a header to the file. Reset the local variable for number of measu... | def new_file(self):
self.filename = QFileDialog.getSaveFileName(
None, 'Title', '', 'TXT (*.txt)'
)
if self.filename[0]:
self.currentfile = open(self.filename[0], 'w')
(self.base_name, self.ext) = os.path.splitext(self.filename[0])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_file():\r\n\r\n file_name, ok = QFileDialog.getSaveFileName(MainWindow, '保存输入文件', default_path, 'txt(*.txt)')\r\n try:\r\n get_measure_par(input_parameters)\r\n input_parameters.check_data()\r\n input_parameters.close_ser()\r\n except Exception as e:\r\n QMessageBox.cr... | [
"0.63446736",
"0.6315409",
"0.6082766",
"0.6069871",
"0.60295033",
"0.60274047",
"0.5962177",
"0.5936258",
"0.5863543",
"0.58622694",
"0.5860359",
"0.58338547",
"0.58133197",
"0.5812401",
"0.5780677",
"0.57552195",
"0.57400274",
"0.57241136",
"0.57232356",
"0.5710348",
"0.569... | 0.6089908 | 2 |
Create a dialog box explaining why measurement cannot start. | def run_error_messages(self):
self.error = ""
#while self.error_queue:
#self.error += (self.error_messages.get(
# self.error_queue.popleft, None
# ) + " ")
#self.error += self.I_source.query("STAT:QUE?")
#print(self.error)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_error(self):\n if self.error is None:\n return\n from PartSeg.common_gui.error_report import ErrorDialog\n\n if isinstance(self.error, TiffFileException):\n mess = QMessageBox()\n mess.setIcon(QMessageBox.Critical)\n mess.setText(\"During re... | [
"0.6401454",
"0.630986",
"0.6306927",
"0.62711555",
"0.6116938",
"0.6109479",
"0.6104505",
"0.60883665",
"0.6031911",
"0.598907",
"0.5923355",
"0.59219784",
"0.59204906",
"0.58927524",
"0.5883991",
"0.5874046",
"0.587354",
"0.58649987",
"0.5846545",
"0.5846545",
"0.5834964",
... | 0.0 | -1 |
Execute the UI loop | def main():
app = QtGui.QApplication(sys.argv)
form = dIdVGui()
form.show()
app.exec_() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n self.cmdloop()",
"def run(self):\n\n while not self.done:\n\n self.event_loop()\n\n self.update()",
"def takeControl(self):\n mainloop()",
"def takeControl(self):\n mainloop()",
"def __loop(self):\n\n self.__update_table()\n s... | [
"0.7921923",
"0.77360135",
"0.75328994",
"0.75328994",
"0.7509691",
"0.7382489",
"0.7374895",
"0.73469794",
"0.7283956",
"0.72793925",
"0.72655976",
"0.7254827",
"0.71981347",
"0.7173483",
"0.7072041",
"0.7068032",
"0.7064065",
"0.7043865",
"0.6990638",
"0.6969184",
"0.695363... | 0.0 | -1 |
Wrapper around print with color options, it applies colors only on ttys >>> color_print(Color.BOLD, 'Home =>', Color.BLUE, '/home/example') >>> "Home =>" would be bold and "/home/example" would be blue | def color_print(
*messages,
default_color=Color.NORMAL,
sep=' ',
end='\n',
file=stdout,
flush=False,
):
string = []
print_colors = file.isatty()
if print_colors:
string.append(str(default_color))
messages_iter = iter(messages)
# Print first message and deal with 'se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def printcolor(color, text):\r\n pushcolor()\r\n setcolor(color)\r\n print text\r\n popcolor()",
"def print_color(text: str, color:bcolors = bcolors.BOLD):\n print(f\"{color}{text}{bcolors.ENDC}\")",
"def print_with_color(message, color):\n if color in colors:\n print(colors[color] + m... | [
"0.77834445",
"0.74662054",
"0.7423158",
"0.7419605",
"0.7315081",
"0.706688",
"0.70493037",
"0.6995986",
"0.69395125",
"0.688094",
"0.6754055",
"0.67533886",
"0.6724027",
"0.66706485",
"0.6551255",
"0.65488976",
"0.6486677",
"0.6465688",
"0.6439469",
"0.6406669",
"0.63382816... | 0.66232353 | 14 |
Jobs are actions that BigQuery runs on your behalf to load data, export data, query data, or copy data. Once a BigQuery job is created, it cannot be changed or deleted. Example Usage | def __init__(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
copy: Optional[pulumi.Input[pulumi.InputType['JobCopyArgs']]] = None,
extract: Optional[pulumi.Input[pulumi.InputType['JobExtractArgs']]] = None,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_jobs():\n return _get_bigquery_service().jobs()",
"def query_bigquery(sql_query, gdrive=False, retries=2, job_name=None,\n project='khanacademy.org:deductive-jet-827'):\n # We could probably do 'import bq' and call out directly, but\n # I couldn't figure out an easy way to do ... | [
"0.66288114",
"0.6231927",
"0.6087227",
"0.60524",
"0.5904442",
"0.586172",
"0.56854284",
"0.5576546",
"0.55539566",
"0.5550587",
"0.5516396",
"0.5515099",
"0.551495",
"0.5507597",
"0.550355",
"0.5487884",
"0.54843163",
"0.54824436",
"0.5452061",
"0.5447395",
"0.5433585",
"... | 0.0 | -1 |
Get an existing Job resource's state with the given name, id, and optional extra properties used to qualify the lookup. | def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None,
copy: Optional[pulumi.Input[pulumi.InputType['JobCopyArgs']]] = None,
extract: Optional[pulumi.Input[pulumi.InputType['JobExtractArgs']]] = None,
job_id: Optional... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lookup(job_id: str) -> JobState:\n job = JobState(job_id)\n job.update()\n return job",
"def get(resource_name: str,\n id: pulumi.Input[str],\n opts: Optional[pulumi.ResourceOptions] = None) -> 'Job':\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=... | [
"0.752408",
"0.6754207",
"0.6295021",
"0.6050239",
"0.5956845",
"0.59274155",
"0.5833936",
"0.57959604",
"0.5761722",
"0.5756654",
"0.57362854",
"0.57168263",
"0.5636522",
"0.5632625",
"0.5629977",
"0.56236506",
"0.5582701",
"0.5581278",
"0.5558081",
"0.55574095",
"0.55572",
... | 0.64249945 | 2 |
Copies a table. Structure is documented below. | def copy(self) -> pulumi.Output[Optional['outputs.JobCopy']]:
return pulumi.get(self, "copy") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy_table(self, table: Table) -> Table:\n self._requires_table(table)\n return table.copy()",
"def Copy(self, copy):\n return _table.Table_Copy(self, copy)",
"def copy_table(document, table, cut=False):\n if cut:\n document._body._element._insert_tbl(table._tbl)\n else:\n... | [
"0.80779123",
"0.75334173",
"0.73572755",
"0.71226597",
"0.68560654",
"0.6740201",
"0.6629716",
"0.6619253",
"0.6537283",
"0.64276606",
"0.63529986",
"0.6326202",
"0.6305635",
"0.6281829",
"0.6225138",
"0.62093914",
"0.62093914",
"0.61507237",
"0.6050223",
"0.5972014",
"0.596... | 0.0 | -1 |
Configures an extract job. Structure is documented below. | def extract(self) -> pulumi.Output[Optional['outputs.JobExtract']]:
return pulumi.get(self, "extract") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, settings, ui_id, job_id):\n # Call the original constructor\n super().__init__(settings, ui_id, job_id)\n\n # Set the local template\n self.local_template = 'settings/bilby_local.sh'\n # Set our job parameter path\n self.job_parameter_file = os.path.join... | [
"0.5821657",
"0.5677721",
"0.5594135",
"0.5460422",
"0.53917944",
"0.53839976",
"0.53659284",
"0.5331715",
"0.5310294",
"0.5286848",
"0.52693266",
"0.52497065",
"0.523421",
"0.5232084",
"0.52013916",
"0.5182275",
"0.5161715",
"0.5121684",
"0.50993395",
"0.509534",
"0.50854534... | 0.5435409 | 4 |
The ID of the job. The ID must contain only letters (az, AZ), numbers (09), underscores (_), or dashes (). The maximum length is 1,024 characters. | def job_id(self) -> pulumi.Output[str]:
return pulumi.get(self, "job_id") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_job_id(self) -> str:\n return self.split_name[2][3:]",
"def _get_job_id(self):\n return uuid.uuid4().hex",
"def _generate_job_id():\n # CAIP job id can contains only numbers, letters and underscores.\n unique_tag = str(uuid.uuid4()).replace(\"-\", \"_\")\n return \"tf_cloud_train_{}... | [
"0.81548387",
"0.7609381",
"0.7318471",
"0.7308317",
"0.722384",
"0.69657046",
"0.69571614",
"0.6926118",
"0.6921736",
"0.6895819",
"0.6787473",
"0.67803437",
"0.6737579",
"0.66389865",
"0.6589558",
"0.6570669",
"0.65549666",
"0.65227807",
"0.6467001",
"0.6406802",
"0.6378020... | 0.71984714 | 5 |
Job timeout in milliseconds. If this time limit is exceeded, BigQuery may attempt to terminate the job. | def job_timeout_ms(self) -> pulumi.Output[Optional[str]]:
return pulumi.get(self, "job_timeout_ms") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def timeout(self) -> str:\n return pulumi.get(self, \"timeout\")",
"def timeout(self) -> int:\n\n return self._timeout",
"def check_timeout(self, msg):\n if msg.clock.secs > self.timeout and not self.is_cancelled:\n rospy.loginfo(\"Test timed out, cancelling job\")\n ... | [
"0.5882542",
"0.58566386",
"0.58173275",
"0.58124197",
"0.57919353",
"0.5783616",
"0.57713014",
"0.572862",
"0.5660806",
"0.56589997",
"0.5643863",
"0.5643863",
"0.5625082",
"0.55886996",
"0.55886996",
"0.55886996",
"0.55886996",
"0.5574897",
"0.557383",
"0.5548075",
"0.55405... | 0.69198066 | 0 |
The type of the job. | def job_type(self) -> pulumi.Output[str]:
return pulumi.get(self, "job_type") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def job_type(self):\n return self._job_type",
"def type(self) -> Optional[pulumi.Input['JobType']]:\n return pulumi.get(self, \"type\")",
"def job_details_type(self) -> str:\n return pulumi.get(self, \"job_details_type\")",
"def job_details_type(self) -> str:\n return pulumi.get(s... | [
"0.9002671",
"0.844342",
"0.76216686",
"0.76216686",
"0.76216686",
"0.7435503",
"0.726418",
"0.709847",
"0.7038003",
"0.7030451",
"0.7030451",
"0.7030451",
"0.7030451",
"0.7030451",
"0.7030451",
"0.7030451",
"0.7030451",
"0.7030451",
"0.7030451",
"0.7030451",
"0.7030451",
"... | 0.87467295 | 1 |
The labels associated with this job. You can use these to organize and group your jobs. | def labels(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
return pulumi.get(self, "labels") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_label(self):\n return self.job[self.label_key]",
"def labels(self) -> Mapping[str, str]:\n return pulumi.get(self, \"labels\")",
"def labels(self) -> Mapping[str, str]:\n return pulumi.get(self, \"labels\")",
"def labels(self) -> Mapping[str, str]:\n return pulumi.get(self... | [
"0.7774395",
"0.757336",
"0.757336",
"0.757336",
"0.757336",
"0.757336",
"0.757336",
"0.757336",
"0.757336",
"0.7461375",
"0.7347413",
"0.7347413",
"0.723107",
"0.72306985",
"0.720582",
"0.720582",
"0.720582",
"0.720582",
"0.720582",
"0.71988285",
"0.7185549",
"0.71437156",... | 0.71388465 | 29 |
Configures a load job. Structure is documented below. | def load(self) -> pulumi.Output[Optional['outputs.JobLoad']]:
return pulumi.get(self, "load") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_jobs(self):\n\n jobs = self.app.config.get('SCHEDULER_JOBS')\n job_stores = self.app.config.get('SCHEDULER_JOBSTORES')\n\n if not jobs:\n jobs = self.app.config.get('JOBS')\n\n if jobs:\n if job_stores:\n self.reload_jobs(jobs=jobs)\n ... | [
"0.63670856",
"0.6113547",
"0.6055729",
"0.6047948",
"0.60470104",
"0.6004085",
"0.5966015",
"0.595499",
"0.58224434",
"0.5799299",
"0.5777906",
"0.57345104",
"0.5729571",
"0.5707282",
"0.57072353",
"0.56807077",
"0.56798977",
"0.567705",
"0.5670196",
"0.5660629",
"0.56246996... | 0.5583495 | 23 |
The geographic location of the job. The default value is US. | def location(self) -> pulumi.Output[Optional[str]]:
return pulumi.get(self, "location") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def location(self) -> str:\n return pulumi.get(self, \"location\")",
"def location(self) -> str:\n return pulumi.get(self, \"location\")",
"def location(self) -> str:\n return pulumi.get(self, \"location\")",
"def location(self) -> str:\n return pulumi.get(self, \"location\")",
... | [
"0.74507964",
"0.74507964",
"0.74507964",
"0.74507964",
"0.74507964",
"0.74507964",
"0.74507964",
"0.74507964",
"0.74507964",
"0.74507964",
"0.74507964",
"0.74507964",
"0.74507964",
"0.733936",
"0.7273975",
"0.72535896",
"0.72535896",
"0.72535896",
"0.7241201",
"0.7181057",
"... | 0.7040756 | 30 |
The ID of the project in which the resource belongs. If it is not provided, the provider project is used. | def project(self) -> pulumi.Output[str]:
return pulumi.get(self, "project") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def project_id(self) -> Optional[str]:\n return pulumi.get(self, \"project_id\")",
"def project_id(self) -> str:\n return pulumi.get(self, \"project_id\")",
"def project_id(self) -> str:\n return pulumi.get(self, \"project_id\")",
"def project_id(self) -> str:\n return pulumi.get(... | [
"0.8160074",
"0.8047798",
"0.8047798",
"0.8047798",
"0.8047798",
"0.7885196",
"0.78261137",
"0.7762521",
"0.7762521",
"0.7762521",
"0.7762521",
"0.7762521",
"0.7635239",
"0.7635239",
"0.7528419",
"0.7518447",
"0.75087434",
"0.7489456",
"0.74297875",
"0.734286",
"0.7273379",
... | 0.64872843 | 94 |
Configures a query job. Structure is documented below. | def query(self) -> pulumi.Output[Optional['outputs.JobQuery']]:
return pulumi.get(self, "query") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_google_bigquery_job_config():\n job_config = bigquery.QueryJobConfig()\n job_config.maximum_bytes_billed = getattr(settings, 'OPR_GOOGLE_BIGQUERY_MAX_PROCESS_BYTES', None)\n job_config.use_query_cache = getattr(settings, 'OPR_GOOGLE_BIGQUERY_USE_CACHE', False)\n\n return job_config",
"def con... | [
"0.5962772",
"0.587585",
"0.5862887",
"0.56656957",
"0.562309",
"0.5573987",
"0.55305994",
"0.54989725",
"0.5483543",
"0.54443306",
"0.54435676",
"0.53984964",
"0.53947663",
"0.53442645",
"0.53322864",
"0.53170633",
"0.52949715",
"0.52949715",
"0.527428",
"0.5274196",
"0.5269... | 0.52722174 | 20 |
Email address of the user who ran the job. | def user_email(self) -> pulumi.Output[str]:
return pulumi.get(self, "user_email") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_useremail(self):\n return self.user.email",
"def email(self, instance):\r\n return instance.user.email",
"def get_user_email(self):\n member = self.get_user()\n if member:\n return member.getProperty('email')",
"def email(self) -> str:\n return pulumi.get... | [
"0.8045067",
"0.7482019",
"0.72746706",
"0.7197063",
"0.7197063",
"0.7197063",
"0.7195695",
"0.7189387",
"0.7168474",
"0.7168474",
"0.7168474",
"0.7168474",
"0.71192086",
"0.7095948",
"0.7094554",
"0.70901",
"0.69890106",
"0.6986238",
"0.6955563",
"0.691718",
"0.68999255",
... | 0.8011265 | 1 |
Parse the command line options | def get_options():
# pass in the access_token via commandline
parser = OptionParser()
parser.add_option("--data-dir", default='/tmp',
action="store", type="string", dest="data_dir",
help="Directory where DBs exist")
parser.add_option("--malicious",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_options():\n global parser\n parser.add_option(\"-r\", \"--regions\", dest=\"input_brain_regions\",\n help=\"Input file for brain region data\",\n action=\"store\", type='string')\n\n parser.add_option(\"-g\", \"--gray\", dest=\"input_gray_levels\",\n ... | [
"0.81653506",
"0.78263617",
"0.7749474",
"0.7708489",
"0.77028614",
"0.762441",
"0.75952876",
"0.7572062",
"0.7568611",
"0.75644726",
"0.74594223",
"0.7434058",
"0.74286336",
"0.7371361",
"0.7363095",
"0.7334798",
"0.732726",
"0.7313284",
"0.73038536",
"0.727963",
"0.72284585... | 0.0 | -1 |
Using the options and stdin check the bloom filters for IOCs | def main():
options = get_options()
data_path = str(options.data_dir)
bloom = BloomCategory(malicious_path=data_path + '/malicious-ips.bloom',
predicted_path=data_path + '/predicted-ips.bloom',
has_intel_path=data_path + '/ip-threat-intel.bloom')
with ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\r\n arguments = collections.deque(sys.argv)\r\n arguments.popleft()\r\n file_name = arguments.popleft()\r\n if len(arguments) == 0:\r\n print(\"Please enter filter commands to run the program. (host, port, ip, tcp, udp, icmp, net)\")\r\n sys.exit()\r\n packets_info = read_a... | [
"0.59075195",
"0.571198",
"0.56005055",
"0.55080795",
"0.54815006",
"0.5467969",
"0.54254556",
"0.54060715",
"0.53923625",
"0.53685206",
"0.5339621",
"0.5333452",
"0.5298472",
"0.5276344",
"0.5259351",
"0.5253875",
"0.5249222",
"0.52447957",
"0.5241998",
"0.5231878",
"0.52266... | 0.7171011 | 0 |
Allow all users which are in 'users' group. | def has_permission(self, request):
return request.user.is_active \
and request.user.groups.filter(name='users').count() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_in_group(user, *group_names):\n\treturn bool(user.groups.filter(name__in=group_names)) | user.is_superuser",
"def test_all_users_in_group_are_seen(self):\n\n logged_user = utils.create_user_and_authenticate(self)\n self.group.users.add(logged_user)\n\n test_users_in_group = []\n ... | [
"0.645859",
"0.64161813",
"0.63618237",
"0.6341922",
"0.6307062",
"0.6291116",
"0.6262052",
"0.624811",
"0.6224953",
"0.6148409",
"0.6102744",
"0.6082598",
"0.60788065",
"0.6070103",
"0.60507107",
"0.5984473",
"0.5979317",
"0.59507567",
"0.59330946",
"0.5902153",
"0.58936113"... | 0.5525438 | 54 |
Makes keep alive request. | def __call__(self, session=None, lightweight=None):
(response, elapsed_time) = self.request(session=session)
self.client.set_session_token(response.get('token'))
return self.process_response(response, KeepAliveResource, elapsed_time, lightweight) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keepalive(self) -> None:",
"def keep_alive(self):\n req = BFGlobalFactory.create(\"ns1:KeepAliveReq\")\n rsp = self._soapcall(BFGlobalService.keepAlive, req)\n if rsp.header.errorCode != APIErrorEnum.OK:\n logger.error(\"{keepAlive} failed with error {%s}\",\n ... | [
"0.7858032",
"0.7399388",
"0.73251414",
"0.70766056",
"0.65952",
"0.65890306",
"0.6548859",
"0.65116495",
"0.64874387",
"0.64856464",
"0.6415641",
"0.64016193",
"0.6316313",
"0.6245971",
"0.62115264",
"0.6207706",
"0.6188858",
"0.6148815",
"0.6091063",
"0.5997852",
"0.5929846... | 0.6231983 | 14 |
Create a background file for motif analysis. | def create_background_file(
outfile, bg_type, fmt="fasta", size=None, genome=None, inputfile=None, number=10000
):
fmt = fmt.lower()
if fmt in ["fa", "fsa"]:
fmt = "fasta"
if bg_type not in BG_TYPES:
logger.error(f"The argument 'type' should be one of: {','.join(BG_TYPES)}")
sys... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_background(argv):\n args = parse_args(argv)\n\n # Create fasta files\n sys.stdout.write(f\"Generating input fasta file...\")\n generate_input_fasta(regulatory_regions_file=args.regulatory_regions_file,\n background_input_fasta=args.background_input_fasta,\n ... | [
"0.6770991",
"0.6409098",
"0.60642445",
"0.600799",
"0.58706754",
"0.58117944",
"0.5713409",
"0.56881523",
"0.5673229",
"0.5517937",
"0.5509815",
"0.5440462",
"0.5392011",
"0.5383787",
"0.53739244",
"0.5337144",
"0.5326043",
"0.53088874",
"0.5253408",
"0.52207017",
"0.519795"... | 0.68112105 | 0 |
Create index of GC content for a genome. | def create_gc_bin_index(genome, fname, min_bin_size=100):
logger.info("Creating index for genomic GC frequencies.")
g = Genome(genome)
fasta = g.filename
sizes = g.filename + ".sizes" # props["sizes"]["sizes"]
with NamedTemporaryFile() as tmp:
# pylint: disable=unexpected-keyword-arg
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_index(self):\r\n date_time('Building indexes in citations table')\r\n self.cursor.execute('DROP INDEX IF EXISTS IDX_citations ;')\r\n self.cursor.execute('CREATE INDEX IDX_citations ON citations (citation);')\r\n self.conn.commit()\r\n gc.collect()",
"def index_genome... | [
"0.63085175",
"0.6208266",
"0.6030924",
"0.5986668",
"0.5840511",
"0.58364654",
"0.5822908",
"0.57987857",
"0.5792786",
"0.5771251",
"0.57565176",
"0.56883234",
"0.5687291",
"0.5676972",
"0.5670533",
"0.5667721",
"0.56395346",
"0.5570101",
"0.5566708",
"0.5549159",
"0.5545711... | 0.7131006 | 0 |
Create a BED file from different GC bins. | def gc_bin_bedfile(
bedfile, genome, number, length=200, bins=None, random_state=None, min_bin_size=100
):
if bins is None:
bins = [(0.0, 0.2), (0.8, 1.0)]
for b in np.arange(0.2, 0.799, 0.05):
bins.append((round(b, 2), round(b + 0.05, 2)))
bins = sorted(bins)
if number ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_gc_bin_index(genome, fname, min_bin_size=100):\n logger.info(\"Creating index for genomic GC frequencies.\")\n g = Genome(genome)\n fasta = g.filename\n sizes = g.filename + \".sizes\" # props[\"sizes\"][\"sizes\"]\n\n with NamedTemporaryFile() as tmp:\n # pylint: disable=unexpect... | [
"0.60980815",
"0.5793627",
"0.5760087",
"0.5706503",
"0.56810117",
"0.56430155",
"0.56416684",
"0.5589777",
"0.55267876",
"0.55234665",
"0.5493021",
"0.54800487",
"0.5461782",
"0.5357284",
"0.5355436",
"0.53348494",
"0.53264964",
"0.5325675",
"0.53226894",
"0.52907103",
"0.52... | 0.6333996 | 0 |
Create a BED file with GC% matched to input file. | def matched_gc_bedfile(bedfile, matchfile, genome, number, size=None, min_bin_size=100):
g = Genome(genome)
genome_fa = g.filename
try:
fa = Fasta(matchfile)
gc = [
(seq.upper().count("C") + seq.upper().count("G")) / len(seq)
for seq in fa.seqs
]
sizes... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_bgf(self, filename):\n body = [\"BIOGRF{0:>5s}\\n\".format(self.biogrf)]\n if self.descrp:\n body.append(\"DESCRP {0}\\n\".format(self.descrp))\n else:\n body.append(\"DESCRP {0}\\n\".format(filename))\n body.append(\"FORCEFIELD {0}\\n\".format(self.ff))\... | [
"0.6062387",
"0.56986284",
"0.55833983",
"0.55601734",
"0.5551539",
"0.5389084",
"0.53258824",
"0.53198844",
"0.52998364",
"0.52686113",
"0.52623475",
"0.5166518",
"0.51603377",
"0.51446456",
"0.51310086",
"0.5125808",
"0.50954264",
"0.5057726",
"0.503264",
"0.5031262",
"0.50... | 0.6236064 | 0 |
Return parsed json of data from sensors in dictionary form | def getDataParsed():
serialConsole.flush()
rawData = serialConsole.readline().decode("utf-8").rstrip()
parsedJson = json.loads(rawData)
return parsedJson | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def device_details_json():\n return [\n {\n \"dateutc\": 1547094300000,\n \"winddir\": 344,\n \"windspeedmph\": 1.6,\n \"windgustmph\": 2.2,\n \"maxdailygust\": 3.4,\n \"tempf\": 34,\n \"hourlyrainin\": 0,\n \"eventra... | [
"0.7102904",
"0.6808078",
"0.6580409",
"0.64217085",
"0.6421479",
"0.63857055",
"0.63110226",
"0.63013804",
"0.6255397",
"0.62031794",
"0.6200998",
"0.6193295",
"0.60692954",
"0.6065768",
"0.6063692",
"0.60188586",
"0.599554",
"0.5960094",
"0.59268564",
"0.59105647",
"0.59093... | 0.605225 | 15 |
Stack each of the args horizontally, spaced by delta_x, from left to right. | def set_delta_x(self, *args: str, delta_x: Reversible[float] | float = 0.0) -> None:
if not isinstance(delta_x, float):
delta_x = list(reversed(delta_x))
self.set_delta('x', *reversed(args), delta=delta_x) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def horizontal_stack(*args):\r\n # Note: 'horizontal_stack' and 'vertical_stack' do not behave exactly like\r\n # Numpy's hstack and vstack functions. This is intended, because Numpy's\r\n # functions have potentially confusing/incoherent behavior (try them on 1D\r\n # arrays). If this is fixed in a fu... | [
"0.62705624",
"0.58168936",
"0.5685121",
"0.5365151",
"0.5355684",
"0.5308677",
"0.5262725",
"0.5255217",
"0.5250414",
"0.52227384",
"0.52144426",
"0.5204895",
"0.51811",
"0.51687783",
"0.51582426",
"0.51582426",
"0.51582426",
"0.5128119",
"0.5115836",
"0.51113474",
"0.508057... | 0.56655216 | 3 |
Stack each of the args vertically, spaced by delta_y, from top to bottom. | def set_delta_y(self, *args: str, delta_y: Sequence[float] | float = 0.0) -> None:
self.set_delta('y', *args, delta=delta_y) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def botStack_y(self):\r\n self.y_stack=self.img.shape[1]-1\r\n \r\n self.pixmap3=self.drawPixmap(\"xz\")\r\n self.lbl3.setPixmap(self.pixmap3)\r\n self.pixmap4= self.writeEdge(\"xz\")\r\n self.lbl4.setPixmap(self.pixmap4)\r\n self.y_stack_lbl.setText(str(self.y_stac... | [
"0.5773231",
"0.5634331",
"0.5516587",
"0.542991",
"0.5422386",
"0.5393093",
"0.5393093",
"0.5393093",
"0.5393093",
"0.5393093",
"0.5393093",
"0.5393093",
"0.5393093",
"0.5393093",
"0.5393093",
"0.5393093",
"0.52656275",
"0.52176785",
"0.51273435",
"0.5104197",
"0.50842553",
... | 0.46237653 | 45 |
Set c.x, c.y = location. | def set_location(self, c: str, location: tuple[float, float]) -> None:
if len(location) != 2: # noqa: PLR2004
raise ValueError
self.set_x(c, location[0])
self.set_y(c, location[1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_new_location(self, xPos, yPos):",
"def set_coordinates(self, x, y):\n self.x = x\n self.y = y",
"def position(self, x, y):\n self.x = x \n self.y = y\n self.pos[0] = x \n self.pos[1] = y",
"def set_location(self, x, y, z=0):\n self._rect.topleft = (x, ... | [
"0.7428723",
"0.72963333",
"0.7262265",
"0.72220844",
"0.72200346",
"0.71369195",
"0.7072781",
"0.7039247",
"0.69732124",
"0.69413865",
"0.6907883",
"0.6855876",
"0.68402445",
"0.67735624",
"0.6736265",
"0.6662019",
"0.6643821",
"0.6624045",
"0.6596092",
"0.65817606",
"0.6552... | 0.72543436 | 3 |
Space n items with spacing according to (n1) ratios. E.g., ratios=[0, 1] puts item[1] at item[0] fraction = (dc)/(dc + (ed)) => (dc) = (ec) fraction. | def set_between(self,
coord: str,
*items: str,
ratios: None | Sequence[float] = None) -> None:
if ratios is None:
ratios = [1] * (len(items) - 1)
for c, d, e, r1, r2 in zip(items, items[1:], items[2:], ratios, ratios[1:],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spacing(self, divisions=10, ratio=1.0, thickness=1.0):\r\n if divisions == 1:\r\n sp = [0.0, 1.0]\r\n return np.array(sp)\r\n\r\n growth = ratio**(1.0 / (float(divisions) - 1.0))\r\n\r\n if growth == 1.0:\r\n growth = 1.0 + 1.0e-10\r\n\r\n s0 = 1.0\r... | [
"0.6269365",
"0.62639314",
"0.5947355",
"0.5471383",
"0.52522314",
"0.523624",
"0.51842475",
"0.51664436",
"0.5130865",
"0.5109552",
"0.51064223",
"0.5102746",
"0.50894815",
"0.50866324",
"0.5018106",
"0.5007691",
"0.4956959",
"0.4938565",
"0.49329013",
"0.4932875",
"0.493201... | 0.5090766 | 12 |
Set c d = e f. | def set_delta_equal(self, coord: str, c: str, d: str, e: str, f: str) -> None:
a = self.blank()
a[self.index(coord, c)] += 1.0
a[self.index(coord, d)] -= 1.0
a[self.index(coord, e)] -= 1.0
a[self.index(coord, f)] += 1.0
self.add_constraint(a, 0.0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_e(new_e):\n global e\n if old_set_e is not None:\n old_set_e(new_e)\n e = new_e",
"def f_set(self, data):\n raise NotImplementedError(\"Should have implemented this.\")",
"def set():",
"def set_c(self, c):\n self.c = c",
"def set():\n pass",
"def setC(self, c):\n\... | [
"0.59207237",
"0.5489756",
"0.5407103",
"0.52503955",
"0.5216911",
"0.5045269",
"0.49974662",
"0.49689245",
"0.49604604",
"0.4934092",
"0.4934092",
"0.491751",
"0.49079654",
"0.4887534",
"0.48573717",
"0.483059",
"0.4809637",
"0.4806166",
"0.48061296",
"0.4800933",
"0.4795013... | 0.52701014 | 3 |
Mutate individual in place; sigma much higher that 0.25 can will leed to long execution time | def GausianMutator(individual, sigma, indpb):
for idx, gene in enumerate(individual):
if rand.random() > indpb:
dtype = gene.type
if dtype == bool:
gene.value(not gene.value())
continue
min_value, max_value = gene.min, gene.max
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _mutate(self, noise_generator, sigma):\n\n mutation_indexes = torch.distributions.categorical.Categorical(\n torch.tensor([self.mutation_prob, 1 - self.mutation_prob])).sample([self.population_size]) > 0.5\n\n noise = noise_generator.sample([self.population_size, len(self.population[0]... | [
"0.6688608",
"0.655262",
"0.6480654",
"0.6246567",
"0.61921453",
"0.6139258",
"0.6087077",
"0.6059703",
"0.60146874",
"0.5908357",
"0.5848488",
"0.580409",
"0.5796968",
"0.57791954",
"0.57513815",
"0.5739943",
"0.5710097",
"0.56995106",
"0.5689599",
"0.5685349",
"0.56732017",... | 0.70532256 | 0 |
put local file to qiniu. If key is None, the server will generate one. | def put_file(self, key=None, local_file=None, rename=None):
if local_file is None:
raise NameError('upload file to qiniu error!')
policy = rs.PutPolicy(bucket_name)
policy.saveKey = rename
up_token = policy.token()
ret, err = io.put_file(up_token, key, local_file)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put_file(uptoken, key, localfile, extra=None):\r\n if extra is not None and extra.check_crc == 1:\r\n extra.crc32 = _get_file_crc32(localfile)\r\n with open(localfile, 'rb') as f:\r\n return put(uptoken, key, f, extra)",
"def key_upload(self, key=None):\n raise NotImplementedError"... | [
"0.7133599",
"0.69790006",
"0.682977",
"0.66461545",
"0.65120673",
"0.64975405",
"0.6486899",
"0.6470201",
"0.6447628",
"0.6422348",
"0.6378536",
"0.63577235",
"0.62944865",
"0.6294383",
"0.6289327",
"0.62754655",
"0.62322944",
"0.61883247",
"0.61791635",
"0.6174863",
"0.6158... | 0.738366 | 0 |
put your data to qiniu. If key is None, the server will generate one. | def put(self, img_url, key=None, rename=None):
r = None
if img_url is None:
raise ValueError('upload img path to qiniu error!')
for i in range(5):
r = requests.get(img_url, timeout=10.0)
if r is not None:
break
policy = rs.PutPolicy(bu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _put(self, key, data):\n path = self._get_key_path(key)\n with open(path, \"wb\") as pickle_file:\n pickle.dump(data, pickle_file)",
"def key_upload(self, key=None):\n raise NotImplementedError",
"def put(uptoken, key, data, extra=None):\r\n fields = {\r\n }\r\n\r\n ... | [
"0.67822343",
"0.66594857",
"0.64644325",
"0.6435055",
"0.6350956",
"0.6157565",
"0.6139091",
"0.6123082",
"0.6119663",
"0.60871285",
"0.60520744",
"0.59724325",
"0.5944511",
"0.5920651",
"0.59184194",
"0.5911955",
"0.5910028",
"0.58842486",
"0.5879357",
"0.5855878",
"0.58557... | 0.0 | -1 |
The WF logger should not affect other loggers. | def test_logger(self):
from workflow import engine
logging.root.handlers = []
engine.LOG.handlers = []
other_logger = logging.getLogger('other')
wf_logger = engine.get_logger('workflow.test')
test_io = StringIO()
root_io = StringIO()
other_io = StringIO... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logger(self):\n pass",
"def logging(self):\r\n return None",
"def _get_logger(self):",
"def __init__(self):\n self.logger = logging.getLogger(FeatureEngineeringLogger.__name__)",
"def _alter_logger(*args, **kwargs):\n\n # TODO: dress up root logger here under Celery\n # confi... | [
"0.75074375",
"0.7398417",
"0.73017997",
"0.676276",
"0.67371225",
"0.6724812",
"0.66514564",
"0.6629838",
"0.6603422",
"0.65883774",
"0.6566416",
"0.656227",
"0.6554883",
"0.6518183",
"0.64989567",
"0.6482461",
"0.64790404",
"0.645304",
"0.642595",
"0.6422455",
"0.641227",
... | 0.6728836 | 5 |
Tries to log in the user given the credentials. | def __init__(
self,
username: str,
password: str
) -> None:
super().__init__(username, password) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def login_user(self):\r\n self.client.login(username=self.user.username, password=\"password\")",
"def login(self, **kwargs):\n\tusername = kwargs.get('username', self.username)\n\tif not username:\n\t raise RuntimeError, 'no username provided'\n\n\tpassword = kwargs.get('password', self.password)\n\ti... | [
"0.7679506",
"0.76482505",
"0.7451814",
"0.7355336",
"0.70666087",
"0.7053605",
"0.70083594",
"0.70048815",
"0.70040303",
"0.69907624",
"0.69900215",
"0.6979392",
"0.69255257",
"0.6909606",
"0.69065005",
"0.68814677",
"0.6881249",
"0.68759793",
"0.68714905",
"0.68651444",
"0.... | 0.0 | -1 |
Retrieves a list of placed orders | def get_orders_list(
self
) -> list:
response = self.session.get("http://automationpractice.com/index.php?controller=history")
self.HTMLParser.set_html(response.text)
tbody = self.HTMLParser.find_elements_by_xpath("//tbody/tr")
if not len(tbody):
raise NoOrder... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_orders():",
"def get_all_orders():\n response = requests.get(\n settings.SHOPIFY_ORDERS_URL,\n auth=(settings.SHOPIFY_API_KEY, settings.SHOPIFY_PASSWORD),\n )\n return response.json()[\"orders\"]",
"def get_orders(self):\n return self.order_lst",
"def orders(self):\n... | [
"0.8061578",
"0.79425263",
"0.78433585",
"0.78185993",
"0.7811087",
"0.77156186",
"0.7402565",
"0.7319279",
"0.7295969",
"0.72657025",
"0.7246338",
"0.71543074",
"0.70233506",
"0.7015748",
"0.7004499",
"0.6945827",
"0.69139475",
"0.6882968",
"0.6867857",
"0.6842282",
"0.68313... | 0.7029751 | 12 |
Generates a `Datasets` object from a list. | def from_list(list_of_datasets):
train, valid, test = None, None, None
train = list_of_datasets[0]
if len(list_of_datasets) > 3:
print("There are more then 3 Datasets here...")
return list_of_datasets
if len(list_of_datasets) > 1:
test = list_of_datase... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_dataset():\n num_list = 10\n return [generate_list() for _ in range(num_list)]",
"def create(data):\n \n return Setlist(\n list_id = data['id'],\n name = data['name'],\n items = data['num_sets'])",
"def CreateDataset(all_arrays):\n dataset = ... | [
"0.713642",
"0.67912585",
"0.6644632",
"0.64633846",
"0.6451107",
"0.63641775",
"0.60139936",
"0.6010649",
"0.5985657",
"0.5928591",
"0.59258014",
"0.5889244",
"0.5883013",
"0.5867555",
"0.58655316",
"0.5801068",
"0.57994795",
"0.57927996",
"0.57612014",
"0.5750914",
"0.57479... | 0.76773876 | 0 |
Stack some datasets calling stack for each dataset. | def stack(*datasets_s):
return Datasets.from_list(
[
Dataset.stack(*[d[k] for d in datasets_s if d[k] is not None])
for k in range(3)
]
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stack(*datasets):\n return Dataset(\n data=vstack([d.data for d in datasets]),\n target=stack_or_concat([d.target for d in datasets]),\n sample_info=np.concatenate([d.sample_info for d in datasets]),\n info={\n k: [d.info.get(k, None) for d in d... | [
"0.74105006",
"0.6224133",
"0.61153567",
"0.605392",
"0.60062796",
"0.5918449",
"0.5896614",
"0.5779996",
"0.5749291",
"0.5718587",
"0.57030183",
"0.56620634",
"0.5621588",
"0.5579488",
"0.55665857",
"0.55463654",
"0.5545169",
"0.552239",
"0.552239",
"0.54799163",
"0.5455473"... | 0.71461445 | 1 |
for save setting purposes, does not save the actual data | def setting(self):
return {
"num_examples": self.num_examples,
"dim_data": self.dim_data,
"dim_target": self.dim_target,
"info": self.info,
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_data(self):\n pass",
"def save_without_setting_canon(self, *args, **kwargs):\n super(DocumentSetFieldEntry, self).save(*args, **kwargs)",
"def save(self, data):\n\t\tif self.value:\n\t\t\tdata['value'] = self.value",
"def saveData(self):\n pass",
"def save():\n pass",
"... | [
"0.74729323",
"0.73483574",
"0.73252064",
"0.7324794",
"0.7164953",
"0.71245915",
"0.7028371",
"0.70192415",
"0.70192415",
"0.70192415",
"0.70192415",
"0.70192415",
"0.7014613",
"0.6994",
"0.6983602",
"0.69741017",
"0.69239044",
"0.68728495",
"0.6843766",
"0.6839468",
"0.6803... | 0.0 | -1 |
Return a standard feed dictionary for this dataset. | def create_supplier(self, x, y, other_feeds=None, name=None):
if not other_feeds:
other_feeds = {}
# noinspection PyUnusedLocal
def _supplier(step=None):
"""
:param step: unused, just for making it compatible with `HG` and `Saver`
:return: the fe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def feed_dict(self, dataset: Dataset, train: bool = False) -> FeedDict:\n return {}",
"def make_feed_dict(self, data):\r\n raise NotImplementedError",
"def make_feed_dict(data):\n raise NotImplemented()",
"def get_feed_dict(self, contexts, endings, **kwargs):\n return {}",
"def ... | [
"0.7395898",
"0.7168172",
"0.68816406",
"0.6846803",
"0.6486111",
"0.6357085",
"0.63534397",
"0.6323259",
"0.6295681",
"0.6267062",
"0.621977",
"0.6208225",
"0.6144665",
"0.6024322",
"0.601893",
"0.59780514",
"0.59629107",
"0.5940235",
"0.5908434",
"0.5869132",
"0.5869132",
... | 0.0 | -1 |
Assuming that the datasets have same structure, stacks data, targets and other info | def stack(*datasets):
return Dataset(
data=vstack([d.data for d in datasets]),
target=stack_or_concat([d.target for d in datasets]),
sample_info=np.concatenate([d.sample_info for d in datasets]),
info={
k: [d.info.get(k, None) for d in datasets]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def combine_stack_and_label(filesource_dataset_1,filesource_dataset_2,num_sample):\n\n x = filesource_dataset_1[0]\n x_utterances = len(filesource_dataset_1)\n for idx in tqdm(range(1, x_utterances)):\n x = np.hstack((x, filesource_dataset_1[idx]))\n #print(x.shape)\n y = filesource_datas... | [
"0.6439451",
"0.63662523",
"0.5770458",
"0.57640004",
"0.56014407",
"0.5594226",
"0.55866146",
"0.5569384",
"0.55502826",
"0.5504315",
"0.5489888",
"0.5488856",
"0.5467876",
"0.5466481",
"0.54472476",
"0.54406786",
"0.5429611",
"0.5415711",
"0.54056656",
"0.54047024",
"0.5401... | 0.7734438 | 0 |
Generates and returns a single Datasets (possibly composed by training, validation and test sets) according to args and kwargs | def generate_datasets(self, rand=None, *args, **kwargs):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _generate_datasets(self):\n\n degrade_test = False\n if self._opts['degrade_step'] == 'test':\n degrade_test = True\n\n use_trainset_for_tests = UseTrainForTest.IDENTICAL # can be different in few shot workflow\n\n train_dataset, test_dataset = self._gen_datasets_with_options(self._opts['tr... | [
"0.7621178",
"0.69473433",
"0.69207567",
"0.68117255",
"0.67662066",
"0.67376935",
"0.67357695",
"0.66206133",
"0.6593647",
"0.6577879",
"0.65543586",
"0.6548655",
"0.6536837",
"0.64582735",
"0.6456158",
"0.6447764",
"0.6381144",
"0.6376832",
"0.6368962",
"0.63482434",
"0.633... | 0.68321073 | 3 |
Generates a batch of Datasets | def generate_batch(self, batch_size, rand=None, *args, **kwargs):
return [
self.generate_datasets(rand, *args, **kwargs) for _ in range(batch_size)
] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def batches(set_name):\n global num_batches, args, ds_sizes \n # num_batches = how many batches in each dataset(train, valid, test)\n # ds_sizes = dataset_sizes \n for b in range(num_batches[set_name]):\n bi = b * args.batch_size # one batch mul batch_size \n bj = (b + 1) * args.batch_siz... | [
"0.7514917",
"0.7382531",
"0.71878946",
"0.70822203",
"0.70486933",
"0.69871813",
"0.6983089",
"0.68874186",
"0.68354505",
"0.6826487",
"0.68052757",
"0.67925185",
"0.6784843",
"0.6781102",
"0.6780172",
"0.67646056",
"0.673245",
"0.67176384",
"0.67146957",
"0.66864365",
"0.66... | 0.71700495 | 3 |
Class for managing windowed input data (like TIMIT). | def __init__(self, data, row_sentence_bounds, window=5, process_all=False):
assert it is not None, "NEED PACKAGE INTERVALTREE!"
self.window = window
self.data = data
base_shape = self.data.shape
self.shape = (base_shape[0], (2 * self.window + 1) * base_shape[1])
self.tree... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_data(self, windowed_data):\n return",
"def WindowData(d,twin,t0shift=None,object_history=False,instance=None):\n twcut=TimeWindow(twin)\n if(t0shift!=None):\n twcut.shift(t0shift)\n try:\n if(isinstance(d,TimeSeries)):\n if(d.dead()):\n # Functi... | [
"0.6172538",
"0.5824715",
"0.579524",
"0.5777404",
"0.5741833",
"0.56970376",
"0.5631466",
"0.5602177",
"0.555027",
"0.55155164",
"0.5480653",
"0.5460816",
"0.54408014",
"0.53961843",
"0.53608793",
"0.53503096",
"0.53198206",
"0.5311485",
"0.53044426",
"0.52996355",
"0.526758... | 0.0 | -1 |
Class for stochastic sampling of data points. It is most useful for feeding examples for the the training ops of `ReverseHG` or `ForwardHG`. Most notably, if the number of epochs is specified, the class takes track of the examples per minibatches which is important for the backward pass of `ReverseHG` method. | def __init__(self, dataset, batch_size, epochs=None, rnd=None):
self.dataset = dataset
self.batch_size = batch_size
self.epochs = epochs
self.T = int(np.ceil(dataset.num_examples / batch_size))
if self.epochs:
self.T *= self.epochs
self.rnd = get_rand_state(r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_samples(self, n_samples):",
"def generate_samples(self, n_samples):",
"def _sample_mini_dataset(dataset, num_classes, num_shots):\n shuffled = list(dataset)\n random.shuffle(shuffled)\n for class_idx, class_obj in enumerate(shuffled[:num_classes]):\n for sample in class_obj.sample(... | [
"0.65095025",
"0.65095025",
"0.62867826",
"0.61317563",
"0.61276025",
"0.610246",
"0.610246",
"0.6065455",
"0.6057883",
"0.60466325",
"0.60249513",
"0.6012527",
"0.5995907",
"0.59938455",
"0.59754515",
"0.5971747",
"0.59705216",
"0.5960324",
"0.5956033",
"0.59375805",
"0.5925... | 0.5782709 | 40 |
Generates and stores example visiting scheme, as a numpy array of integers. | def generate_visiting_scheme(self):
def all_indices_shuffled():
_res = list(range(self.dataset.num_examples))
self.rnd.shuffle(_res)
return _res
# noinspection PyUnusedLocal
_tmp_ts = np.concatenate(
[all_indices_shuffled() for _ in range(self.ep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def originalData(self): \n self.__exampleIndices = array(list(range(0, self.__numExamples)))",
"def data_gen(size, p):\n #print(np.random.get_state()[1][0])\n random_table = np.random.binomial(size = size, p = p, n = 1)\n test_array = np.zeros((size, 2), dtype = int)\n for i in range(size):\n ... | [
"0.5792245",
"0.57152265",
"0.5646653",
"0.56107265",
"0.54559135",
"0.53339714",
"0.5332648",
"0.53321683",
"0.5320349",
"0.5287736",
"0.5264665",
"0.5232722",
"0.5185454",
"0.5129824",
"0.5108268",
"0.50851935",
"0.5042504",
"0.5032581",
"0.50246435",
"0.50160766",
"0.50070... | 0.4968345 | 24 |
Tender Qualification Documents List | def collection_get(self):
if self.request.params.get("all", ""):
collection_data = [i.serialize("view") for i in self.context.documents]
else:
collection_data = sorted(
dict([(i.id, i.serialize("view")) for i in self.context.documents]).values(),
k... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def documents(pmid_23982599, civic_aid6_document):\n return [pmid_23982599, civic_aid6_document]",
"def getDocuments(self):\n return self.objectValues('Multifile')",
"def get_documents():\n documents = []\n for category in movie_reviews.categories():\n for fileid in movie_reviews.fileids... | [
"0.6024513",
"0.58850753",
"0.58229226",
"0.57380384",
"0.57273",
"0.5612921",
"0.56083256",
"0.5542388",
"0.55306774",
"0.5491607",
"0.546858",
"0.54549557",
"0.54500514",
"0.5425209",
"0.54043716",
"0.53956443",
"0.53795594",
"0.53604776",
"0.5360414",
"0.53452253",
"0.5339... | 0.0 | -1 |
Tender Qualification Document Upload | def collection_post(self):
document = upload_file(self.request)
document.author = self.request.authenticated_role
self.context.documents.append(document)
if save_tender(self.request):
self.LOGGER.info(
"Created tender qualification document {}".format(document... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put(self):\n document = upload_file(self.request)\n self.request.validated[\"qualification\"].documents.append(document)\n if save_tender(self.request):\n self.LOGGER.info(\n \"Updated tender qualification document {}\".format(self.request.context.id),\n ... | [
"0.7011324",
"0.6625791",
"0.6056341",
"0.604441",
"0.599105",
"0.58514357",
"0.58014864",
"0.57448494",
"0.5722403",
"0.5647626",
"0.5646104",
"0.5611597",
"0.55856794",
"0.55776405",
"0.5573368",
"0.5542979",
"0.55415756",
"0.5528359",
"0.55037415",
"0.5495104",
"0.54863006... | 0.6640573 | 1 |
Tender Qualification Document Read | def get(self):
if self.request.params.get("download"):
return get_file(self.request)
document = self.request.validated["document"]
document_data = document.serialize("view")
document_data["previousVersions"] = [
i.serialize("view") for i in self.request.validated[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_reader(qn_filepath, answers_dirpath):\n qns = get_questions(qn_filepath)\n for qn in qns:\n if qn.qid == 100:\n q = qn\n break\n assert q\n docs = get_documents(answers_dirpath, q.qid)\n print docs\n print docs[0].content",
"def find_document(self):\n ... | [
"0.5713616",
"0.55995387",
"0.5426383",
"0.5347822",
"0.52830064",
"0.52730966",
"0.523003",
"0.5208073",
"0.5207551",
"0.519923",
"0.5193545",
"0.5178876",
"0.5173786",
"0.5148251",
"0.51301056",
"0.5124473",
"0.51232445",
"0.5108244",
"0.5097899",
"0.5074501",
"0.5055006",
... | 0.0 | -1 |
Tender Qualification Document Update | def put(self):
document = upload_file(self.request)
self.request.validated["qualification"].documents.append(document)
if save_tender(self.request):
self.LOGGER.info(
"Updated tender qualification document {}".format(self.request.context.id),
extra=con... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_document(self):\n pass",
"def edit_document():",
"def patch(self):\n if apply_patch(self.request, src=self.request.context.serialize()):\n update_file_content_type(self.request)\n self.LOGGER.info(\n \"Updated tender qualification document {}\".form... | [
"0.65441775",
"0.6009176",
"0.6004787",
"0.5918397",
"0.5706653",
"0.56903756",
"0.56212336",
"0.5521491",
"0.550605",
"0.5475452",
"0.54754287",
"0.54498464",
"0.54302835",
"0.53948754",
"0.5377633",
"0.53746945",
"0.534313",
"0.534106",
"0.5327438",
"0.5279192",
"0.527067",... | 0.6770321 | 0 |
Tender Qualification Document Update | def patch(self):
if apply_patch(self.request, src=self.request.context.serialize()):
update_file_content_type(self.request)
self.LOGGER.info(
"Updated tender qualification document {}".format(self.request.context.id),
extra=context_unpack(self.request, {"M... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put(self):\n document = upload_file(self.request)\n self.request.validated[\"qualification\"].documents.append(document)\n if save_tender(self.request):\n self.LOGGER.info(\n \"Updated tender qualification document {}\".format(self.request.context.id),\n ... | [
"0.67698103",
"0.65418416",
"0.60076684",
"0.5916366",
"0.57062167",
"0.5689535",
"0.56196195",
"0.5519839",
"0.55059135",
"0.54753315",
"0.547409",
"0.54489356",
"0.5429259",
"0.5393973",
"0.5376314",
"0.5374029",
"0.53423685",
"0.5339217",
"0.5326033",
"0.52789885",
"0.5269... | 0.6004739 | 3 |
Return _aware_ `datetime.now()` object in UTC timezone. This function must be used to insert or update `datetime` fields in the database, otherwise the validation `validate_utc` will reject the value. | def utcnow():
# From the Python documentation:
# https://docs.python.org/3/library/datetime.html#datetime.datetime.utcnow
# datetime.utcnow()
# Return the current UTC date and time, with `tzinfo None`.
# This is like `now()`, but returns the current UTC date and time, as a
# naive `datetim... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def datetime_utc_now() -> datetime:\n return datetime.now(timezone.utc)",
"def now_utc() -> datetime:\n return datetime.now(timezone.utc)",
"def utc_now():\n return datetime.now(tz=timezone.utc)",
"def get_utc_now():\n return datetime.datetime.utcnow().replace(tzinfo=pytz.timezone(\"UTC\"))",
"... | [
"0.8656396",
"0.8527489",
"0.8506886",
"0.8276427",
"0.8191999",
"0.815434",
"0.801268",
"0.7952559",
"0.7899885",
"0.78881174",
"0.7862986",
"0.7835481",
"0.7827097",
"0.775173",
"0.765144",
"0.7639328",
"0.76259637",
"0.7582488",
"0.7496754",
"0.74300855",
"0.74300855",
"... | 0.73830366 | 23 |
Emulate legacy field superseeded by `patient_consent_date`. The `paitient_consent_date` field is the only source of truth. | def patient_consent(self):
return 1 if self.patient_consent_date is not None else 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patient_consent(self, value):\n self.patient_consent_date = utcnow() if value else None",
"def patient_consent_date(self, value):\n self._patient_consent_date = value\n self._patient_consent = 1 if value else 0",
"def _read_patient_consent_date(self, d: dict):\n consent_date = d... | [
"0.68482417",
"0.6833161",
"0.67046666",
"0.65385973",
"0.5847413",
"0.5256622",
"0.5145824",
"0.51359266",
"0.5100234",
"0.5099467",
"0.49738032",
"0.49723637",
"0.49418914",
"0.49067584",
"0.49050087",
"0.4872588",
"0.48719132",
"0.48694134",
"0.4868018",
"0.48641708",
"0.4... | 0.61643326 | 4 |
To use in Query expressions, define SQL expression separately. | def patient_consent(self):
return self.patient_consent_date != None # noqa: E711 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _expression(self, expression):\n exp, values = _convert_expression(expression)\n if isinstance(exp, sqlalchemy.sql.expression.ClauseElement):\n return exp\n if exp is None:\n return sqlalchemy.sql.expression.literal(True)\n qbh = expr.QueryBuilderHelper(self.ta... | [
"0.6696251",
"0.636851",
"0.634157",
"0.6295323",
"0.62208486",
"0.6195918",
"0.603287",
"0.6005952",
"0.59504604",
"0.59500873",
"0.5903553",
"0.58978915",
"0.5895683",
"0.58679605",
"0.5867883",
"0.5845525",
"0.5841332",
"0.5833717",
"0.57903737",
"0.5781723",
"0.57561094",... | 0.0 | -1 |
Emulate legacy field superseeded by `patient_consent_date`. Forward to current datetime to `patient_consent_date` setter, which will set both underlying columns. | def patient_consent(self, value):
self.patient_consent_date = utcnow() if value else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patient_consent_date(self, value):\n self._patient_consent_date = value\n self._patient_consent = 1 if value else 0",
"def patient_consent_date(self):\n return self._patient_consent_date",
"def set_to_date(self):\n self.set_value_into_input_field(self.set_to_date_locator, self.g... | [
"0.668064",
"0.5796747",
"0.57947594",
"0.571031",
"0.571031",
"0.5642255",
"0.5556245",
"0.5523759",
"0.55139166",
"0.5509836",
"0.55023223",
"0.5477226",
"0.5464905",
"0.5369002",
"0.5365053",
"0.5335959",
"0.53224725",
"0.5223045",
"0.5208461",
"0.5204645",
"0.51883584",
... | 0.6615058 | 1 |
Get internal value for `patient_consent_date`. | def patient_consent_date(self):
return self._patient_consent_date | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_patient_consent_date(self, d: dict):\n consent_date = d.get('patient_consent_date')\n consent_bool = d.get('patient_consent')\n if consent_date is not None:\n return self._str_to_datetime(consent_date)\n elif consent_bool:\n t0 = datetime.datetime.fromtim... | [
"0.8094495",
"0.7589582",
"0.7246536",
"0.71703386",
"0.6186469",
"0.60771775",
"0.582364",
"0.582364",
"0.582364",
"0.582364",
"0.5744298",
"0.57036215",
"0.5643021",
"0.56060433",
"0.56060433",
"0.56060433",
"0.56038517",
"0.5568324",
"0.5548201",
"0.55249274",
"0.5518372",... | 0.8428358 | 0 |
Set consent for both legacy `patient_consent` and new `patient_consent_date`. If consent is given, set the `patient_consent_date` to the current datetime in UTC. (If the real date of consent is known, one should set `patient_consent_date` directly). If consent is revoked, set the `patient_consent_date` to None. | def patient_consent_date(self, value):
self._patient_consent_date = value
self._patient_consent = 1 if value else 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patient_consent(self, value):\n self.patient_consent_date = utcnow() if value else None",
"def consent(self, consent):\n if consent is None:\n raise ValueError(\"Invalid value for `consent`, must not be `None`\") # noqa: E501\n\n self._consent = consent",
"def patient_conse... | [
"0.73732257",
"0.6368166",
"0.6134412",
"0.5915429",
"0.58693725",
"0.56939834",
"0.5567969",
"0.5020891",
"0.5020535",
"0.48919058",
"0.4779866",
"0.4765815",
"0.47550648",
"0.47453716",
"0.47379932",
"0.47163343",
"0.46686274",
"0.4600456",
"0.45884106",
"0.45701525",
"0.45... | 0.7228571 | 1 |
Read patient_consent information from dict serialization. For existing rows that did not record the actual consent date, if `patient_consent` is True, `ceation_date` is used if present, UNIX epoch 0 if it is missing. | def _read_patient_consent_date(self, d: dict):
consent_date = d.get('patient_consent_date')
consent_bool = d.get('patient_consent')
if consent_date is not None:
return self._str_to_datetime(consent_date)
elif consent_bool:
t0 = datetime.datetime.fromtimestamp(0, t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patient_consent(self):\n return 1 if self.patient_consent_date is not None else 0",
"def patient_consent(self, value):\n self.patient_consent_date = utcnow() if value else None",
"def patient_consent_date(self, value):\n self._patient_consent_date = value\n self._patient_consent... | [
"0.5926589",
"0.5809377",
"0.5732567",
"0.56433344",
"0.55838776",
"0.5239948",
"0.514208",
"0.5133141",
"0.4684602",
"0.45138747",
"0.44812942",
"0.44552103",
"0.44459537",
"0.44308993",
"0.44297066",
"0.4419778",
"0.43893576",
"0.4386389",
"0.43847585",
"0.4346647",
"0.4310... | 0.73424447 | 0 |
Read transaction from dictionary | def read_dict(self, d: dict):
self.transaction_id = d.get('transaction_id')
self.study_id = d.get('study_id')
self.patient_id = d.get('patient_id')
self.name = d.get('name')
birth_date = d.get('birth_date')
self.birth_date = datetime.datetime.strptime(
birth_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_transactions(self):\r\n\t\tlogger.debug(\"Enter\")\r\n\t\ttry:\r\n\t\t\twith open(self._state_file, 'rb') as tmp:\r\n\t\t\t\tlogger.debug(\"There is a file.\")\r\n\t\t\t\ttmp_dict = pickle.load(tmp)\r\n\t\t\t\tlogger.debug(\"Dictionary loaded from file: %s\" % tmp_dict)\r\n\t\texcept IOError as e: # File... | [
"0.62972873",
"0.6246917",
"0.608508",
"0.5919277",
"0.58387107",
"0.5822863",
"0.5689972",
"0.5678795",
"0.5596907",
"0.5539039",
"0.5362343",
"0.535953",
"0.5318176",
"0.53046554",
"0.52756685",
"0.52726775",
"0.525928",
"0.5177265",
"0.5176545",
"0.51757026",
"0.51573217",... | 0.5942677 | 3 |
convert a DuReaderYesNo example into necessary features | def convert_example(example,
tokenizer,
label_list,
max_seq_length=512,
is_test=False):
def _truncate_seqs(seqs, max_seq_length):
# Account for [CLS], [SEP], [SEP] with "- 3"
tokens_a, tokens_b = seqs
max_seq_le... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_example(example, tokenizer):\n\n feature = tokenizer(\n text=example['question'],\n text_pair=example['answer'],\n max_seq_len=args.max_seq_length)\n feature['labels'] = example['labels']\n feature['id'] = example['id']\n\n return feature",
"def ParseYesNo(src):\n ... | [
"0.5797586",
"0.57104677",
"0.56959134",
"0.56715715",
"0.55233496",
"0.5512573",
"0.5502822",
"0.5428499",
"0.5363724",
"0.5356651",
"0.53244007",
"0.5321539",
"0.53180873",
"0.5256663",
"0.525582",
"0.5243374",
"0.52147835",
"0.5206472",
"0.5185587",
"0.51831275",
"0.517994... | 0.0 | -1 |
Prepare the mnist or fashionmnist data to feed to the model. | def get_data(dataset):
if dataset not in possible_datasets:
datasets_output = ', '.join(possible_datasets)
raise ValueError('dataset must be one of: {}'.format(datasets_output))
if dataset == 'mnist':
(clean_train, __), (clean_test, __) = mnist.load_data()
elif dataset == '... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _prepare_data(self):\n #TODO hardcoded values need to change\n print_info(\"Preprocessing the train data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"train\"),\n self.TRAIN_OUT_PATH)\n\n print_info(\"Preprocessing the test data..... | [
"0.71029925",
"0.7001878",
"0.68021387",
"0.66606903",
"0.6657912",
"0.6647711",
"0.65342814",
"0.6513322",
"0.6462048",
"0.6341769",
"0.63327867",
"0.6331993",
"0.63136804",
"0.6295836",
"0.6294832",
"0.6288506",
"0.6255097",
"0.6247711",
"0.62466383",
"0.62195545",
"0.62018... | 0.0 | -1 |
Trains a UNet to learn denoising by selfsupervision (noise2self). Uses matplotlib to display the results. | def train_model(clean_train, clean_test, noisy_test, num_batches=150,
batch_size=32, show_loss_plot=False, verbose=False, seed=1337):
if num_batches <= 0:
raise ValueError('must have a positive number of batches')
if batch_size <= 0:
raise ValueError('must have a positive b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trainNet():",
"def demo(image, model_class, do_add_noise=True):\n Log.enable_output = True\n Log.set_log_max_depth(8)\n\n image = normalise(image)\n image = numpy.expand_dims(image, axis=0)\n image = numpy.expand_dims(image, axis=0)\n noisy = add_noise(image) if do_add_noise else image\n ... | [
"0.6543201",
"0.63936913",
"0.61371124",
"0.60957474",
"0.603511",
"0.6034276",
"0.59679383",
"0.58697367",
"0.58606166",
"0.58570796",
"0.5854856",
"0.58541954",
"0.5833947",
"0.5821031",
"0.5809367",
"0.5758914",
"0.5753244",
"0.5733578",
"0.57328314",
"0.56852037",
"0.5683... | 0.0 | -1 |
Saves the weights of model to output_path. | def save_model_weights(model, output_path):
output_dir = os.path.dirname(output_path)
if output_dir and not os.path.exists(output_dir):
os.makedirs(output_dir)
model.save_weights(output_path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_model_weights(self, filename):\n self.model.save_weights(filename)",
"def save_model(self, file_name):\n\t\tself.model.save_weights(file_name)",
"def save(self, filename):\n self.model.save_weights(filename)",
"def save_model(self, model_filename):\n self.model.save_weights(mode... | [
"0.80955356",
"0.7926381",
"0.7886226",
"0.7832939",
"0.7832589",
"0.77854276",
"0.77565",
"0.7726169",
"0.77205503",
"0.77095634",
"0.7655661",
"0.7647746",
"0.76366",
"0.75701165",
"0.75657123",
"0.75270814",
"0.7525037",
"0.7525037",
"0.74478704",
"0.7430976",
"0.74265957"... | 0.8475825 | 0 |
Generates a set of examples from the trained model. | def plot_examples(model, clean_test, noisy_test, num_examples=15,
randomize=False, output_path=None):
if num_examples <= 0:
raise ValueError('must generate a positive number of examples')
if randomize:
indices = np.random.choice(clean_test.shape[0], num_examples)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_train_examples(self, data_path):\r\n return self.create_examples(self.read_data(data_path), 'train')",
"def get_train_examples(self):\n raise NotImplementedError()",
"def build_examples():\n build_models([\n \"VGG_16\",\n \"VGG_19\",\n \"RESNET_50\",\n \"MOB... | [
"0.6898566",
"0.68552566",
"0.68252814",
"0.65360844",
"0.6499116",
"0.64343864",
"0.64343864",
"0.64343864",
"0.64343864",
"0.64343864",
"0.64343864",
"0.64343864",
"0.64186585",
"0.64186585",
"0.64146006",
"0.64114195",
"0.64114195",
"0.64114195",
"0.64114195",
"0.64114195",
... | 0.0 | -1 |
Initialize the GenericProcessing class. | def __init__(self):
self.bpf_lcut = 10
self.bpf_hcut = 425
self.lpf_lcut = 5
self.lp_butter_order = 4
self.bp_butter_order = 2
self.data_rate = None
self.process_time = [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _initialize(self):\n pass",
"def _initialize(self):\n pass",
"def _initialize(self):\n pass",
"def initialize(cls):",
"def __init__(self, *args, **kwargs):\n # count the cores available on the local machine\n self.tasks = mp.cpu_count()\n super(ParallelPreproce... | [
"0.6463012",
"0.6463012",
"0.6463012",
"0.6433146",
"0.6373256",
"0.6362228",
"0.63576984",
"0.6353064",
"0.6337008",
"0.6281862",
"0.6280358",
"0.6260662",
"0.6260662",
"0.62492085",
"0.6231807",
"0.6200611",
"0.6200611",
"0.6200611",
"0.6200611",
"0.6200611",
"0.6199629",
... | 0.0 | -1 |
Create a butter bandpass filter. | def _butter_bandpass(lowcut: float, highcut: float, fs: float, order: int = 5) -> tuple:
nyq = 0.5 * fs
low = lowcut / nyq
high = highcut / nyq
b, a = butter(order, [low, high], btype="band")
return b, a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def butter_filter(datalist):\n fs = 200.00\n fHigh = 50.00\n fLow = 5.00\n N=4\n [b,a]=sg.butter(N,[fLow/fs, fHigh/fs], btype='band')\n global filtered\n #IIR filter\n return sg.filtfilt(b,a,datalist)",
"def butter_bandpass_filter(data, lowcut, highcut, fs, order=5, axis=0): \n o... | [
"0.7451614",
"0.71119744",
"0.70526403",
"0.70473236",
"0.701966",
"0.6992632",
"0.6988554",
"0.6983021",
"0.6854008",
"0.67565495",
"0.6697159",
"0.6620907",
"0.65991974",
"0.6589245",
"0.6563564",
"0.6532885",
"0.63735956",
"0.6355377",
"0.6267423",
"0.6253552",
"0.6224801"... | 0.6940084 | 8 |
Create a butter lowpass filter. | def _butter_lowpass(lowcut, fs, order=4) -> tuple:
nyq = 0.5 * fs
low = lowcut / nyq
b, a = butter(order, [low], btype="low")
return b, a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def butter_lowpass_filter(data, cutoff, fs, order=1):\n b, a = butter_lowpass(cutoff, fs, order=order)\n y = filtfilt(b, a, data)\n return y",
"def butter_lowpass_filter(self, data: np.ndarray, lowcut: float, fs: float, order: int = 4) -> np.ndarray:\n b, a = self._butter_lowpass(lowcut, fs, orde... | [
"0.744177",
"0.7354153",
"0.7298044",
"0.72915983",
"0.72183937",
"0.72033155",
"0.7202647",
"0.70877373",
"0.7069501",
"0.70666546",
"0.702754",
"0.7013197",
"0.70112276",
"0.7000103",
"0.69962335",
"0.69581854",
"0.69211996",
"0.66302556",
"0.6578073",
"0.65766674",
"0.6520... | 0.6737992 | 17 |
Apply a butter bandpass filter. | def _butter_bandpass_filter(self, data: np.ndarray, lowcut: float, highcut: float, fs: float, order: int = 5):
b, a = self._butter_bandpass(lowcut, highcut, fs, order=order)
y = lfilter(b, a, data)
return y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def butter_bandpass_filter(data, lowcut, highcut, fs, order=5, axis=0): \n omega = 0.5 * fs\n low = lowcut / omega\n high = highcut / omega\n b, a = signal.butter(order, [low, high], btype='band')\n y = signal.lfilter(b, a, data, axis=0)\n return y",
"def butter_filter(datalist):\n fs ... | [
"0.7581869",
"0.75664645",
"0.7475748",
"0.74545556",
"0.7397321",
"0.73342526",
"0.7259128",
"0.7098314",
"0.70211107",
"0.6906156",
"0.6815835",
"0.66446453",
"0.6626587",
"0.66065145",
"0.6584951",
"0.65104455",
"0.64792573",
"0.6366289",
"0.634029",
"0.629268",
"0.6233594... | 0.7138827 | 7 |
Apply a butter lowpass filter. | def butter_lowpass_filter(self, data: np.ndarray, lowcut: float, fs: float, order: int = 4) -> np.ndarray:
b, a = self._butter_lowpass(lowcut, fs, order=order)
y = filtfilt(b, a, data)
return y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def butter_lowpass_filter(data, cutoff, fs, order=1):\n b, a = butter_lowpass(cutoff, fs, order=order)\n y = filtfilt(b, a, data)\n return y",
"def butter_bandpass_filter(data, lowcut, highcut, fs, order=1):\n b, a = butter_bandpass(lowcut, highcut, fs, order=order)\n y = filtfilt(b, a, data)\n ... | [
"0.77225924",
"0.758474",
"0.75541186",
"0.74821657",
"0.74796224",
"0.74441874",
"0.74429524",
"0.7362974",
"0.7348949",
"0.7328772",
"0.73254126",
"0.7311591",
"0.72724277",
"0.71420956",
"0.7005642",
"0.6849895",
"0.6796962",
"0.6738573",
"0.66404504",
"0.660009",
"0.65754... | 0.7719998 | 1 |
Center the EMG data. | def center(emg_data: np.ndarray, center_value: float = None) -> np.ndarray:
center_value = center_value if center_value else emg_data.mean(axis=1)
emg_centered = np.copy(emg_data)
for i in range(emg_data.shape[0]):
emg_centered[i, :] = emg_data[i, :] - center_value[i]
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def centerAxis():\n dislin.center()",
"def center(self):\n cp = self.dat.flowsheet.getCenter()\n self.centerOn(cp[0], cp[1])",
"def GetCenter(self):\n ...",
"def GetCenter(self):\n ...",
"def GetCenter(self):\n ...",
"def GetCenter(self):\n ...",
"def center... | [
"0.715392",
"0.7150732",
"0.7057086",
"0.7057086",
"0.7057086",
"0.7057086",
"0.6961718",
"0.6929149",
"0.68829924",
"0.6846377",
"0.6817087",
"0.67858565",
"0.6771365",
"0.6628032",
"0.66244245",
"0.6572838",
"0.65496373",
"0.65375334",
"0.6534411",
"0.6523956",
"0.6498194",... | 0.687216 | 9 |
Apply a calibration matrix to the data. | def calibration_matrix(self, data: np.ndarray, matrix: np.ndarray) -> np.ndarray:
tic = time.time()
data_cal = np.dot(matrix, data)
self.process_time.append(time.time() - tic)
return data_cal | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, data):\n cal = self.calc()\n assert data.shape == cal.shape, \\\n \"data shape does not match calibration ({} != {})\".format(data.shape, cal.shape)\n return data * cal",
"def _applyCalibration(self, ws, detPos):\n alg = self.createChildAlgorithm('ApplyCa... | [
"0.69434965",
"0.62040365",
"0.6035492",
"0.5958941",
"0.59398246",
"0.5786696",
"0.574981",
"0.57194704",
"0.55841017",
"0.5576397",
"0.55610746",
"0.5532381",
"0.5509009",
"0.5477683",
"0.5476905",
"0.54610693",
"0.5456806",
"0.5437726",
"0.5427076",
"0.5380523",
"0.5365716... | 0.72663486 | 0 |
update the signal processing parameters. | def update_signal_processing_parameters(self, **kwargs):
for key, value in kwargs.items():
if key in self.__dict__:
self.__dict__[key] = value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_parameters(self):\n # We update gamma, gamma0, lambda and nu in turn (Bottolo et al, 2011)\n self.update_gamma()\n self.update_gamma0()\n self.update_lambda()\n self.update_nu()\n if self.sample_xi:\n self.update_xi()",
"def updateSignals(self):\n ... | [
"0.6584715",
"0.6542431",
"0.62621695",
"0.6258087",
"0.62553895",
"0.62539536",
"0.61550564",
"0.6127215",
"0.60999376",
"0.60887265",
"0.60854816",
"0.6067803",
"0.60374635",
"0.6030319",
"0.5960224",
"0.5955644",
"0.5927045",
"0.5896254",
"0.57902694",
"0.57900864",
"0.578... | 0.79885525 | 0 |
Initialize the class for real time processing. | def __init__(self, data_rate: Union[int, float], processing_window: int = None):
super().__init__()
self.data_rate = data_rate
self.processing_window = processing_window if processing_window else data_rate
self.raw_data_buffer = []
self.processed_data_buffer = []
self._is... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize(self):\n self._start = time.time()",
"def initialize(self):\n self._startTime = time.time()",
"def __init__(self):\n\t\tself._logger = None\n\t\tself._instanciate_logger()\n\t\tself._video_manager = VideoManager(self, self._logger)\n\t\tself._video_thread = None\n\t\tself._audio_ma... | [
"0.7711892",
"0.76289284",
"0.73504174",
"0.7244866",
"0.7172699",
"0.71558505",
"0.7131929",
"0.7114648",
"0.71031666",
"0.71031666",
"0.71031666",
"0.71031666",
"0.71031666",
"0.71031666",
"0.71031666",
"0.71031666",
"0.70616686",
"0.70616686",
"0.7052515",
"0.7051719",
"0.... | 0.0 | -1 |
Process EMG data in realtime. | def process_emg(
self,
emg_data: np.ndarray,
mvc_list: Union[list, tuple] = None,
band_pass_filter=True,
low_pass_filter=False,
moving_average=True,
centering=True,
absolute_value=True,
normalization=False,
moving_average_window=200,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\r\n self.collect_data()",
"def process():",
"def run(self):\n while(not self.stop_event.is_set()):\n # read values until stop is sent\n response1 = _read_once(1,self.serial)\n response2 = _read_once(2,self.serial)\n #print(response)\n ... | [
"0.6334594",
"0.62554085",
"0.6160218",
"0.6159584",
"0.6151509",
"0.6107726",
"0.6082145",
"0.5994185",
"0.59724444",
"0.59122896",
"0.5894136",
"0.5888195",
"0.5872895",
"0.58719957",
"0.5846285",
"0.5831141",
"0.58255845",
"0.58187026",
"0.58187026",
"0.57989854",
"0.57989... | 0.59569275 | 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.