PredictionOutput:\n test_dataloader = self.get_test_dataloader(test_dataset)\n return self._prediction_loop(test_dataloader, description=\"Prediction\")","def predict(self, model, x_test):\n pass","def trainAndPredict(self):\r\n print(\"train\")\r\n filename= 'finalized_model.sav'\r\n # train the algorithm on training data and predict using the testing data\r\n model = self.svc_model.fit(self.X.T, self.Y)\r\n pickle.dump(model, open(filename, 'wb'))\r\n #model = pickle.load(open(filename, 'rb'))\r\n pred1 =model.predict(self.TestSet.T)\r\n # print the accuracy score of the model\r\n print(\"LinearSVC accuracy : \", accuracy_score(self.TestSetY, pred1, normalize=True))","def predict(self, X_test):\n return self.model.predict(X_test)","def _fit_predict(X_train, y_train, X_test):\n raise NotImplementedError()","def predict(config: Config, device: torch.device, resume: Optional[ResumeInfo]) -> None:\n # pylint: disable=too-many-locals\n # Load datasets\n print(colored(\"loading training datasets:\", attrs=[\"bold\"]))\n dataset_factory = DatasetFactory()\n datasets, preprocessors = dataset_factory.create(config)\n print(f\"train: {len(datasets.train)}\")\n print(f\"val: {len(datasets.val)}\")\n print(f\"test: {len(datasets.test)}\")\n\n print(colored(\"saving question ids:\", attrs=[\"bold\"]))\n split_map = {\n \"train\": (config.training.data.train, datasets.train),\n \"val\": (config.training.data.val, datasets.val),\n \"test\": (config.training.data.test, datasets.test),\n }\n for split, (dataconfig, dataset) in split_map.items():\n root = Path(wandb.run.dir) / \"predictions\"\n if not root.exists():\n root.mkdir(parents=True)\n path = root / f\"{split}_ids.json\"\n start = int(dataconfig.subset[0] * len(dataset))\n end = int(dataconfig.subset[1] * len(dataset))\n subset = torch.utils.data.Subset(dataset, range(start, end))\n ids = [subset[i][\"question\"][\"questionId\"] for i in range(len(subset))]\n with open(path, \"w\") as file:\n json.dump(ids, file)\n\n # Create model runner\n print(colored(\"model:\", attrs=[\"bold\"]))\n runner_factory = RunnerFactory()\n runner = runner_factory.create(config, device, preprocessors, datasets, resume)\n print(f\"{runner.model=}\")\n\n print(colored(\"loading prediction datasets:\", attrs=[\"bold\"]))\n dataset_factory = DatasetFactory(training=False)\n datasets, pred_preprocessors = dataset_factory.create(config)\n print(f\"train: {len(datasets.train)}\")\n print(f\"val: {len(datasets.val)}\")\n print(f\"test: {len(datasets.test)}\")\n\n # Extend question embedding dictionary with pad vector for OOV.\n # The runner will check if a question token index is out of bounds and\n # set it to the padding index if so.\n runner.model.question_embeddings = torch.nn.Embedding.from_pretrained(\n torch.cat(\n (\n runner.model.question_embeddings.weight.data,\n torch.zeros(\n (\n len(pred_preprocessors.questions.index_to_word)\n - runner.model.question_embeddings.num_embeddings,\n runner.model.question_embeddings.embedding_dim,\n )\n ).to(device),\n ),\n dim=0,\n )\n )\n # Update datasets and preprocessors for prediction\n runner.datasets = datasets\n runner.preprocessors = pred_preprocessors\n\n print(colored(\"predicting:\", attrs=[\"bold\"]))\n runner.predict()","def train_predict(descriptions_models,\n X_train, y_train,\n X_valid, y_valid,\n scoring=None):\n\n results = []\n for description, model in descriptions_models:\n\n scorer = check_scoring(model, scoring=scoring)\n result = {'description': description}\n\n # Train\n start = time.time()\n model.fit(X_train, y_train)\n result['time_train'] = time.time() - start\n\n # Predict train\n start = time.time()\n result['score_train'] = scorer(model, X_train, y_train)\n result['time_predict_train'] = time.time() - start\n\n # Predict validation\n start = time.time()\n result['score_valid'] = scorer(model, X_valid, y_valid)\n result['time_predict_valid'] = time.time() - start\n\n results.append(result)\n\n return pd.DataFrame(results)[[\n 'description', 'score_train', 'score_valid',\n 'time_train', 'time_predict_train', 'time_predict_valid']]","def fit_and_predict(self, X_train, y_train, X_test, y_test):\n if self.feature_transform_func:\n X_train, X_test = self.feature_transform_func(X_train, X_test)\n\n self.fit(X_train, y_train)\n y_predict = self.predict(X_test)\n return self.Acu_eval(y_predict, y_test)","def after_pred(self):\n # If training then skip\n if self.training:\n return\n\n # Get ground truths in epoch 0 i.e. start of training\n if self.epoch == 0:\n self.y_true.extend(self.y.cpu().flatten().numpy())\n\n # Get predictions from each batch and add them to prediction container\n y_pred = self.pred.detach().cpu()\n \n self.y_pred.extend(y_pred.flatten().numpy())","def predict(self, test_data):\n return self.leader.predict(test_data)","def make_predictions(self):\n if is_classification(self.model):\n if self.ct == None:\n prediction = self.model.predict(self.input_data.to_numpy())\n probabilities = self.model.predict_proba(self.input_data.to_numpy())\n return prediction, probabilities\n elif self.ct != None: \n prediction = self.model.predict(self.data_into_model())\n probabilities = self.model.predict_proba(self.data_into_model())\n return prediction, probabilities\n else:\n raise Exception((\"{} not supported. Please create an issue on Github\").format(self.model))\n \n else:\n if self.ct == None:\n prediction = self.model.predict(self.input_data)\n return prediction\n elif self.ct != None: \n prediction = self.model.predict(self.data_into_model())\n return prediction\n else:\n raise Exception((\"{} not supported. Please create an issue on Github\").format(self.self.model))","def predict(self, test_data):\n random.seed(self.seed)\n preds = [{\"id\": instance['id'], \"prediction\": random.choice([0, 1])} for instance in test_data]\n return preds","def make_predictions(self):\n \n self.Y = self.X.dot(self.w)","def predict(self):\n path = self._artifact_repo.artifact_path(self._ARTIFACT_MODEL)\n model = tf.keras.models.load_model(path)\n\n _, _, x_test, y_test = self._load_data()\n x_test = tf.keras.utils.normalize(x_test, axis=1)\n\n preds = model.predict(x_test)\n self._show_cf_matrix(np.array([np.argmax(probas) for probas in preds]), y_test)","def get_initial_predictions(tuner, input_data, output_path, model_save_name):\n\n best_model = tuner.best_estimator()\n batch_job = best_model.transformer(1, \"ml.m5.large\", output_path=output_path.as_uri(),\n model_name=model_save_name)\n batch_job.transform(input_data.as_uri())\n # TODO: Do an ls first so we can get any/all files\n output_file = output_path / 'validation.csv.out'\n with smart.open(output_file.as_uri(), 'r', transport_params={'session': boto_session}) as f:\n predictions = pd.read_csv(f, header=None)\n return predictions","def predict(trained_model, X_test, y_test, image_name):\n if MODEL == 1:\n return predict_1(trained_model, X_test, y_test)\n elif MODEL == 3:\n if CROSS_VALIDATION:\n return cv_predict_3(trained_model, X_test, y_test)\n else:\n return predict_3(trained_model, X_test, y_test, image_name)\n elif MODEL == 2:\n return predict_2(trained_model, X_test, y_test)\n else:\n # For models 4, 5 and 6\n return predict_4(trained_model, X_test, y_test)","def predict(self, test_data):\r\n return self.gs.predict(test_data)","def fit_predict_model(self, X_train, y_train, X_test, pipeline):\n\n pipeline.fit(X_train, y_train)\n y_pred = pipeline.predict(X_test)\n return y_pred","def test():\n # load dataset and model\n X, observed_y = load_data('../data/dev.txt')\n\n model = pickle.load(open('test.model', 'rb'))\n model.traverse()\n\n # predict labels for dataset\n preds = model.predict(X)\n\n # print(preds)\n # output model predictions\n np.savetxt('test.predictions', preds, fmt='%s')","def _predict_preproc_model(self, model_cfg, model,):\n model = self._make_model(model_cfg['model_name'], databunch=self._data)\n model.model_param = model_cfg['model_param']\n model.wrapper_params = model_cfg['wrapper_params']\n return(model)","def predict(self, scenes, tmp_dir):\n self.backend.load_model(tmp_dir)\n\n for scene in scenes:\n with scene.activate():\n labels = self.predict_scene(scene, tmp_dir)\n label_store = scene.prediction_label_store\n label_store.save(labels)\n\n if self.config.debug and self.config.predict_debug_uri:\n self.save_debug_predict_image(\n scene, self.config.predict_debug_uri)","def predict_1(trained_model, X_test, y_test):\n # Predict with test data\n start_time = timeit.default_timer()\n test_prediction = trained_model.predict(X_test)\n end_time = timeit.default_timer()\n time = end_time - start_time\n speed = int(X_test.shape[0] / time)\n \n # Get loss and accuracy\n test_loss, test_accuracy = trained_model.evaluate(X_test, y_test)\n \n # Prepare results messages\n msg_time = \"prediction time: {:.3f}s ({}px/s)\\n\".format(time, speed)\n msg_test_loss = \"test_loss: {:.3f}\\n\".format(test_loss)\n msg_test_acc = \"test_accuracy: {:.3f}\\n\\n\".format(test_accuracy)\n \n # Write results messages\n with open(OUTPUT_FILE, 'a') as f:\n f.write(msg_time)\n f.write(msg_test_loss)\n f.write(msg_test_acc)","def predict(self, test_inputs, batch_size=None):\n if batch_size is None:\n num_batches = 1\n else:\n num_batches = util.ceil_divide(test_inputs.shape[0], batch_size)\n\n test_inputs = np.array_split(test_inputs, num_batches)\n pred_means = util.init_list(0.0, [num_batches])\n pred_vars = util.init_list(0.0, [num_batches])\n for i in range(num_batches):\n pred_means[i], pred_vars[i] = self.session.run(\n self.predictions, feed_dict={self.test_inputs: test_inputs[i]})\n\n return np.concatenate(pred_means, axis=0), np.concatenate(pred_vars, axis=0)","def _predict(self, dataset):\n binary_predictions = ProxyClassifier._predict(self, dataset)\n self.ca.estimates = binary_predictions\n predictions = [ {-1: self.__predictneg,\n +1: self.__predictpos}[x] for x in binary_predictions]\n self.ca.predictions = predictions\n return predictions","def predict(self, epochs): # noqa\n\n # Check that classifier has predict_method (e.g. predict_proba is not\n # always available):\n if not hasattr(self.clf, self.predict_method):\n raise NotImplementedError('%s does not have \"%s\"' % (\n self.clf, self.predict_method))\n\n # Check that at least one classifier has been trained\n if not hasattr(self, 'estimators_'):\n raise RuntimeError('Please fit models before trying to predict')\n\n # Check predict mode\n if self.predict_mode not in ['cross-validation', 'mean-prediction']:\n raise ValueError('predict_mode must be a str, \"mean-prediction\" '\n 'or \"cross-validation\"')\n\n # Check that training cv and predicting cv match\n if self.predict_mode == 'cross-validation':\n n_est_cv = [len(estimator) for estimator in self.estimators_]\n heterogeneous_cv = len(set(n_est_cv)) != 1\n mismatch_cv = n_est_cv[0] != len(self._cv_splits)\n mismatch_y = len(self.y_train_) != len(epochs)\n if heterogeneous_cv or mismatch_cv or mismatch_y:\n raise ValueError(\n 'When predict_mode = \"cross-validation\", the training '\n 'and predicting cv schemes must be identical.')\n\n # Clean attributes\n for att in ['y_pred_', 'test_times_', 'scores_', 'scorer_', 'y_true_']:\n if hasattr(self, att):\n delattr(self, att)\n _warn_once.clear() # reset self-baked warning tracker\n\n X, y, _ = _check_epochs_input(epochs, None, self.picks_)\n\n if not np.all([len(test) for train, test in self._cv_splits]):\n warn('Some folds do not have any test epochs.')\n\n # Define testing sliding window\n if self.test_times == 'diagonal':\n test_times = _DecodingTime()\n test_times['slices'] = [[s] for s in self.train_times_['slices']]\n test_times['times'] = [[s] for s in self.train_times_['times']]\n elif isinstance(self.test_times, dict):\n test_times = copy.deepcopy(self.test_times)\n else:\n raise ValueError('test_times must be a dict or \"diagonal\"')\n\n if 'slices' not in test_times:\n if 'length' not in self.train_times_.keys():\n ValueError('Need test_times[\"slices\"] with adhoc train_times.')\n # Check that same number of time sample in testing than in training\n # (otherwise it won 't be the same number of features')\n test_times['length'] = test_times.get('length',\n self.train_times_['length'])\n # Make a sliding window for each training time.\n slices_list = list()\n for _ in range(len(self.train_times_['slices'])):\n test_times_ = _sliding_window(epochs.times, test_times,\n epochs.info['sfreq'])\n slices_list += [test_times_['slices']]\n test_times = test_times_\n test_times['slices'] = slices_list\n test_times['times'] = [_set_window_time(test, epochs.times)\n for test in test_times['slices']]\n\n for train, tests in zip(self.train_times_['slices'],\n test_times['slices']):\n # The user may define irregular timing. We thus need to ensure\n # that the dimensionality of each estimator (i.e. training\n # time) corresponds to the dimensionality of each testing time)\n if not np.all([len(test) == len(train) for test in tests]):\n raise ValueError('train_times and test_times must '\n 'have identical lengths')\n\n # Store all testing times parameters\n self.test_times_ = test_times\n\n n_orig_epochs, _, n_times = X.shape\n\n # Subselects the to-be-predicted epochs so as to manipulate a\n # contiguous array X by using slices rather than indices.\n test_epochs = []\n if self.predict_mode == 'cross-validation':\n test_idxs = [ii for train, test in self._cv_splits for ii in test]\n start = 0\n for _, test in self._cv_splits:\n n_test_epochs = len(test)\n stop = start + n_test_epochs\n test_epochs.append(slice(start, stop, 1))\n start += n_test_epochs\n X = X[test_idxs]\n\n # Prepare parallel predictions across testing time points\n # FIXME Note that this means that TimeDecoding.predict isn't parallel\n parallel, p_func, n_jobs = parallel_func(_predict_slices, self.n_jobs)\n n_test_slice = max(len(sl) for sl in self.test_times_['slices'])\n # Loop across estimators (i.e. training times)\n n_chunks = min(n_test_slice, n_jobs)\n chunks = [np.array_split(slices, n_chunks)\n for slices in self.test_times_['slices']]\n chunks = map(list, zip(*chunks))\n\n # To minimize memory during parallelization, we apply some chunking\n y_pred = parallel(p_func(\n estimators=self.estimators_, cv_splits=self._cv_splits,\n predict_mode=self.predict_mode, predict_method=self.predict_method,\n n_orig_epochs=n_orig_epochs, test_epochs=test_epochs,\n **dict(zip(['X', 'train_times'], _chunk_data(X, chunk))))\n for chunk in chunks)\n\n # Concatenate chunks across test time dimension.\n n_tests = [len(sl) for sl in self.test_times_['slices']]\n if len(set(n_tests)) == 1: # does GAT deal with a regular array/matrix\n self.y_pred_ = np.concatenate(y_pred, axis=1)\n else:\n # Non regular testing times, y_pred is an array of arrays with\n # different lengths.\n # FIXME: should do this with numpy operators only\n self.y_pred_ = [[test for chunk in train for test in chunk]\n for train in map(list, zip(*y_pred))]\n return self.y_pred_","def prediction(input_path=INPUT_DIR,\n output_path=OUTPUT_DIR,\n model_path=MODEL_PATH,\n test=False):\n\n X = tf.placeholder(shape=[None, chunk_size, chunk_size], dtype=tf.float32, name='input_area')\n y_inter = deepcn.deepcn(X, chunk_size, False)\n y_pred = tf.cast(tf.argmax(tf.squeeze(y_inter), -1), tf.uint8)\n\n img_ids = []\n for name in os.listdir(input_path):\n if os.path.isdir(os.path.join(input_path, name)):\n img_ids.append(name)\n all_preds = np.zeros((len(img_ids), 256, 256))\n print('num of images: ', len(img_ids))\n\n loader = tf.train.Saver()\n\n with tf.Session() as sess:\n print(\"Import model from: %s\" %model_path)\n loader.restore(sess, model_path)\n # sess.run(tf.global_variables_initializer())\n\n batch_start_pos = 0\n while batch_start_pos < len(img_ids):\n batch_size = 100\n batch_end_pos = min(batch_start_pos + batch_size, len(img_ids))\n print('predict from %s, to %s' % (batch_start_pos, batch_end_pos))\n batch = img_ids[batch_start_pos:batch_end_pos]\n pw = predict_data_wrapper.PredictWrapper(path=input_path,\n resize_size=chunk_size,\n img_ids=batch)\n input_arr = pw.ResizedTestData()\n print(\"input_arr.shape: \", input_arr.shape)\n # input test_data_batch, output prediction of shape batch_size * 256 * 256\n pred_arr = sess.run(y_pred, feed_dict={X: input_arr})\n print(\"pred_arr.shape: \", pred_arr.shape)\n all_preds[batch_start_pos:batch_end_pos] = pred_arr\n pw.OutputPrediction(pred_arr*100, path=output_path)\n batch_start_pos = batch_end_pos\n\n # Use all img_ids and all_preds to generate single cell split csv file\n pw = predict_data_wrapper.PredictWrapper(path=input_path,\n resize_size=chunk_size,\n img_ids=img_ids)\n pw.GenerateSubmit(all_preds, output_path, cutoff=0.5)","def predict(self, data, verbose=0):\n\n if self.model is None:\n raise StandardError('Model is not built. Run build method or load model before fitting')\n # print len(data[0])\n # print type(data[0])\n # print data.shape\n return self.model.predict(data, 1, verbose) # ,steps)","def predict(self, test_set, test_labels):\n\n with tf.Session() as self.tf_session:\n self.tf_saver.restore(self.tf_session, self.models_dir + self.model_name)\n return self.accuracy.eval({self.input_data: test_set, self.input_labels: test_labels})","def train(self):\n\t\tself.model.fit(self.training_data, self.training_labels)","def predict(self, dataset):\n # TODO: self.model(training=False)\n # logging.info('Predicting')\n # if self.verbosity > 1:\n # print('Predicting')\n dataset = rdata.data2dataset(dataset) # Convert to dataset\n assert dataset.get_dim_input() == self.n_inputs, \\\n 'Number of covariates does not match the model %d -> %d' % (dataset.get_dim_input(), self.n_inputs)\n n_data = dataset.get_n_data()\n\n pred = self._predict(dataset=dataset) # Predict\n\n if self.isprobabilistic():\n assert pred[0].shape == (n_data, self.n_outputs)\n assert pred[1].shape == (n_data, self.n_outputs)\n else:\n assert pred.shape == (n_data, self.n_outputs)\n return pred","def get_model_predictions(\n self,\n model: Type[Model],\n start_task_index: int = 0,\n stop_task_index: Optional[int] = None,\n batched: bool = False,\n batch_size: int = _DEFAULT_BATCH_SIZE,\n skip_validation: bool = False,\n ) -> Dict[str, Dict[str, Union[str, float]]]:\n predictions = {}\n if not batched:\n batch_size = None\n n_tasks = (stop_task_index or self.n_tasks) - start_task_index\n with tqdm(total=n_tasks) as pbar:\n if not batched:\n for support_x, support_y, query_x, metadata in self.get_tasks(\n start_task_index=start_task_index,\n stop_task_index=stop_task_index,\n ):\n query_y, scores = _parse_fit_and_predict_result(\n model.fit_and_predict(\n support_x=support_x,\n support_y=support_y,\n target_x=query_x,\n metadata=metadata,\n )\n )\n if not skip_validation:\n validate(query_y, metadata['labels'])\n predictions.update(\n _convert_fit_and_predict_result_to_predictions(\n query_y=query_y,\n scores=scores,\n query_question_ids=metadata['query_question_ids']\n )\n )\n pbar.update(1)\n else:\n for batch in grouper(\n batch_size,\n self.get_tasks(\n start_task_index=start_task_index,\n stop_task_index=stop_task_index,\n )\n ):\n support_x, support_y, query_x, metadata = zip(*(b for b in batch if b is not None))\n n_tasks_in_batch = len(support_x)\n query_y, scores = _parse_fit_and_predict_result(\n model.fit_and_predict(\n support_x=support_x,\n support_y=support_y,\n target_x=query_x,\n metadata=metadata,\n )\n )\n try:\n query_y = flatten(query_y)\n scores = flatten(scores) if scores is not None else None\n except TypeError:\n # Already flattened\n pass\n query_question_ids_flat = flatten(m['query_question_ids'] for m in metadata)\n if not skip_validation:\n validate(query_y, metadata['labels'])\n predictions.update(\n _convert_fit_and_predict_result_to_predictions(\n query_y=query_y,\n scores=scores,\n query_question_ids=query_question_ids_flat,\n )\n )\n pbar.update(n_tasks_in_batch)\n return predictions","def correct_age_predictions(train_preds, train_age, test_preds, test_age):\n lr = LinearRegression()\n\n train_resids = np.array(train_preds - train_age)\n test_resids = np.array(test_preds - test_age)\n\n # fit model\n lr.fit(train_age[:,np.newaxis], train_resids)\n\n # predict test residuals using age\n pred_resid = lr.predict(test_age[:,np.newaxis])\n\n # correct model predictions\n corrected_predictions = test_preds - pred_resid\n\n return corrected_predictions","def test_fit_predict() -> None:\n mapie = MapieRegressor()\n mapie.fit(X_toy, y_toy)\n mapie.predict(X_toy)","def fit_predict_single_fold(\n self, train: TabularDataset, valid: TabularDataset\n ) -> Tuple[TorchBasedLinearEstimator, np.ndarray]:\n if type(train) is PandasDataset:\n train = train.to_numpy()\n valid = valid.to_numpy()\n\n model = self._infer_params()\n\n model.fit(\n train.data,\n train.target,\n train.weights,\n valid.data,\n valid.target,\n valid.weights,\n )\n\n val_pred = model.predict(valid.data)\n\n return model, val_pred","def run(self, orig_target_df):\n\n # For each fold\n for fold_idx, (fold_training_set_df, fold_testing_set_df, fold_target_df, fold_truth_df) in enumerate(self._generate_validation_fold()):\n train_test_date_split = fold_training_set_df[\"date\"].max()\n eval_start_date = train_test_date_split - timedelta(days = self.test_nb_days)\n date_to_predict = train_test_date_split + timedelta(days = 1)\n print(\"Warning: date_to_predict offset should be computed dynamically. Currently fixed to 1.\")\n\n # For each prediction method\n for process, process_name in zip(self.process_lst, self.process_names_lst):\n print(\"Running validation for process:\", process_name, \"on fold:\", fold_idx, \"...\")\n\n # Train the model\n with open(self.data_cache_path_str + \"data_bkp.pkl\", \"wb\") as f:\n pickle.dump((fold_training_set_df, fold_testing_set_df, fold_target_df, fold_truth_df), f)\n\n y_train = fold_target_df[\"demand\"].reset_index(drop = True)\n model = process(train_test_date_split, eval_start_date)\n model.fit(fold_training_set_df, y_train)\n\n # Generate predictions for validation set\n preds = model.predict(fold_testing_set_df, date_to_predict)\n preds[\"demand\"] = (orig_target_df[\"shifted_demand\"] + preds[\"demand\"]).apply(np.expm1)\n\n # Score the predictions\n preds2 = preds.copy()\n preds2.columns = [\"id\", \"date\", \"preds\"]\n preds_rmse_by_date_df = preds2.merge(fold_truth_df, how = \"left\", on = [\"id\", \"date\"])\n preds_rmse_by_date_df = preds_rmse_by_date_df[[\"date\", \"preds\", \"demand\"]].groupby(\"date\").apply(lambda x: self._rmse(x[\"demand\"], x[\"preds\"])).reset_index()\n preds_rmse_by_date_df.columns = [\"date\", \"preds_rmse\"]\n\n best_preds_piv = preds[[\"id\", \"date\", \"demand\"]].pivot(index = \"id\", columns = \"date\", values = \"demand\").reset_index()\n truth_piv = fold_truth_df[[\"id\", \"date\", \"demand\"]].pivot(index = \"id\", columns = \"date\", values = \"demand\").reset_index()\n truth_piv.set_index(\"id\", inplace = True)\n best_preds_piv.set_index(\"id\", inplace = True)\n best_preds_piv.columns = [\"F\" + str(i) for i in range(1, 29)]\n truth_piv.columns = [\"F\" + str(i) for i in range(1, 29)]\n validation_WRMSSE = round(model.evaluator.wrmsse(best_preds_piv, truth_piv, score_only = True), 6)\n\n # Save result for later use\n self.scores[process_name].append((fold_idx, preds_rmse_by_date_df, validation_WRMSSE))\n \n if self.verbose == True: \n print(process_name, \"had a score of\", validation_WRMSSE, \"on validation period\", fold_testing_set_df[\"date\"].min(), \"to\", fold_testing_set_df[\"date\"].max())\n\n metrics_lst = []\n for process_name, content in self.scores.items():\n for fold_idx, preds_rmse_by_date_df, validation_WRMSSE in content:\n preds_rmse_by_date_df[\"process_name\"] = process_name\n preds_rmse_by_date_df[\"fold_idx\"] = fold_idx\n preds_rmse_by_date_df[\"WRMSSE\"] = validation_WRMSSE\n metrics_lst.append(preds_rmse_by_date_df)\n\n metrics_df = pd.concat(metrics_lst, axis = 0)\n metrics_df.set_index(\"date\", inplace = True)\n\n return metrics_df","def __train_and_predict(self, X_train, y, X_test):\n self.model.fit(X_train, y, eval_metric='auc')\n prediction_probs = self.model.predict_proba(X_train)[:, 1]\n print \"Training auc = %f\" % roc_auc_score(y, prediction_probs)\n self.__write_csv(prediction_probs,\n X_train.shape[0], self.train_out_file)\n\n prediction_probs = self.model.predict_proba(X_test)[:, 1]\n self.__write_csv(prediction_probs,\n X_test.shape[0], self.test_out_file)\n\n self.feature_imp()","def train(\n self, training_data: Dataset, validation_data: Optional[Dataset] = None\n ) -> Predictor:\n raise NotImplementedError","def predict_4(trained_model, X_test, y_test):\n # Predict with test data\n start_time = timeit.default_timer()\n trained_model.predict(X_test)\n end_time = timeit.default_timer()\n time = end_time - start_time\n speed = int(X_test.shape[0] / time)\n \n # Get loss and accuracy\n test_accuracy = trained_model.score(X_test, y_test)\n \n # Prepare results messages\n msg_time = \"prediction time: {:.3f}s ({}px/s)\\n\".format(time, speed)\n msg_test_acc = \"test_accuracy: {:.3f}\\n\\n\".format(test_accuracy)\n \n # Write results messages\n with open(OUTPUT_FILE, 'a') as f:\n f.write(msg_time)\n f.write(msg_test_acc)","def train_predict(model_list,X_train, X_test, y_train, y_test):\n P = np.zeros((y_test.shape[0], len(model_list)))\n P = pd.DataFrame(P)\n\n print(\"Fitting models.\")\n cols = list()\n for i, (name, m) in enumerate(models.items()):\n print(\"%s...\" % name, end=\" \", flush=False)\n m.fit(X_train, y_train)\n P.iloc[:, i] = m.predict_proba(X_test)[:, 1]\n cols.append(name)\n print(\"done\")\n\n P.columns = cols\n print(\"Done.\\n\")\n return P","def generate_predictions(inputs, model, tokenizer):\n # Generate model results\n outputs = model(**inputs)\n\n # Convert logit outputs into predictions for table cells and aggregation operators\n predicted_table_cell_coords, predicted_aggregation_operators = tokenizer.convert_logits_to_predictions(\n inputs,\n outputs.logits.detach(),\n outputs.logits_aggregation.detach()\n )\n\n print(predicted_table_cell_coords)\n print(predicted_aggregation_operators)\n\n # Return values\n return predicted_table_cell_coords, predicted_aggregation_operators","def test_predict(self):\n # Check build does not raise errors\n dataset = KDDCupDataset()\n dataset.create_fixed_samples(\n *self.data, samples_num=1, partition_sizes=self.partition_sizes)\n dataset.set_current_sample(0)\n model = self.MODEL(dataset, **self.model_arguments)\n model.fit(training_epochs=50)\n true, predictions = model.predict('test')\n expected_size = ((dataset.num_examples('test') //\n model.batch_size) * model.batch_size)\n self.assertEqual(true.shape[0], expected_size)\n self.assertEqual(true.shape, predictions.shape)","def predict_2(trained_model, X_test, y_test):\n # Predict with test data\n start_time = timeit.default_timer()\n test_prediction = trained_model.predict(X_test)\n end_time = timeit.default_timer()\n time = end_time - start_time\n speed = int(X_test.shape[0] / time)\n \n # Get loss and accuracy\n test_loss, test_accuracy = trained_model.evaluate(X_test, y_test)\n \n # Prepare results messages\n msg_time = \"prediction time: {:.3f}s ({}px/s)\\n\".format(time, speed)\n msg_test_loss = \"test_loss: {:.3f}\\n\".format(test_loss)\n msg_test_acc = \"test_accuracy: {:.3f}\\n\\n\".format(test_accuracy)\n \n # Write results messages\n with open(OUTPUT_FILE, 'a') as f:\n f.write(msg_time)\n f.write(msg_test_loss)\n f.write(msg_test_acc)","def fit_predict(self, train_x: pd.DataFrame, train_y: pd.Series, test_x: pd.DataFrame, test_y: pd.Series) -> dict:\n self.evaluator.fit(train_x, train_y, test_x, test_y)\n predictions = self.evaluator.predict(test_x)\n print(predictions)\n metrics = metrics_stat(predictions, test_y)\n return metrics","def predict(model, dataset_info, args):\n dataset_info, model_info = fill_info_dicts(dataset_info, args)\n\n fill_pred_op_info(dataset_info, model, args, model_info)\n # fill_topic_op(args, model_info)\n\n str_ = 'Predictions of the given text data of dataset %s using different ' \\\n 'saved models:' % args.predict_dataset\n labels = [str(i) for i in dataset_info[args.predict_dataset]['labels']]\n if len(labels) == 2 or args.task == 'regression':\n # TODO currently just hard code for binary\n header = 'id\\tlabel\\t' + str(1) + '\\n'\n else:\n header = 'id\\tlabel\\t' + '\\t'.join(labels) + '\\n'\n\n saver = tf.train.Saver(max_to_keep=100)\n\n model_names = args.datasets\n if len(args.datasets) > 1:\n model_names.append('MULT')\n\n for model_name in model_names:\n # load the saved best model\n str_ += '\\nUsing the model that performs the best on (%s)\\n' % model_name\n\n output = header\n str_ += header\n\n data = []\n\n with tf.Session() as sess:\n if model_name == 'MULT':\n checkpoint_path = os.path.join(args.checkpoint_dir, 'MULT',\n 'model')\n else:\n checkpoint_path = model_info[model_name]['checkpoint_path']\n\n saver.restore(sess, checkpoint_path)\n\n dataset_name = args.predict_dataset\n\n # import pdb\n # sess.run(model_info[dataset_name]['pred_iter'].initializer)\n # batch = model_info[dataset_name]['pred_batch']\n # text, weights = sess.run([batch['text'], batch['text_weights']])\n # pdb.set_trace()\n\n _pred_op = model_info[dataset_name]['pred_pred_op']\n _pred_iter = model_info[dataset_name]['pred_iter']\n _ids, _predictions, _scores = get_all_pred_res(sess, _pred_op,\n _pred_iter, args)\n\n for id, pred, score in zip(_ids, _predictions, _scores):\n record = {\n 'id': id,\n 'label': pred\n }\n if args.task == 'classification':\n for l, s in zip(labels, score):\n record[str(l)] = s\n else:\n record['score'] = score[0]\n data.append(record)\n\n # output positive score for binary classification\n\n if len(score) == 2:\n score = str(score[1])\n else:\n score = '\\t'.join([str(i) for i in score])\n str_ += id + '\\t' + str(int(pred)) + '\\t' + score + '\\n'\n output += id + '\\t' + str(int(pred)) + '\\t' + score + '\\n'\n\n make_dir(args.predict_output_folder)\n\n with open(\n os.path.join(args.predict_output_folder, model_name) + '.tsv',\n 'w') as file:\n # for i in _predictions:\n # file.write(str(i))\n file.write(output)\n\n with open(\n os.path.join(args.predict_output_folder, model_name) + '.json',\n 'wt') as file:\n json.dump(data, file, ensure_ascii=False)\n\n logging.info(str_)","def evaluate(self):\n\n\t\t## We should be evaluating on dev dataset as well, so commenting x_test\n\t\t#self.model_score = self.model.evaluate(self.x_test, self.y_test_oh, batch_size=2048)\n\t\tself.model_score = self.model.evaluate(self.x_dev, self.y_dev_oh, batch_size=2048)\n\t\tprint(\"%s score = %f\\n\" %(self.modelName, self.model_score[1]))\n\n\t\t##Saving atucal vs predicted predictions\n\t\t##np.argmax returns the index where it see's 1 in the row\n\t\t#y_pred = np.argmax(self.model.predict(self.x_test, batch_size=2048), axis=1)\n\t\ty_pred = np.argmax(self.model.predict(self.x_dev, batch_size=2048), axis=1)\n\n\t\t## vstack will stack them in 2 rows, so we use Trasnpose to get them in column stack\n\t\t#output_predict = np.vstack((np.argmax(self.y_test_oh, axis=1), y_pred)).T\n\t\toutput_predict = np.vstack((np.argmax(self.y_dev_oh, axis=1), y_pred)).T\n\t\toutputFile = self.resultDir + \"/outputPredict.csv\" \n\t\tnp.savetxt(outputFile, output_predict, fmt=\"%5.0f\", delimiter=\",\")\n\n\t\t##Error Analysis of the prediction\n\t\terrorAnalysis(outputFile)\n\n\t\treturn self.model_score","def postprocess_model_outputs(self, predictions, expected):\n\n predictions = {k: t.numpy() for k, t in predictions.items()}\n\n return predictions, expected","def load_and_predict(self):\n if DataLoader.data is None:\n messagebox.showerror(\"Information\", \"Data file is empty, please load the data first.\")\n return\n\n path = filedialog.askopenfilename()\n with open(path, 'rb') as file:\n Trainer.model = pickle.load(file)\n\n scale = DataLoader.data['out'].max() - DataLoader.data['out'].min()\n scaler = MinMaxScaler(feature_range=(0, 1))\n scaler.fit(DataLoader.data)\n data_scaled = pd.DataFrame(scaler.transform(DataLoader.data), columns=DataLoader.data.columns)\n\n Trainer.y_pred = batch_predict(Trainer.model, data_scaled.drop(columns=['out']))\n Trainer.y_true = data_scaled['out']\n\n self.test_rmse = scale * math.sqrt(mean_squared_error(Trainer.y_pred, Trainer.y_true))\n print(self.test_rmse)\n self.r_squared = np.corrcoef(Trainer.y_pred * scale, data_scaled['out'] * scale)[0, 1] ** 2\n print(self.r_squared)\n\n models = Trainer.model.get_models()\n param_string = f'Component Function Trained Parameters:\\n'\n for i in range(len(models)):\n param_string += \"length scale: {:.4f}\".format(models[i].kernel_.k1.length_scale) + ' ' + \\\n \"noise level: {:.4e}\".format(models[i].kernel_.k2.noise_level) + '\\n'\n param_string += f'\\nRMSE on the test set: {self.test_rmse}\\n'\n param_string += f'R^2 value on the test set: {self.r_squared}'\n display_params = ttk.Label(self, text=param_string, width=40)\n display_params.grid(row=24 + 7, column=0, columnspan=2, sticky=tk.W + tk.E)","def model_predict(classifier, X_test:list) -> list:\n y_predict = classifier.predict(X_test)\n return y_predict","def predictions(self, model):\n return get_predictions_from_df(\n model=model, df=self.prediction_df,\n fixed_effects=self.fixed_effects,\n random_effect=self.random_effect,\n spline=self.spline,\n offset=self.offset,\n )","def predict(self, inputs):\n return self.model.predict(inputs)","def predict_only(self):","def _predict(cls, model, is_log_transformed,\n raw_actual, interpolated_actual,\n training_end=None, seasonal_feature_scoring=None, pred_date=None, order_of_diff=None,\n training_tail=None, ext_training_features=None, pred_len=None, freq=None,\n include_holidays_exog=None):\n\n import numpy as np\n import pandas as pd\n import scipy.stats as st\n from numpy.linalg import LinAlgError\n import math\n\n alpha = cls._sig_level\n alpha_extreme = cls._sig_level_extreme\n\n include_holidays_exog = include_holidays_exog if ext_training_features else 0\n\n index = pd.date_range(start=training_end, end=pred_date, freq=freq)[1:] # Holidays are always daily.\n\n de_obj = DataExploration()\n pred_exog = de_obj._get_exog_data(pred_date, pred_date, index) if include_holidays_exog else None\n\n if pred_exog is not None and set(pred_exog.columns.values) != set(ext_training_features):\n missing_col_list = list(set(ext_training_features) - set(pred_exog.columns.values))\n common_cols = list(set(ext_training_features).intersection(set(pred_exog.columns.values)))\n temp_df = pred_exog[common_cols]\n missing_feat_df = pd.DataFrame(np.zeros([len(pred_exog), len(missing_col_list)]),\n columns=missing_col_list, index=pred_exog.index.values)\n pred_exog = pd.concat([temp_df, missing_feat_df], axis=1)\n pred_exog = pred_exog[ext_training_features]\n\n freq = \"1\" + freq if not any(char.isdigit() for char in freq) else freq\n\n forecast_ndays = int((pred_date - pd.Timestamp(training_end)) / pd.Timedelta(freq))\n model_freshness = forecast_ndays / float(pred_len)\n\n try:\n if forecast_ndays > pred_len:\n raise ValueError('Current trained model object expired')\n\n float_min = 1e-10\n\n # set exogenous (holiday) variables for input data\n if include_holidays_exog:\n pred_exog = pred_exog.loc[pd.Timestamp(training_end) + pd.Timedelta(freq): pred_date]\n else:\n pred_exog = None\n\n if seasonal_feature_scoring:\n if not include_holidays_exog:\n pred_exog = seasonal_feature_scoring[:forecast_ndays]\n else:\n pred_exog['fourier_feature'] = seasonal_feature_scoring[:forecast_ndays]\n\n forecast = list(model.forecast(steps=forecast_ndays, alpha=alpha, exog=pred_exog))\n interpolated_training_data = list(zip(*training_tail))[1]\n\n for order in list(reversed(range(order_of_diff))):\n training_data_diff = np.diff(interpolated_training_data,\n order) if order > 0 else interpolated_training_data\n\n forecast_diff_mean = [training_data_diff[-1]]\n forecast_diff_ci = []\n\n for i in range(forecast_ndays):\n forecast_diff_mean.append(forecast_diff_mean[-1] + forecast[0][i])\n forecast_diff_ci.append([forecast_diff_mean[-1] -\n (st.norm.ppf(1 - (alpha / 2.0)) * forecast[1][i]),\n forecast_diff_mean[-1] +\n (st.norm.ppf(1 - (alpha / 2.0)) * forecast[1][i])])\n forecast[0] = forecast_diff_mean[1:]\n forecast[2] = forecast_diff_ci\n\n if is_log_transformed:\n transformed_back_forecast = np.exp(forecast[0][-1] + ((forecast[1][-1] ** 2) / 2.0)) - 1\n transformed_back_std_err = np.sqrt((np.exp(forecast[1][-1] ** 2) - 1) * (np.exp((2 * forecast[0][-1]) +\n (forecast[1][\n -1] ** 2))))\n transformed_back_CILower = transformed_back_forecast - \\\n st.norm.ppf(1 - (alpha / 2.0), 0, transformed_back_std_err) \\\n if transformed_back_std_err != 0 else transformed_back_forecast\n transformed_back_CIUpper = transformed_back_forecast + \\\n st.norm.ppf(1 - (alpha / 2.0), 0, transformed_back_std_err) \\\n if transformed_back_std_err != 0 else transformed_back_forecast\n transformed_back_interpolated_actual = float(np.exp(interpolated_actual) - 1)\n if np.sum(np.isnan(forecast[0][-1])) or np.isnan(forecast[1][-1]):\n raise ValueError('Predicted null value')\n\n if is_log_transformed:\n zscore = (transformed_back_interpolated_actual -\n transformed_back_forecast) / max(float(transformed_back_std_err), float_min)\n\n anomaly_probability = (2 * st.norm(0, 1).cdf(abs(zscore))) - 1\n if math.isnan(anomaly_probability) or math.isnan(transformed_back_CILower) \\\n or math.isnan(transformed_back_CIUpper):\n raise ValueError('Either Anomaly probability or CILower or CIUpper is NaN under log transform')\n down_anomaly_probability = 1 - st.norm(0, 1).cdf(zscore)\n up_anomaly_probability = st.norm(0, 1).cdf(zscore)\n\n result = {'Success': True,\n 'IsLogTransformed': is_log_transformed,\n 'LogTransformedAdjustedActual': interpolated_actual,\n 'LogTransformedPrediction': float(forecast[0][-1]),\n 'LogTransformedStdErr': float(forecast[1][-1]),\n 'LogTransformedCILower': float(forecast[2][-1][0]),\n 'LogTransformedCIUpper': float(forecast[2][-1][1]),\n 'AdjustedActual': transformed_back_interpolated_actual,\n 'Prediction': float(transformed_back_forecast) if not float(\n transformed_back_forecast) == float('inf') else 0.0,\n 'StdErr': float(transformed_back_std_err) if not float(\n transformed_back_std_err) == float('inf') else 0.0,\n 'CILower': float(transformed_back_CILower) if not float(\n transformed_back_CILower) == float('-inf') else 0.0,\n 'CIUpper': float(transformed_back_CIUpper) if not float(\n transformed_back_CIUpper) == float('inf') else 0.0,\n 'ConfLevel': float(1.0 - alpha) * 100,\n 'ExogenousHolidays': include_holidays_exog,\n 'IsAnomaly': bool(anomaly_probability > 1 - alpha),\n 'IsAnomalyExtreme': bool(anomaly_probability > 1 - alpha_extreme),\n 'AnomalyProbability': 1 if raw_actual is None else float(anomaly_probability),\n 'DownAnomalyProbability': 1 if raw_actual is None else float(down_anomaly_probability),\n 'UpAnomalyProbability': 1 if raw_actual is None else float(up_anomaly_probability),\n 'ModelFreshness': model_freshness}\n\n else:\n zscore = (interpolated_actual - forecast[0][-1]) / max(float(forecast[1][-1]), float_min)\n\n anomaly_probability = (2 * st.norm(0, 1).cdf(abs(zscore))) - 1\n if math.isnan(anomaly_probability) or math.isnan(forecast[2][-1][0]) or math.isnan(forecast[2][-1][1]):\n raise ValueError('Either Anomaly probability or CILower or CIUpper is NaN')\n\n down_anomaly_probability = 1 - st.norm(0, 1).cdf(zscore)\n up_anomaly_probability = st.norm(0, 1).cdf(zscore)\n\n result = {'Success': True,\n 'IsLogTransformed': is_log_transformed,\n 'AdjustedActual': interpolated_actual,\n 'Prediction': float(forecast[0][-1]) if not float(\n forecast[0][-1]) == float('inf') else 0.0,\n 'StdErr': float(forecast[1][-1]) if not float(\n forecast[1][-1]) == float('inf') else 0.0,\n 'CILower': float(forecast[2][-1][0]) if not float(\n forecast[2][-1][0]) == float('-inf') else 0.0,\n 'CIUpper': float(forecast[2][-1][1]) if not float(\n forecast[2][-1][1]) == float('inf') else 0.0,\n 'ConfLevel': float(1.0 - alpha) * 100,\n 'ExogenousHolidays': include_holidays_exog,\n 'IsAnomaly': bool(anomaly_probability > 1 - alpha),\n 'IsAnomalyExtreme': bool(anomaly_probability > 1 - alpha_extreme),\n 'AnomalyProbability': 1 if raw_actual is None else float(anomaly_probability),\n 'DownAnomalyProbability': 1 if raw_actual is None else float(down_anomaly_probability),\n 'UpAnomalyProbability': 1 if raw_actual is None else float(up_anomaly_probability),\n 'ModelFreshness': model_freshness}\n\n except (LinAlgError, ValueError, LADStructuralError) as e:\n result = {'Success': False,\n 'AdjustedActual': interpolated_actual,\n 'ErrorMessage': str(e)}\n\n return result","def prediction(self, test_path, dest_path):\n logger.info(f\"prediction on files from {test_path}\")\n\n if self.train_time is None:\n self.train_time = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')\n\n save_path = data_functions.create_path(dest_path, self.train_time)\n save_path = data_functions.create_path(save_path, 'raw_pred')\n logger.info(f\"saving predictions to {save_path}\")\n\n test_gen = self.test_generator(test_path)\n for img, img_entry, orig_shape in test_gen:\n logger.info(f\"getting prediction for {img_entry.name}\")\n pred_raw = self.model.predict(img, batch_size=1)[0]\n pred_raw_resized = cv2.resize(pred_raw, orig_shape)\n\n file_name = img_entry.name.rsplit('.', 1)[0] + '.npy'\n npy_file_save_path = os.path.join(save_path, file_name)\n np.save(npy_file_save_path, pred_raw_resized, allow_pickle=True)\n\n pred_image = (255 * pred_raw_resized).astype(np.uint8)\n cv2.imwrite(os.path.join(save_path, img_entry.name), pred_image)\n\n return save_path","def predict(data, model_predict):\n # Execute any steps you need to do before scoring\n\n # This method makes predictions against the raw, deserialized model\n #predictions = model_predict(data)\n\n data.to_csv(\"/opt/code/chemprop_folder/for_scoring.csv\", index=False)\n\n args = PredictArgs().parse_args([\n '--test_path', '/opt/chemprop_folder/for_scoring.csv',\n '--checkpoint_path', '/opt/code/model.pth',\n '--preds_path', '/opt/chemprop_folder/preds.csv'\n ])\n\n make_predictions(args)\n\n preds_df = pds.read_csv(\"/opt/chemprop_folder/preds.csv\")\n sh = str(preds_df.shape)\n print(sh)\n\n preds_df = preds_df.rename(columns = {\"p_np\": \"positive_class_label\"})\n preds_df = preds_df.drop(columns=['smiles'])\n preds_df[\"negative_class_label\"] = 1 - preds_df[\"positive_class_label\"]\n\n print(preds_df.head())\n\n # Execute any steps you need to do after scoring\n # Note: To properly send predictions back to DataRobot, the returned DataFrame should contain a\n # column for each output label for classification or a single value column for regression\n return preds_df","def fit_predict_score(self, train_reviews: List[ParsedText],\n test_reviews: List[ParsedText], test_reviews_pred: List[ParsedText],\n **kwargs) -> List[ParsedText]:\n\n self.fit(train_texts=train_reviews, val_texts=test_reviews, **kwargs)\n test_reviews_pred = self.predict(test_reviews_pred)\n logging.info(f'Score: {self.score(texts=test_reviews, texts_pred=test_reviews_pred)}')\n return test_reviews_pred","def predict_single_fold(self, model: TorchBasedLinearEstimator, dataset: TabularDataset) -> np.ndarray:\n pred = model.predict(dataset.data)\n\n return pred","def predict(self, testx=None):\n if self.best_model is None:\n raise Exception(\"Train a model first\")\n\n if testx is None:\n testx = self.test_X\n\n return self._predict(testx)","def predict(self, data, version='default'):\n if self.transform_service:\n data = self.transform_service.predict(data, version)\n return self.model_service.predict(data, version)","def predict(self, trained_model, prediction_datetime):\n return trained_model.predict()","def _predict(self, testX):\n pass","def eval_epoch(self, final=False, save_predictions=False):\n t1 = time()\n output = {'tp': [], 'fp': [], 'fn': [], 'tn': [], 'loss': [], 'preds': [],'truth': [], 'true': 0,'true_sep':np.zeros(self.rel_size)}\n test_info = []\n test_result = []\n self.model.eval()\n test_iter = self.iterator(self.data['test'], batch_size=self.params['batch'], shuffle_=False)\n # preds=[]\n # truths=[]\n for batch_idx, batch in enumerate(test_iter):\n batch = self.convert_batch(batch, istrain=False, save=True)\n\n with torch.no_grad():\n loss, stats, predictions, select, pred_pairs, multi_truths, mask, _ = self.model(\n batch) # pred_pairs <#pair, relations_num>\n pred_pairs = torch.sigmoid(pred_pairs)\n\n output['loss'] += [loss.item()]\n output['tp'] += [stats['tp'].to('cpu').data.numpy()]\n output['fp'] += [stats['fp'].to('cpu').data.numpy()]\n output['fn'] += [stats['fn'].to('cpu').data.numpy()]\n output['tn'] += [stats['tn'].to('cpu').data.numpy()]\n output['preds'] += [predictions.to('cpu').data.numpy()]\n # preds.extend(predictions.to('cpu').data.numpy())\n # truths.extend(truth.to('cpu').data.numpy())\n\n if True:\n test_infos = batch['info'][select[0].to('cpu').data.numpy(),\n select[1].to('cpu').data.numpy(),\n select[2].to('cpu').data.numpy()][mask.to('cpu').data.numpy()]\n test_info += [test_infos]\n\n pred_pairs = pred_pairs.data.cpu().numpy()\n multi_truths = multi_truths.data.cpu().numpy()\n output['true'] += multi_truths.sum() - multi_truths[:, self.loader.label2ignore].sum()\n output['true_sep'] = output['true_sep'] +multi_truths.sum(axis=0)\n if save_predictions:\n assert test_infos.shape[0] == len(pred_pairs), print(\n \"test info=%d, pred_pair=%d\" % (len(test_infos.shape[0]), len(pred_pairs)))\n for pair_id in range(len(pred_pairs)):\n multi_truth = multi_truths[pair_id] #第pair_id个实体对的true\n for r in range(0, self.rel_size):\n if r == self.loader.label2ignore:\n continue\n\n test_result.append((int(multi_truth[r]) == 1, float(pred_pairs[pair_id][r]),\n test_infos[pair_id]['intrain'],test_infos[pair_id]['cross'], self.loader.index2rel[r], r,\n len(test_info) - 1, pair_id))\n\n\n # estimate performance\n total_loss, scores = self.performance(output)\n # pairs*rel_size*batch\n test_result.sort(key=lambda x: x[1], reverse=True)\n\n input_theta, w, f1,p,r,scores_class = self.tune_f1_theta(test_result, output['true'],output['true_sep'], self.params['input_theta'], isTest=save_predictions)\n\n t2 = time()\n if not final:\n self.test_res['loss'] += [total_loss]\n # self.test_res['score'] += [scores[self.primary_metric]]\n self.test_res['score'] += [f1]\n self.test_res['p'] = p\n self.test_res['r'] = r\n print(' TEST | LOSS = {:.05f}, '.format(total_loss), end=\"\")\n print_results(scores, scores_class, self.show_class, t2 - t1)\n # print(\"不同类别：\")\n # t = classification_report(truths, preds,target_names=[\"NA\",\"父母子女\", \"祖孙\", \"兄弟姐妹\", \"叔伯姑舅姨\", \"夫妻\", \"其他亲戚\", \"好友\", \"上下级\", \"师生\", \"合作\", \"情侣\", \"对立\", \"共现\", \"同学\", \"同门\"])\n # print(t)\n\n if save_predictions:\n\n test_result = test_result[: w + 1]\n test_result_pred = []\n test_result_info = []\n for item in test_result:\n test_result_pred.append([(item[-3], item[1])]) #预测的关系是的概率\n test_result_info.append([test_info[item[-2]][item[-1]]])\n assert (item[-3] in test_info[item[-2]][item[-1]]['rel']) == item[0], print(\"item\\n\", item, \"\\n\",\n test_info[item[-2]][\n item[-1]])\n write_errors(test_result_pred, test_result_info, self.preds_file, map_=self.loader.index2rel, type=\"theta\")\n write_preds(test_result_pred, test_result_info, self.preds_file, map_=self.loader.index2rel)\n # f1_score_t=f1_score(truths, preds, average='micro')\n # print(f1, scores['micro_f'], f1_score_t)\n\n return f1, scores['micro_f'],input_theta,p,r","def predict(self,Xpred, nsamples=2000, tune=100, progress=True, points2=[]):\n if self.type_y=='affine':\n return self.predict_affine(Xpred, nsamples, tune, progress, points2)\n elif self.type_y=='regression':\n return self.predict_regression(Xpred, nsamples, tune, progress, points2)\n elif self.type_y=='mixed':\n return self.predict_mixed(Xpred, nsamples, tune, progress, points2)","def predict(self):\n for track in self.tracks:\n track.predict(self.kf)\n #track.du_doan(self.kf_test)","def predict(self, batched_features, model_load_dir=None):\n\n previous_mode = self._mode\n self._mode = 'predict'\n\n if model_load_dir is None:\n model_load_dir = self._save_dir\n logger.info('Model is lodded from {}'.format(model_load_dir))\n\n if not self._is_graph_build:\n logger.info('Initializing the model for prediction...')\n self.compile()\n\n gpu_options = tf.GPUOptions(allow_growth=True)\n sess_config = tf.ConfigProto(gpu_options=gpu_options, allow_soft_placement=True, log_device_placement=True)\n with tf.Session(config=sess_config) as sess:\n saver = tf.train.Saver()\n logger.info(\"Getting latest checkpoint in {}\".format(model_load_dir))\n last_checkpoint = tf.train.latest_checkpoint(model_load_dir)\n logger.info(\"Attempting to load checkpoint at {}\".format(last_checkpoint))\n saver.restore(sess, last_checkpoint)\n logger.info(\"Successfully loaded {}!\".format(last_checkpoint))\n\n feed_dict = self._get_test_feed_dict(batched_features)\n y_pred = sess.run(self.prediction, feed_dict=feed_dict)\n\n self._mode = previous_mode\n return y_pred","def evaluate(model, test_files):\n print(\"Running predictions.\")\n models = load_model(model)\n predictions = predict(models, test_files)\n\n # # write predictions to file\n # write_predictions(\"evaluate_out.json\",predictions)\n evaluate_individual(predictions, test_files, models)\n evaluate_overall(predictions)","def predict(self, data):\n return self.result.predict(data)","def test_predict(self):\n self.regression_single.predict(self.X_test)\n self.assertTrue(len(self.regression_single.y_pred))\n self.regression_boston.predict(self.boston_x_test)\n self.assertTrue(len(self.regression_boston.y_pred))","def predict(dataset):\n import capsnet\n\n # Load (standardized) input data and associated file names\n test_x, _, names = _load_data(dataset)\n\n # Predict class probabilities for each model (epoch)\n at_preds, sed_preds = [], []\n\n for epoch in _determine_epochs(cfg.prediction_epochs):\n model = _load_model(epoch)\n at_pred, sed_pred = utils.timeit(\n lambda: capsnet.gccaps_predict(test_x, model),\n '[Epoch %d] Predicted class probabilities' % epoch)\n\n at_preds.append(at_pred)\n sed_preds.append(sed_pred)\n\n # Average predictions to give an overall output\n total_at_pred = np.mean(at_preds, axis=0)\n total_sed_pred = np.mean(sed_preds, axis=0)\n\n # Ensure output directory exists and set file path format\n os.makedirs(os.path.dirname(cfg.predictions_path), exist_ok=True)\n predictions_path = cfg.predictions_path.format('%s', dataset.name)\n\n # Save free parameters to disk\n utils.log_parameters({'prediction_epochs': cfg.prediction_epochs},\n os.path.join(os.path.dirname(cfg.predictions_path),\n 'parameters.json'))\n\n # Write predictions to disk\n utils.write_predictions(names, total_at_pred, predictions_path % 'at')\n utils.write_predictions(names, total_sed_pred, predictions_path % 'sed')","def predict(self, model, context, data):\n pass","def test_predict(self):\n\n docs = self.docs\n for m in self.models:\n preds = m.predict(docs)\n self.assertTrue(isinstance(preds, turicreate.SArray))\n self.assertEqual(len(preds), len(docs))\n self.assertEqual(preds.dtype, int)\n\n preds = m.predict(docs, output_type=\"probability\")\n self.assertTrue(isinstance(preds, turicreate.SArray))\n self.assertTrue(len(preds) == len(docs))\n s = preds.apply(lambda x: sum(x))\n self.assertTrue((s.apply(lambda x: abs(x - 1)) < 0.000001).all())\n\n # Test predictions when docs have new words\n new_docs = turicreate.SArray([{\"-1,-1\": 3.0, \"0,4\": 5.0, \"0,3\": 2.0}])\n preds = m.predict(new_docs)\n self.assertEqual(len(preds), len(new_docs))\n\n # Test additional burnin. Ideally we could show that things\n # converge as you increase burnin.\n preds_no_burnin = m.predict(docs, output_type=\"probability\", num_burnin=0)\n self.assertEqual(len(preds_no_burnin), len(docs))","def test_fit_predict() -> None:\n mapie = MapieClassifier()\n mapie.fit(X_toy, y_toy)\n mapie.predict(X_toy)","def train_model():\n return model.fit(train_images, train_labels, epochs=10, validation_data=(test_images, test_labels), shuffle='True')","def predict_model(args):\n print(args)\n\n if args.cuda:\n print(\"=====> use gpu id: '{}'\".format(args.gpus))\n os.environ[\"CUDA_VISIBLE_DEVICES\"] = args.gpus\n if not torch.cuda.is_available():\n raise Exception(\"no GPU found or wrong gpu id, please run without --cuda\")\n\n # build the model\n model = build_model(args.model, num_classes=args.classes)\n\n if args.cuda:\n model = model.cuda() # using GPU for inference\n cudnn.benchmark = True\n\n if not os.path.exists(args.save_seg_dir):\n os.makedirs(args.save_seg_dir)\n\n # load the test set\n datas, testLoader = build_dataset_test(args.dataset, args.num_workers, none_gt=True)\n\n if args.checkpoint:\n if os.path.isfile(args.checkpoint):\n print(\"=====> loading checkpoint '{}'\".format(args.checkpoint))\n checkpoint = torch.load(args.checkpoint)\n model.load_state_dict(checkpoint['model'])\n # model.load_state_dict(convert_state_dict(checkpoint['model']))\n else:\n print(\"=====> no checkpoint found at '{}'\".format(args.checkpoint))\n raise FileNotFoundError(\"no checkpoint found at '{}'\".format(args.checkpoint))\n\n print(\"=====> beginning testing\")\n print(\"test set length: \", len(testLoader))\n predict(args, testLoader, model)","def make_predict_step(self):\n return self.make_eval_step()","def predict(self, X_test, **kwargs):\n\n # Normalize inputs\n if self.normalize_input:\n X_, _, _ = zero_mean_unit_var_normalization(X_test, self.X_mean, self.X_std)\n else:\n X_ = X_test\n\n # Sample a number of predictions for each given point\n # Generate mean and variance for each given point from sampled predictions\n\n X_ = torch.Tensor(X_)\n self.model.eval()\n Yt_hat = self.model(X_).data.cpu().numpy()\n\n if self.normalize_output:\n Yt_hat = zero_mean_unit_var_denormalization(Yt_hat, self.y_mean, self.y_std)\n\n logger.debug(f\"Generated final outputs array of shape {Yt_hat.shape}\")\n\n return Yt_hat","def sequence_predict(self, load_script=False, variant=\"predict\"):\n\n if variant != 'internal':\n # Open an existing model and get the input dataset. \n # Target for historical data are expected if using previous targets as a feature.\n request_data = self._get_model_and_data(ordered_data=True) \n if type(request_data) == list:\n X, y = request_data\n else:\n X = request_data\n else:\n X = self.X_test.copy()\n y = self.y_test.copy()\n\n # Scale the targets and increase stationarity if required\n if variant != 'internal' and self.model.lag_target and (self.model.scale_target or self.model.make_stationary):\n # If using differencing, we retain original y values for inversing the transformation later\n y_orig = y.values.ravel() if self.model.make_stationary=='difference' else None\n # Apply the transformer to the targets\n y = self.model.target_transformer.transform(y)\n # Drop samples where y cannot be transformed due to insufficient lags\n X = X.iloc[len(X)-len(y):]\n\n # Set the number of periods to be predicted\n prediction_periods = self.model.prediction_periods\n # Set the number of rows required for one prediction\n self.rows_per_pred = 1\n self.diff_lags = max(self.model.stationarity_lags) if self.model.lag_target and self.model.make_stationary=='difference' else 0\n # Set property depending on whether the current sample will be included as an input, or if we only use lag observations for predictions\n self.first_pred_modifier = 1 if self.model.current_sample_as_input else 0 \n\n # Check that the input data includes history to meet any lag calculation requirements\n if self.model.lags:\n # An additional lag observation is needed if previous targets are being added to the features\n self.rows_per_pred = self.model.lags+self.first_pred_modifier+1 if self.model.lag_target else self.model.lags+self.first_pred_modifier\n # If the target is being lagged and made stationary through differencing additional lag periods are required\n if self.model.lag_target and self.model.make_stationary=='difference':\n extra_msg = \" plus an additional {} periods for making the target stationary using differencing\".format(self.diff_lags)\n # For multi-step predictions we only expect lag values, not the current period's values\n # self.rows_per_pred = self.rows_per_pred-1 if prediction_periods > 1 else self.rows_per_pred\n assert len(X) >= self.rows_per_pred + self.diff_lags, \"Insufficient input data as the model requires {} lag periods for each prediction\".format(self.rows_per_pred) + extra_msg\n\n if variant != 'internal':\n # Prepare the response DataFrame\n # Initially set up with the 'model_name' and 'key' columns and the same index as request_df\n self.response = self.request_df.drop(columns=['n_features'])\n \n # Set up a list to contain predictions and probabilities if required\n predictions = []\n get_proba = False\n if variant == 'predict_proba':\n get_proba = True\n probabilities = [] \n\n # Refresh the keras model to avoid tensorflow errors\n if self.model.using_keras:\n self._keras_refresh()\n\n if prediction_periods > 1:\n if not self.model.lag_target:\n y = None\n\n # Check that we can generate 1 or more predictions of prediction_periods each\n n_samples = len(X)\n assert (n_samples - self.rows_per_pred) >= prediction_periods, \\\n \"Cannot generate predictions for {} periods with {} rows, with {} rows required for lag observations. You may need to provide more historical data or sufficient placeholder rows for future periods.\"\\\n .format(prediction_periods, n_samples, self.rows_per_pred)\n \n # For multi-step predictions we can add lag observations up front as we only use actual values\n # i.e. We don't use predicted y values for further predictions \n if self.model.lags or self.model.lag_target:\n X = self._add_lags(X, y=y, extrapolate=self.first_pred_modifier) \n\n # We start generating predictions from the first row as lags will already have been added to each sample\n start = 0\n else:\n # We start generating predictions from the point where we will have sufficient lag observations\n start = self.rows_per_pred\n \n if self.model.lag_target or prediction_periods > 1:\n # Get the predictions by walking forward over the data\n for i in range(start, len(X) + self.first_pred_modifier, prediction_periods): \n # For multi-step predictions we take in self.rows_per_pred rows of X to generate predictions for prediction_periods\n if prediction_periods > 1:\n batch_X = X.iloc[[i]]\n \n if not get_proba:\n # Get the prediction. \n pred = self.model.pipe.predict(batch_X)\n # Flatten the predictions for multi-step outputs and add to the list\n pred = pred.ravel().tolist()\n predictions += pred\n else:\n # Get the predicted probability for each sample \n proba = self.model.pipe.predict_proba(batch_X)\n proba = proba.reshape(-1, len(self.model.pipe.named_steps['estimator'].classes_))\n probabilities += proba.tolist()\n # For walk forward predictions with lag targets we use each prediction as input to the next prediction, with X values avaialble for future periods.\n else:\n batch_X = X.iloc[i-self.rows_per_pred : i] \n # Add lag observations\n batch_y = y.iloc[i-self.rows_per_pred : i]\n batch_X = self._add_lags(batch_X, y=batch_y, extrapolate=self.first_pred_modifier)\n\n # Get the prediction. We only get a prediction for the last sample in the batch, the remaining samples only being used to add lags.\n pred = self.model.pipe.predict(batch_X.iloc[[-1],:])\n\n # Add the prediction to the list. \n predictions.append(pred)\n \n # Add the prediction to y to be used as a lag target for the next prediction\n y.iloc[i - self.first_pred_modifier, 0] = pred\n\n # If probabilities need to be returned\n if get_proba:\n # Get the predicted probability for each sample \n probabilities.append(self.model.pipe.predict_proba(batch_X.iloc[[-1],:]))\n else:\n # Add lag observations to the samples if required\n if self.model.lags:\n X = self._add_lags(X, extrapolate=self.first_pred_modifier)\n\n # Get prediction for X\n predictions = self.model.pipe.predict(X)\n\n # If probabilities need to be returned\n if get_proba:\n # Get the predicted probability for each sample \n probabilities = self.model.pipe.predict_proba(X)\n \n # Set the number of placeholders needed in the response\n # These are samples for which predictions were not generated due to insufficient lag periods or for meeting multi-step prediction period requirements\n self.placeholders = self.rows_per_pred + self.diff_lags - self.first_pred_modifier\n\n # Transform probabilities to a readable string\n if get_proba:\n # Add the required number of placeholders at the start of the response list\n y = [\"\\x00\"] * self.placeholders\n \n # Truncate multi-step predictions if the (number of samples - self.rows_per_pred) is not a multiple of prediction_periods\n if prediction_periods > 1 and ((n_samples-self.rows_per_pred) % prediction_periods) > 0: \n probabilities = probabilities[:-len(probabilities)+(n_samples-self.rows_per_pred)]\n \n for a in probabilities:\n s = \"\"\n i = 0\n for b in a:\n s = s + \", {0}: {1:.3f}\".format(self.model.pipe.named_steps['estimator'].classes_[i], b)\n i += 1\n y.append(s[2:])\n\n # Prepare predictions\n else:\n if prediction_periods > 1:\n # Set the value to use for nulls\n null = np.NaN if is_numeric_dtype(np.array(predictions)) else \"\\x00\"\n\n # Truncate multi-step predictions if the (number of samples - self.placeholders) is not a multiple of prediction_periods\n if (n_samples-self.rows_per_pred) % prediction_periods > 0:\n predictions = predictions[:-len(predictions)+(n_samples-self.rows_per_pred)]\n\n # Add null values at the start of the response list to match the cardinality of the input from Qlik\n y = np.array(([null] * (self.rows_per_pred - self.first_pred_modifier)) + predictions)\n elif self.model.lag_target: \n # Remove actual values for which we did not generate predictions due to insufficient lags\n if is_numeric_dtype(y.iloc[:, 0].dtype):\n y.iloc[:self.placeholders - self.first_pred_modifier, 0] = np.NaN\n else:\n y.iloc[:self.placeholders - self.first_pred_modifier, 0] = \"\\x00\"\n # Flatten y to the expected 1D shape\n y = y.values.ravel()\n else:\n y = np.array(predictions)\n \n # Inverse transformations on the targets if required \n if variant != 'internal' and (self.model.scale_target or self.model.make_stationary):\n # Take out placeholder values before inverse transform of targets\n null_values = y[:self.rows_per_pred - self.first_pred_modifier] if prediction_periods > 1 or self.model.lag_target else []\n # Add placeholders for samples removed during differencing\n if self.model.make_stationary=='difference':\n null_values = np.append(null_values, np.repeat(null_values[0], self.diff_lags))\n y = y if len(null_values) == 0 else y[-len(predictions):]\n # Add untransformed lag values for differencing if required\n end = self.placeholders\n start = end - self.diff_lags\n y = y if y_orig is None else np.append(y_orig[start : end], y)\n\n # Apply the transformer to the test targets\n y = self.model.target_transformer.inverse_transform(y) \n\n # Remove lags used for making the series stationary in case of differencing\n if self.model.make_stationary == 'difference':\n y = y[self.diff_lags:]\n\n # Replace lags used for making the series stationary with nulls in case of differencing\n # if self.model.make_stationary == 'difference':\n #null = np.NaN if is_numeric_dtype(np.array(predictions)) else \"\\x00\"\n # y = np.append(np.array([null]*self.diff_lags), y[self.diff_lags:])\n \n # Add back the placeholders for lag values\n if len(null_values) > 0:\n y = np.append(null_values, y)\n \n if variant == 'internal':\n return y\n\n # Add predictions / probabilities to the response\n self.response['result'] = y\n\n # Reindex the response to reset to the original sort order\n self.response = self.response.reindex(self.original_index)\n \n if load_script:\n # If the function was called through the load script we return a Data Frame\n self._send_table_description(\"predict\")\n \n # Debug information is printed to the terminal and logs if the paramater debug = true\n if self.model.debug:\n self._print_log(4)\n \n return self.response\n \n # If the function was called through a chart expression we return a Series\n else:\n # Debug information is printed to the terminal and logs if the paramater debug = true\n if self.model.debug:\n self._print_log(4)\n \n return self.response.loc[:,'result']","def predict(self, instances):\r\n raise NotImplementedError","def predict(self, num_samples = BATCH_SIZE, display_predictions = True):\n if self.model is None:\n raise Exception(\"Model is empty, either build or load it\")\n\n print(\"==> Prediction on model from\", self.model_dir)\n file_names, file_labels = self.get_sample_files(num_samples)\n self.predict_dataset = tf.data.Dataset.from_tensor_slices((file_names, file_labels))\n self.predict_dataset = self.predict_dataset.map(self.map_fn, num_parallel_calls=AUTOTUNE)\n self.predict_dataset = self.predict_dataset.batch(BATCH_SIZE)\n\n self.predictions = self.model.predict(self.predict_dataset)\n\n if display_predictions:\n self.display_predictions()","def save_predictions(model, dataset, output_dir):\n preds = model.predict(dataset, verbose=1)\n preds = scipy.special.softmax(preds, 1) # Apply softmax\n with tf.io.gfile.GFile(os.path.join(output_dir, 'test_preds.pkl'), 'wb') as f:\n pickle.dump(preds, f)","def predict(self, inputs):\n\n return self.model.predict(inputs)","def predict_and_evaluate(config, workdir, ckpt_path=None):\n logging.info('Starting testing at %s', workdir)\n tf.io.gfile.makedirs(workdir)\n\n rng = jax.random.PRNGKey(config.seed)\n # Build input pipeline.\n rng, data_rng = jax.random.split(rng)\n data_rng = jax.random.fold_in(data_rng, jax.process_index())\n test_ds = []\n for split in config.dataset.test_splits:\n ds = input_pipeline.create_val_dataset(\n config.dataset, split, config.dataset.test_per_device_batch_size,\n config.dataset.test_pad_last_batch)\n test_ds.append(ds)\n\n # Initialize model.\n inputs = train_utils.get_init_inputs(test_ds[0])\n rng, model_rng = jax.random.split(rng)\n predict_config = models.TransformerConfig(**config.model.to_dict())\n predict_config = predict_config.replace(decode=True)\n model = models.Model(predict_config)\n state = train_utils.create_train_state(\n model, config, model_rng, inputs=inputs)\n\n writer = metric_writers.create_default_writer(\n workdir, just_logging=jax.process_index() > 0)\n\n # Set up checkpointing of the model and the input pipeline.\n checkpoint_dir = os.path.join(workdir, 'checkpoints')\n ckpt = checkpoint.MultihostCheckpoint(checkpoint_dir, max_to_keep=3)\n\n logging.info('Testing and evaluating checkpoint %s', ckpt_path)\n try:\n state = ckpt.restore(state, ckpt_path)\n except FileNotFoundError:\n state = ckpt.restore_or_initialize(state)\n step = int(state.step)\n\n p_pred_step = jax.pmap(\n functools.partial(predict_step, config=predict_config),\n axis_name='batch',\n static_broadcasted_argnums=(3,))\n p_init_cache = jax.pmap(\n functools.partial(init_cache, config=predict_config), axis_name='batch')\n\n # Distribute testing.\n state = flax_utils.replicate(state)\n with metric_writers.ensure_flushes(writer):\n test_metrics = {}\n for ds, split in zip(test_ds, config.dataset.test_splits):\n ds_metrics = evaluate_sequence_accuracy(p_pred_step, p_init_cache, state,\n ds, config, split, workdir,\n config.num_test_steps)\n ds_metrics = {f'{k}_{split}': v for k, v in ds_metrics.items()}\n test_metrics.update(ds_metrics)\n writer.write_scalars(step, test_metrics)","def postprocess_model_outputs(self, predictions, expected):\n\n for key, val in predictions.items():\n predictions[key] = val.numpy()\n\n for key, val in expected.items():\n expected[key] = val.numpy()\n\n return predictions, expected","def predict(self, X_test):\n\n # Predict Label 0\n i = 0\n X = X_test\n\n # Retrieve trained classifier for label 0\n clf = self.trained[i]\n\n # Make prediction\n y = clf.predict(X)\n result = np.zeros((X_test.shape[0], self.label_dim))\n\n result[:, i] = y\n\n # Concatenate result to X\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\"csr\")\n\n # iterator = tqdm.trange(1, self.label_dim)\n iterator = range(1, self.label_dim)\n for i in iterator:\n # Predict Label i\n\n # Retrieve trained classifier for label i\n clf = self.trained[i]\n\n # Make prediction\n y = clf.predict(X)\n\n result[:, i] = y\n\n # Concatenate result to X\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\"csr\")\n\n return result","def predict(self, testloader, field=None):\n model_name = str(field).lower()\n\n assert field == HOME or field == AWAY, 'ERROR - model predict: WRONG model name. Give \"home\" or \"away\"'\n\n preds = {}\n\n for i, model in enumerate(self.models):\n if (model_name == HOME):\n # logger.info('> Calling Home Network')\n field_net = model.model.home_network\n elif (model_name == AWAY):\n # logger.info('> Calling Away Network')\n field_net = model.model.away_network\n else:\n raise ValueError('Model - predict: Wrong model name')\n\n model_preds = []\n with torch.no_grad():\n\n for x in testloader:\n x = torch.Tensor(x).to(self.device)\n out = field_net(x)\n\n out = out.squeeze()\n\n model_preds.append(out.item())\n\n preds[i] = model_preds\n\n return preds[i]"],"string":"[\n \"def generate_original_preds(train = True):\\n x_train, y_train, x_val, y_val, id_to_word = load_data() \\n model = create_original_model()\\n\\n if train:\\n filepath=\\\"models/original.hdf5\\\"\\n checkpoint = ModelCheckpoint(filepath, monitor='val_acc', \\n verbose=1, save_best_only=True, mode='max')\\n callbacks_list = [checkpoint]\\n model.fit(x_train, y_train, validation_data=(x_val, y_val),callbacks = callbacks_list, epochs=epochs, batch_size=batch_size)\\n\\n model.load_weights('./models/original.hdf5', \\n by_name=True) \\n\\n pred_train = model.predict(x_train,verbose = 1, batch_size = 1000)\\n pred_val = model.predict(x_val,verbose = 1, batch_size = 1000)\\n if not train:\\n print('The val accuracy is {}'.format(calculate_acc(pred_val,y_val)))\\n print('The train accuracy is {}'.format(calculate_acc(pred_train,y_train)))\\n\\n\\n np.save('data/pred_train.npy', pred_train)\\n np.save('data/pred_val.npy', pred_val)\",\n \"def fit_predict(self):\\n self.classifier = self.model\\n self.classifier.fit(self.X_sample, self.y_sample)\\n self.y_pred = self.classifier.predict(self.X_test)\",\n \"def get_predictions(fitted_model_filename):\\n click.echo(\\\"Mode: predicting probabilities.\\\\n\\\")\\n defaults = get_defaults()\\n\\n fitted_model_filename = add_extension(fitted_model_filename)\\n fitted_model_path = os.path.join(defaults.OUTPUT.FITTED_MODELS_PATH, fitted_model_filename)\\n new_options = [\\\"OUTPUT.FITTED_MODEL_PATH\\\", fitted_model_path]\\n\\n # boot_data = bootstrap(new_options, mode=\\\"internal_test\\\")\\n # model = boot_data['model']\\n #\\n # X_test_int, y_test_int = boot_data['data']\\n # internal_test_proba = model.predict_proba(X_test_int)\\n # internal_test_proba = np.c_[y_test_int, internal_test_proba[:, 1]]\\n\\n boot_data = bootstrap(new_options, mode=\\\"external_test\\\")\\n model = boot_data['model']\\n X_test_ext, y_test_ext = boot_data['data']\\n\\n # fit scaler on train data and transform test data\\n scaler = StandardScaler()\\n X_train, y_train = load_data(defaults, which='train')\\n\\n numeric_cols = X_train.select_dtypes(include=np.float64).columns.tolist()\\n scaler.fit(X_train[numeric_cols])\\n X_test_ext.loc[:, numeric_cols] = scaler.transform(X_test_ext[numeric_cols])\\n\\n external_test_proba = model.predict_proba(X_test_ext)\\n external_test_proba = np.c_[y_test_ext, external_test_proba[:, 1]]\\n\\n # internal_test_results_path = os.path.join(defaults.OUTPUT.PREDS_PATH, \\\"internal_test_preds.csv\\\")\\n external_test_results_path = os.path.join(defaults.OUTPUT.PREDS_PATH,\\n f\\\"external_test_preds_{fitted_model_filename.replace('.pkl', '')}.csv\\\")\\n # pd.DataFrame(internal_test_proba, columns=['target', 'proba']).to_csv(internal_test_results_path, index=False)\\n pd.DataFrame(external_test_proba, columns=['target', 'proba']).to_csv(external_test_results_path, index=False)\",\n \"def make_prediction(x_train, y_train, x_test, model):\\n model.fit(x_train, y_train)\\n y_predict = model.predict(x_test)\\n return y_predict\",\n \"def predict(self):\\n batch = get_predict_batch(1, num_rec_out=self.num_test_rec)\\n self.g_model.test_batch(\\n batch, self.global_step, num_rec_out=self.num_test_rec)\",\n \"def predict(self, test_batch_size=64, device='cuda', load=False, model_path=None, dataloader_num_workers=4, save_prediction=True):\\n self.model.eval()\\n self.device = device\\n self.test_batch_size = test_batch_size\\n if load:\\n if model_path:\\n self.load(model_path, device=self.device)\\n else:\\n model_path = os.path.join(path_checkpoints_dir, f\\\"{self.experiment_id}.pth\\\")\\n print(f\\\"loaded model={model_path}\\\")\\n self.load(model_path, device=self.device)\\n if self.model is None:\\n raise Exception(\\\"model cannot be None. Load or train the model before inference\\\")\\n dataloader = self.data_module.get_test_dataloader(batch_size=self.test_batch_size, shuffle=False, num_workers=dataloader_num_workers)\\n all_outputs = []\\n tk0 = tqdm(enumerate(dataloader, 1), total=len(dataloader))\\n for batch_id, data in tk0:\\n for key, value in data.items():\\n data[key] = value.to(self.device)\\n # batch_outputs, batch_loss = self.model(**data)\\n batch_outputs, batch_loss= self.validate_one_batch(data)\\n all_outputs.append(batch_outputs.detach().cpu().numpy())\\n predictions = np.concatenate(all_outputs, axis=0)\\n if save_prediction:\\n submission = pd.read_csv(path_sample_submission_file)\\n assert submission.shape[0] == predictions.shape[0], \\\"unexpected behavior.code fix required\\\"\\n submission.iloc[:, 1:] = predictions\\n\\n if not os.path.isdir(path_submissions_dir):\\n os.mkdir(path_submissions_dir)\\n submission.to_csv(os.path.join(path_submissions_dir, f\\\"{self.experiment_id}.csv\\\"), index=False)\\n tk0.close()\\n return predictions\",\n \"def _predict(self, test_dl: torch.utils.data.DataLoader) -> torch.Tensor:\\n\\n # Initialize an empty tensor to store the predicted output\\n output = torch.tensor([]).to(cfg.training.device)\\n # Set the model to evaluation mode (disables gradient computation and dropout)\\n self.eval()\\n # Disable gradient tracking for efficiency\\n with torch.no_grad():\\n # Iterate over the test data loader\\n for x_batch in test_dl:\\n # Move the batch to the appropriate device\\n x_batch = x_batch.to(cfg.training.device)\\n # Forward pass to obtain model predictions\\n y_star = self.forward(x_batch)\\n # Concatenate the predictions to the output tensor\\n output = torch.cat((output, y_star), 0)\\n\\n # Return the tensor containing the predicted output\\n return output\",\n \"def predict(model, X_testing):\\n predictions = model.predict(X_testing)\\n\\n return predictions\",\n \"def predict(self):\\n self.predicted_test_summary = []\\n for step in xrange(0, self.test_size // self.test_batch_size):\\n print 'Predicting Batch No.:', step\\n offset = (step * self.test_batch_size) % self.test_size\\n batch_data_fwd = self.X_tst_fwd[offset:(offset + self.test_batch_size), :].T\\n batch_data_bwd = self.X_tst_bwd[offset:(offset + self.test_batch_size), :].T\\n summary_test_out = self._predict_batch(batch_data_fwd, batch_data_bwd)\\n self.predicted_test_summary.extend(summary_test_out)\\n\\n print 'Prediction Complete. Moving Forward..'\\n\\n # test answers\\n self.test_review = self.X_tst_fwd\\n self.predicted_test_summary = self.predicted_test_summary\\n self.true_summary = self.Y_tst\",\n \"def predict(self): \\n return self.model.predict(self.test_x)\",\n \"def test(self) -> None:\\n\\n self._predictions = self._lr.predict(self._X_test)\",\n \"def predict(self, x_test, y_test, model_path):\\n tf.reset_default_graph()\\n with tf.compat.v1.Session() as sess:\\n saver = tf.compat.v1.train.import_meta_graph(model_path + \\\".meta\\\")\\n saver.restore(sess, model_path)\\n graph = tf.compat.v1.get_default_graph()\\n x = graph.get_operation_by_name(\\\"x_input\\\").outputs[0]\\n y = tf.compat.v1.get_collection(\\\"network_architecture\\\")[0]\\n no_samples = x_test.shape[0]\\n predictions = []\\n n_iteration = no_samples // self.batch_size\\n for step in range(n_iteration):\\n x_batch, y_batch = get_batch_data(x_test, y_test, iter_step=step, batch_size=self.batch_size)\\n preds = sess.run(y, feed_dict={x: x_batch})\\n predictions.append(preds)\\n return predictions\",\n \"def predict():\\n\\n predict_cfg = get_predict_args()\\n device = get_device()\\n print(device)\\n\\n # load checkpoint\\n ckpt_path = find_ckpt_in_directory(predict_cfg.ckpt)\\n ckpt = torch.load(ckpt_path, map_location=device)\\n best_iter = ckpt[\\\"best_iter\\\"]\\n cfg = ckpt[\\\"cfg\\\"]\\n aspect = cfg[\\\"aspect\\\"]\\n\\n for k, v in cfg.items():\\n print(\\\"{:20} : {:10}\\\".format(k, str(v)))\\n\\n eval_batch_size = 64\\n\\n print(\\\"Loading data\\\")\\n dev_data = list(beer_reader(cfg[\\\"dev_path\\\"]))\\n test_data = beer_annotations_reader(cfg[\\\"test_path\\\"], aspect=aspect)\\n\\n print(\\\"dev\\\", len(dev_data))\\n print(\\\"test\\\", len(test_data))\\n\\n print(\\\"Loading pre-trained word embeddings\\\")\\n vocab = Vocabulary()\\n vectors = load_embeddings(cfg[\\\"embeddings\\\"], vocab) # required for vocab\\n\\n # build model\\n model = build_model(cfg[\\\"model\\\"], vocab, cfg=cfg)\\n\\n # load parameters from checkpoint into model\\n print(\\\"Loading saved model..\\\")\\n model.load_state_dict(ckpt[\\\"state_dict\\\"])\\n model.to(device)\\n print(\\\"Done\\\")\\n\\n print(model)\\n print_parameters(model)\\n\\n print(\\\"Evaluating\\\")\\n dev_eval = evaluate_loss(\\n model, dev_data, batch_size=eval_batch_size,\\n device=device, cfg=cfg)\\n test_eval = evaluate_loss(\\n model, test_data, batch_size=eval_batch_size,\\n device=device, cfg=cfg)\\n\\n if hasattr(model, \\\"z\\\"):\\n path = os.path.join(\\n cfg[\\\"save_path\\\"], \\\"final_rationales.txt\\\")\\n test_precision, test_macro_prec = evaluate_rationale(\\n model, test_data, aspect=aspect, device=device,\\n batch_size=eval_batch_size, path=path)\\n else:\\n test_precision = 0.\\n test_macro_prec = 0.\\n test_eval[\\\"precision\\\"] = test_precision\\n test_eval[\\\"macro_precision\\\"] = test_macro_prec\\n\\n dev_s = make_kv_string(dev_eval)\\n test_s = make_kv_string(test_eval)\\n\\n print(\\\"best model iter {:d} dev {} test {}\\\".format(\\n best_iter, dev_s, test_s))\",\n \"def fit_and_get_test_predictions(self, trace, tuning=True):\\n pass\",\n \"def predict(self, data, verbose=0):\\n\\n if self.model is None:\\n raise StandardError('Model is not built. Run build method or load model before fitting')\\n return self.model.predict(data, 1, verbose) # ,steps)\",\n \"def predict(self, data, verbose=0):\\n\\n if self.model is None:\\n raise StandardError('Model is not built. Run build method or load model before fitting')\\n return self.model.predict(data, 1, verbose) # ,steps)\",\n \"def predict(self, test_dataset: Dataset) -> PredictionOutput:\\n test_dataloader = self.get_test_dataloader(test_dataset)\\n return self._prediction_loop(test_dataloader, description=\\\"Prediction\\\")\",\n \"def predict(self, model, x_test):\\n pass\",\n \"def trainAndPredict(self):\\r\\n print(\\\"train\\\")\\r\\n filename= 'finalized_model.sav'\\r\\n # train the algorithm on training data and predict using the testing data\\r\\n model = self.svc_model.fit(self.X.T, self.Y)\\r\\n pickle.dump(model, open(filename, 'wb'))\\r\\n #model = pickle.load(open(filename, 'rb'))\\r\\n pred1 =model.predict(self.TestSet.T)\\r\\n # print the accuracy score of the model\\r\\n print(\\\"LinearSVC accuracy : \\\", accuracy_score(self.TestSetY, pred1, normalize=True))\",\n \"def predict(self, X_test):\\n return self.model.predict(X_test)\",\n \"def _fit_predict(X_train, y_train, X_test):\\n raise NotImplementedError()\",\n \"def predict(config: Config, device: torch.device, resume: Optional[ResumeInfo]) -> None:\\n # pylint: disable=too-many-locals\\n # Load datasets\\n print(colored(\\\"loading training datasets:\\\", attrs=[\\\"bold\\\"]))\\n dataset_factory = DatasetFactory()\\n datasets, preprocessors = dataset_factory.create(config)\\n print(f\\\"train: {len(datasets.train)}\\\")\\n print(f\\\"val: {len(datasets.val)}\\\")\\n print(f\\\"test: {len(datasets.test)}\\\")\\n\\n print(colored(\\\"saving question ids:\\\", attrs=[\\\"bold\\\"]))\\n split_map = {\\n \\\"train\\\": (config.training.data.train, datasets.train),\\n \\\"val\\\": (config.training.data.val, datasets.val),\\n \\\"test\\\": (config.training.data.test, datasets.test),\\n }\\n for split, (dataconfig, dataset) in split_map.items():\\n root = Path(wandb.run.dir) / \\\"predictions\\\"\\n if not root.exists():\\n root.mkdir(parents=True)\\n path = root / f\\\"{split}_ids.json\\\"\\n start = int(dataconfig.subset[0] * len(dataset))\\n end = int(dataconfig.subset[1] * len(dataset))\\n subset = torch.utils.data.Subset(dataset, range(start, end))\\n ids = [subset[i][\\\"question\\\"][\\\"questionId\\\"] for i in range(len(subset))]\\n with open(path, \\\"w\\\") as file:\\n json.dump(ids, file)\\n\\n # Create model runner\\n print(colored(\\\"model:\\\", attrs=[\\\"bold\\\"]))\\n runner_factory = RunnerFactory()\\n runner = runner_factory.create(config, device, preprocessors, datasets, resume)\\n print(f\\\"{runner.model=}\\\")\\n\\n print(colored(\\\"loading prediction datasets:\\\", attrs=[\\\"bold\\\"]))\\n dataset_factory = DatasetFactory(training=False)\\n datasets, pred_preprocessors = dataset_factory.create(config)\\n print(f\\\"train: {len(datasets.train)}\\\")\\n print(f\\\"val: {len(datasets.val)}\\\")\\n print(f\\\"test: {len(datasets.test)}\\\")\\n\\n # Extend question embedding dictionary with pad vector for OOV.\\n # The runner will check if a question token index is out of bounds and\\n # set it to the padding index if so.\\n runner.model.question_embeddings = torch.nn.Embedding.from_pretrained(\\n torch.cat(\\n (\\n runner.model.question_embeddings.weight.data,\\n torch.zeros(\\n (\\n len(pred_preprocessors.questions.index_to_word)\\n - runner.model.question_embeddings.num_embeddings,\\n runner.model.question_embeddings.embedding_dim,\\n )\\n ).to(device),\\n ),\\n dim=0,\\n )\\n )\\n # Update datasets and preprocessors for prediction\\n runner.datasets = datasets\\n runner.preprocessors = pred_preprocessors\\n\\n print(colored(\\\"predicting:\\\", attrs=[\\\"bold\\\"]))\\n runner.predict()\",\n \"def train_predict(descriptions_models,\\n X_train, y_train,\\n X_valid, y_valid,\\n scoring=None):\\n\\n results = []\\n for description, model in descriptions_models:\\n\\n scorer = check_scoring(model, scoring=scoring)\\n result = {'description': description}\\n\\n # Train\\n start = time.time()\\n model.fit(X_train, y_train)\\n result['time_train'] = time.time() - start\\n\\n # Predict train\\n start = time.time()\\n result['score_train'] = scorer(model, X_train, y_train)\\n result['time_predict_train'] = time.time() - start\\n\\n # Predict validation\\n start = time.time()\\n result['score_valid'] = scorer(model, X_valid, y_valid)\\n result['time_predict_valid'] = time.time() - start\\n\\n results.append(result)\\n\\n return pd.DataFrame(results)[[\\n 'description', 'score_train', 'score_valid',\\n 'time_train', 'time_predict_train', 'time_predict_valid']]\",\n \"def fit_and_predict(self, X_train, y_train, X_test, y_test):\\n if self.feature_transform_func:\\n X_train, X_test = self.feature_transform_func(X_train, X_test)\\n\\n self.fit(X_train, y_train)\\n y_predict = self.predict(X_test)\\n return self.Acu_eval(y_predict, y_test)\",\n \"def after_pred(self):\\n # If training then skip\\n if self.training:\\n return\\n\\n # Get ground truths in epoch 0 i.e. start of training\\n if self.epoch == 0:\\n self.y_true.extend(self.y.cpu().flatten().numpy())\\n\\n # Get predictions from each batch and add them to prediction container\\n y_pred = self.pred.detach().cpu()\\n \\n self.y_pred.extend(y_pred.flatten().numpy())\",\n \"def predict(self, test_data):\\n return self.leader.predict(test_data)\",\n \"def make_predictions(self):\\n if is_classification(self.model):\\n if self.ct == None:\\n prediction = self.model.predict(self.input_data.to_numpy())\\n probabilities = self.model.predict_proba(self.input_data.to_numpy())\\n return prediction, probabilities\\n elif self.ct != None: \\n prediction = self.model.predict(self.data_into_model())\\n probabilities = self.model.predict_proba(self.data_into_model())\\n return prediction, probabilities\\n else:\\n raise Exception((\\\"{} not supported. Please create an issue on Github\\\").format(self.model))\\n \\n else:\\n if self.ct == None:\\n prediction = self.model.predict(self.input_data)\\n return prediction\\n elif self.ct != None: \\n prediction = self.model.predict(self.data_into_model())\\n return prediction\\n else:\\n raise Exception((\\\"{} not supported. Please create an issue on Github\\\").format(self.self.model))\",\n \"def predict(self, test_data):\\n random.seed(self.seed)\\n preds = [{\\\"id\\\": instance['id'], \\\"prediction\\\": random.choice([0, 1])} for instance in test_data]\\n return preds\",\n \"def make_predictions(self):\\n \\n self.Y = self.X.dot(self.w)\",\n \"def predict(self):\\n path = self._artifact_repo.artifact_path(self._ARTIFACT_MODEL)\\n model = tf.keras.models.load_model(path)\\n\\n _, _, x_test, y_test = self._load_data()\\n x_test = tf.keras.utils.normalize(x_test, axis=1)\\n\\n preds = model.predict(x_test)\\n self._show_cf_matrix(np.array([np.argmax(probas) for probas in preds]), y_test)\",\n \"def get_initial_predictions(tuner, input_data, output_path, model_save_name):\\n\\n best_model = tuner.best_estimator()\\n batch_job = best_model.transformer(1, \\\"ml.m5.large\\\", output_path=output_path.as_uri(),\\n model_name=model_save_name)\\n batch_job.transform(input_data.as_uri())\\n # TODO: Do an ls first so we can get any/all files\\n output_file = output_path / 'validation.csv.out'\\n with smart.open(output_file.as_uri(), 'r', transport_params={'session': boto_session}) as f:\\n predictions = pd.read_csv(f, header=None)\\n return predictions\",\n \"def predict(trained_model, X_test, y_test, image_name):\\n if MODEL == 1:\\n return predict_1(trained_model, X_test, y_test)\\n elif MODEL == 3:\\n if CROSS_VALIDATION:\\n return cv_predict_3(trained_model, X_test, y_test)\\n else:\\n return predict_3(trained_model, X_test, y_test, image_name)\\n elif MODEL == 2:\\n return predict_2(trained_model, X_test, y_test)\\n else:\\n # For models 4, 5 and 6\\n return predict_4(trained_model, X_test, y_test)\",\n \"def predict(self, test_data):\\r\\n return self.gs.predict(test_data)\",\n \"def fit_predict_model(self, X_train, y_train, X_test, pipeline):\\n\\n pipeline.fit(X_train, y_train)\\n y_pred = pipeline.predict(X_test)\\n return y_pred\",\n \"def test():\\n # load dataset and model\\n X, observed_y = load_data('../data/dev.txt')\\n\\n model = pickle.load(open('test.model', 'rb'))\\n model.traverse()\\n\\n # predict labels for dataset\\n preds = model.predict(X)\\n\\n # print(preds)\\n # output model predictions\\n np.savetxt('test.predictions', preds, fmt='%s')\",\n \"def _predict_preproc_model(self, model_cfg, model,):\\n model = self._make_model(model_cfg['model_name'], databunch=self._data)\\n model.model_param = model_cfg['model_param']\\n model.wrapper_params = model_cfg['wrapper_params']\\n return(model)\",\n \"def predict(self, scenes, tmp_dir):\\n self.backend.load_model(tmp_dir)\\n\\n for scene in scenes:\\n with scene.activate():\\n labels = self.predict_scene(scene, tmp_dir)\\n label_store = scene.prediction_label_store\\n label_store.save(labels)\\n\\n if self.config.debug and self.config.predict_debug_uri:\\n self.save_debug_predict_image(\\n scene, self.config.predict_debug_uri)\",\n \"def predict_1(trained_model, X_test, y_test):\\n # Predict with test data\\n start_time = timeit.default_timer()\\n test_prediction = trained_model.predict(X_test)\\n end_time = timeit.default_timer()\\n time = end_time - start_time\\n speed = int(X_test.shape[0] / time)\\n \\n # Get loss and accuracy\\n test_loss, test_accuracy = trained_model.evaluate(X_test, y_test)\\n \\n # Prepare results messages\\n msg_time = \\\"prediction time: {:.3f}s ({}px/s)\\\\n\\\".format(time, speed)\\n msg_test_loss = \\\"test_loss: {:.3f}\\\\n\\\".format(test_loss)\\n msg_test_acc = \\\"test_accuracy: {:.3f}\\\\n\\\\n\\\".format(test_accuracy)\\n \\n # Write results messages\\n with open(OUTPUT_FILE, 'a') as f:\\n f.write(msg_time)\\n f.write(msg_test_loss)\\n f.write(msg_test_acc)\",\n \"def predict(self, test_inputs, batch_size=None):\\n if batch_size is None:\\n num_batches = 1\\n else:\\n num_batches = util.ceil_divide(test_inputs.shape[0], batch_size)\\n\\n test_inputs = np.array_split(test_inputs, num_batches)\\n pred_means = util.init_list(0.0, [num_batches])\\n pred_vars = util.init_list(0.0, [num_batches])\\n for i in range(num_batches):\\n pred_means[i], pred_vars[i] = self.session.run(\\n self.predictions, feed_dict={self.test_inputs: test_inputs[i]})\\n\\n return np.concatenate(pred_means, axis=0), np.concatenate(pred_vars, axis=0)\",\n \"def _predict(self, dataset):\\n binary_predictions = ProxyClassifier._predict(self, dataset)\\n self.ca.estimates = binary_predictions\\n predictions = [ {-1: self.__predictneg,\\n +1: self.__predictpos}[x] for x in binary_predictions]\\n self.ca.predictions = predictions\\n return predictions\",\n \"def predict(self, epochs): # noqa\\n\\n # Check that classifier has predict_method (e.g. predict_proba is not\\n # always available):\\n if not hasattr(self.clf, self.predict_method):\\n raise NotImplementedError('%s does not have \\\"%s\\\"' % (\\n self.clf, self.predict_method))\\n\\n # Check that at least one classifier has been trained\\n if not hasattr(self, 'estimators_'):\\n raise RuntimeError('Please fit models before trying to predict')\\n\\n # Check predict mode\\n if self.predict_mode not in ['cross-validation', 'mean-prediction']:\\n raise ValueError('predict_mode must be a str, \\\"mean-prediction\\\" '\\n 'or \\\"cross-validation\\\"')\\n\\n # Check that training cv and predicting cv match\\n if self.predict_mode == 'cross-validation':\\n n_est_cv = [len(estimator) for estimator in self.estimators_]\\n heterogeneous_cv = len(set(n_est_cv)) != 1\\n mismatch_cv = n_est_cv[0] != len(self._cv_splits)\\n mismatch_y = len(self.y_train_) != len(epochs)\\n if heterogeneous_cv or mismatch_cv or mismatch_y:\\n raise ValueError(\\n 'When predict_mode = \\\"cross-validation\\\", the training '\\n 'and predicting cv schemes must be identical.')\\n\\n # Clean attributes\\n for att in ['y_pred_', 'test_times_', 'scores_', 'scorer_', 'y_true_']:\\n if hasattr(self, att):\\n delattr(self, att)\\n _warn_once.clear() # reset self-baked warning tracker\\n\\n X, y, _ = _check_epochs_input(epochs, None, self.picks_)\\n\\n if not np.all([len(test) for train, test in self._cv_splits]):\\n warn('Some folds do not have any test epochs.')\\n\\n # Define testing sliding window\\n if self.test_times == 'diagonal':\\n test_times = _DecodingTime()\\n test_times['slices'] = [[s] for s in self.train_times_['slices']]\\n test_times['times'] = [[s] for s in self.train_times_['times']]\\n elif isinstance(self.test_times, dict):\\n test_times = copy.deepcopy(self.test_times)\\n else:\\n raise ValueError('test_times must be a dict or \\\"diagonal\\\"')\\n\\n if 'slices' not in test_times:\\n if 'length' not in self.train_times_.keys():\\n ValueError('Need test_times[\\\"slices\\\"] with adhoc train_times.')\\n # Check that same number of time sample in testing than in training\\n # (otherwise it won 't be the same number of features')\\n test_times['length'] = test_times.get('length',\\n self.train_times_['length'])\\n # Make a sliding window for each training time.\\n slices_list = list()\\n for _ in range(len(self.train_times_['slices'])):\\n test_times_ = _sliding_window(epochs.times, test_times,\\n epochs.info['sfreq'])\\n slices_list += [test_times_['slices']]\\n test_times = test_times_\\n test_times['slices'] = slices_list\\n test_times['times'] = [_set_window_time(test, epochs.times)\\n for test in test_times['slices']]\\n\\n for train, tests in zip(self.train_times_['slices'],\\n test_times['slices']):\\n # The user may define irregular timing. We thus need to ensure\\n # that the dimensionality of each estimator (i.e. training\\n # time) corresponds to the dimensionality of each testing time)\\n if not np.all([len(test) == len(train) for test in tests]):\\n raise ValueError('train_times and test_times must '\\n 'have identical lengths')\\n\\n # Store all testing times parameters\\n self.test_times_ = test_times\\n\\n n_orig_epochs, _, n_times = X.shape\\n\\n # Subselects the to-be-predicted epochs so as to manipulate a\\n # contiguous array X by using slices rather than indices.\\n test_epochs = []\\n if self.predict_mode == 'cross-validation':\\n test_idxs = [ii for train, test in self._cv_splits for ii in test]\\n start = 0\\n for _, test in self._cv_splits:\\n n_test_epochs = len(test)\\n stop = start + n_test_epochs\\n test_epochs.append(slice(start, stop, 1))\\n start += n_test_epochs\\n X = X[test_idxs]\\n\\n # Prepare parallel predictions across testing time points\\n # FIXME Note that this means that TimeDecoding.predict isn't parallel\\n parallel, p_func, n_jobs = parallel_func(_predict_slices, self.n_jobs)\\n n_test_slice = max(len(sl) for sl in self.test_times_['slices'])\\n # Loop across estimators (i.e. training times)\\n n_chunks = min(n_test_slice, n_jobs)\\n chunks = [np.array_split(slices, n_chunks)\\n for slices in self.test_times_['slices']]\\n chunks = map(list, zip(*chunks))\\n\\n # To minimize memory during parallelization, we apply some chunking\\n y_pred = parallel(p_func(\\n estimators=self.estimators_, cv_splits=self._cv_splits,\\n predict_mode=self.predict_mode, predict_method=self.predict_method,\\n n_orig_epochs=n_orig_epochs, test_epochs=test_epochs,\\n **dict(zip(['X', 'train_times'], _chunk_data(X, chunk))))\\n for chunk in chunks)\\n\\n # Concatenate chunks across test time dimension.\\n n_tests = [len(sl) for sl in self.test_times_['slices']]\\n if len(set(n_tests)) == 1: # does GAT deal with a regular array/matrix\\n self.y_pred_ = np.concatenate(y_pred, axis=1)\\n else:\\n # Non regular testing times, y_pred is an array of arrays with\\n # different lengths.\\n # FIXME: should do this with numpy operators only\\n self.y_pred_ = [[test for chunk in train for test in chunk]\\n for train in map(list, zip(*y_pred))]\\n return self.y_pred_\",\n \"def prediction(input_path=INPUT_DIR,\\n output_path=OUTPUT_DIR,\\n model_path=MODEL_PATH,\\n test=False):\\n\\n X = tf.placeholder(shape=[None, chunk_size, chunk_size], dtype=tf.float32, name='input_area')\\n y_inter = deepcn.deepcn(X, chunk_size, False)\\n y_pred = tf.cast(tf.argmax(tf.squeeze(y_inter), -1), tf.uint8)\\n\\n img_ids = []\\n for name in os.listdir(input_path):\\n if os.path.isdir(os.path.join(input_path, name)):\\n img_ids.append(name)\\n all_preds = np.zeros((len(img_ids), 256, 256))\\n print('num of images: ', len(img_ids))\\n\\n loader = tf.train.Saver()\\n\\n with tf.Session() as sess:\\n print(\\\"Import model from: %s\\\" %model_path)\\n loader.restore(sess, model_path)\\n # sess.run(tf.global_variables_initializer())\\n\\n batch_start_pos = 0\\n while batch_start_pos < len(img_ids):\\n batch_size = 100\\n batch_end_pos = min(batch_start_pos + batch_size, len(img_ids))\\n print('predict from %s, to %s' % (batch_start_pos, batch_end_pos))\\n batch = img_ids[batch_start_pos:batch_end_pos]\\n pw = predict_data_wrapper.PredictWrapper(path=input_path,\\n resize_size=chunk_size,\\n img_ids=batch)\\n input_arr = pw.ResizedTestData()\\n print(\\\"input_arr.shape: \\\", input_arr.shape)\\n # input test_data_batch, output prediction of shape batch_size * 256 * 256\\n pred_arr = sess.run(y_pred, feed_dict={X: input_arr})\\n print(\\\"pred_arr.shape: \\\", pred_arr.shape)\\n all_preds[batch_start_pos:batch_end_pos] = pred_arr\\n pw.OutputPrediction(pred_arr*100, path=output_path)\\n batch_start_pos = batch_end_pos\\n\\n # Use all img_ids and all_preds to generate single cell split csv file\\n pw = predict_data_wrapper.PredictWrapper(path=input_path,\\n resize_size=chunk_size,\\n img_ids=img_ids)\\n pw.GenerateSubmit(all_preds, output_path, cutoff=0.5)\",\n \"def predict(self, data, verbose=0):\\n\\n if self.model is None:\\n raise StandardError('Model is not built. Run build method or load model before fitting')\\n # print len(data[0])\\n # print type(data[0])\\n # print data.shape\\n return self.model.predict(data, 1, verbose) # ,steps)\",\n \"def predict(self, test_set, test_labels):\\n\\n with tf.Session() as self.tf_session:\\n self.tf_saver.restore(self.tf_session, self.models_dir + self.model_name)\\n return self.accuracy.eval({self.input_data: test_set, self.input_labels: test_labels})\",\n \"def train(self):\\n\\t\\tself.model.fit(self.training_data, self.training_labels)\",\n \"def predict(self, dataset):\\n # TODO: self.model(training=False)\\n # logging.info('Predicting')\\n # if self.verbosity > 1:\\n # print('Predicting')\\n dataset = rdata.data2dataset(dataset) # Convert to dataset\\n assert dataset.get_dim_input() == self.n_inputs, \\\\\\n 'Number of covariates does not match the model %d -> %d' % (dataset.get_dim_input(), self.n_inputs)\\n n_data = dataset.get_n_data()\\n\\n pred = self._predict(dataset=dataset) # Predict\\n\\n if self.isprobabilistic():\\n assert pred[0].shape == (n_data, self.n_outputs)\\n assert pred[1].shape == (n_data, self.n_outputs)\\n else:\\n assert pred.shape == (n_data, self.n_outputs)\\n return pred\",\n \"def get_model_predictions(\\n self,\\n model: Type[Model],\\n start_task_index: int = 0,\\n stop_task_index: Optional[int] = None,\\n batched: bool = False,\\n batch_size: int = _DEFAULT_BATCH_SIZE,\\n skip_validation: bool = False,\\n ) -> Dict[str, Dict[str, Union[str, float]]]:\\n predictions = {}\\n if not batched:\\n batch_size = None\\n n_tasks = (stop_task_index or self.n_tasks) - start_task_index\\n with tqdm(total=n_tasks) as pbar:\\n if not batched:\\n for support_x, support_y, query_x, metadata in self.get_tasks(\\n start_task_index=start_task_index,\\n stop_task_index=stop_task_index,\\n ):\\n query_y, scores = _parse_fit_and_predict_result(\\n model.fit_and_predict(\\n support_x=support_x,\\n support_y=support_y,\\n target_x=query_x,\\n metadata=metadata,\\n )\\n )\\n if not skip_validation:\\n validate(query_y, metadata['labels'])\\n predictions.update(\\n _convert_fit_and_predict_result_to_predictions(\\n query_y=query_y,\\n scores=scores,\\n query_question_ids=metadata['query_question_ids']\\n )\\n )\\n pbar.update(1)\\n else:\\n for batch in grouper(\\n batch_size,\\n self.get_tasks(\\n start_task_index=start_task_index,\\n stop_task_index=stop_task_index,\\n )\\n ):\\n support_x, support_y, query_x, metadata = zip(*(b for b in batch if b is not None))\\n n_tasks_in_batch = len(support_x)\\n query_y, scores = _parse_fit_and_predict_result(\\n model.fit_and_predict(\\n support_x=support_x,\\n support_y=support_y,\\n target_x=query_x,\\n metadata=metadata,\\n )\\n )\\n try:\\n query_y = flatten(query_y)\\n scores = flatten(scores) if scores is not None else None\\n except TypeError:\\n # Already flattened\\n pass\\n query_question_ids_flat = flatten(m['query_question_ids'] for m in metadata)\\n if not skip_validation:\\n validate(query_y, metadata['labels'])\\n predictions.update(\\n _convert_fit_and_predict_result_to_predictions(\\n query_y=query_y,\\n scores=scores,\\n query_question_ids=query_question_ids_flat,\\n )\\n )\\n pbar.update(n_tasks_in_batch)\\n return predictions\",\n \"def correct_age_predictions(train_preds, train_age, test_preds, test_age):\\n lr = LinearRegression()\\n\\n train_resids = np.array(train_preds - train_age)\\n test_resids = np.array(test_preds - test_age)\\n\\n # fit model\\n lr.fit(train_age[:,np.newaxis], train_resids)\\n\\n # predict test residuals using age\\n pred_resid = lr.predict(test_age[:,np.newaxis])\\n\\n # correct model predictions\\n corrected_predictions = test_preds - pred_resid\\n\\n return corrected_predictions\",\n \"def test_fit_predict() -> None:\\n mapie = MapieRegressor()\\n mapie.fit(X_toy, y_toy)\\n mapie.predict(X_toy)\",\n \"def fit_predict_single_fold(\\n self, train: TabularDataset, valid: TabularDataset\\n ) -> Tuple[TorchBasedLinearEstimator, np.ndarray]:\\n if type(train) is PandasDataset:\\n train = train.to_numpy()\\n valid = valid.to_numpy()\\n\\n model = self._infer_params()\\n\\n model.fit(\\n train.data,\\n train.target,\\n train.weights,\\n valid.data,\\n valid.target,\\n valid.weights,\\n )\\n\\n val_pred = model.predict(valid.data)\\n\\n return model, val_pred\",\n \"def run(self, orig_target_df):\\n\\n # For each fold\\n for fold_idx, (fold_training_set_df, fold_testing_set_df, fold_target_df, fold_truth_df) in enumerate(self._generate_validation_fold()):\\n train_test_date_split = fold_training_set_df[\\\"date\\\"].max()\\n eval_start_date = train_test_date_split - timedelta(days = self.test_nb_days)\\n date_to_predict = train_test_date_split + timedelta(days = 1)\\n print(\\\"Warning: date_to_predict offset should be computed dynamically. Currently fixed to 1.\\\")\\n\\n # For each prediction method\\n for process, process_name in zip(self.process_lst, self.process_names_lst):\\n print(\\\"Running validation for process:\\\", process_name, \\\"on fold:\\\", fold_idx, \\\"...\\\")\\n\\n # Train the model\\n with open(self.data_cache_path_str + \\\"data_bkp.pkl\\\", \\\"wb\\\") as f:\\n pickle.dump((fold_training_set_df, fold_testing_set_df, fold_target_df, fold_truth_df), f)\\n\\n y_train = fold_target_df[\\\"demand\\\"].reset_index(drop = True)\\n model = process(train_test_date_split, eval_start_date)\\n model.fit(fold_training_set_df, y_train)\\n\\n # Generate predictions for validation set\\n preds = model.predict(fold_testing_set_df, date_to_predict)\\n preds[\\\"demand\\\"] = (orig_target_df[\\\"shifted_demand\\\"] + preds[\\\"demand\\\"]).apply(np.expm1)\\n\\n # Score the predictions\\n preds2 = preds.copy()\\n preds2.columns = [\\\"id\\\", \\\"date\\\", \\\"preds\\\"]\\n preds_rmse_by_date_df = preds2.merge(fold_truth_df, how = \\\"left\\\", on = [\\\"id\\\", \\\"date\\\"])\\n preds_rmse_by_date_df = preds_rmse_by_date_df[[\\\"date\\\", \\\"preds\\\", \\\"demand\\\"]].groupby(\\\"date\\\").apply(lambda x: self._rmse(x[\\\"demand\\\"], x[\\\"preds\\\"])).reset_index()\\n preds_rmse_by_date_df.columns = [\\\"date\\\", \\\"preds_rmse\\\"]\\n\\n best_preds_piv = preds[[\\\"id\\\", \\\"date\\\", \\\"demand\\\"]].pivot(index = \\\"id\\\", columns = \\\"date\\\", values = \\\"demand\\\").reset_index()\\n truth_piv = fold_truth_df[[\\\"id\\\", \\\"date\\\", \\\"demand\\\"]].pivot(index = \\\"id\\\", columns = \\\"date\\\", values = \\\"demand\\\").reset_index()\\n truth_piv.set_index(\\\"id\\\", inplace = True)\\n best_preds_piv.set_index(\\\"id\\\", inplace = True)\\n best_preds_piv.columns = [\\\"F\\\" + str(i) for i in range(1, 29)]\\n truth_piv.columns = [\\\"F\\\" + str(i) for i in range(1, 29)]\\n validation_WRMSSE = round(model.evaluator.wrmsse(best_preds_piv, truth_piv, score_only = True), 6)\\n\\n # Save result for later use\\n self.scores[process_name].append((fold_idx, preds_rmse_by_date_df, validation_WRMSSE))\\n \\n if self.verbose == True: \\n print(process_name, \\\"had a score of\\\", validation_WRMSSE, \\\"on validation period\\\", fold_testing_set_df[\\\"date\\\"].min(), \\\"to\\\", fold_testing_set_df[\\\"date\\\"].max())\\n\\n metrics_lst = []\\n for process_name, content in self.scores.items():\\n for fold_idx, preds_rmse_by_date_df, validation_WRMSSE in content:\\n preds_rmse_by_date_df[\\\"process_name\\\"] = process_name\\n preds_rmse_by_date_df[\\\"fold_idx\\\"] = fold_idx\\n preds_rmse_by_date_df[\\\"WRMSSE\\\"] = validation_WRMSSE\\n metrics_lst.append(preds_rmse_by_date_df)\\n\\n metrics_df = pd.concat(metrics_lst, axis = 0)\\n metrics_df.set_index(\\\"date\\\", inplace = True)\\n\\n return metrics_df\",\n \"def __train_and_predict(self, X_train, y, X_test):\\n self.model.fit(X_train, y, eval_metric='auc')\\n prediction_probs = self.model.predict_proba(X_train)[:, 1]\\n print \\\"Training auc = %f\\\" % roc_auc_score(y, prediction_probs)\\n self.__write_csv(prediction_probs,\\n X_train.shape[0], self.train_out_file)\\n\\n prediction_probs = self.model.predict_proba(X_test)[:, 1]\\n self.__write_csv(prediction_probs,\\n X_test.shape[0], self.test_out_file)\\n\\n self.feature_imp()\",\n \"def train(\\n self, training_data: Dataset, validation_data: Optional[Dataset] = None\\n ) -> Predictor:\\n raise NotImplementedError\",\n \"def predict_4(trained_model, X_test, y_test):\\n # Predict with test data\\n start_time = timeit.default_timer()\\n trained_model.predict(X_test)\\n end_time = timeit.default_timer()\\n time = end_time - start_time\\n speed = int(X_test.shape[0] / time)\\n \\n # Get loss and accuracy\\n test_accuracy = trained_model.score(X_test, y_test)\\n \\n # Prepare results messages\\n msg_time = \\\"prediction time: {:.3f}s ({}px/s)\\\\n\\\".format(time, speed)\\n msg_test_acc = \\\"test_accuracy: {:.3f}\\\\n\\\\n\\\".format(test_accuracy)\\n \\n # Write results messages\\n with open(OUTPUT_FILE, 'a') as f:\\n f.write(msg_time)\\n f.write(msg_test_acc)\",\n \"def train_predict(model_list,X_train, X_test, y_train, y_test):\\n P = np.zeros((y_test.shape[0], len(model_list)))\\n P = pd.DataFrame(P)\\n\\n print(\\\"Fitting models.\\\")\\n cols = list()\\n for i, (name, m) in enumerate(models.items()):\\n print(\\\"%s...\\\" % name, end=\\\" \\\", flush=False)\\n m.fit(X_train, y_train)\\n P.iloc[:, i] = m.predict_proba(X_test)[:, 1]\\n cols.append(name)\\n print(\\\"done\\\")\\n\\n P.columns = cols\\n print(\\\"Done.\\\\n\\\")\\n return P\",\n \"def generate_predictions(inputs, model, tokenizer):\\n # Generate model results\\n outputs = model(**inputs)\\n\\n # Convert logit outputs into predictions for table cells and aggregation operators\\n predicted_table_cell_coords, predicted_aggregation_operators = tokenizer.convert_logits_to_predictions(\\n inputs,\\n outputs.logits.detach(),\\n outputs.logits_aggregation.detach()\\n )\\n\\n print(predicted_table_cell_coords)\\n print(predicted_aggregation_operators)\\n\\n # Return values\\n return predicted_table_cell_coords, predicted_aggregation_operators\",\n \"def test_predict(self):\\n # Check build does not raise errors\\n dataset = KDDCupDataset()\\n dataset.create_fixed_samples(\\n *self.data, samples_num=1, partition_sizes=self.partition_sizes)\\n dataset.set_current_sample(0)\\n model = self.MODEL(dataset, **self.model_arguments)\\n model.fit(training_epochs=50)\\n true, predictions = model.predict('test')\\n expected_size = ((dataset.num_examples('test') //\\n model.batch_size) * model.batch_size)\\n self.assertEqual(true.shape[0], expected_size)\\n self.assertEqual(true.shape, predictions.shape)\",\n \"def predict_2(trained_model, X_test, y_test):\\n # Predict with test data\\n start_time = timeit.default_timer()\\n test_prediction = trained_model.predict(X_test)\\n end_time = timeit.default_timer()\\n time = end_time - start_time\\n speed = int(X_test.shape[0] / time)\\n \\n # Get loss and accuracy\\n test_loss, test_accuracy = trained_model.evaluate(X_test, y_test)\\n \\n # Prepare results messages\\n msg_time = \\\"prediction time: {:.3f}s ({}px/s)\\\\n\\\".format(time, speed)\\n msg_test_loss = \\\"test_loss: {:.3f}\\\\n\\\".format(test_loss)\\n msg_test_acc = \\\"test_accuracy: {:.3f}\\\\n\\\\n\\\".format(test_accuracy)\\n \\n # Write results messages\\n with open(OUTPUT_FILE, 'a') as f:\\n f.write(msg_time)\\n f.write(msg_test_loss)\\n f.write(msg_test_acc)\",\n \"def fit_predict(self, train_x: pd.DataFrame, train_y: pd.Series, test_x: pd.DataFrame, test_y: pd.Series) -> dict:\\n self.evaluator.fit(train_x, train_y, test_x, test_y)\\n predictions = self.evaluator.predict(test_x)\\n print(predictions)\\n metrics = metrics_stat(predictions, test_y)\\n return metrics\",\n \"def predict(model, dataset_info, args):\\n dataset_info, model_info = fill_info_dicts(dataset_info, args)\\n\\n fill_pred_op_info(dataset_info, model, args, model_info)\\n # fill_topic_op(args, model_info)\\n\\n str_ = 'Predictions of the given text data of dataset %s using different ' \\\\\\n 'saved models:' % args.predict_dataset\\n labels = [str(i) for i in dataset_info[args.predict_dataset]['labels']]\\n if len(labels) == 2 or args.task == 'regression':\\n # TODO currently just hard code for binary\\n header = 'id\\\\tlabel\\\\t' + str(1) + '\\\\n'\\n else:\\n header = 'id\\\\tlabel\\\\t' + '\\\\t'.join(labels) + '\\\\n'\\n\\n saver = tf.train.Saver(max_to_keep=100)\\n\\n model_names = args.datasets\\n if len(args.datasets) > 1:\\n model_names.append('MULT')\\n\\n for model_name in model_names:\\n # load the saved best model\\n str_ += '\\\\nUsing the model that performs the best on (%s)\\\\n' % model_name\\n\\n output = header\\n str_ += header\\n\\n data = []\\n\\n with tf.Session() as sess:\\n if model_name == 'MULT':\\n checkpoint_path = os.path.join(args.checkpoint_dir, 'MULT',\\n 'model')\\n else:\\n checkpoint_path = model_info[model_name]['checkpoint_path']\\n\\n saver.restore(sess, checkpoint_path)\\n\\n dataset_name = args.predict_dataset\\n\\n # import pdb\\n # sess.run(model_info[dataset_name]['pred_iter'].initializer)\\n # batch = model_info[dataset_name]['pred_batch']\\n # text, weights = sess.run([batch['text'], batch['text_weights']])\\n # pdb.set_trace()\\n\\n _pred_op = model_info[dataset_name]['pred_pred_op']\\n _pred_iter = model_info[dataset_name]['pred_iter']\\n _ids, _predictions, _scores = get_all_pred_res(sess, _pred_op,\\n _pred_iter, args)\\n\\n for id, pred, score in zip(_ids, _predictions, _scores):\\n record = {\\n 'id': id,\\n 'label': pred\\n }\\n if args.task == 'classification':\\n for l, s in zip(labels, score):\\n record[str(l)] = s\\n else:\\n record['score'] = score[0]\\n data.append(record)\\n\\n # output positive score for binary classification\\n\\n if len(score) == 2:\\n score = str(score[1])\\n else:\\n score = '\\\\t'.join([str(i) for i in score])\\n str_ += id + '\\\\t' + str(int(pred)) + '\\\\t' + score + '\\\\n'\\n output += id + '\\\\t' + str(int(pred)) + '\\\\t' + score + '\\\\n'\\n\\n make_dir(args.predict_output_folder)\\n\\n with open(\\n os.path.join(args.predict_output_folder, model_name) + '.tsv',\\n 'w') as file:\\n # for i in _predictions:\\n # file.write(str(i))\\n file.write(output)\\n\\n with open(\\n os.path.join(args.predict_output_folder, model_name) + '.json',\\n 'wt') as file:\\n json.dump(data, file, ensure_ascii=False)\\n\\n logging.info(str_)\",\n \"def evaluate(self):\\n\\n\\t\\t## We should be evaluating on dev dataset as well, so commenting x_test\\n\\t\\t#self.model_score = self.model.evaluate(self.x_test, self.y_test_oh, batch_size=2048)\\n\\t\\tself.model_score = self.model.evaluate(self.x_dev, self.y_dev_oh, batch_size=2048)\\n\\t\\tprint(\\\"%s score = %f\\\\n\\\" %(self.modelName, self.model_score[1]))\\n\\n\\t\\t##Saving atucal vs predicted predictions\\n\\t\\t##np.argmax returns the index where it see's 1 in the row\\n\\t\\t#y_pred = np.argmax(self.model.predict(self.x_test, batch_size=2048), axis=1)\\n\\t\\ty_pred = np.argmax(self.model.predict(self.x_dev, batch_size=2048), axis=1)\\n\\n\\t\\t## vstack will stack them in 2 rows, so we use Trasnpose to get them in column stack\\n\\t\\t#output_predict = np.vstack((np.argmax(self.y_test_oh, axis=1), y_pred)).T\\n\\t\\toutput_predict = np.vstack((np.argmax(self.y_dev_oh, axis=1), y_pred)).T\\n\\t\\toutputFile = self.resultDir + \\\"/outputPredict.csv\\\" \\n\\t\\tnp.savetxt(outputFile, output_predict, fmt=\\\"%5.0f\\\", delimiter=\\\",\\\")\\n\\n\\t\\t##Error Analysis of the prediction\\n\\t\\terrorAnalysis(outputFile)\\n\\n\\t\\treturn self.model_score\",\n \"def postprocess_model_outputs(self, predictions, expected):\\n\\n predictions = {k: t.numpy() for k, t in predictions.items()}\\n\\n return predictions, expected\",\n \"def load_and_predict(self):\\n if DataLoader.data is None:\\n messagebox.showerror(\\\"Information\\\", \\\"Data file is empty, please load the data first.\\\")\\n return\\n\\n path = filedialog.askopenfilename()\\n with open(path, 'rb') as file:\\n Trainer.model = pickle.load(file)\\n\\n scale = DataLoader.data['out'].max() - DataLoader.data['out'].min()\\n scaler = MinMaxScaler(feature_range=(0, 1))\\n scaler.fit(DataLoader.data)\\n data_scaled = pd.DataFrame(scaler.transform(DataLoader.data), columns=DataLoader.data.columns)\\n\\n Trainer.y_pred = batch_predict(Trainer.model, data_scaled.drop(columns=['out']))\\n Trainer.y_true = data_scaled['out']\\n\\n self.test_rmse = scale * math.sqrt(mean_squared_error(Trainer.y_pred, Trainer.y_true))\\n print(self.test_rmse)\\n self.r_squared = np.corrcoef(Trainer.y_pred * scale, data_scaled['out'] * scale)[0, 1] ** 2\\n print(self.r_squared)\\n\\n models = Trainer.model.get_models()\\n param_string = f'Component Function Trained Parameters:\\\\n'\\n for i in range(len(models)):\\n param_string += \\\"length scale: {:.4f}\\\".format(models[i].kernel_.k1.length_scale) + ' ' + \\\\\\n \\\"noise level: {:.4e}\\\".format(models[i].kernel_.k2.noise_level) + '\\\\n'\\n param_string += f'\\\\nRMSE on the test set: {self.test_rmse}\\\\n'\\n param_string += f'R^2 value on the test set: {self.r_squared}'\\n display_params = ttk.Label(self, text=param_string, width=40)\\n display_params.grid(row=24 + 7, column=0, columnspan=2, sticky=tk.W + tk.E)\",\n \"def model_predict(classifier, X_test:list) -> list:\\n y_predict = classifier.predict(X_test)\\n return y_predict\",\n \"def predictions(self, model):\\n return get_predictions_from_df(\\n model=model, df=self.prediction_df,\\n fixed_effects=self.fixed_effects,\\n random_effect=self.random_effect,\\n spline=self.spline,\\n offset=self.offset,\\n )\",\n \"def predict(self, inputs):\\n return self.model.predict(inputs)\",\n \"def predict_only(self):\",\n \"def _predict(cls, model, is_log_transformed,\\n raw_actual, interpolated_actual,\\n training_end=None, seasonal_feature_scoring=None, pred_date=None, order_of_diff=None,\\n training_tail=None, ext_training_features=None, pred_len=None, freq=None,\\n include_holidays_exog=None):\\n\\n import numpy as np\\n import pandas as pd\\n import scipy.stats as st\\n from numpy.linalg import LinAlgError\\n import math\\n\\n alpha = cls._sig_level\\n alpha_extreme = cls._sig_level_extreme\\n\\n include_holidays_exog = include_holidays_exog if ext_training_features else 0\\n\\n index = pd.date_range(start=training_end, end=pred_date, freq=freq)[1:] # Holidays are always daily.\\n\\n de_obj = DataExploration()\\n pred_exog = de_obj._get_exog_data(pred_date, pred_date, index) if include_holidays_exog else None\\n\\n if pred_exog is not None and set(pred_exog.columns.values) != set(ext_training_features):\\n missing_col_list = list(set(ext_training_features) - set(pred_exog.columns.values))\\n common_cols = list(set(ext_training_features).intersection(set(pred_exog.columns.values)))\\n temp_df = pred_exog[common_cols]\\n missing_feat_df = pd.DataFrame(np.zeros([len(pred_exog), len(missing_col_list)]),\\n columns=missing_col_list, index=pred_exog.index.values)\\n pred_exog = pd.concat([temp_df, missing_feat_df], axis=1)\\n pred_exog = pred_exog[ext_training_features]\\n\\n freq = \\\"1\\\" + freq if not any(char.isdigit() for char in freq) else freq\\n\\n forecast_ndays = int((pred_date - pd.Timestamp(training_end)) / pd.Timedelta(freq))\\n model_freshness = forecast_ndays / float(pred_len)\\n\\n try:\\n if forecast_ndays > pred_len:\\n raise ValueError('Current trained model object expired')\\n\\n float_min = 1e-10\\n\\n # set exogenous (holiday) variables for input data\\n if include_holidays_exog:\\n pred_exog = pred_exog.loc[pd.Timestamp(training_end) + pd.Timedelta(freq): pred_date]\\n else:\\n pred_exog = None\\n\\n if seasonal_feature_scoring:\\n if not include_holidays_exog:\\n pred_exog = seasonal_feature_scoring[:forecast_ndays]\\n else:\\n pred_exog['fourier_feature'] = seasonal_feature_scoring[:forecast_ndays]\\n\\n forecast = list(model.forecast(steps=forecast_ndays, alpha=alpha, exog=pred_exog))\\n interpolated_training_data = list(zip(*training_tail))[1]\\n\\n for order in list(reversed(range(order_of_diff))):\\n training_data_diff = np.diff(interpolated_training_data,\\n order) if order > 0 else interpolated_training_data\\n\\n forecast_diff_mean = [training_data_diff[-1]]\\n forecast_diff_ci = []\\n\\n for i in range(forecast_ndays):\\n forecast_diff_mean.append(forecast_diff_mean[-1] + forecast[0][i])\\n forecast_diff_ci.append([forecast_diff_mean[-1] -\\n (st.norm.ppf(1 - (alpha / 2.0)) * forecast[1][i]),\\n forecast_diff_mean[-1] +\\n (st.norm.ppf(1 - (alpha / 2.0)) * forecast[1][i])])\\n forecast[0] = forecast_diff_mean[1:]\\n forecast[2] = forecast_diff_ci\\n\\n if is_log_transformed:\\n transformed_back_forecast = np.exp(forecast[0][-1] + ((forecast[1][-1] ** 2) / 2.0)) - 1\\n transformed_back_std_err = np.sqrt((np.exp(forecast[1][-1] ** 2) - 1) * (np.exp((2 * forecast[0][-1]) +\\n (forecast[1][\\n -1] ** 2))))\\n transformed_back_CILower = transformed_back_forecast - \\\\\\n st.norm.ppf(1 - (alpha / 2.0), 0, transformed_back_std_err) \\\\\\n if transformed_back_std_err != 0 else transformed_back_forecast\\n transformed_back_CIUpper = transformed_back_forecast + \\\\\\n st.norm.ppf(1 - (alpha / 2.0), 0, transformed_back_std_err) \\\\\\n if transformed_back_std_err != 0 else transformed_back_forecast\\n transformed_back_interpolated_actual = float(np.exp(interpolated_actual) - 1)\\n if np.sum(np.isnan(forecast[0][-1])) or np.isnan(forecast[1][-1]):\\n raise ValueError('Predicted null value')\\n\\n if is_log_transformed:\\n zscore = (transformed_back_interpolated_actual -\\n transformed_back_forecast) / max(float(transformed_back_std_err), float_min)\\n\\n anomaly_probability = (2 * st.norm(0, 1).cdf(abs(zscore))) - 1\\n if math.isnan(anomaly_probability) or math.isnan(transformed_back_CILower) \\\\\\n or math.isnan(transformed_back_CIUpper):\\n raise ValueError('Either Anomaly probability or CILower or CIUpper is NaN under log transform')\\n down_anomaly_probability = 1 - st.norm(0, 1).cdf(zscore)\\n up_anomaly_probability = st.norm(0, 1).cdf(zscore)\\n\\n result = {'Success': True,\\n 'IsLogTransformed': is_log_transformed,\\n 'LogTransformedAdjustedActual': interpolated_actual,\\n 'LogTransformedPrediction': float(forecast[0][-1]),\\n 'LogTransformedStdErr': float(forecast[1][-1]),\\n 'LogTransformedCILower': float(forecast[2][-1][0]),\\n 'LogTransformedCIUpper': float(forecast[2][-1][1]),\\n 'AdjustedActual': transformed_back_interpolated_actual,\\n 'Prediction': float(transformed_back_forecast) if not float(\\n transformed_back_forecast) == float('inf') else 0.0,\\n 'StdErr': float(transformed_back_std_err) if not float(\\n transformed_back_std_err) == float('inf') else 0.0,\\n 'CILower': float(transformed_back_CILower) if not float(\\n transformed_back_CILower) == float('-inf') else 0.0,\\n 'CIUpper': float(transformed_back_CIUpper) if not float(\\n transformed_back_CIUpper) == float('inf') else 0.0,\\n 'ConfLevel': float(1.0 - alpha) * 100,\\n 'ExogenousHolidays': include_holidays_exog,\\n 'IsAnomaly': bool(anomaly_probability > 1 - alpha),\\n 'IsAnomalyExtreme': bool(anomaly_probability > 1 - alpha_extreme),\\n 'AnomalyProbability': 1 if raw_actual is None else float(anomaly_probability),\\n 'DownAnomalyProbability': 1 if raw_actual is None else float(down_anomaly_probability),\\n 'UpAnomalyProbability': 1 if raw_actual is None else float(up_anomaly_probability),\\n 'ModelFreshness': model_freshness}\\n\\n else:\\n zscore = (interpolated_actual - forecast[0][-1]) / max(float(forecast[1][-1]), float_min)\\n\\n anomaly_probability = (2 * st.norm(0, 1).cdf(abs(zscore))) - 1\\n if math.isnan(anomaly_probability) or math.isnan(forecast[2][-1][0]) or math.isnan(forecast[2][-1][1]):\\n raise ValueError('Either Anomaly probability or CILower or CIUpper is NaN')\\n\\n down_anomaly_probability = 1 - st.norm(0, 1).cdf(zscore)\\n up_anomaly_probability = st.norm(0, 1).cdf(zscore)\\n\\n result = {'Success': True,\\n 'IsLogTransformed': is_log_transformed,\\n 'AdjustedActual': interpolated_actual,\\n 'Prediction': float(forecast[0][-1]) if not float(\\n forecast[0][-1]) == float('inf') else 0.0,\\n 'StdErr': float(forecast[1][-1]) if not float(\\n forecast[1][-1]) == float('inf') else 0.0,\\n 'CILower': float(forecast[2][-1][0]) if not float(\\n forecast[2][-1][0]) == float('-inf') else 0.0,\\n 'CIUpper': float(forecast[2][-1][1]) if not float(\\n forecast[2][-1][1]) == float('inf') else 0.0,\\n 'ConfLevel': float(1.0 - alpha) * 100,\\n 'ExogenousHolidays': include_holidays_exog,\\n 'IsAnomaly': bool(anomaly_probability > 1 - alpha),\\n 'IsAnomalyExtreme': bool(anomaly_probability > 1 - alpha_extreme),\\n 'AnomalyProbability': 1 if raw_actual is None else float(anomaly_probability),\\n 'DownAnomalyProbability': 1 if raw_actual is None else float(down_anomaly_probability),\\n 'UpAnomalyProbability': 1 if raw_actual is None else float(up_anomaly_probability),\\n 'ModelFreshness': model_freshness}\\n\\n except (LinAlgError, ValueError, LADStructuralError) as e:\\n result = {'Success': False,\\n 'AdjustedActual': interpolated_actual,\\n 'ErrorMessage': str(e)}\\n\\n return result\",\n \"def prediction(self, test_path, dest_path):\\n logger.info(f\\\"prediction on files from {test_path}\\\")\\n\\n if self.train_time is None:\\n self.train_time = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')\\n\\n save_path = data_functions.create_path(dest_path, self.train_time)\\n save_path = data_functions.create_path(save_path, 'raw_pred')\\n logger.info(f\\\"saving predictions to {save_path}\\\")\\n\\n test_gen = self.test_generator(test_path)\\n for img, img_entry, orig_shape in test_gen:\\n logger.info(f\\\"getting prediction for {img_entry.name}\\\")\\n pred_raw = self.model.predict(img, batch_size=1)[0]\\n pred_raw_resized = cv2.resize(pred_raw, orig_shape)\\n\\n file_name = img_entry.name.rsplit('.', 1)[0] + '.npy'\\n npy_file_save_path = os.path.join(save_path, file_name)\\n np.save(npy_file_save_path, pred_raw_resized, allow_pickle=True)\\n\\n pred_image = (255 * pred_raw_resized).astype(np.uint8)\\n cv2.imwrite(os.path.join(save_path, img_entry.name), pred_image)\\n\\n return save_path\",\n \"def predict(data, model_predict):\\n # Execute any steps you need to do before scoring\\n\\n # This method makes predictions against the raw, deserialized model\\n #predictions = model_predict(data)\\n\\n data.to_csv(\\\"/opt/code/chemprop_folder/for_scoring.csv\\\", index=False)\\n\\n args = PredictArgs().parse_args([\\n '--test_path', '/opt/chemprop_folder/for_scoring.csv',\\n '--checkpoint_path', '/opt/code/model.pth',\\n '--preds_path', '/opt/chemprop_folder/preds.csv'\\n ])\\n\\n make_predictions(args)\\n\\n preds_df = pds.read_csv(\\\"/opt/chemprop_folder/preds.csv\\\")\\n sh = str(preds_df.shape)\\n print(sh)\\n\\n preds_df = preds_df.rename(columns = {\\\"p_np\\\": \\\"positive_class_label\\\"})\\n preds_df = preds_df.drop(columns=['smiles'])\\n preds_df[\\\"negative_class_label\\\"] = 1 - preds_df[\\\"positive_class_label\\\"]\\n\\n print(preds_df.head())\\n\\n # Execute any steps you need to do after scoring\\n # Note: To properly send predictions back to DataRobot, the returned DataFrame should contain a\\n # column for each output label for classification or a single value column for regression\\n return preds_df\",\n \"def fit_predict_score(self, train_reviews: List[ParsedText],\\n test_reviews: List[ParsedText], test_reviews_pred: List[ParsedText],\\n **kwargs) -> List[ParsedText]:\\n\\n self.fit(train_texts=train_reviews, val_texts=test_reviews, **kwargs)\\n test_reviews_pred = self.predict(test_reviews_pred)\\n logging.info(f'Score: {self.score(texts=test_reviews, texts_pred=test_reviews_pred)}')\\n return test_reviews_pred\",\n \"def predict_single_fold(self, model: TorchBasedLinearEstimator, dataset: TabularDataset) -> np.ndarray:\\n pred = model.predict(dataset.data)\\n\\n return pred\",\n \"def predict(self, testx=None):\\n if self.best_model is None:\\n raise Exception(\\\"Train a model first\\\")\\n\\n if testx is None:\\n testx = self.test_X\\n\\n return self._predict(testx)\",\n \"def predict(self, data, version='default'):\\n if self.transform_service:\\n data = self.transform_service.predict(data, version)\\n return self.model_service.predict(data, version)\",\n \"def predict(self, trained_model, prediction_datetime):\\n return trained_model.predict()\",\n \"def _predict(self, testX):\\n pass\",\n \"def eval_epoch(self, final=False, save_predictions=False):\\n t1 = time()\\n output = {'tp': [], 'fp': [], 'fn': [], 'tn': [], 'loss': [], 'preds': [],'truth': [], 'true': 0,'true_sep':np.zeros(self.rel_size)}\\n test_info = []\\n test_result = []\\n self.model.eval()\\n test_iter = self.iterator(self.data['test'], batch_size=self.params['batch'], shuffle_=False)\\n # preds=[]\\n # truths=[]\\n for batch_idx, batch in enumerate(test_iter):\\n batch = self.convert_batch(batch, istrain=False, save=True)\\n\\n with torch.no_grad():\\n loss, stats, predictions, select, pred_pairs, multi_truths, mask, _ = self.model(\\n batch) # pred_pairs <#pair, relations_num>\\n pred_pairs = torch.sigmoid(pred_pairs)\\n\\n output['loss'] += [loss.item()]\\n output['tp'] += [stats['tp'].to('cpu').data.numpy()]\\n output['fp'] += [stats['fp'].to('cpu').data.numpy()]\\n output['fn'] += [stats['fn'].to('cpu').data.numpy()]\\n output['tn'] += [stats['tn'].to('cpu').data.numpy()]\\n output['preds'] += [predictions.to('cpu').data.numpy()]\\n # preds.extend(predictions.to('cpu').data.numpy())\\n # truths.extend(truth.to('cpu').data.numpy())\\n\\n if True:\\n test_infos = batch['info'][select[0].to('cpu').data.numpy(),\\n select[1].to('cpu').data.numpy(),\\n select[2].to('cpu').data.numpy()][mask.to('cpu').data.numpy()]\\n test_info += [test_infos]\\n\\n pred_pairs = pred_pairs.data.cpu().numpy()\\n multi_truths = multi_truths.data.cpu().numpy()\\n output['true'] += multi_truths.sum() - multi_truths[:, self.loader.label2ignore].sum()\\n output['true_sep'] = output['true_sep'] +multi_truths.sum(axis=0)\\n if save_predictions:\\n assert test_infos.shape[0] == len(pred_pairs), print(\\n \\\"test info=%d, pred_pair=%d\\\" % (len(test_infos.shape[0]), len(pred_pairs)))\\n for pair_id in range(len(pred_pairs)):\\n multi_truth = multi_truths[pair_id] #第pair_id个实体对的true\\n for r in range(0, self.rel_size):\\n if r == self.loader.label2ignore:\\n continue\\n\\n test_result.append((int(multi_truth[r]) == 1, float(pred_pairs[pair_id][r]),\\n test_infos[pair_id]['intrain'],test_infos[pair_id]['cross'], self.loader.index2rel[r], r,\\n len(test_info) - 1, pair_id))\\n\\n\\n # estimate performance\\n total_loss, scores = self.performance(output)\\n # pairs*rel_size*batch\\n test_result.sort(key=lambda x: x[1], reverse=True)\\n\\n input_theta, w, f1,p,r,scores_class = self.tune_f1_theta(test_result, output['true'],output['true_sep'], self.params['input_theta'], isTest=save_predictions)\\n\\n t2 = time()\\n if not final:\\n self.test_res['loss'] += [total_loss]\\n # self.test_res['score'] += [scores[self.primary_metric]]\\n self.test_res['score'] += [f1]\\n self.test_res['p'] = p\\n self.test_res['r'] = r\\n print(' TEST | LOSS = {:.05f}, '.format(total_loss), end=\\\"\\\")\\n print_results(scores, scores_class, self.show_class, t2 - t1)\\n # print(\\\"不同类别：\\\")\\n # t = classification_report(truths, preds,target_names=[\\\"NA\\\",\\\"父母子女\\\", \\\"祖孙\\\", \\\"兄弟姐妹\\\", \\\"叔伯姑舅姨\\\", \\\"夫妻\\\", \\\"其他亲戚\\\", \\\"好友\\\", \\\"上下级\\\", \\\"师生\\\", \\\"合作\\\", \\\"情侣\\\", \\\"对立\\\", \\\"共现\\\", \\\"同学\\\", \\\"同门\\\"])\\n # print(t)\\n\\n if save_predictions:\\n\\n test_result = test_result[: w + 1]\\n test_result_pred = []\\n test_result_info = []\\n for item in test_result:\\n test_result_pred.append([(item[-3], item[1])]) #预测的关系是的概率\\n test_result_info.append([test_info[item[-2]][item[-1]]])\\n assert (item[-3] in test_info[item[-2]][item[-1]]['rel']) == item[0], print(\\\"item\\\\n\\\", item, \\\"\\\\n\\\",\\n test_info[item[-2]][\\n item[-1]])\\n write_errors(test_result_pred, test_result_info, self.preds_file, map_=self.loader.index2rel, type=\\\"theta\\\")\\n write_preds(test_result_pred, test_result_info, self.preds_file, map_=self.loader.index2rel)\\n # f1_score_t=f1_score(truths, preds, average='micro')\\n # print(f1, scores['micro_f'], f1_score_t)\\n\\n return f1, scores['micro_f'],input_theta,p,r\",\n \"def predict(self,Xpred, nsamples=2000, tune=100, progress=True, points2=[]):\\n if self.type_y=='affine':\\n return self.predict_affine(Xpred, nsamples, tune, progress, points2)\\n elif self.type_y=='regression':\\n return self.predict_regression(Xpred, nsamples, tune, progress, points2)\\n elif self.type_y=='mixed':\\n return self.predict_mixed(Xpred, nsamples, tune, progress, points2)\",\n \"def predict(self):\\n for track in self.tracks:\\n track.predict(self.kf)\\n #track.du_doan(self.kf_test)\",\n \"def predict(self, batched_features, model_load_dir=None):\\n\\n previous_mode = self._mode\\n self._mode = 'predict'\\n\\n if model_load_dir is None:\\n model_load_dir = self._save_dir\\n logger.info('Model is lodded from {}'.format(model_load_dir))\\n\\n if not self._is_graph_build:\\n logger.info('Initializing the model for prediction...')\\n self.compile()\\n\\n gpu_options = tf.GPUOptions(allow_growth=True)\\n sess_config = tf.ConfigProto(gpu_options=gpu_options, allow_soft_placement=True, log_device_placement=True)\\n with tf.Session(config=sess_config) as sess:\\n saver = tf.train.Saver()\\n logger.info(\\\"Getting latest checkpoint in {}\\\".format(model_load_dir))\\n last_checkpoint = tf.train.latest_checkpoint(model_load_dir)\\n logger.info(\\\"Attempting to load checkpoint at {}\\\".format(last_checkpoint))\\n saver.restore(sess, last_checkpoint)\\n logger.info(\\\"Successfully loaded {}!\\\".format(last_checkpoint))\\n\\n feed_dict = self._get_test_feed_dict(batched_features)\\n y_pred = sess.run(self.prediction, feed_dict=feed_dict)\\n\\n self._mode = previous_mode\\n return y_pred\",\n \"def evaluate(model, test_files):\\n print(\\\"Running predictions.\\\")\\n models = load_model(model)\\n predictions = predict(models, test_files)\\n\\n # # write predictions to file\\n # write_predictions(\\\"evaluate_out.json\\\",predictions)\\n evaluate_individual(predictions, test_files, models)\\n evaluate_overall(predictions)\",\n \"def predict(self, data):\\n return self.result.predict(data)\",\n \"def test_predict(self):\\n self.regression_single.predict(self.X_test)\\n self.assertTrue(len(self.regression_single.y_pred))\\n self.regression_boston.predict(self.boston_x_test)\\n self.assertTrue(len(self.regression_boston.y_pred))\",\n \"def predict(dataset):\\n import capsnet\\n\\n # Load (standardized) input data and associated file names\\n test_x, _, names = _load_data(dataset)\\n\\n # Predict class probabilities for each model (epoch)\\n at_preds, sed_preds = [], []\\n\\n for epoch in _determine_epochs(cfg.prediction_epochs):\\n model = _load_model(epoch)\\n at_pred, sed_pred = utils.timeit(\\n lambda: capsnet.gccaps_predict(test_x, model),\\n '[Epoch %d] Predicted class probabilities' % epoch)\\n\\n at_preds.append(at_pred)\\n sed_preds.append(sed_pred)\\n\\n # Average predictions to give an overall output\\n total_at_pred = np.mean(at_preds, axis=0)\\n total_sed_pred = np.mean(sed_preds, axis=0)\\n\\n # Ensure output directory exists and set file path format\\n os.makedirs(os.path.dirname(cfg.predictions_path), exist_ok=True)\\n predictions_path = cfg.predictions_path.format('%s', dataset.name)\\n\\n # Save free parameters to disk\\n utils.log_parameters({'prediction_epochs': cfg.prediction_epochs},\\n os.path.join(os.path.dirname(cfg.predictions_path),\\n 'parameters.json'))\\n\\n # Write predictions to disk\\n utils.write_predictions(names, total_at_pred, predictions_path % 'at')\\n utils.write_predictions(names, total_sed_pred, predictions_path % 'sed')\",\n \"def predict(self, model, context, data):\\n pass\",\n \"def test_predict(self):\\n\\n docs = self.docs\\n for m in self.models:\\n preds = m.predict(docs)\\n self.assertTrue(isinstance(preds, turicreate.SArray))\\n self.assertEqual(len(preds), len(docs))\\n self.assertEqual(preds.dtype, int)\\n\\n preds = m.predict(docs, output_type=\\\"probability\\\")\\n self.assertTrue(isinstance(preds, turicreate.SArray))\\n self.assertTrue(len(preds) == len(docs))\\n s = preds.apply(lambda x: sum(x))\\n self.assertTrue((s.apply(lambda x: abs(x - 1)) < 0.000001).all())\\n\\n # Test predictions when docs have new words\\n new_docs = turicreate.SArray([{\\\"-1,-1\\\": 3.0, \\\"0,4\\\": 5.0, \\\"0,3\\\": 2.0}])\\n preds = m.predict(new_docs)\\n self.assertEqual(len(preds), len(new_docs))\\n\\n # Test additional burnin. Ideally we could show that things\\n # converge as you increase burnin.\\n preds_no_burnin = m.predict(docs, output_type=\\\"probability\\\", num_burnin=0)\\n self.assertEqual(len(preds_no_burnin), len(docs))\",\n \"def test_fit_predict() -> None:\\n mapie = MapieClassifier()\\n mapie.fit(X_toy, y_toy)\\n mapie.predict(X_toy)\",\n \"def train_model():\\n return model.fit(train_images, train_labels, epochs=10, validation_data=(test_images, test_labels), shuffle='True')\",\n \"def predict_model(args):\\n print(args)\\n\\n if args.cuda:\\n print(\\\"=====> use gpu id: '{}'\\\".format(args.gpus))\\n os.environ[\\\"CUDA_VISIBLE_DEVICES\\\"] = args.gpus\\n if not torch.cuda.is_available():\\n raise Exception(\\\"no GPU found or wrong gpu id, please run without --cuda\\\")\\n\\n # build the model\\n model = build_model(args.model, num_classes=args.classes)\\n\\n if args.cuda:\\n model = model.cuda() # using GPU for inference\\n cudnn.benchmark = True\\n\\n if not os.path.exists(args.save_seg_dir):\\n os.makedirs(args.save_seg_dir)\\n\\n # load the test set\\n datas, testLoader = build_dataset_test(args.dataset, args.num_workers, none_gt=True)\\n\\n if args.checkpoint:\\n if os.path.isfile(args.checkpoint):\\n print(\\\"=====> loading checkpoint '{}'\\\".format(args.checkpoint))\\n checkpoint = torch.load(args.checkpoint)\\n model.load_state_dict(checkpoint['model'])\\n # model.load_state_dict(convert_state_dict(checkpoint['model']))\\n else:\\n print(\\\"=====> no checkpoint found at '{}'\\\".format(args.checkpoint))\\n raise FileNotFoundError(\\\"no checkpoint found at '{}'\\\".format(args.checkpoint))\\n\\n print(\\\"=====> beginning testing\\\")\\n print(\\\"test set length: \\\", len(testLoader))\\n predict(args, testLoader, model)\",\n \"def make_predict_step(self):\\n return self.make_eval_step()\",\n \"def predict(self, X_test, **kwargs):\\n\\n # Normalize inputs\\n if self.normalize_input:\\n X_, _, _ = zero_mean_unit_var_normalization(X_test, self.X_mean, self.X_std)\\n else:\\n X_ = X_test\\n\\n # Sample a number of predictions for each given point\\n # Generate mean and variance for each given point from sampled predictions\\n\\n X_ = torch.Tensor(X_)\\n self.model.eval()\\n Yt_hat = self.model(X_).data.cpu().numpy()\\n\\n if self.normalize_output:\\n Yt_hat = zero_mean_unit_var_denormalization(Yt_hat, self.y_mean, self.y_std)\\n\\n logger.debug(f\\\"Generated final outputs array of shape {Yt_hat.shape}\\\")\\n\\n return Yt_hat\",\n \"def sequence_predict(self, load_script=False, variant=\\\"predict\\\"):\\n\\n if variant != 'internal':\\n # Open an existing model and get the input dataset. \\n # Target for historical data are expected if using previous targets as a feature.\\n request_data = self._get_model_and_data(ordered_data=True) \\n if type(request_data) == list:\\n X, y = request_data\\n else:\\n X = request_data\\n else:\\n X = self.X_test.copy()\\n y = self.y_test.copy()\\n\\n # Scale the targets and increase stationarity if required\\n if variant != 'internal' and self.model.lag_target and (self.model.scale_target or self.model.make_stationary):\\n # If using differencing, we retain original y values for inversing the transformation later\\n y_orig = y.values.ravel() if self.model.make_stationary=='difference' else None\\n # Apply the transformer to the targets\\n y = self.model.target_transformer.transform(y)\\n # Drop samples where y cannot be transformed due to insufficient lags\\n X = X.iloc[len(X)-len(y):]\\n\\n # Set the number of periods to be predicted\\n prediction_periods = self.model.prediction_periods\\n # Set the number of rows required for one prediction\\n self.rows_per_pred = 1\\n self.diff_lags = max(self.model.stationarity_lags) if self.model.lag_target and self.model.make_stationary=='difference' else 0\\n # Set property depending on whether the current sample will be included as an input, or if we only use lag observations for predictions\\n self.first_pred_modifier = 1 if self.model.current_sample_as_input else 0 \\n\\n # Check that the input data includes history to meet any lag calculation requirements\\n if self.model.lags:\\n # An additional lag observation is needed if previous targets are being added to the features\\n self.rows_per_pred = self.model.lags+self.first_pred_modifier+1 if self.model.lag_target else self.model.lags+self.first_pred_modifier\\n # If the target is being lagged and made stationary through differencing additional lag periods are required\\n if self.model.lag_target and self.model.make_stationary=='difference':\\n extra_msg = \\\" plus an additional {} periods for making the target stationary using differencing\\\".format(self.diff_lags)\\n # For multi-step predictions we only expect lag values, not the current period's values\\n # self.rows_per_pred = self.rows_per_pred-1 if prediction_periods > 1 else self.rows_per_pred\\n assert len(X) >= self.rows_per_pred + self.diff_lags, \\\"Insufficient input data as the model requires {} lag periods for each prediction\\\".format(self.rows_per_pred) + extra_msg\\n\\n if variant != 'internal':\\n # Prepare the response DataFrame\\n # Initially set up with the 'model_name' and 'key' columns and the same index as request_df\\n self.response = self.request_df.drop(columns=['n_features'])\\n \\n # Set up a list to contain predictions and probabilities if required\\n predictions = []\\n get_proba = False\\n if variant == 'predict_proba':\\n get_proba = True\\n probabilities = [] \\n\\n # Refresh the keras model to avoid tensorflow errors\\n if self.model.using_keras:\\n self._keras_refresh()\\n\\n if prediction_periods > 1:\\n if not self.model.lag_target:\\n y = None\\n\\n # Check that we can generate 1 or more predictions of prediction_periods each\\n n_samples = len(X)\\n assert (n_samples - self.rows_per_pred) >= prediction_periods, \\\\\\n \\\"Cannot generate predictions for {} periods with {} rows, with {} rows required for lag observations. You may need to provide more historical data or sufficient placeholder rows for future periods.\\\"\\\\\\n .format(prediction_periods, n_samples, self.rows_per_pred)\\n \\n # For multi-step predictions we can add lag observations up front as we only use actual values\\n # i.e. We don't use predicted y values for further predictions \\n if self.model.lags or self.model.lag_target:\\n X = self._add_lags(X, y=y, extrapolate=self.first_pred_modifier) \\n\\n # We start generating predictions from the first row as lags will already have been added to each sample\\n start = 0\\n else:\\n # We start generating predictions from the point where we will have sufficient lag observations\\n start = self.rows_per_pred\\n \\n if self.model.lag_target or prediction_periods > 1:\\n # Get the predictions by walking forward over the data\\n for i in range(start, len(X) + self.first_pred_modifier, prediction_periods): \\n # For multi-step predictions we take in self.rows_per_pred rows of X to generate predictions for prediction_periods\\n if prediction_periods > 1:\\n batch_X = X.iloc[[i]]\\n \\n if not get_proba:\\n # Get the prediction. \\n pred = self.model.pipe.predict(batch_X)\\n # Flatten the predictions for multi-step outputs and add to the list\\n pred = pred.ravel().tolist()\\n predictions += pred\\n else:\\n # Get the predicted probability for each sample \\n proba = self.model.pipe.predict_proba(batch_X)\\n proba = proba.reshape(-1, len(self.model.pipe.named_steps['estimator'].classes_))\\n probabilities += proba.tolist()\\n # For walk forward predictions with lag targets we use each prediction as input to the next prediction, with X values avaialble for future periods.\\n else:\\n batch_X = X.iloc[i-self.rows_per_pred : i] \\n # Add lag observations\\n batch_y = y.iloc[i-self.rows_per_pred : i]\\n batch_X = self._add_lags(batch_X, y=batch_y, extrapolate=self.first_pred_modifier)\\n\\n # Get the prediction. We only get a prediction for the last sample in the batch, the remaining samples only being used to add lags.\\n pred = self.model.pipe.predict(batch_X.iloc[[-1],:])\\n\\n # Add the prediction to the list. \\n predictions.append(pred)\\n \\n # Add the prediction to y to be used as a lag target for the next prediction\\n y.iloc[i - self.first_pred_modifier, 0] = pred\\n\\n # If probabilities need to be returned\\n if get_proba:\\n # Get the predicted probability for each sample \\n probabilities.append(self.model.pipe.predict_proba(batch_X.iloc[[-1],:]))\\n else:\\n # Add lag observations to the samples if required\\n if self.model.lags:\\n X = self._add_lags(X, extrapolate=self.first_pred_modifier)\\n\\n # Get prediction for X\\n predictions = self.model.pipe.predict(X)\\n\\n # If probabilities need to be returned\\n if get_proba:\\n # Get the predicted probability for each sample \\n probabilities = self.model.pipe.predict_proba(X)\\n \\n # Set the number of placeholders needed in the response\\n # These are samples for which predictions were not generated due to insufficient lag periods or for meeting multi-step prediction period requirements\\n self.placeholders = self.rows_per_pred + self.diff_lags - self.first_pred_modifier\\n\\n # Transform probabilities to a readable string\\n if get_proba:\\n # Add the required number of placeholders at the start of the response list\\n y = [\\\"\\\\x00\\\"] * self.placeholders\\n \\n # Truncate multi-step predictions if the (number of samples - self.rows_per_pred) is not a multiple of prediction_periods\\n if prediction_periods > 1 and ((n_samples-self.rows_per_pred) % prediction_periods) > 0: \\n probabilities = probabilities[:-len(probabilities)+(n_samples-self.rows_per_pred)]\\n \\n for a in probabilities:\\n s = \\\"\\\"\\n i = 0\\n for b in a:\\n s = s + \\\", {0}: {1:.3f}\\\".format(self.model.pipe.named_steps['estimator'].classes_[i], b)\\n i += 1\\n y.append(s[2:])\\n\\n # Prepare predictions\\n else:\\n if prediction_periods > 1:\\n # Set the value to use for nulls\\n null = np.NaN if is_numeric_dtype(np.array(predictions)) else \\\"\\\\x00\\\"\\n\\n # Truncate multi-step predictions if the (number of samples - self.placeholders) is not a multiple of prediction_periods\\n if (n_samples-self.rows_per_pred) % prediction_periods > 0:\\n predictions = predictions[:-len(predictions)+(n_samples-self.rows_per_pred)]\\n\\n # Add null values at the start of the response list to match the cardinality of the input from Qlik\\n y = np.array(([null] * (self.rows_per_pred - self.first_pred_modifier)) + predictions)\\n elif self.model.lag_target: \\n # Remove actual values for which we did not generate predictions due to insufficient lags\\n if is_numeric_dtype(y.iloc[:, 0].dtype):\\n y.iloc[:self.placeholders - self.first_pred_modifier, 0] = np.NaN\\n else:\\n y.iloc[:self.placeholders - self.first_pred_modifier, 0] = \\\"\\\\x00\\\"\\n # Flatten y to the expected 1D shape\\n y = y.values.ravel()\\n else:\\n y = np.array(predictions)\\n \\n # Inverse transformations on the targets if required \\n if variant != 'internal' and (self.model.scale_target or self.model.make_stationary):\\n # Take out placeholder values before inverse transform of targets\\n null_values = y[:self.rows_per_pred - self.first_pred_modifier] if prediction_periods > 1 or self.model.lag_target else []\\n # Add placeholders for samples removed during differencing\\n if self.model.make_stationary=='difference':\\n null_values = np.append(null_values, np.repeat(null_values[0], self.diff_lags))\\n y = y if len(null_values) == 0 else y[-len(predictions):]\\n # Add untransformed lag values for differencing if required\\n end = self.placeholders\\n start = end - self.diff_lags\\n y = y if y_orig is None else np.append(y_orig[start : end], y)\\n\\n # Apply the transformer to the test targets\\n y = self.model.target_transformer.inverse_transform(y) \\n\\n # Remove lags used for making the series stationary in case of differencing\\n if self.model.make_stationary == 'difference':\\n y = y[self.diff_lags:]\\n\\n # Replace lags used for making the series stationary with nulls in case of differencing\\n # if self.model.make_stationary == 'difference':\\n #null = np.NaN if is_numeric_dtype(np.array(predictions)) else \\\"\\\\x00\\\"\\n # y = np.append(np.array([null]*self.diff_lags), y[self.diff_lags:])\\n \\n # Add back the placeholders for lag values\\n if len(null_values) > 0:\\n y = np.append(null_values, y)\\n \\n if variant == 'internal':\\n return y\\n\\n # Add predictions / probabilities to the response\\n self.response['result'] = y\\n\\n # Reindex the response to reset to the original sort order\\n self.response = self.response.reindex(self.original_index)\\n \\n if load_script:\\n # If the function was called through the load script we return a Data Frame\\n self._send_table_description(\\\"predict\\\")\\n \\n # Debug information is printed to the terminal and logs if the paramater debug = true\\n if self.model.debug:\\n self._print_log(4)\\n \\n return self.response\\n \\n # If the function was called through a chart expression we return a Series\\n else:\\n # Debug information is printed to the terminal and logs if the paramater debug = true\\n if self.model.debug:\\n self._print_log(4)\\n \\n return self.response.loc[:,'result']\",\n \"def predict(self, instances):\\r\\n raise NotImplementedError\",\n \"def predict(self, num_samples = BATCH_SIZE, display_predictions = True):\\n if self.model is None:\\n raise Exception(\\\"Model is empty, either build or load it\\\")\\n\\n print(\\\"==> Prediction on model from\\\", self.model_dir)\\n file_names, file_labels = self.get_sample_files(num_samples)\\n self.predict_dataset = tf.data.Dataset.from_tensor_slices((file_names, file_labels))\\n self.predict_dataset = self.predict_dataset.map(self.map_fn, num_parallel_calls=AUTOTUNE)\\n self.predict_dataset = self.predict_dataset.batch(BATCH_SIZE)\\n\\n self.predictions = self.model.predict(self.predict_dataset)\\n\\n if display_predictions:\\n self.display_predictions()\",\n \"def save_predictions(model, dataset, output_dir):\\n preds = model.predict(dataset, verbose=1)\\n preds = scipy.special.softmax(preds, 1) # Apply softmax\\n with tf.io.gfile.GFile(os.path.join(output_dir, 'test_preds.pkl'), 'wb') as f:\\n pickle.dump(preds, f)\",\n \"def predict(self, inputs):\\n\\n return self.model.predict(inputs)\",\n \"def predict_and_evaluate(config, workdir, ckpt_path=None):\\n logging.info('Starting testing at %s', workdir)\\n tf.io.gfile.makedirs(workdir)\\n\\n rng = jax.random.PRNGKey(config.seed)\\n # Build input pipeline.\\n rng, data_rng = jax.random.split(rng)\\n data_rng = jax.random.fold_in(data_rng, jax.process_index())\\n test_ds = []\\n for split in config.dataset.test_splits:\\n ds = input_pipeline.create_val_dataset(\\n config.dataset, split, config.dataset.test_per_device_batch_size,\\n config.dataset.test_pad_last_batch)\\n test_ds.append(ds)\\n\\n # Initialize model.\\n inputs = train_utils.get_init_inputs(test_ds[0])\\n rng, model_rng = jax.random.split(rng)\\n predict_config = models.TransformerConfig(**config.model.to_dict())\\n predict_config = predict_config.replace(decode=True)\\n model = models.Model(predict_config)\\n state = train_utils.create_train_state(\\n model, config, model_rng, inputs=inputs)\\n\\n writer = metric_writers.create_default_writer(\\n workdir, just_logging=jax.process_index() > 0)\\n\\n # Set up checkpointing of the model and the input pipeline.\\n checkpoint_dir = os.path.join(workdir, 'checkpoints')\\n ckpt = checkpoint.MultihostCheckpoint(checkpoint_dir, max_to_keep=3)\\n\\n logging.info('Testing and evaluating checkpoint %s', ckpt_path)\\n try:\\n state = ckpt.restore(state, ckpt_path)\\n except FileNotFoundError:\\n state = ckpt.restore_or_initialize(state)\\n step = int(state.step)\\n\\n p_pred_step = jax.pmap(\\n functools.partial(predict_step, config=predict_config),\\n axis_name='batch',\\n static_broadcasted_argnums=(3,))\\n p_init_cache = jax.pmap(\\n functools.partial(init_cache, config=predict_config), axis_name='batch')\\n\\n # Distribute testing.\\n state = flax_utils.replicate(state)\\n with metric_writers.ensure_flushes(writer):\\n test_metrics = {}\\n for ds, split in zip(test_ds, config.dataset.test_splits):\\n ds_metrics = evaluate_sequence_accuracy(p_pred_step, p_init_cache, state,\\n ds, config, split, workdir,\\n config.num_test_steps)\\n ds_metrics = {f'{k}_{split}': v for k, v in ds_metrics.items()}\\n test_metrics.update(ds_metrics)\\n writer.write_scalars(step, test_metrics)\",\n \"def postprocess_model_outputs(self, predictions, expected):\\n\\n for key, val in predictions.items():\\n predictions[key] = val.numpy()\\n\\n for key, val in expected.items():\\n expected[key] = val.numpy()\\n\\n return predictions, expected\",\n \"def predict(self, X_test):\\n\\n # Predict Label 0\\n i = 0\\n X = X_test\\n\\n # Retrieve trained classifier for label 0\\n clf = self.trained[i]\\n\\n # Make prediction\\n y = clf.predict(X)\\n result = np.zeros((X_test.shape[0], self.label_dim))\\n\\n result[:, i] = y\\n\\n # Concatenate result to X\\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\\\"csr\\\")\\n\\n # iterator = tqdm.trange(1, self.label_dim)\\n iterator = range(1, self.label_dim)\\n for i in iterator:\\n # Predict Label i\\n\\n # Retrieve trained classifier for label i\\n clf = self.trained[i]\\n\\n # Make prediction\\n y = clf.predict(X)\\n\\n result[:, i] = y\\n\\n # Concatenate result to X\\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\\\"csr\\\")\\n\\n return result\",\n \"def predict(self, testloader, field=None):\\n model_name = str(field).lower()\\n\\n assert field == HOME or field == AWAY, 'ERROR - model predict: WRONG model name. Give \\\"home\\\" or \\\"away\\\"'\\n\\n preds = {}\\n\\n for i, model in enumerate(self.models):\\n if (model_name == HOME):\\n # logger.info('> Calling Home Network')\\n field_net = model.model.home_network\\n elif (model_name == AWAY):\\n # logger.info('> Calling Away Network')\\n field_net = model.model.away_network\\n else:\\n raise ValueError('Model - predict: Wrong model name')\\n\\n model_preds = []\\n with torch.no_grad():\\n\\n for x in testloader:\\n x = torch.Tensor(x).to(self.device)\\n out = field_net(x)\\n\\n out = out.squeeze()\\n\\n model_preds.append(out.item())\\n\\n preds[i] = model_preds\\n\\n return preds[i]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7163424","0.69594693","0.6906497","0.6859476","0.67500716","0.6679552","0.6597463","0.654829","0.65226644","0.6456303","0.643875","0.6437849","0.6430144","0.6410656","0.6405512","0.6405512","0.6370887","0.6341422","0.63307375","0.6271287","0.6262299","0.6240893","0.62325644","0.62218654","0.62156755","0.6215209","0.62057686","0.619975","0.6193283","0.6188175","0.6182176","0.6181253","0.6163572","0.6162134","0.6156047","0.614601","0.61432296","0.6138808","0.6131204","0.61294997","0.61189586","0.6114997","0.6110694","0.6075934","0.6071032","0.6064739","0.6062961","0.60594016","0.60593134","0.60550773","0.6049336","0.6027752","0.6022168","0.6022107","0.60118306","0.60088384","0.6006876","0.5999732","0.599522","0.59908664","0.5987105","0.59767514","0.5975781","0.5964823","0.5959551","0.5958922","0.5958591","0.59579647","0.5948274","0.59462225","0.594403","0.5940711","0.5935464","0.5932445","0.59323466","0.59292895","0.5928166","0.5926356","0.5925943","0.59232163","0.5922889","0.59179926","0.59178865","0.5908666","0.5906437","0.58996207","0.589621","0.58924586","0.5890479","0.5887225","0.5883389","0.588304","0.58798987","0.58772606","0.5871457","0.58656967","0.5864669","0.5863566","0.5863164","0.5858163"],"string":"[\n \"0.7163424\",\n \"0.69594693\",\n \"0.6906497\",\n \"0.6859476\",\n \"0.67500716\",\n \"0.6679552\",\n \"0.6597463\",\n \"0.654829\",\n \"0.65226644\",\n \"0.6456303\",\n \"0.643875\",\n \"0.6437849\",\n \"0.6430144\",\n \"0.6410656\",\n \"0.6405512\",\n \"0.6405512\",\n \"0.6370887\",\n \"0.6341422\",\n \"0.63307375\",\n \"0.6271287\",\n \"0.6262299\",\n \"0.6240893\",\n \"0.62325644\",\n \"0.62218654\",\n \"0.62156755\",\n \"0.6215209\",\n \"0.62057686\",\n \"0.619975\",\n \"0.6193283\",\n \"0.6188175\",\n \"0.6182176\",\n \"0.6181253\",\n \"0.6163572\",\n \"0.6162134\",\n \"0.6156047\",\n \"0.614601\",\n \"0.61432296\",\n \"0.6138808\",\n \"0.6131204\",\n \"0.61294997\",\n \"0.61189586\",\n \"0.6114997\",\n \"0.6110694\",\n \"0.6075934\",\n \"0.6071032\",\n \"0.6064739\",\n \"0.6062961\",\n \"0.60594016\",\n \"0.60593134\",\n \"0.60550773\",\n \"0.6049336\",\n \"0.6027752\",\n \"0.6022168\",\n \"0.6022107\",\n \"0.60118306\",\n \"0.60088384\",\n \"0.6006876\",\n \"0.5999732\",\n \"0.599522\",\n \"0.59908664\",\n \"0.5987105\",\n \"0.59767514\",\n \"0.5975781\",\n \"0.5964823\",\n \"0.5959551\",\n \"0.5958922\",\n \"0.5958591\",\n \"0.59579647\",\n \"0.5948274\",\n \"0.59462225\",\n \"0.594403\",\n \"0.5940711\",\n \"0.5935464\",\n \"0.5932445\",\n \"0.59323466\",\n \"0.59292895\",\n \"0.5928166\",\n \"0.5926356\",\n \"0.5925943\",\n \"0.59232163\",\n \"0.5922889\",\n \"0.59179926\",\n \"0.59178865\",\n \"0.5908666\",\n \"0.5906437\",\n \"0.58996207\",\n \"0.589621\",\n \"0.58924586\",\n \"0.5890479\",\n \"0.5887225\",\n \"0.5883389\",\n \"0.588304\",\n \"0.58798987\",\n \"0.58772606\",\n \"0.5871457\",\n \"0.58656967\",\n \"0.5864669\",\n \"0.5863566\",\n \"0.5863164\",\n \"0.5858163\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6127523"},"document_rank":{"kind":"string","value":"40"}}},{"rowIdx":93,"cells":{"query":{"kind":"string","value":"Compose the largest number out of a set of integers."},"document":{"kind":"string","value":"def largest_number(digits):\n res = \"\"\n while digits:\n max_digit = None\n for digit in digits:\n if max_digit is None or \\\n is_greater_or_equal_than(digit, max_digit):\n max_digit = digit\n res += max_digit\n digits.remove(max_digit)\n return res"},"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 largest_int(numbers):\n\n if numbers == []:\n return \n max_int = numbers[0]\n for number in numbers:\n if number > max_int:\n max_int = number\n \n return max_int","def max_(lst: Iterable[int]) -> int:\n return reduce(lambda x, y: x if x > y else y, lst)","def max_num(num_list):\n\n return max(num_list)","def find_greatest_number(incoming_list: list):\n return max(incoming_list)","def max(input: list[int]) -> int:\n if len(input) == 0:\n raise ValueError(\"max() arg is an empty List\")\n else:\n input.sort()\n return input[-1]","def find_greatest_number(incoming_list):\n #magiclownumber= none\n #retval= magiclownumber\n #for value in incoming_list:\n #if not retval:\n #retval = value\n # if value> retvale\n #retval= value\n #return retval\n greatest_number = max(incoming_list)\n return greatest_number","def largestNumber(self, nums): \n def string_comp(item1, item2):\n return 1 if str(item1) + str(item2) < str(item2) + str(item1) else -1\n res_list = sorted(nums, key=cmp_to_key(string_comp))\n\n # Catch edge case where list of 0s will produce \"000..\" instead of a single \"0\"\n if set(res_list) == {0}:\n return \"0\"\n return \"\".join([str(i) for i in res_list])","def question_24(list_num: int) -> int:\n return max(list_num, key=list_num.count)","def find_greatest_number(incoming_list):\n retval = max(incoming_list)\n return retval","def list_max(numbers):\n maxnum = 0\n \n for num in numbers[0:]:\n if num > maxnum:\n maxnum = num\n return maxnum","def max(input: list[int]) -> int:\n if len(input) == 0:\n raise ValueError(\"max() arg is an empty List\")\n most: int = input[0]\n n: int = 1\n while n < len(input):\n if input[n] > most:\n most = input[n]\n n += 1 \n return most","def find_largest_element(num_1, num_2, num_3):\n\n return max([num_1, num_2, num_3])","def maxNumber(x):\n maxVal = x[0]\n for num in x:\n if maxVal <num:\n maxVal=num\n return maxVal","def find_greatest_number(incoming_list):\n #return_value = max(incoming_list)\n #return return_value\n\n MAGIC_LOW_NUMBER = None\n retval = MAGIC_LOW_NUMBER\n\n # 1,2,3,4,5,1\n # MAGIC_LOW_NUMBER, 1 ->STORE 1\n #1 , 2 ->STORE 2\n #2, , 3 ->STORE 3\n #3, , 4 ->STORE 4 \n #4, , 5 ->STORE 5\n #5, , 1 ->??? nothing \n for value in incoming_list:\n if not retval:\n retval = value\n if value > retval:\n retval = value","def max(input: list[int]) -> int:\n i = 0\n if len(input) == 0:\n raise ValueError(\"max() arg is an empty List\")\n\n else:\n while i < len(input):\n j = i + 1\n while j < len(input):\n if input[i] > input[j]:\n if j == len(input) - 1:\n if input[i] >= input[len(input) - 1]:\n return input[i]\n j += 1\n else:\n j += len(input)\n i += 1\n return input[len(input) - 1]","def largest_sum(data: Iterator[str]) -> int:\n numbers = parse_input(data)\n return max(n.magnitude for n in possible_sums(numbers))","def largest_product(digits, size):\n # Why does a blank set of digits have a maximum product of 1?\n slice_list = slices(digits, size)\n def mult_reduce(items):\n total = 1\n for i in items:\n total *= i\n return total\n slice_list = [mult_reduce(l) for l in slice_list]\n return max(slice_list)","def largest_number(a):\n\n array = new_quick_sort(a)\n\n largest_number = \"\"\n\n for number in array:\n largest_number += str(number)\n\n return largest_number","def max(self, num_list):\n try:\n max = int(num_list[0])\n\n for number in num_list:\n try:\n if number > max:\n max = number\n except Exception as e:\n print(\"Error\", e)\n\n except Exception as e:\n print(\"Error:\", e)\n\n return max","def maxi(a, b):\n return max(a, b)","def greatest_difference(num_list):","def highest_product(list_of_ints):\n\t# Initialize lists of highest positive integers, # max len 3\n\t#\t\t\t\t lowest positive integers # max len 2\n\t# \t\t\t\t highest negative integers, # max len 2\n\t# lowest negative integers # max len 3\n\t# \t Boolean for zero exists in list\n\thighest_pos = []\n\thighest_neg = []\n\tlowest_neg = []\n\tlowest_pos = []\n\tzero_int_exists = False\n\n\t# Loop thru input list of integers:\n\t# \tBuild lists initialized above, and set zero_int_exists\n\n\tfor i in range(len(list_of_ints)):\n\t\t# Process zero\n\t\tif list_of_ints[i] == 0: \n\t\t\tzero_int_exists = True\n\n\t\t# Process positive integer\n\t\telif list_of_ints[i] > 0:\n\t\t\tif len(highest_pos) < 3:\n\t\t\t\thighest_pos.append(list_of_ints[i])\n\t\t\telif list_of_ints[i] > min(highest_pos):\n\t\t\t\thighest_pos.remove(min(highest_pos))\n\t\t\t\thighest_pos.append(list_of_ints[i])\n\n\t\t\tif len(lowest_pos) < 2:\n\t\t\t\tlowest_pos.append(list_of_ints[i])\n\t\t\telif list_of_ints[i] < max(lowest_pos):\n\t\t\t\tlowest_pos.remove(max(lowest_pos))\n\t\t\t\tlowest_pos.append(list_of_ints[i])\n\t\t# Process negative integer\n\t\telse:\n\t\t\tif len(lowest_neg) < 2:\n\t\t\t\tlowest_neg.append(list_of_ints[i])\n\t\t\telse:\n\t\t\t\tif list_of_ints[i] < max(lowest_neg):\n\t\t\t\t\tlowest_neg.remove(max(lowest_neg))\n\t\t\t\t\tlowest_neg.append(list_of_ints[i])\n\n\t\t\tif len(highest_neg) < 3:\n\t\t\t\thighest_neg.append(list_of_ints[i])\n\t\t\telse:\n\t\t\t\tif list_of_ints[i] > min(highest_neg):\n\t\t\t\t\thighest_neg.remove(min(highest_neg))\n\t\t\t\t\thighest_neg.append(list_of_ints[i]) \n\n\t# Sort lists\n\thighest_pos.sort()\n\tlowest_pos.sort()\n\tlowest_neg.sort()\n\thighest_neg.sort()\n\n\t# Print input list, sub-lists\n\tprint(\"\\n\", list_of_ints)\n\tprint(\"zero_int_exists, highest/lowest pos, highest/lowest neg: \", \n\t\t\"\\n\", zero_int_exists, highest_pos, lowest_pos, highest_neg, lowest_neg)\n\n\t# Build high product candidates list\n\tpossible_high_prods = []\n\n\t# Add positive products to high product candidates list\n\tif len(highest_pos) == 3:\n\t\tpossible_high_prods.append(highest_pos[0] * highest_pos[1] * highest_pos[2])\n\n\tif len(lowest_neg) == 2 and len(highest_pos) >= 1:\n\t\tpossible_high_prods.append(lowest_neg[0] * lowest_neg[1] * highest_pos[-1])\n\n\t# If no high product candidates, append zero and negative products to high product candidates\n\tif len(possible_high_prods) == 0:\n\t\tif zero_int_exists:\n\t\t\tpossible_high_prods.append(0)\n\t\telse:\n\t\t\tif len(lowest_pos) == 0:\n\t\t\t\tpossible_high_prods.append(highest_neg[0] * highest_neg[1] * highest_neg[2])\n\t\t\telse:\n\t\t\t\tpossible_high_prods.append(lowest_pos[0] * lowest_pos[1] * lowest_neg[-1])\n\t\n\tprint(possible_high_prods)\n\treturn max(possible_high_prods)","def largest(n,xs):\n return sorted(xs, reverse = True)[:n][::-1]","def find_largest_5_digit_number(digits):\r\n return max(int(digits[i:i + 5]) for i, v in enumerate(digits))","def max_in_list(list):\n x=list[0] #set x be the first number in the list\n for i in range(0,len(list)):#go over the number in the list\n if x<=list[i]: #if the second one is bigger than the first\n x=list[i] #assign x to the bigger one\n else:\n continue#repeat until find the max number\n return x","def max_val(t): \n \n result = []\n if isinstance(t, int):\n result.append(t)\n return result\n elif isinstance (t, (tuple,list)):\n def update_result(t):\n for item in t:\n if isinstance(item, (tuple,list)):\n update_result(item)\n else:\n result.append(item)\n update_result(t)\n return max(result)","def find_largest_number_in_list(self, list_with_numbers):\n return 0","def maximumProduct1(self, nums: List[int]) -> int:\n s_nums = sorted(nums, reverse=True)\n return max(s_nums[0] * s_nums[1] * s_nums[2], s_nums[0] * s_nums[-1] * s_nums[-2])","def _max_factor(number, factors):\n return max(n for n in factors if n <= number)","def maximum(self):\n return max(self.numbers)","def max_num_in_list(a_list):\n max_number = max(a_list)\n return max_number","def four():\r\n \r\n i = 999\r\n j = i\r\n largest = 0\r\n \r\n while i > 0:\r\n while j > 0:\r\n number = str(i * j)\r\n forward = str(number)\r\n reverse = \"\"\r\n for char in number:\r\n reverse = char + reverse\r\n if forward == reverse:\r\n if largest < i * j:\r\n largest = i * j\r\n break\r\n else:\r\n j = j - 1\r\n i = i - 1\r\n j = i\r\n return largest","def r_max(nxs):\n largest = None\n for i,e in enumerate(nxs):\n if type(e) == type([]):\n val = r_max(e)\n else:\n val = e\n\n if i == 0 or val > largest:\n largest = val\n\n return largest","def get_max(num_one, num_two):\n temp_a = int(str(num_one) + str(num_two))\n temp_b = int(str(num_two) + str(num_one))\n if temp_a >= temp_b:\n return num_one\n else:\n return num_two","def largest(*args):\r\n if len(args) == 2:\r\n a, b = args\r\n return switch(a > b, a, b)\r\n else:\r\n return max(stack(*args), axis=0)","def fuction_call(chest):\n\n for i in chest:\n max_i = maximum(chest,i)\n if max_i >= 2:\n print(\"The maximum size of a set Matyoshka Dolls with outermost doll\",i,\"is\",max_i)","def maximum(iterable):\n max_item = 0\n if type(iterable) == list or type(iterable) == tuple:\n for i in iterable:\n if type(i)==int:\n if max_item<i:\n max_item = i\n else:\n max_item = -999\n break\n else:\n\n max_item=-999\n return max_item","def findMaxProduct(n):\n large = 0\n for i in range(len(s)):\n p = 1\n number = s[i:i+n]\n for iteration in range(len(number)):\n h = number[iteration]\n p = p * int(h)\n if p > large:\n large = p\n\n \n return large","def highest_product_2(arr):\n\n # make a list to store the highest three ints, initializing to first three\n maxes = [arr[0], arr[1], arr[2]]\n\n # find the lowest of the highest three ints\n lowest_max = min(maxes)\n\n # go through the rest of the list to check for higher values\n for num in arr[3:]:\n # if any value is higher than the lowest max, update maxes list\n if num > lowest_max:\n # remove the old maximum\n maxes.remove(lowest_max)\n # add the new one\n maxes.append(num)\n # recalculate the lowest max for continued comparison\n lowest_max = min(maxes)\n\n return maxes[0] * maxes[1] * maxes[2]","def max(scores):\n return __builtin__.max(scores) if len(scores) else 0","def my_max(in_list):\n biggest = in_list[0]\n for l in in_list:\n if l > biggest:\n biggest = l\n return biggest","def largestPrimeFactor(number):\n factorlist = primeFactors(number)\n maximumfactor = max(factorlist)\n return maximumfactor","def largest_non_adjacent_sum(ints):\n # Initialize the \"with\" and \"without\" last value\n w = 0\n wo = 0\n\n for val in ints:\n # Whatever is higher, that's your highest possible without `val`\n next_wo = max(w, wo)\n\n # \"Without last\" added to val is highest non-adjacent sum\n w = wo + val\n\n # Set the next \"Without last\"\n wo = next_wo\n\n # Return the max of thet two\n return max(w, wo)","def max_list_iter(int_list): # must use iteration not recursion\n if int_list == []:\n return None\n elif int_list == None:\n raise ValueError\n max_int = int_list[0]\n \n for i in int_list:\n if i > max_int:\n max_int = i\n return max_int","def max_pairwise_product_sort(numbers):\n sorted_list = sorted(numbers)\n ans = sorted_list[-1]*sorted_list[-2]\n return ans","def highest_product(arr):\n\n product = 1\n\n for i in range(3):\n # find the max value in the list, get the index, pop it, and mulitply\n product *= arr.pop(arr.index(max(arr)))\n\n return product","def max_list_iter(int_list): # must use iteration not recursion\n if int_list == None: # error handling\n raise ValueError\n elif len(int_list) == 0: # when the list is empty\n return None\n else:\n max_num = int_list[0]\n for num in int_list:\n if num > max_num:\n max_num = num\n return max_num","def main():\n\n s = set()\n\n while True:\n n = input('Enter a number: ')\n if n == -99:\n break\n\n s.add(n)\n\n l = list(s)\n\n if len(l) < 2:\n print 'sorry but the list is too small'\n exit(1)\n\n l.sort()\n print 'The second largest number is', l[-2]","def maximum(some_list):\n return max(some_list)","def argmax(x):\n def op(a, b):\n comp = (a[1] > b[1])\n return comp.if_else(a[0], b[0]), comp.if_else(a[1], b[1])\n return tree_reduce(op, enumerate(x))[0]","def argmax(x):\n def op(a, b):\n comp = (a[1] > b[1])\n return comp.if_else(a[0], b[0]), comp.if_else(a[1], b[1])\n return tree_reduce(op, enumerate(x))[0]","def get_max_combination(total_cuts):\n max_pieces = 0\n for i in range(total_cuts):\n result = i * (total_cuts - i)\n if result > max_pieces:\n max_pieces = result\n print(max_pieces)","def v6_multimax(iterable):\n maximums = []\n for item in iterable:\n if not maximums or maximums[0] == item:\n maximums.append(item)\n elif item > maximums[0]:\n maximums = [item]\n return maximums","def get_big_joker_value(deck: List[int]) -> int:\n return max(deck)","def v3_multimax(iterable):\n max_item = None\n for item in iterable:\n if max_item is None or item > max_item:\n max_item = item\n return [\n item\n for item in iterable\n if item == max_item\n ]","def get_max_num_onsets():\r\n \"\"\" based on the numbers above, should equal to 932945... \"\"\"\r\n c1 = len(gen_onset_c1())\r\n c2 = len(gen_onset_c2())\r\n c3 = len(gen_onset_c3_c4())\r\n c4 = len(gen_onset_c3_c4())\r\n temp = c1\r\n temp = temp + ( c1 * c2 )\r\n temp = temp + ( c1 * c3 )\r\n temp = temp + ( c1 * c2 * c3 )\r\n temp = temp + ( c1 * c3 * c4 )\r\n temp = temp + ( c1 * c2 * c3 * c4 )\r\n return temp","def get_min_max(ints):\n if len(ints) == 0:\n return None, None\n \n min_e = ints[0]\n max_e = ints[-1]\n for e in ints:\n if isinstance(e, int) == False: # if the list includes non-integer number, do not find min, max \n return None,None\n if e < min_e:\n min_e = e\n if e > max_e:\n max_e = e\n return min_e, max_e","def max():\n return KeeperOfMinOrMax(int.__lt__)","def return_max(lst, highest=None):\n if highest is None and len(lst) > 0:\n highest = lst[0]\n if len(lst) <= 1:\n return highest\n highest = max(highest, lst[0])\n return return_max(lst[1:], highest)","def find_max_tidy_num(s_number):\n\n len_input = len(s_number) - 1\n\n if len_input == 0:\n return s_number\n\n for i in range(0, len_input):\n if int(s_number[i]) > int(s_number[i+1]):\n\n final_str = '9' * (len_input - i)\n s_number = s_number[:(i+1)]\n\n return ''.join([find_max_tidy_num(str(int(s_number)-1)), final_str])\n\n return s_number","def findMaximal(freqSet):","def get_min_max(nums):\n assert(type(nums) == list), \"nums has to be a list\"\n assert(len(nums) > 0), \"get_min_max() arg is an empty sequence\"\n min_ = nums[0]\n max_ = nums[0]\n for n in nums:\n assert(type(n) == int), \"numbers in the list have to be an integer\"\n if n < min_:\n min_ = n\n if n > max_:\n max_ = n\n return (min_, max_)","def maxi(a,b):\n\tif a > b: \n\t\treturn a\n\treturn b","def get_max_salary(n, numbers):\n temp_n = n\n result = \"\"\n while temp_n != 0:\n max_num = numbers[0]\n temp_index = 0\n for i in range(0, n):\n max_num = get_max(max_num, numbers[i])\n if(max_num == numbers[i]):\n temp_index = i\n result += str(max_num)\n numbers[temp_index] = 0\n temp_n -= 1\n print(result)","def find_max_sum(triangle):\n while len(triangle) > 1:\n _reduce_triangle(triangle)\n return triangle[0][0]","def get_max_sum4(a):\n return max(get_max_sum2(a), 0)","def max_val(t): \n maxVal = False\n \n def helper(obj):\n nonlocal maxVal\n for el in obj:\n if isinstance(el, int):\n if maxVal == False or maxVal < el:\n maxVal = el\n else:\n helper(el)\n \n helper(t)\n return maxVal","def get_min_max(ints):\n current_max = None\n current_min = None\n\n if (len(ints) == 0) or (ints is None):\n return tuple([current_min, current_max])\n\n for i, n in enumerate(ints):\n if i == 0:\n current_max = n\n current_min = n\n else:\n if n > current_max:\n current_max = n\n elif n < current_min:\n current_min = n\n\n return tuple([current_min, current_max])","def max_product(s):\n # if s == []:\n # return 1\n # elif s[0] in s[2:]:\n # products = [s[0] ** s.count(s[0])]\n # else:\n # products = [s[0] * max(s[2:])]\n # return max(products)\n if s == []:\n return 1\n # elif len(s) == 1:\n # return s[0]\n else:\n return max(s[0] * max_product(s[2:]), max_product(s[1:]))","def max_pairwise_product_fast(numbers):\n num_list = numbers.copy()\n max_num_1 = max(num_list)\n num_list.remove(max_num_1)\n max_num_2 = max(num_list)\n ans = max_num_1*max_num_2\n return ans","def test_max_integer(self):\n self.assertEqual(max_integer([1, 2, 3, 4, 5]), 5)\n self.assertEqual(max_integer([4, 6, 2, 10, 1]), 10)","def second_largest(values: List[int]) -> int:\n try:\n return sorted(set(values))[-2]\n except IndexError:\n raise ValueError(\"second_largest() needs at least two distinct values\")","def maxn(a,b):\n\n if a>b:\n return a\n else:\n return b","def my_max(*args):\n def sorter(sequence):\n \"\"\"\n This function find max in given sequence of simple numbers\n \"\"\"\n def bubble_sort(a):\n \"\"\"\n This function sort the list\n \"\"\"\n for i in reversed(range(len(a))):\n for j in range(1, i + 1):\n if a[j-1] > a[j]:\n a[j], a[j-1] = a[j-1], a[j]\n return a\n\n listed_seq = list(sequence)\n for number in listed_seq:\n if not isinstance(number, int):\n raise ValueError(\"Can't find max, wrong data format\")\n return bubble_sort(listed_seq)[-1]\n\n if not args:\n raise ValueError(\"Can't find max, no data given\")\n if len(args) == 1:\n thing = args[0]\n if isinstance(thing, (list, tuple)):\n return sorter(thing)\n if isinstance(thing, int):\n return thing\n raise ValueError(\"Can't find max, wrong data format\")\n return sorter(args)","def max_list_iter(int_list: Optional[List]) -> Optional[int]:\r\n if int_list is None:\r\n raise ValueError\r\n elif len(int_list) == 0:\r\n return None\r\n elif len(int_list) == 1:\r\n return int_list[0]\r\n else:\r\n maxVal = int_list[0]\r\n for value in int_list:\r\n if value > maxVal:\r\n maxVal = value\r\n return value","def problem41():\n for i in range(len(PANDIGITAL), 1, -1):\n cur_max = 0\n for p in itertools.permutations(PANDIGITAL[:i]):\n n = int(\"\".join(p))\n if pelib.is_prime(n) and n > cur_max:\n cur_max = n\n\n if cur_max > 0:\n return cur_max","def v7_multimax(iterable):\n iterable = list(iterable)\n max_item = max(iterable, default=None)\n return [\n item\n for item in iterable\n if item == max_item\n ]","def largest_item(list):\n pass","def max_list_iter(int_list): # must use iteration not recursion\n if int_list == None:\n raise ValueError(\"Must be list\")\n else:\n if len(int_list) < 1:\n return None\n max = int_list[0]\n for val in int_list:\n if val > max:\n max = val\n return max","def get_min_max(ints):\r\n if len(ints) == 0:\r\n return None\r\n max = ints[0]\r\n min = ints[0]\r\n\r\n for int in ints:\r\n if int < min:\r\n min = int\r\n if int > max:\r\n max = int\r\n \r\n return min, max","def largest_element(a):\n\n return None","def v0_multimax(iterable):\n max_item = None\n for item in iterable:\n if max_item is None or item > max_item:\n max_item = item\n items = []\n for item in iterable:\n if item == max_item:\n items.append(item)\n return items","def solution(resources, args):\n largest_prime_factor = 1\n number = args.number\n prime_generator = primes.get_prime_generator()\n\n while number > 1:\n prime = next(prime_generator)\n if number % prime == 0:\n number /= prime\n largest_prime_factor = prime\n\n if largest_prime_factor == 1:\n largest_prime_factor = args.number\n\n return largest_prime_factor","def max(x):\n pass","def get_min_max(ints):\n if not ints:\n return\n max = ints[0]\n min = ints[0]\n\n\n for i in ints:\n if i > max:\n max = i\n if i < min:\n min = i\n return (min, max)","def max_val(t):\n # Your code here\n\n def openItem(term):\n newList = []\n\n for item in term:\n if type(item) == int:\n newList.append(item)\n\n else:\n newList += openItem(item)\n\n return newList\n\n sortingList = openItem(t)\n\n maximum = sortingList[0]\n\n for item in sortingList:\n if maximum < item:\n maximum = item\n\n return maximum","def maximumProduct2(self, nums: List[int]) -> int:\n big_1 = big_2 = big_3 = -float(\"inf\")\n small_1 = small_2 = float(\"inf\")\n for n in nums:\n if n >= big_1:\n big_1, big_2, big_3 = n, big_1, big_2\n elif n >= big_2:\n big_2, big_3 = n, big_2\n elif n >= big_3:\n big_3 = n\n \n if n <= small_1:\n small_1, small_2 = n, small_1\n elif n <= small_2:\n small_2 = n\n \n return max(big_1 * big_2 * big_3, big_1 * small_1 * small_2)","def allmax(iterable, key=None):\n result, maxcal = [], None\n key = key or (lambda x: x)\n for x in iterable:\n xval = key(x)\n if not result or xval > maxval:\n result, maxval = [x], xval\n elif xval == maxval:\n result.append(x)\n if len(result) == 1:\n result = result[0]\n return result","def get_highest_seat_id(seat_ids):\n\n return max(seat_ids)","def max3(stdin):\n # return max(map(float, stdin.split()))\n return float(run(\"./max3\", [], stdin)[1])","def r_max(nxs):\n largest = None\n first_time = True\n for e in nxs:\n if type(e) == type([]):\n val = r_max(e)\n else:\n val = e\n\n if first_time or val > largest:\n largest = val\n first_time = False\n\n return largest","def get_max_run(run):\n max = 0\n max_i = 0\n for i in range(800, 900):\n if int(run[i]) > int(max):\n max = run[i]\n max_i = i\n return max, max_i","def most_abundant(ids, seqs='ignored'):\r\n id_groups = [len(groups[seq_to_group[i]]) for i in ids]\r\n return ids[argmax(id_groups)]","def max(self, fn=lambda x: x):\n return _(max(*self._, key=fn))","def max_list_iter(int_list): # must use iteration not recursion\n max = \"blank\"\n if int_list is None:\n raise ValueError\n elif len(int_list) == 0:\n return None\n for i in int_list:\n if max == \"blank\":\n max = i\n elif i > max:\n max = i\n return max","def nmax(num, T, nwords):\n top_n = T.argsort()[-num:][::-1]\n for n in top_n:\n nwords.append(data['all_words'][n])\n return nwords","def nmax(num, T, nwords):\n top_n = T.argsort()[-num:][::-1]\n for n in top_n:\n nwords.append(data['all_words'][n])\n return nwords","def nmax(num, T, nwords):\n values = []\n top_n = T.argsort()[-num:][::-1]\n for n in top_n:\n nwords.append(((data['all_words'][n])))\n values.append(round(T[n],3))\n return nwords","def multimax(iterable, key=lambda x: x):\n\n maxes = []\n largest = None\n for element in iterable:\n if largest is None or key(element) > key(largest):\n maxes = [element]\n largest = element\n elif key(element) == key(largest):\n maxes.append(element)\n return maxes","def argmax(sequence):\r\n\r\n import operator\r\n index, value = max(enumerate(sequence), key=operator.itemgetter(1))\r\n\r\n return index"],"string":"[\n \"def largest_int(numbers):\\n\\n if numbers == []:\\n return \\n max_int = numbers[0]\\n for number in numbers:\\n if number > max_int:\\n max_int = number\\n \\n return max_int\",\n \"def max_(lst: Iterable[int]) -> int:\\n return reduce(lambda x, y: x if x > y else y, lst)\",\n \"def max_num(num_list):\\n\\n return max(num_list)\",\n \"def find_greatest_number(incoming_list: list):\\n return max(incoming_list)\",\n \"def max(input: list[int]) -> int:\\n if len(input) == 0:\\n raise ValueError(\\\"max() arg is an empty List\\\")\\n else:\\n input.sort()\\n return input[-1]\",\n \"def find_greatest_number(incoming_list):\\n #magiclownumber= none\\n #retval= magiclownumber\\n #for value in incoming_list:\\n #if not retval:\\n #retval = value\\n # if value> retvale\\n #retval= value\\n #return retval\\n greatest_number = max(incoming_list)\\n return greatest_number\",\n \"def largestNumber(self, nums): \\n def string_comp(item1, item2):\\n return 1 if str(item1) + str(item2) < str(item2) + str(item1) else -1\\n res_list = sorted(nums, key=cmp_to_key(string_comp))\\n\\n # Catch edge case where list of 0s will produce \\\"000..\\\" instead of a single \\\"0\\\"\\n if set(res_list) == {0}:\\n return \\\"0\\\"\\n return \\\"\\\".join([str(i) for i in res_list])\",\n \"def question_24(list_num: int) -> int:\\n return max(list_num, key=list_num.count)\",\n \"def find_greatest_number(incoming_list):\\n retval = max(incoming_list)\\n return retval\",\n \"def list_max(numbers):\\n maxnum = 0\\n \\n for num in numbers[0:]:\\n if num > maxnum:\\n maxnum = num\\n return maxnum\",\n \"def max(input: list[int]) -> int:\\n if len(input) == 0:\\n raise ValueError(\\\"max() arg is an empty List\\\")\\n most: int = input[0]\\n n: int = 1\\n while n < len(input):\\n if input[n] > most:\\n most = input[n]\\n n += 1 \\n return most\",\n \"def find_largest_element(num_1, num_2, num_3):\\n\\n return max([num_1, num_2, num_3])\",\n \"def maxNumber(x):\\n maxVal = x[0]\\n for num in x:\\n if maxVal <num:\\n maxVal=num\\n return maxVal\",\n \"def find_greatest_number(incoming_list):\\n #return_value = max(incoming_list)\\n #return return_value\\n\\n MAGIC_LOW_NUMBER = None\\n retval = MAGIC_LOW_NUMBER\\n\\n # 1,2,3,4,5,1\\n # MAGIC_LOW_NUMBER, 1 ->STORE 1\\n #1 , 2 ->STORE 2\\n #2, , 3 ->STORE 3\\n #3, , 4 ->STORE 4 \\n #4, , 5 ->STORE 5\\n #5, , 1 ->??? nothing \\n for value in incoming_list:\\n if not retval:\\n retval = value\\n if value > retval:\\n retval = value\",\n \"def max(input: list[int]) -> int:\\n i = 0\\n if len(input) == 0:\\n raise ValueError(\\\"max() arg is an empty List\\\")\\n\\n else:\\n while i < len(input):\\n j = i + 1\\n while j < len(input):\\n if input[i] > input[j]:\\n if j == len(input) - 1:\\n if input[i] >= input[len(input) - 1]:\\n return input[i]\\n j += 1\\n else:\\n j += len(input)\\n i += 1\\n return input[len(input) - 1]\",\n \"def largest_sum(data: Iterator[str]) -> int:\\n numbers = parse_input(data)\\n return max(n.magnitude for n in possible_sums(numbers))\",\n \"def largest_product(digits, size):\\n # Why does a blank set of digits have a maximum product of 1?\\n slice_list = slices(digits, size)\\n def mult_reduce(items):\\n total = 1\\n for i in items:\\n total *= i\\n return total\\n slice_list = [mult_reduce(l) for l in slice_list]\\n return max(slice_list)\",\n \"def largest_number(a):\\n\\n array = new_quick_sort(a)\\n\\n largest_number = \\\"\\\"\\n\\n for number in array:\\n largest_number += str(number)\\n\\n return largest_number\",\n \"def max(self, num_list):\\n try:\\n max = int(num_list[0])\\n\\n for number in num_list:\\n try:\\n if number > max:\\n max = number\\n except Exception as e:\\n print(\\\"Error\\\", e)\\n\\n except Exception as e:\\n print(\\\"Error:\\\", e)\\n\\n return max\",\n \"def maxi(a, b):\\n return max(a, b)\",\n \"def greatest_difference(num_list):\",\n \"def highest_product(list_of_ints):\\n\\t# Initialize lists of highest positive integers, # max len 3\\n\\t#\\t\\t\\t\\t lowest positive integers # max len 2\\n\\t# \\t\\t\\t\\t highest negative integers, # max len 2\\n\\t# lowest negative integers # max len 3\\n\\t# \\t Boolean for zero exists in list\\n\\thighest_pos = []\\n\\thighest_neg = []\\n\\tlowest_neg = []\\n\\tlowest_pos = []\\n\\tzero_int_exists = False\\n\\n\\t# Loop thru input list of integers:\\n\\t# \\tBuild lists initialized above, and set zero_int_exists\\n\\n\\tfor i in range(len(list_of_ints)):\\n\\t\\t# Process zero\\n\\t\\tif list_of_ints[i] == 0: \\n\\t\\t\\tzero_int_exists = True\\n\\n\\t\\t# Process positive integer\\n\\t\\telif list_of_ints[i] > 0:\\n\\t\\t\\tif len(highest_pos) < 3:\\n\\t\\t\\t\\thighest_pos.append(list_of_ints[i])\\n\\t\\t\\telif list_of_ints[i] > min(highest_pos):\\n\\t\\t\\t\\thighest_pos.remove(min(highest_pos))\\n\\t\\t\\t\\thighest_pos.append(list_of_ints[i])\\n\\n\\t\\t\\tif len(lowest_pos) < 2:\\n\\t\\t\\t\\tlowest_pos.append(list_of_ints[i])\\n\\t\\t\\telif list_of_ints[i] < max(lowest_pos):\\n\\t\\t\\t\\tlowest_pos.remove(max(lowest_pos))\\n\\t\\t\\t\\tlowest_pos.append(list_of_ints[i])\\n\\t\\t# Process negative integer\\n\\t\\telse:\\n\\t\\t\\tif len(lowest_neg) < 2:\\n\\t\\t\\t\\tlowest_neg.append(list_of_ints[i])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif list_of_ints[i] < max(lowest_neg):\\n\\t\\t\\t\\t\\tlowest_neg.remove(max(lowest_neg))\\n\\t\\t\\t\\t\\tlowest_neg.append(list_of_ints[i])\\n\\n\\t\\t\\tif len(highest_neg) < 3:\\n\\t\\t\\t\\thighest_neg.append(list_of_ints[i])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif list_of_ints[i] > min(highest_neg):\\n\\t\\t\\t\\t\\thighest_neg.remove(min(highest_neg))\\n\\t\\t\\t\\t\\thighest_neg.append(list_of_ints[i]) \\n\\n\\t# Sort lists\\n\\thighest_pos.sort()\\n\\tlowest_pos.sort()\\n\\tlowest_neg.sort()\\n\\thighest_neg.sort()\\n\\n\\t# Print input list, sub-lists\\n\\tprint(\\\"\\\\n\\\", list_of_ints)\\n\\tprint(\\\"zero_int_exists, highest/lowest pos, highest/lowest neg: \\\", \\n\\t\\t\\\"\\\\n\\\", zero_int_exists, highest_pos, lowest_pos, highest_neg, lowest_neg)\\n\\n\\t# Build high product candidates list\\n\\tpossible_high_prods = []\\n\\n\\t# Add positive products to high product candidates list\\n\\tif len(highest_pos) == 3:\\n\\t\\tpossible_high_prods.append(highest_pos[0] * highest_pos[1] * highest_pos[2])\\n\\n\\tif len(lowest_neg) == 2 and len(highest_pos) >= 1:\\n\\t\\tpossible_high_prods.append(lowest_neg[0] * lowest_neg[1] * highest_pos[-1])\\n\\n\\t# If no high product candidates, append zero and negative products to high product candidates\\n\\tif len(possible_high_prods) == 0:\\n\\t\\tif zero_int_exists:\\n\\t\\t\\tpossible_high_prods.append(0)\\n\\t\\telse:\\n\\t\\t\\tif len(lowest_pos) == 0:\\n\\t\\t\\t\\tpossible_high_prods.append(highest_neg[0] * highest_neg[1] * highest_neg[2])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tpossible_high_prods.append(lowest_pos[0] * lowest_pos[1] * lowest_neg[-1])\\n\\t\\n\\tprint(possible_high_prods)\\n\\treturn max(possible_high_prods)\",\n \"def largest(n,xs):\\n return sorted(xs, reverse = True)[:n][::-1]\",\n \"def find_largest_5_digit_number(digits):\\r\\n return max(int(digits[i:i + 5]) for i, v in enumerate(digits))\",\n \"def max_in_list(list):\\n x=list[0] #set x be the first number in the list\\n for i in range(0,len(list)):#go over the number in the list\\n if x<=list[i]: #if the second one is bigger than the first\\n x=list[i] #assign x to the bigger one\\n else:\\n continue#repeat until find the max number\\n return x\",\n \"def max_val(t): \\n \\n result = []\\n if isinstance(t, int):\\n result.append(t)\\n return result\\n elif isinstance (t, (tuple,list)):\\n def update_result(t):\\n for item in t:\\n if isinstance(item, (tuple,list)):\\n update_result(item)\\n else:\\n result.append(item)\\n update_result(t)\\n return max(result)\",\n \"def find_largest_number_in_list(self, list_with_numbers):\\n return 0\",\n \"def maximumProduct1(self, nums: List[int]) -> int:\\n s_nums = sorted(nums, reverse=True)\\n return max(s_nums[0] * s_nums[1] * s_nums[2], s_nums[0] * s_nums[-1] * s_nums[-2])\",\n \"def _max_factor(number, factors):\\n return max(n for n in factors if n <= number)\",\n \"def maximum(self):\\n return max(self.numbers)\",\n \"def max_num_in_list(a_list):\\n max_number = max(a_list)\\n return max_number\",\n \"def four():\\r\\n \\r\\n i = 999\\r\\n j = i\\r\\n largest = 0\\r\\n \\r\\n while i > 0:\\r\\n while j > 0:\\r\\n number = str(i * j)\\r\\n forward = str(number)\\r\\n reverse = \\\"\\\"\\r\\n for char in number:\\r\\n reverse = char + reverse\\r\\n if forward == reverse:\\r\\n if largest < i * j:\\r\\n largest = i * j\\r\\n break\\r\\n else:\\r\\n j = j - 1\\r\\n i = i - 1\\r\\n j = i\\r\\n return largest\",\n \"def r_max(nxs):\\n largest = None\\n for i,e in enumerate(nxs):\\n if type(e) == type([]):\\n val = r_max(e)\\n else:\\n val = e\\n\\n if i == 0 or val > largest:\\n largest = val\\n\\n return largest\",\n \"def get_max(num_one, num_two):\\n temp_a = int(str(num_one) + str(num_two))\\n temp_b = int(str(num_two) + str(num_one))\\n if temp_a >= temp_b:\\n return num_one\\n else:\\n return num_two\",\n \"def largest(*args):\\r\\n if len(args) == 2:\\r\\n a, b = args\\r\\n return switch(a > b, a, b)\\r\\n else:\\r\\n return max(stack(*args), axis=0)\",\n \"def fuction_call(chest):\\n\\n for i in chest:\\n max_i = maximum(chest,i)\\n if max_i >= 2:\\n print(\\\"The maximum size of a set Matyoshka Dolls with outermost doll\\\",i,\\\"is\\\",max_i)\",\n \"def maximum(iterable):\\n max_item = 0\\n if type(iterable) == list or type(iterable) == tuple:\\n for i in iterable:\\n if type(i)==int:\\n if max_item<i:\\n max_item = i\\n else:\\n max_item = -999\\n break\\n else:\\n\\n max_item=-999\\n return max_item\",\n \"def findMaxProduct(n):\\n large = 0\\n for i in range(len(s)):\\n p = 1\\n number = s[i:i+n]\\n for iteration in range(len(number)):\\n h = number[iteration]\\n p = p * int(h)\\n if p > large:\\n large = p\\n\\n \\n return large\",\n \"def highest_product_2(arr):\\n\\n # make a list to store the highest three ints, initializing to first three\\n maxes = [arr[0], arr[1], arr[2]]\\n\\n # find the lowest of the highest three ints\\n lowest_max = min(maxes)\\n\\n # go through the rest of the list to check for higher values\\n for num in arr[3:]:\\n # if any value is higher than the lowest max, update maxes list\\n if num > lowest_max:\\n # remove the old maximum\\n maxes.remove(lowest_max)\\n # add the new one\\n maxes.append(num)\\n # recalculate the lowest max for continued comparison\\n lowest_max = min(maxes)\\n\\n return maxes[0] * maxes[1] * maxes[2]\",\n \"def max(scores):\\n return __builtin__.max(scores) if len(scores) else 0\",\n \"def my_max(in_list):\\n biggest = in_list[0]\\n for l in in_list:\\n if l > biggest:\\n biggest = l\\n return biggest\",\n \"def largestPrimeFactor(number):\\n factorlist = primeFactors(number)\\n maximumfactor = max(factorlist)\\n return maximumfactor\",\n \"def largest_non_adjacent_sum(ints):\\n # Initialize the \\\"with\\\" and \\\"without\\\" last value\\n w = 0\\n wo = 0\\n\\n for val in ints:\\n # Whatever is higher, that's your highest possible without `val`\\n next_wo = max(w, wo)\\n\\n # \\\"Without last\\\" added to val is highest non-adjacent sum\\n w = wo + val\\n\\n # Set the next \\\"Without last\\\"\\n wo = next_wo\\n\\n # Return the max of thet two\\n return max(w, wo)\",\n \"def max_list_iter(int_list): # must use iteration not recursion\\n if int_list == []:\\n return None\\n elif int_list == None:\\n raise ValueError\\n max_int = int_list[0]\\n \\n for i in int_list:\\n if i > max_int:\\n max_int = i\\n return max_int\",\n \"def max_pairwise_product_sort(numbers):\\n sorted_list = sorted(numbers)\\n ans = sorted_list[-1]*sorted_list[-2]\\n return ans\",\n \"def highest_product(arr):\\n\\n product = 1\\n\\n for i in range(3):\\n # find the max value in the list, get the index, pop it, and mulitply\\n product *= arr.pop(arr.index(max(arr)))\\n\\n return product\",\n \"def max_list_iter(int_list): # must use iteration not recursion\\n if int_list == None: # error handling\\n raise ValueError\\n elif len(int_list) == 0: # when the list is empty\\n return None\\n else:\\n max_num = int_list[0]\\n for num in int_list:\\n if num > max_num:\\n max_num = num\\n return max_num\",\n \"def main():\\n\\n s = set()\\n\\n while True:\\n n = input('Enter a number: ')\\n if n == -99:\\n break\\n\\n s.add(n)\\n\\n l = list(s)\\n\\n if len(l) < 2:\\n print 'sorry but the list is too small'\\n exit(1)\\n\\n l.sort()\\n print 'The second largest number is', l[-2]\",\n \"def maximum(some_list):\\n return max(some_list)\",\n \"def argmax(x):\\n def op(a, b):\\n comp = (a[1] > b[1])\\n return comp.if_else(a[0], b[0]), comp.if_else(a[1], b[1])\\n return tree_reduce(op, enumerate(x))[0]\",\n \"def argmax(x):\\n def op(a, b):\\n comp = (a[1] > b[1])\\n return comp.if_else(a[0], b[0]), comp.if_else(a[1], b[1])\\n return tree_reduce(op, enumerate(x))[0]\",\n \"def get_max_combination(total_cuts):\\n max_pieces = 0\\n for i in range(total_cuts):\\n result = i * (total_cuts - i)\\n if result > max_pieces:\\n max_pieces = result\\n print(max_pieces)\",\n \"def v6_multimax(iterable):\\n maximums = []\\n for item in iterable:\\n if not maximums or maximums[0] == item:\\n maximums.append(item)\\n elif item > maximums[0]:\\n maximums = [item]\\n return maximums\",\n \"def get_big_joker_value(deck: List[int]) -> int:\\n return max(deck)\",\n \"def v3_multimax(iterable):\\n max_item = None\\n for item in iterable:\\n if max_item is None or item > max_item:\\n max_item = item\\n return [\\n item\\n for item in iterable\\n if item == max_item\\n ]\",\n \"def get_max_num_onsets():\\r\\n \\\"\\\"\\\" based on the numbers above, should equal to 932945... \\\"\\\"\\\"\\r\\n c1 = len(gen_onset_c1())\\r\\n c2 = len(gen_onset_c2())\\r\\n c3 = len(gen_onset_c3_c4())\\r\\n c4 = len(gen_onset_c3_c4())\\r\\n temp = c1\\r\\n temp = temp + ( c1 * c2 )\\r\\n temp = temp + ( c1 * c3 )\\r\\n temp = temp + ( c1 * c2 * c3 )\\r\\n temp = temp + ( c1 * c3 * c4 )\\r\\n temp = temp + ( c1 * c2 * c3 * c4 )\\r\\n return temp\",\n \"def get_min_max(ints):\\n if len(ints) == 0:\\n return None, None\\n \\n min_e = ints[0]\\n max_e = ints[-1]\\n for e in ints:\\n if isinstance(e, int) == False: # if the list includes non-integer number, do not find min, max \\n return None,None\\n if e < min_e:\\n min_e = e\\n if e > max_e:\\n max_e = e\\n return min_e, max_e\",\n \"def max():\\n return KeeperOfMinOrMax(int.__lt__)\",\n \"def return_max(lst, highest=None):\\n if highest is None and len(lst) > 0:\\n highest = lst[0]\\n if len(lst) <= 1:\\n return highest\\n highest = max(highest, lst[0])\\n return return_max(lst[1:], highest)\",\n \"def find_max_tidy_num(s_number):\\n\\n len_input = len(s_number) - 1\\n\\n if len_input == 0:\\n return s_number\\n\\n for i in range(0, len_input):\\n if int(s_number[i]) > int(s_number[i+1]):\\n\\n final_str = '9' * (len_input - i)\\n s_number = s_number[:(i+1)]\\n\\n return ''.join([find_max_tidy_num(str(int(s_number)-1)), final_str])\\n\\n return s_number\",\n \"def findMaximal(freqSet):\",\n \"def get_min_max(nums):\\n assert(type(nums) == list), \\\"nums has to be a list\\\"\\n assert(len(nums) > 0), \\\"get_min_max() arg is an empty sequence\\\"\\n min_ = nums[0]\\n max_ = nums[0]\\n for n in nums:\\n assert(type(n) == int), \\\"numbers in the list have to be an integer\\\"\\n if n < min_:\\n min_ = n\\n if n > max_:\\n max_ = n\\n return (min_, max_)\",\n \"def maxi(a,b):\\n\\tif a > b: \\n\\t\\treturn a\\n\\treturn b\",\n \"def get_max_salary(n, numbers):\\n temp_n = n\\n result = \\\"\\\"\\n while temp_n != 0:\\n max_num = numbers[0]\\n temp_index = 0\\n for i in range(0, n):\\n max_num = get_max(max_num, numbers[i])\\n if(max_num == numbers[i]):\\n temp_index = i\\n result += str(max_num)\\n numbers[temp_index] = 0\\n temp_n -= 1\\n print(result)\",\n \"def find_max_sum(triangle):\\n while len(triangle) > 1:\\n _reduce_triangle(triangle)\\n return triangle[0][0]\",\n \"def get_max_sum4(a):\\n return max(get_max_sum2(a), 0)\",\n \"def max_val(t): \\n maxVal = False\\n \\n def helper(obj):\\n nonlocal maxVal\\n for el in obj:\\n if isinstance(el, int):\\n if maxVal == False or maxVal < el:\\n maxVal = el\\n else:\\n helper(el)\\n \\n helper(t)\\n return maxVal\",\n \"def get_min_max(ints):\\n current_max = None\\n current_min = None\\n\\n if (len(ints) == 0) or (ints is None):\\n return tuple([current_min, current_max])\\n\\n for i, n in enumerate(ints):\\n if i == 0:\\n current_max = n\\n current_min = n\\n else:\\n if n > current_max:\\n current_max = n\\n elif n < current_min:\\n current_min = n\\n\\n return tuple([current_min, current_max])\",\n \"def max_product(s):\\n # if s == []:\\n # return 1\\n # elif s[0] in s[2:]:\\n # products = [s[0] ** s.count(s[0])]\\n # else:\\n # products = [s[0] * max(s[2:])]\\n # return max(products)\\n if s == []:\\n return 1\\n # elif len(s) == 1:\\n # return s[0]\\n else:\\n return max(s[0] * max_product(s[2:]), max_product(s[1:]))\",\n \"def max_pairwise_product_fast(numbers):\\n num_list = numbers.copy()\\n max_num_1 = max(num_list)\\n num_list.remove(max_num_1)\\n max_num_2 = max(num_list)\\n ans = max_num_1*max_num_2\\n return ans\",\n \"def test_max_integer(self):\\n self.assertEqual(max_integer([1, 2, 3, 4, 5]), 5)\\n self.assertEqual(max_integer([4, 6, 2, 10, 1]), 10)\",\n \"def second_largest(values: List[int]) -> int:\\n try:\\n return sorted(set(values))[-2]\\n except IndexError:\\n raise ValueError(\\\"second_largest() needs at least two distinct values\\\")\",\n \"def maxn(a,b):\\n\\n if a>b:\\n return a\\n else:\\n return b\",\n \"def my_max(*args):\\n def sorter(sequence):\\n \\\"\\\"\\\"\\n This function find max in given sequence of simple numbers\\n \\\"\\\"\\\"\\n def bubble_sort(a):\\n \\\"\\\"\\\"\\n This function sort the list\\n \\\"\\\"\\\"\\n for i in reversed(range(len(a))):\\n for j in range(1, i + 1):\\n if a[j-1] > a[j]:\\n a[j], a[j-1] = a[j-1], a[j]\\n return a\\n\\n listed_seq = list(sequence)\\n for number in listed_seq:\\n if not isinstance(number, int):\\n raise ValueError(\\\"Can't find max, wrong data format\\\")\\n return bubble_sort(listed_seq)[-1]\\n\\n if not args:\\n raise ValueError(\\\"Can't find max, no data given\\\")\\n if len(args) == 1:\\n thing = args[0]\\n if isinstance(thing, (list, tuple)):\\n return sorter(thing)\\n if isinstance(thing, int):\\n return thing\\n raise ValueError(\\\"Can't find max, wrong data format\\\")\\n return sorter(args)\",\n \"def max_list_iter(int_list: Optional[List]) -> Optional[int]:\\r\\n if int_list is None:\\r\\n raise ValueError\\r\\n elif len(int_list) == 0:\\r\\n return None\\r\\n elif len(int_list) == 1:\\r\\n return int_list[0]\\r\\n else:\\r\\n maxVal = int_list[0]\\r\\n for value in int_list:\\r\\n if value > maxVal:\\r\\n maxVal = value\\r\\n return value\",\n \"def problem41():\\n for i in range(len(PANDIGITAL), 1, -1):\\n cur_max = 0\\n for p in itertools.permutations(PANDIGITAL[:i]):\\n n = int(\\\"\\\".join(p))\\n if pelib.is_prime(n) and n > cur_max:\\n cur_max = n\\n\\n if cur_max > 0:\\n return cur_max\",\n \"def v7_multimax(iterable):\\n iterable = list(iterable)\\n max_item = max(iterable, default=None)\\n return [\\n item\\n for item in iterable\\n if item == max_item\\n ]\",\n \"def largest_item(list):\\n pass\",\n \"def max_list_iter(int_list): # must use iteration not recursion\\n if int_list == None:\\n raise ValueError(\\\"Must be list\\\")\\n else:\\n if len(int_list) < 1:\\n return None\\n max = int_list[0]\\n for val in int_list:\\n if val > max:\\n max = val\\n return max\",\n \"def get_min_max(ints):\\r\\n if len(ints) == 0:\\r\\n return None\\r\\n max = ints[0]\\r\\n min = ints[0]\\r\\n\\r\\n for int in ints:\\r\\n if int < min:\\r\\n min = int\\r\\n if int > max:\\r\\n max = int\\r\\n \\r\\n return min, max\",\n \"def largest_element(a):\\n\\n return None\",\n \"def v0_multimax(iterable):\\n max_item = None\\n for item in iterable:\\n if max_item is None or item > max_item:\\n max_item = item\\n items = []\\n for item in iterable:\\n if item == max_item:\\n items.append(item)\\n return items\",\n \"def solution(resources, args):\\n largest_prime_factor = 1\\n number = args.number\\n prime_generator = primes.get_prime_generator()\\n\\n while number > 1:\\n prime = next(prime_generator)\\n if number % prime == 0:\\n number /= prime\\n largest_prime_factor = prime\\n\\n if largest_prime_factor == 1:\\n largest_prime_factor = args.number\\n\\n return largest_prime_factor\",\n \"def max(x):\\n pass\",\n \"def get_min_max(ints):\\n if not ints:\\n return\\n max = ints[0]\\n min = ints[0]\\n\\n\\n for i in ints:\\n if i > max:\\n max = i\\n if i < min:\\n min = i\\n return (min, max)\",\n \"def max_val(t):\\n # Your code here\\n\\n def openItem(term):\\n newList = []\\n\\n for item in term:\\n if type(item) == int:\\n newList.append(item)\\n\\n else:\\n newList += openItem(item)\\n\\n return newList\\n\\n sortingList = openItem(t)\\n\\n maximum = sortingList[0]\\n\\n for item in sortingList:\\n if maximum < item:\\n maximum = item\\n\\n return maximum\",\n \"def maximumProduct2(self, nums: List[int]) -> int:\\n big_1 = big_2 = big_3 = -float(\\\"inf\\\")\\n small_1 = small_2 = float(\\\"inf\\\")\\n for n in nums:\\n if n >= big_1:\\n big_1, big_2, big_3 = n, big_1, big_2\\n elif n >= big_2:\\n big_2, big_3 = n, big_2\\n elif n >= big_3:\\n big_3 = n\\n \\n if n <= small_1:\\n small_1, small_2 = n, small_1\\n elif n <= small_2:\\n small_2 = n\\n \\n return max(big_1 * big_2 * big_3, big_1 * small_1 * small_2)\",\n \"def allmax(iterable, key=None):\\n result, maxcal = [], None\\n key = key or (lambda x: x)\\n for x in iterable:\\n xval = key(x)\\n if not result or xval > maxval:\\n result, maxval = [x], xval\\n elif xval == maxval:\\n result.append(x)\\n if len(result) == 1:\\n result = result[0]\\n return result\",\n \"def get_highest_seat_id(seat_ids):\\n\\n return max(seat_ids)\",\n \"def max3(stdin):\\n # return max(map(float, stdin.split()))\\n return float(run(\\\"./max3\\\", [], stdin)[1])\",\n \"def r_max(nxs):\\n largest = None\\n first_time = True\\n for e in nxs:\\n if type(e) == type([]):\\n val = r_max(e)\\n else:\\n val = e\\n\\n if first_time or val > largest:\\n largest = val\\n first_time = False\\n\\n return largest\",\n \"def get_max_run(run):\\n max = 0\\n max_i = 0\\n for i in range(800, 900):\\n if int(run[i]) > int(max):\\n max = run[i]\\n max_i = i\\n return max, max_i\",\n \"def most_abundant(ids, seqs='ignored'):\\r\\n id_groups = [len(groups[seq_to_group[i]]) for i in ids]\\r\\n return ids[argmax(id_groups)]\",\n \"def max(self, fn=lambda x: x):\\n return _(max(*self._, key=fn))\",\n \"def max_list_iter(int_list): # must use iteration not recursion\\n max = \\\"blank\\\"\\n if int_list is None:\\n raise ValueError\\n elif len(int_list) == 0:\\n return None\\n for i in int_list:\\n if max == \\\"blank\\\":\\n max = i\\n elif i > max:\\n max = i\\n return max\",\n \"def nmax(num, T, nwords):\\n top_n = T.argsort()[-num:][::-1]\\n for n in top_n:\\n nwords.append(data['all_words'][n])\\n return nwords\",\n \"def nmax(num, T, nwords):\\n top_n = T.argsort()[-num:][::-1]\\n for n in top_n:\\n nwords.append(data['all_words'][n])\\n return nwords\",\n \"def nmax(num, T, nwords):\\n values = []\\n top_n = T.argsort()[-num:][::-1]\\n for n in top_n:\\n nwords.append(((data['all_words'][n])))\\n values.append(round(T[n],3))\\n return nwords\",\n \"def multimax(iterable, key=lambda x: x):\\n\\n maxes = []\\n largest = None\\n for element in iterable:\\n if largest is None or key(element) > key(largest):\\n maxes = [element]\\n largest = element\\n elif key(element) == key(largest):\\n maxes.append(element)\\n return maxes\",\n \"def argmax(sequence):\\r\\n\\r\\n import operator\\r\\n index, value = max(enumerate(sequence), key=operator.itemgetter(1))\\r\\n\\r\\n return index\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7238424","0.68917364","0.6735405","0.66264164","0.66255736","0.6614427","0.66113424","0.65993583","0.6570257","0.6552687","0.65461093","0.65238184","0.64182717","0.63805205","0.63039565","0.6295779","0.62524813","0.6228118","0.6196727","0.61448497","0.6130623","0.6117291","0.60730374","0.6063948","0.6002691","0.5999068","0.5992838","0.5965339","0.5955259","0.5923953","0.5910738","0.5883439","0.5850895","0.584759","0.5834415","0.58312804","0.58267516","0.5811956","0.58103985","0.58023214","0.57993406","0.57965","0.5780224","0.57713234","0.57699716","0.5766857","0.57666296","0.5753352","0.57525694","0.57521755","0.57521755","0.5751405","0.57511014","0.5743666","0.5743331","0.57398784","0.5738172","0.57294744","0.5718056","0.5716913","0.57158893","0.5708848","0.5701768","0.57012486","0.5687569","0.56838703","0.5682839","0.568168","0.5664108","0.5663767","0.5661589","0.5657534","0.5651706","0.5641533","0.56404275","0.563531","0.5629351","0.5615578","0.56028336","0.5592997","0.5584714","0.5572069","0.55655944","0.55635446","0.55583596","0.5555175","0.55545044","0.5552045","0.55520016","0.55491394","0.55469674","0.5544446","0.5523525","0.55170614","0.5516624","0.55043536","0.55043536","0.54919314","0.54892516","0.54879713"],"string":"[\n \"0.7238424\",\n \"0.68917364\",\n \"0.6735405\",\n \"0.66264164\",\n \"0.66255736\",\n \"0.6614427\",\n \"0.66113424\",\n \"0.65993583\",\n \"0.6570257\",\n \"0.6552687\",\n \"0.65461093\",\n \"0.65238184\",\n \"0.64182717\",\n \"0.63805205\",\n \"0.63039565\",\n \"0.6295779\",\n \"0.62524813\",\n \"0.6228118\",\n \"0.6196727\",\n \"0.61448497\",\n \"0.6130623\",\n \"0.6117291\",\n \"0.60730374\",\n \"0.6063948\",\n \"0.6002691\",\n \"0.5999068\",\n \"0.5992838\",\n \"0.5965339\",\n \"0.5955259\",\n \"0.5923953\",\n \"0.5910738\",\n \"0.5883439\",\n \"0.5850895\",\n \"0.584759\",\n \"0.5834415\",\n \"0.58312804\",\n \"0.58267516\",\n \"0.5811956\",\n \"0.58103985\",\n \"0.58023214\",\n \"0.57993406\",\n \"0.57965\",\n \"0.5780224\",\n \"0.57713234\",\n \"0.57699716\",\n \"0.5766857\",\n \"0.57666296\",\n \"0.5753352\",\n \"0.57525694\",\n \"0.57521755\",\n \"0.57521755\",\n \"0.5751405\",\n \"0.57511014\",\n \"0.5743666\",\n \"0.5743331\",\n \"0.57398784\",\n \"0.5738172\",\n \"0.57294744\",\n \"0.5718056\",\n \"0.5716913\",\n \"0.57158893\",\n \"0.5708848\",\n \"0.5701768\",\n \"0.57012486\",\n \"0.5687569\",\n \"0.56838703\",\n \"0.5682839\",\n \"0.568168\",\n \"0.5664108\",\n \"0.5663767\",\n \"0.5661589\",\n \"0.5657534\",\n \"0.5651706\",\n \"0.5641533\",\n \"0.56404275\",\n \"0.563531\",\n \"0.5629351\",\n \"0.5615578\",\n \"0.56028336\",\n \"0.5592997\",\n \"0.5584714\",\n \"0.5572069\",\n \"0.55655944\",\n \"0.55635446\",\n \"0.55583596\",\n \"0.5555175\",\n \"0.55545044\",\n \"0.5552045\",\n \"0.55520016\",\n \"0.55491394\",\n \"0.55469674\",\n \"0.5544446\",\n \"0.5523525\",\n \"0.55170614\",\n \"0.5516624\",\n \"0.55043536\",\n \"0.55043536\",\n \"0.54919314\",\n \"0.54892516\",\n \"0.54879713\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6804858"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":94,"cells":{"query":{"kind":"string","value":"A function to build the neural network of the required size using the weights and biases provided. Instead of doing this, can we use a simple constructor method and initalize them post the construction? That would be sensible and faster."},"document":{"kind":"string","value":"def neural_net(self, layers):\n model = nn.Sequential()\n for l in range(0, len(layers) - 1):\n model.add_module(\"layer_\"+str(l), nn.Linear(layers[l],layers[l+1], bias=True))\n if l != len(layers) - 2:\n model.add_module(\"tanh_\"+str(l), nn.Tanh())\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 __init__(self, sizes):\r\n self.num_layers = len(sizes)\r\n self.sizes = sizes\r\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\r\n self.weights = [np.random.randn(y, x)\r\n for x, y in zip(sizes[:-1], sizes[1:])]","def __init__(self, sizes):\n self.num_layers = len(sizes)\n self.sizes = sizes\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\n self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]","def __init__(self, sizes):\r\n self.num_layers = len(sizes)\r\n self.sizes = sizes\r\n\r\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\r\n self.weights = [np.random.randn(y, x)\r\n for x, y in zip(sizes[:-1], sizes[1:])]","def __init__(self, sizes):\n self.num_layers = len(sizes)\n self.sizes = sizes\n self.biases = [cp.array(cp.random.randn(y, 1)) for y in sizes[1:]]\n self.weights = [cp.array(cp.random.randn(y, x))\n for x, y in zip(sizes[:-1], sizes[1:])]","def __init__(self, sizes: list):\n self.num_layers = len(sizes)\n self.sizes = sizes\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\n self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]","def __init__(self, netSize):\n\t\t\n\t\t# TRY THIS FOR RANDOM!\n\t\t#\n\t\t#\n\t\t#\n\t\t\n\t\tself.biases = [self.randomArray(i, 1) for i in netSize[1:]] # Biases do not exist for the first layer ! Those are inputs.\n\t\tself.netSize = netSize\n\t\t#Initialize Weights\n\t\t#This initializes the weights for each layer based on the size. The number of rows should be\n\t\t#the number of neurons for the current, and the number of columns should be the same as the number of neurons\n\t\t#in the next layer. There are no weights for the last layer. That's the output layer.\n\t\tself.weights \t\t = [self.randomArray(i, j) for i, j in zip(netSize[:-1], netSize[1:]) ]","def __init__(self, input_size, neurons):\n super().__init__()\n self.input_size = input_size\n self.neurons = neurons\n self.params[\"w\"] = np.random.randn(input_size, neurons)\n self.params[\"b\"] = np.random.randn(1, neurons)\n self.grads = {}","def __init__(self, layerNeurons, numberOfLayers, initialWeights = None, lowerBound = None, upperBound = None):\r\n \r\n # Ensure that there is at-least one input and one output layer in the network\r\n assert len(layerNeurons) > 1, \"At least one input layer and one output layer is needed\"\r\n \r\n # Get the total number of weights needed in the network\r\n totalWeightCount = NeuralNetwork.getSizeOfWeightVector(layerNeurons)*numberOfLayers\r\n \r\n # Initialise the weights with the initialiser or random values\r\n if initialWeights is None:\r\n if lowerBound is None:\r\n lowerBound=-1/np.sqrt(layerNeurons[0])\r\n if upperBound is None:\r\n upperBound=1/np.sqrt(layerNeurons[0])\r\n self.weights = np.random.uniform(lowerBound, upperBound, totalWeightCount)\r\n else:\r\n assert initialWeights.size == totalWeightCount, (\"Length of initial weight matrix incorrect. You need \"+str(totalWeightCount)+\" weights\")\r\n self.weights = initialWeights.view()\r\n \r\n self.weights.shape = (numberOfLayers, -1)\r\n # create an empty array of layers\r\n self.layers = []\r\n layerBlockStart = 0\r\n \r\n for layerInputDimention, layerOutputDimention in zip(layerNeurons, layerNeurons[1:]):\r\n # initialise each layer with its input and output dimentions and bi-directional pointers to the relivant weights\r\n layerBlockEnd = layerBlockStart+(layerInputDimention*layerOutputDimention)\r\n layerBiasEnd = layerBlockEnd+layerOutputDimention\r\n newLayer = batchNetworkLayer(layerInputDimention, layerOutputDimention, numberOfLayers, \r\n self.weights[..., :, layerBlockStart:layerBlockEnd], \r\n self.weights[..., :, layerBlockEnd:layerBiasEnd])\r\n self.layers.append(newLayer)\r\n \r\n layerBlockStart = layerBiasEnd","def __init__(self, sizes, cost=CrossEntropyCost):\n self.num_layers = len(sizes)\n self.sizes = sizes\n self.default_weight_initializer()\n self.cost=cost","def __init__(self, sizes):\n self.sizes = sizes\n self.biases = [random_matrix(1, y)[0] for y in sizes[1:]]\n self.weights = [random_matrix(y, x)\n for x, y in zip(sizes[:-1], sizes[1:])]\n\n self.weighted_layer = []\n self.activations = []","def __init__(self,\n input_size,\n output_size,\n hidden_size=[50, 50],\n weights_initializer=tf.initializers.glorot_uniform(),\n bias_initializer=tf.initializers.zeros(),\n optimizer=tf.optimizers.Adam,\n **optimizer_kwargs):\n self.input_size = input_size\n self.output_size = output_size\n self.hidden_size = hidden_size\n\n np.random.seed(41)\n\n self.initialize_weights(weights_initializer, bias_initializer)\n self.optimizer = optimizer(**optimizer_kwargs)","def __init__(self, input_size, hidden_sizes, output_size, std=1e-4, bstd=1e-4):\r\n num_hidden_layers = len(hidden_sizes)\r\n \r\n # initialize weight matrices\r\n self.weights = []\r\n if num_hidden_layers > 0:\r\n for i in xrange(num_hidden_layers):\r\n if i == 0:\r\n self.weights.append(std * np.random.randn(input_size, hidden_sizes[0]))\r\n else:\r\n self.weights.append(std * np.random.randn(hidden_sizes[i-1], hidden_sizes[i]))\r\n self.weights.append(std * np.random.randn(hidden_sizes[-1], output_size))\r\n else:\r\n self.weights.append(std * np.random.randn(input_size, output_size))\r\n \r\n # initialize bias vectors\r\n self.biases = []\r\n for i in xrange(num_hidden_layers):\r\n self.biases.append(bstd * np.random.randn(hidden_sizes[i]))\r\n self.biases.append(bstd * np.random.randn(output_size))","def __init__(self, layerNeurons, initialWeights = None, layerTypes=None, **kwargs):\r\n \r\n # Ensure that there is at-least one input and one output layer in the network\r\n assert len(layerNeurons)>1, \"At least one input layer and one output layer is needed\"\r\n \r\n # Get the total number of weights needed in the network\r\n totalWeightCount = NeuralNetwork.getSizeOfWeightVector(layerNeurons)\r\n \r\n # Initialise the weights with the initializer or random values\r\n if initialWeights is None:\r\n self.weights = np.random.uniform(-1/np.sqrt(layerNeurons[0]), 1/np.sqrt(layerNeurons[0]), totalWeightCount)\r\n else:\r\n assert len(initialWeights) == totalWeightCount, (\"Length of initial weight matrix incorrect. You need \"+str(totalWeightCount)+\" weights\")\r\n self.weights = np.array(initialWeights, dtype = np.float64) \r\n \r\n # create an empty array of layers\r\n self.layers = []\r\n layerBlockStart = 0\r\n \r\n if layerTypes is None or len(layerTypes)<(len(layerNeurons)-1):\r\n layerTypes=[NetworkLayer]*(len(layerNeurons)-1)\r\n \r\n for layerInputDimention, layerOutputDimention, layerType in zip(layerNeurons, layerNeurons[1:], layerTypes):\r\n # initialise each layer with its input and output dimentions and bi-directional pointers to the relivant weights\r\n layerBlockEnd = layerBlockStart+(layerInputDimention*layerOutputDimention)\r\n layerBiasEnd = layerBlockEnd+layerOutputDimention\r\n newLayer = layerType(layerInputDimention, layerOutputDimention, \r\n self.weights[..., layerBlockStart:layerBlockEnd], \r\n self.weights[..., layerBlockEnd:layerBiasEnd], **kwargs)\r\n self.layers.append(newLayer)\r\n \r\n layerBlockStart = layerBiasEnd\r\n \r\n # Tell the output later to use a different function to calculate the delta \r\n newLayer.calcDelta = newLayer.calcDeltaOutputLayer","def build(self,input_shape):\n\n self.w = self.add_weight(shape=(input_shape[-1],self.units),\n initializer='random_normal',\n trainable=True)\n self.b = self.add_weight(shape=(self.units,),\n initializer='random_normal',\n trainable=True)","def build(self):\n\n self.W = self.init([self.n_atom_input_feat, self.n_output])\n self.b = model_ops.zeros(shape=[\n self.n_output,\n ])\n\n self.trainable_weights = self.W + self.b","def __init__(self, *args, **kwargs):\n self.params = kwargs\n self.output_len = kwargs['num_neurons']\n self.input_len = kwargs['input_len']\n self.weights = Vector(data=np.random.randn(self.output_len, self.input_len))\n self.biases = Vector(data=np.zeros((self.output_len, 1)))\n self.input_activations = None\n self.output_activations = Vector()","def __init__(self, input_size, output_size, hidden_sizes=[],\r\n learning_rate=2.0, weight_scale=0.1, converge=0.01,\r\n random_seed=None):\r\n if random_seed is not None:\r\n seed(random_seed)\r\n\r\n weight_func = partial(normal, 0, weight_scale)\r\n self.converge = converge\r\n self.layers = []\r\n self.layers.append([InputNode(\"in_\" + str(i)) for i in range(input_size)])\r\n for i,layer_size in enumerate(hidden_sizes):\r\n self.layers.append([SigmoidNode(\"hidden_\"+str(i)+\"-\"+str(j),\r\n learning_rate) for j in range(layer_size)])\r\n self.layers.append([SigmoidNode(\"out_\"+str(i), learning_rate) for i\r\n in range(output_size)])\r\n\r\n # densely connect consecutive layers\r\n for source_layer, dest_layer in zip(self.layers, self.layers[1:]):\r\n for source, dest in product(source_layer, dest_layer):\r\n edge = Edge(source, dest, weight_func)\r\n source.out_edges.append(edge)\r\n dest.in_edges.append(edge)\r\n\r\n # connect each node to bias\r\n self.bias = BiasNode()\r\n for layer in self.layers[1:]:\r\n for node in layer:\r\n e = Edge(self.bias, node, weight_func)\r\n node.in_edges.append(e)\r\n self.bias.out_edges.append(e)","def __init__(self, layer_sizes, act_func=Sigmoid, cost_func=CrossEntropy, metric=AccuracyMetric):\n np.random.seed(1) # Used for constant weights and biases initialization. Fell free to change it.\n\n self.layers_num = len(layer_sizes)\n self.act_func = act_func\n self.cost_func = cost_func\n self.metric = metric\n self.biases = [np.random.random(i) for i in layer_sizes[1:]]\n self.weights = [np.random.normal(loc=0, scale=(1 / np.sqrt(layer_sizes[0])), size=(j, i))\n for j, i in zip(layer_sizes[1:], layer_sizes[:-1])]\n self.costs = []\n self.accuracies = []\n self.eta = 0\n self.lambda_r = 0","def __init__(self, num_units, input_size=None,\n nonlinearity=tf.nn.tanh,\n W_init=tf.random_normal_initializer(stddev=0.15),\n b_init=tf.constant_initializer(0.0, dtype=tf.float32),\n weightnorm=False):\n self._num_units = num_units\n self._input_size = input_size or num_units\n self._W_init = W_init\n self._b_init = b_init\n self._weightnorm = weightnorm\n self._nonlin = nonlinearity","def construct_network(self, n_units, n_samples=1, noise_dim=0,\n keep_p=1., nonlinearity=True, init_params=None, name=\"\"):\n print \"constructing network, n_units: \",n_units\n # TODO use kwargs for more elagant solutions to being called by this \n # base class\n assert keep_p ==1. and nonlinearity and noise_dim == 0\n\n assert init_params is None # this is implemented only in the Bayesian flow version of this function\n\n ### Define parameters of the network\n self.weights, self.biases, KL = {}, {}, 0.\n self.layers = []\n # Establish paramters of appromiate posterior over weights and\n # biases.\n for l in range(1, len(n_units)):\n with tf.variable_scope(name+'Layer_%d'%l):\n n_in, n_out = n_units[l-1], n_units[l]\n\n # use non neglidgible uncertainty if we are doing VI\n sigma_init = self.init_sigma_params\n\n w_prior_sigma, b_prior_sigma = self.w_prior_sigma, self.w_prior_sigma\n mu_init_sigma_w, mu_init_sigma_b = np.sqrt(1./(n_in)), 1.\n\n (w_mu, w_logstd), _, w_KL = utils.set_q(name+\"w_%d\"%l,\n sigma_prior=w_prior_sigma, mu_init_sigma=mu_init_sigma_w,\n sigma_init=sigma_init, n_samples=0,\n size=[n_in, n_out], save_summary=True)\n\n # We use same init_sigma for weights and biases.\n (b_mu, b_logstd), _, b_KL = utils.set_q(name+\"b_%d\"%l,\n sigma_prior=b_prior_sigma, mu_init_sigma=mu_init_sigma_b,\n sigma_init=sigma_init, n_samples=0,\n size=[n_out], save_summary=True)\n self.weights['w_%d_mu'%l], self.weights['w_%d_std'%l] = w_mu, tf.nn.softplus(w_logstd)\n self.biases['b_%d_mu'%l], self.biases['b_%d_std'%l] = b_mu, tf.nn.softplus(b_logstd)\n\n self.params += [w_mu, b_mu, w_logstd, b_logstd]\n KL += w_KL + b_KL\n\n # Add an extra dimension to correspond to samples.\n prev_layer = tf.stack([self.x]*n_samples)\n self.layers.append(prev_layer)\n # shape is [n_samples, ?, dim(x)]\n\n ### Define activations in each layer\n for l in range(1,len(n_units)):\n print \"defining activations in layer %d\"%l\n # Multiply with weight matrix and add bias\n prev_layer = tf.reshape(prev_layer, [-1, n_units[l-1]])\n layer_pre_bias = tf.matmul(prev_layer, self.weights['w_%d_mu'%l])\n layer_pre_bias = tf.reshape(layer_pre_bias, [n_samples, -1, n_units[l]])\n # Shape of layer_pre_bias is [n_samples, ?, n_units[l]]\n\n # add mean bias term\n layer = tf.add(layer_pre_bias, self.biases['b_%d_mu'%l][None, None, :])\n\n # Calculate the noise in each hidden unit.\n # must use absolute value of activation because final layer may\n # have negative values.\n layer_var = tf.matmul(tf.reshape(prev_layer**2,[-1,\n n_units[l-1]]), self.weights['w_%d_std'%l]**2)\n layer_var = tf.reshape(layer_var, [n_samples, -1, n_units[l]])\n layer_var += self.biases['b_%d_std'%l]**2\n\n # Now sample noise and add scaled noise.\n # This constitutes the local reparameterization trick.\n eps = tf.random_normal(name='eps_%d'%l, mean=0.,\n stddev=1.0, shape=[n_samples, 1, n_units[l]])\n layer_sigma = tf.sqrt(layer_var)\n layer += layer_sigma*eps\n with tf.name_scope(name+\"Neural_Network_Activations_%d\"%l):\n tf.summary.histogram(name+\"Layer_%d_sigmas\"%l, layer_sigma)\n tf.summary.histogram(name+\"Layer_%d_activations_pre_tanh\"%l, layer)\n\n # Add tanh nonlinearity\n if l != (len(n_units) - 1): layer = tf.nn.tanh(layer)\n\n with tf.name_scope(name+\"Neural_Network_Activations_%d\"%l):\n tf.summary.histogram(name+\"Layer_%d_activations_post_tanh\"%l,layer)\n\n prev_layer = layer\n self.layers.append(prev_layer)\n self.KL_BNN = KL\n return prev_layer","def init_weights(self, load_weights=None):\n if load_weights:\n # TODO\n pass\n else:\n # x: lower layer nodes n\n # y: current layer nodes n\n x = self.weights_shape[1]\n y = self.weights_shape[0]\n self.weights = np.random.randn(y, x) / np.sqrt(x) # pylint: disable=no-member\n self.biases = np.random.randn(y, 1) # pylint: disable=no-member","def __init__(\n self,\n input_size: int,\n hidden_sizes: Sequence[int],\n output_size: int,\n num_layers: int,\n optimizer: Type[Optimizer] = SGD(),\n norm_weights: bool = False\n ):\n self.input_size = input_size\n self.hidden_sizes = hidden_sizes\n self.output_size = output_size\n self.num_layers = num_layers\n self.norm_weights = norm_weights\n\n assert len(hidden_sizes) == (num_layers - 1)\n assert num_layers >= 1\n\n activated_layer_sizes = [input_size] + hidden_sizes\n activated_layers = [LinearLayer(n_in, n_out, activation_func=ReLU) for n_in, n_out in zip(activated_layer_sizes, activated_layer_sizes[1:])]\n final_layer = LinearLayer(activated_layer_sizes[-1], self.output_size, activation_func=Softmax)\n self.layers = activated_layers + [final_layer]\n\n self.optimizer = optimizer","def initialize_weights(self, weights_initializer, bias_initializer):\n wshapes = [\n [self.input_size, self.hidden_size[0]],\n [self.hidden_size[0], self.hidden_size[1]],\n [self.hidden_size[1], self.output_size]\n ]\n\n bshapes = [\n [1, self.hidden_size[0]],\n [1, self.hidden_size[1]],\n [1, self.output_size]\n ]\n\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\n\n self.trainable_variables = self.weights + self.biases","def __init__(self, weights, path, trained, asGraph):\n \n _weights = np.asarray(weights)\n\n numLayers = int(_weights.shape[0]/2)\n wghts = []\n biases = []\n\n for i in range(numLayers):\n j = 2*i\n# print(j,(_weights[j].T).shape)\n wghts.append(_weights[j])\n j = 2*i + 1\n# print(j,(_weights[j].T).shape)\n biases.append(_weights[j])\n #enddo\n\n self.numLayers = numLayers\n self.wghts = np.asarray(wghts)\n self.asGraph = asGraph\n self.wghts = wghts\n self.path = path\n self.trained = trained","def __init__(self, inputSize, hiddenSize, outputSize, epochs = 100, debug = False):\n self.inputSize = inputSize\n self.hiddenSize = hiddenSize\n self.outputSize = outputSize\n self.epochs = epochs\n self.debug = debug\n\n #weights\n self.W1 = np.random.randn(self.inputSize, self.hiddenSize) \n self.W2 = np.random.randn(self.hiddenSize, self.outputSize)","def __init__(self, inputSize, outputSize, hiddenSize): \n\n self.inputSize = inputSize\n self.outputSize = outputSize\n self.hiddenSize = hiddenSize \n \n # Initialize random weight with range [-0.5, 0.5]\n self.weight = np.matrix(np.random.uniform(-0.5, 0.5, (self.hiddenSize, self.inputSize)))\n\n # Initialize random bias with range [0, 1]\n self.bias = np.matrix(np.random.uniform(0, 1, (1, self.hiddenSize)))\n \n self.H = 0\n self.beta = 0","def build_layer(self) :\n inputsWithBias = self.input_count + 1\n self.weights = np.random.rand(inputsWithBias, self.node_count)\n self.weights_and_activations = (self.weights, self.activations)","def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):\n\n self.params = {}\n self.params['W1'] = weight_init_std * \\\n np.random.randn(input_size, hidden_size)\n self.params['b1'] = np.zeros(hidden_size)\n self.params['W2'] = weight_init_std * \\\n np.random.randn(hidden_size, output_size)\n self.params['b2'] = np.zeros(output_size)","def create_neural_network(mode, layer_sizes, use_stored_weights, weights_path):\n\n\tif verbose: print('model_tensorflow.create_neural_network() called')\n\n\tnum_layers = len(layer_sizes) - 1\n\tweights = {}\n\tbiases = {}\n\n\tif verbose: print('creating a DNN with', str(num_layers-1), 'hidden layers of size', \n\t\t\t\t\t str(layer_sizes[1:len(layer_sizes)-1]))\n\n\t# Initialise the weights\n\t# (a) Create new weights and biases\n\tif not use_stored_weights:\n\t\tfor i in range(num_layers): \n\t\t\t# Layer l has dimensions (|l-1|, |l|) for weights and (|l|) for biases\n\t\t\tw_name = 'W' + str(i+1)\n\t\t\tweights[w_name] = tf.get_variable(w_name, [layer_sizes[i], layer_sizes[i+1]], \n\t\t\t\tinitializer = tf.contrib.layers.xavier_initializer(), dtype=tf.float32)\n\t\t\tb_name = 'b' + str(i+1)\n\t\t\tbiases[b_name] = tf.get_variable(b_name, [layer_sizes[i+1]], \n\t\t\t\tinitializer = tf.zeros_initializer(), dtype=tf.float32)\n\n\t\t# Initialise all existing global variables \n\t\tsess.run(tf.global_variables_initializer())\n\n\t\t# Save weights and biases\n\t\tsaver = tf.train.Saver()\n\t\tsave_path = saver.save(sess, weights_path + 'weights/' + 'init.ckpt') \n\t# (b) Restore existing weights and biases\n\telse:\n\t\tfor i in range(num_layers):\n\t\t\t# Prepare variable\n\t\t\tw_name = 'W' + str(i+1)\n\t\t\tb_name = 'b' + str(i+1)\n\t\t\tweights[w_name] = tf.get_variable(w_name, [layer_sizes[i], layer_sizes[i+1]], \n\t\t\t\tinitializer = tf.zeros_initializer(), dtype=tf.float32)\n\t\t\tbiases[b_name] = tf.get_variable(b_name, [layer_sizes[i+1]], \n\t\t\t\tinitializer = tf.zeros_initializer(), dtype=tf.float32)\n\n\t\t# Initialise all existing global variables \n\t\tsess.run(tf.global_variables_initializer())\n\n\t\t# Restore weights and biases\n\t\tsaver = tf.train.Saver()\n\t\tif mode == trn:\n\t\t\tsaver.restore(sess, weights_path + 'weights/' + 'init.ckpt') \n\t\telif mode == tst or mode == app:\n\t\t\tsaver.restore(sess, weights_path + 'weights/' + 'trained.ckpt')\n\n\twb = {'weights': weights, 'biases': biases}\n\treturn wb","def construct(self, weights):\n in_weights = weights # first to append zero column as the last output (no out-degree)\n weights = np.zeros((weights.shape[0], weights.shape[1]+1))\n weights[:,:-1] = in_weights\n din, dout, dhid = self.dim_in, self.dim_out, self.dim_hid # the max dim\n hid = weights.shape[0] - dout # this hidden dim\n if not (weights.shape[1]-din-dout==hid and (0<hid<=dhid)):\n raise self.ANNException('weight matrix hidden nodes not matching')\n if not (dout < weights.shape[0] <= hid+dout):\n raise self.ANNException('weight matrix row shape not matching')\n if not (din+dout < weights.shape[1] <= din+hid+dout):\n raise self.ANNException('weight matrix column shape not matching')\n\n self.weight[din:din+hid,:din+hid] = weights[:hid,:din+hid]\n self.weight[din:din+hid,din+dhid:] = weights[:hid,din+hid:]\n self.weight[din+dhid:,:din+hid] = weights[hid:,:din+hid]\n self.weight[din+dhid:,din+dhid:] = weights[hid:,din+hid:]\n\n for i in range(hid):\n self.connectivity[din+i,:din+i] = True\n self.connectivity[din+dhid:,:din+hid] = True\n for i in range(dout):\n self.connectivity[din+dhid+i,din+dhid:din+dhid+i] = True\n\n self.hidden[:hid] = True","def __init__(self, sizes, afunc): \n\t\tself.num_layers = len(sizes)\n\t\tself.sizes = sizes\n\t\tself.afunc = afunc;\n\t\tself.initialize_weights_uniform()\n\t\t#self.initialize_weights_gaussian(0.1)\n\t\t#self.initialize_weights_xavier()","def __init__(self, inputLayerSize, outputLayerSize, \\\n hiddenLayerSize):\n #Network hyperparameters - neurons per layer - **not altered by training**\n self.inputLayerSize = inputLayerSize\n self.outputLayerSize = outputLayerSize\n self.hiddenLayerSize = hiddenLayerSize\n self.num_params = inputLayerSize * hiddenLayerSize + \\\n hiddenLayerSize * outputLayerSize + hiddenLayerSize \\\n + outputLayerSize\n #--Weights--\n #w_ih - weights of synapses linking input -> hidden\n self.w_ih = np.random.randn( self.inputLayerSize, \\\n self.hiddenLayerSize)\n #w_ho - weights of synapses linking hidden -> output\n self.w_ho = np.random.randn( self.hiddenLayerSize, \\\n self.outputLayerSize)\n \n #--Biases--\n #b_h - biases of hidden layer\n self.b_h = np.random.randn( self.hiddenLayerSize )\n #b_o - biases of output layer\n self.b_o = np.random.randn( self.outputLayerSize )","def __init__(self):\r\n # A dummy layer does nothing\r\n self.weights = np.zeros(shape=(input.shape[1], 10))\r\n bias = np.zeros(shape=(10,))\r\n pass","def construct(self):\n self.input_size = self.numplanes * self.boardsize**2\n \n if self.hidden:\n layers = [\n torch.nn.Linear(self.input_size, self.hidden), \n torch.nn.ReLU(),\n torch.nn.Linear(self.hidden, self.boardsize**2)\n ]\n else:\n layers = [torch.nn.Linear(self.input_size, self.boardsize**2)]\n\n self.layers = torch.nn.ModuleList(layers)\n self.optimizer = torch.optim.Adam(self.parameters(), lr=1e-5)\n logging.info(\"Model initialized: %s\", self)","def __init__(self, weights, alphas):\n self._neurons = [Neuron(a, w) for w, a in zip(weights, alphas)]","def initialize(self, input_size, n_classes):\n\n self.n_classes = n_classes\n self.input_size = input_size\n\n n_hidden_layers = len(self.sizes)\n #############################################################################\n # Allocate space for the hidden and output layers, as well as the gradients #\n #############################################################################\n self.hs = []\n self.grad_hs = []\n for h in range(n_hidden_layers):\n self.hs += [np.zeros((self.sizes[h],))] # hidden layer\n self.grad_hs += [np.zeros((self.sizes[h],))] # ... and gradient\n self.hs += [np.zeros((self.n_classes,))] # output layer\n self.grad_hs += [np.zeros((self.n_classes,))] # ... and gradient\n\n ##################################################################\n # Allocate space for the neural network parameters and gradients #\n ##################################################################\n self.weights = [np.zeros((self.input_size, self.sizes[0]))] # input.csv to 1st hidden layer weights\n self.grad_weights = [np.zeros((self.input_size, self.sizes[0]))] # ... and gradient\n\n self.biases = [np.zeros((self.sizes[0]))] # 1st hidden layer biases\n self.grad_biases = [np.zeros((self.sizes[0]))] # ... and gradient\n\n for h in range(1, n_hidden_layers):\n self.weights += [np.zeros((self.sizes[h - 1], self.sizes[h]))] # h-1 to h hidden layer weights\n self.grad_weights += [np.zeros((self.sizes[h - 1], self.sizes[h]))] # ... and gradient\n\n self.biases += [np.zeros((self.sizes[h]))] # hth hidden layer biases\n self.grad_biases += [np.zeros((self.sizes[h]))] # ... and gradient\n\n self.weights += [np.zeros((self.sizes[-1], self.n_classes))] # last hidden to output layer weights\n self.grad_weights += [np.zeros((self.sizes[-1], self.n_classes))] # ... and gradient\n\n self.biases += [np.zeros((self.n_classes))] # output layer biases\n self.grad_biases += [np.zeros((self.n_classes))] # ... and gradient\n\n #########################\n # Initialize parameters #\n #########################\n\n self.rng = np.random.mtrand.RandomState(self.seed) # create random number generator\n # biases are initialized to zero\n # ... and weights according to the slides\n for m in range(len(self.weights)):\n b = (6 ** 0.5) / ((self.weights[m].shape[0] + self.weights[m].shape[1]) ** 0.5)\n for ind, val in np.ndenumerate(self.weights[m]):\n self.weights[m][ind] = self.rng.uniform(-b, b, 1)\n\n\n self.n_updates = 0 # To keep track of the number of updates, to decrease the learning rate","def create_network(layers):\r\n return NeuronNetwork(layers)","def __init__(self, n_layers, layers_sizes, activation='sigmoid', learning_rate=0.1, weight_init='normal', batch_size=1000, num_epochs=100):\n self.layers_sizes=layers_sizes[1:]\n self.activation=activation\n self.learning_rate=learning_rate\n self.weight_init=weight_init\n self.batch_size=batch_size\n self.num_epochs=num_epochs\n self.weights={}\n self.n_layers=len(self.layers_sizes)\n self.num_samples=0\n self.training_loss_values=[]\n self.testing_loss_values=[]\n self.gg=0.01\n self.XTEST=None\n self.YTEST=None\n self.TTTT=None\n\n if activation not in self.acti_fns:\n raise Exception('Incorrect Activation Function')\n\n if weight_init not in self.weight_inits:\n raise Exception('Incorrect Weight Initialization Function')\n pass","def instantiate_weights(self):\n self.product_embeddings = tf.get_variable(\n name='product_embeddings',\n shape=[50000, 300],\n dtype=tf.float32\n )\n self.aisle_embeddings = tf.get_variable(\n name='aisle_embeddings',\n shape=[250, 50],\n dtype=tf.float32\n )\n self.department_embeddings = tf.get_variable(\n name='department_embeddings',\n shape=[50, 10],\n dtype=tf.float32\n )\n self.W_relu = tf.get_variable(\"W_relu\",shape=[670, 30]) #这个参数后续需要自适应\n self.b_relu = tf.get_variable(\"bias_relu\",shape=[30]) \n self.W_projection = tf.get_variable(\"W_projection\",shape=[30, 1]) \n self.b_projection = tf.get_variable(\"bias_projection\",shape=[1])","def __init__(self, N_sym, n_nodes, activations, N_element, bias = True, scaling = None):\n super(MultiLayerNet, self).__init__()\n N_layers = len(n_nodes)\n if N_layers == 0:\n self.net = torch.nn.Linear(N_sym, N_element, bias = bias)\n else:\n layers = []\n for n in range(N_layers):\n if n == 0:\n layers += [torch.nn.Linear(N_sym, n_nodes[n], bias = bias)]\n layers += [activations[n]]\n else:\n layers += [torch.nn.Linear(n_nodes[n-1], n_nodes[n], bias = bias)]\n layers += [activations[n]]\n layers += [torch.nn.Linear(n_nodes[-1], N_element, bias = bias)]\n self.net = torch.nn.Sequential(*layers)\n \n self.scaling = scaling","def _build_network(self, h_size=16, l_rate=0.001):\n with tf.variable_scope(self.net_name):\n self._X = tf.placeholder(tf.float32, [None, self.input_size], name=\"input_x\")\n net = self._X\n\n net = tf.layers.dense(net, h_size, activation=tf.nn.relu)\n net = tf.layers.dense(net, self.output_size)\n self._Qpred = net\n\n self._Y = tf.placeholder(tf.float32, shape=[None, self.output_size])\n self._loss = tf.losses.mean_squared_error(self._Y, self._Qpred)\n\n optimizer = tf.train.AdamOptimizer(learning_rate=l_rate)\n self._train = optimizer.minimize(self._loss)","def make_neural_net_challenging():\n i0 = Input('i0', -1.0) # this input is immutable\n i1 = Input('i1', 0.0)\n i2 = Input('i2', 0.0)\n seed_random()\n wt1 = random_weight()\n wt2 = random_weight()\n wt3 = random_weight()\n wt4 = random_weight()\n wt5 = random_weight()\n wt6 = random_weight()\n wt7 = random_weight()\n wt8 = random_weight()\n wt9 = random_weight()\n wt10 = random_weight()\n\t\n w1A = Weight('w1A', wt1)\n w2A = Weight('w2A', wt2)\n w1B = Weight('w1B', wt3)\n w2B = Weight('w2B', wt4)\n wA = Weight('wA', -1)\n wB = Weight('wB', -1)\n wAC = Weight('wAC', wt5)\n wBC = Weight('wBC', wt6)\n wC = Weight('wC', -1)\n wAD = Weight('wAD', wt7)\n wBD = Weight('wBD', wt8)\n wD = Weight('wD', -1)\n wCE = Weight('wCE', wt9)\n wDE = Weight('wDE', wt10)\n wE = Weight('wE', -1)\n\n # Inputs must be in the same order as their associated weights\n A = Neuron('A', [i1,i2,i0], [w1A,w2A,wA])\n B = Neuron('B', [i1,i2,i0], [w1B,w2B,wB])\n C = Neuron('C', [A,B,i0], [wAC,wBC,wC])\n D = Neuron('D', [A,B,i0], [wAD,wBD,wD])\n E = Neuron('D', [C,D,i0], [wCE,wDE,wE])\n P = PerformanceElem(E, 0.0)\n\n net = Network(P,[A, B, C, D, E])\n return net","def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):\n \n super().__init__(inputnodes, hiddennodes, outputnodes, learningrate)\n\n # link weight matrices, wih and who\n # weights inside the arrays are w_i_j, where link is from node i to node i to j in the next layer\n # w11 w21\n # w12 w22 etc\n self.wih = numpy.random.normal(\n 0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))\n self.who = numpy.random.normal(\n 0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))\n\n #activation function is the sigmoid function\n self.activation_function = lambda x: scipy.special.expit(x)\n\n pass","def __initialize_weights__(num_neurons: int) -> np.ndarray:\n\n weights = np.zeros((num_neurons, num_neurons))\n\n return weights","def __init__(self, num_units, input_size=None,\n nonlinearity=tf.nn.sigmoid,\n initializer=tf.random_normal_initializer(0.0, 0.1)):\n self._input_size = num_units if not input_size else input_size\n self._num_units = num_units\n self._nonlin = nonlinearity\n self._initializer = initializer","def __init__(self, input_dimensions=2, number_of_nodes=4, transfer_function=\"Hard_limit\"):\r\n self.input_dimensions = input_dimensions\r\n self.number_of_nodes = number_of_nodes\r\n self.transfer_function = transfer_function\r\n self.initialize_weights()","def _setup(self) -> None:\n #TODO: type\n self.activation = self.params['activation']\n\n self.batchsize: int = self.params['batchsize']\n\n self.input_shape: Tuple[int,int,int] = self.params['input_shape']\n\n self.d: int = self.input_shape[1]\n assert(not self.d == 0)\n\n self.n: int = int(sqrt(self.input_shape[2]))\n assert(not self.n == 0)\n\n self.dtype: type = self.params['dtype']\n\n # initialize weights\n self.W: List[tf.Tensor] = []\n \n for i in range(3):\n #TODO: type\n w_init = self.params['initializer_w']\n if self.params['initializer_w' + str(i)] is not None:\n w_init = self.params['initializer_w' + str(i)]\n\n w_stddev: float = self.params['stddev_w']\n if self.params['stddev_w' + str(i)] is not None:\n w_stddev = self.params['stddev_w' + str(i)]\n\n self.W.append(tf.get_variable(\"weights_\" + str(i),\n shape = (self.d, (self.d if i < 2 else 2 * self.d)),\n dtype = self.dtype,\n initializer = w_init(stddev=w_stddev)))\n\n #TODO: type\n b_init = self.params['initializer_b']\n b_stddev = self.params['stddev_b']\n self.B: tf.Tensor = tf.get_variable(\"biases\", shape = (1, self.d, 1),\n dtype = self.dtype,\n initializer = b_init(stddev=b_stddev))\n\n # create/load expand matrix\n with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\n self.expand: tf.Tensor = tf.get_variable(\n \"expand\" + str(self.n),\n shape = (self.n, self.n * self.n),\n dtype = self.dtype,\n initializer = tf.constant_initializer(make_expand(self.n)))\n\n # create/load tile matrix\n tile: np.ndarray = np.array([([1] + [0]*(self.n-1))*self.n])\n for i in range(1, self.n):\n tile = np.append(tile, [([0]*i + [1] + [0]*(self.n-1-i))*self.n], 0)\n\n self.tile: tf.Tensor = tf.constant(tile, self.dtype)","def _build_networks(self):\n # Calling online_convnet will generate a new graph as defined in\n # self._get_network_template using whatever input is passed, but will always\n # share the same weights.\n self.online_convnet = tf.make_template('Online', self._network_template)\n self.target_convnet = tf.make_template('Target', self._network_template)\n self._net_outputs = self.online_convnet(self.state_ph)\n\n self._replay_net_outputs = self.online_convnet(self._replay.states)\n self._replay_next_target_net_outputs = self.target_convnet(\n self._replay.next_states)\n\n if self.acting_policy == 'hyperbolic':\n self._q_argmax = tf.argmax(self._net_outputs.hyp_q_value, axis=1)[0]\n elif self.acting_policy == 'largest_gamma':\n self._q_argmax = tf.argmax(self._net_outputs.q_values[-1], axis=1)[0]\n else:\n raise NotImplementedError","def __init__(self, input_dimensions=2, number_of_nodes=4, transfer_function=\"Hard_limit\"):\n self.input_dimensions = input_dimensions\n self.number_of_nodes = number_of_nodes\n self.transfer_function = transfer_function\n self.initialize_weights()","def __init__(self, emsize):\n super(GatingNetwork, self).__init__()\n self.weight = nn.Linear(emsize, 1)","def __init__(self, params = None, layer_sizes = None, scale = 0.1, rs=npr.RandomState(0)):\n self.layer_sizes = layer_sizes\n\n if params is not None:\n self.param = params\n else:\n if layer_sizes is None:\n raise Exception(\"Please provide the layer sizes\")\n\n self.params = [(scale * rs.randn(m, n), # weight matrix\n scale * rs.randn(n)) # bias vector\n for m, n in zip(layer_sizes[:-1], layer_sizes[1:])]","def build_network(self, dimList, actType=\"Tanh\", verbose=True):\n self.Q_network = Model(dimList, actType, verbose=verbose)\n self.target_network = Model(dimList, actType)\n\n if self.device == torch.device(\"cuda\"):\n self.Q_network.cuda()\n self.target_network.cuda()\n\n self.build_optimizer()","def __init__(self, weights, biases):\n super().__init__()\n\n self.weights = weights\n self.biases = biases","def __init__(self, size: Tuple[int, int], is_output: bool) -> None:\n self.g = Math.sigmoid if is_output else Math.relu\n self.w: List[List[float]] = \\\n [[random.random() * 0.1 for _ in range(size[1])]\n for _ in range(size[0])]\n self.b: List[float] = [0.0] * size[0]\n\n # use of below attributes is optional but recommended\n self.z: List[float] = [0.0] * size[0]\n self.a: List[float] = [0.0] * size[0]\n self.dw: List[List[float]] = \\\n [[0.0 for _ in range(size[1])] for _ in range(size[0])]\n self.db: List[float] = [0.0] * size[0]","def create_base_network(NumberOfFeatures, NumberOfClasses,init_mode='glorot_normal'):\n network = Sequential()\n network.add(Dense(44, activation='sigmoid', kernel_initializer=init_mode,input_dim=NumberOfFeatures))\n# network.add(Dense(22, activation='sigmoid',kernel_initializer=init_mode))\n network.add(Dense(NumberOfClasses, activation='softmax',kernel_initializer=init_mode))\n return network","def __init__(self, num_units, input_size=None,\n nonlinearity=tf.nn.tanh,\n hh_init=tf.random_normal_initializer(stddev=0.15),\n xh_init=tf.random_normal_initializer(stddev=0.15),\n b_init=tf.constant_initializer(0.0, dtype=tf.float32),\n weight_noise=0.0,\n keep_prob=1.0,\n weightnorm=False,\n orthreg=False):\n self._num_units = num_units\n self._input_size = input_size or num_units\n self._nonlinearity = nonlinearity\n self._hh_init = hh_init\n self._xh_init = xh_init\n self._b_init = b_init\n self._weightnorm = weightnorm\n self._keep_prob = keep_prob\n self._weight_noise = weight_noise\n self._orthreg = orthreg","def _generate_network_initialization(self, graph, memory_manager):\n\n # TODO: To be changed if we want to support multiple outputs\n output_buffer_name = graph.outputs[0].name\n\n ops_to_ignore = ['Reshape', 'Mul']\n\n buffers_allocated = []\n\n buffer_declaration = \"\"\n buffer_declaration += \" pico_cnn::naive::Tensor **kernels;\\n\"\n buffer_declaration += \" pico_cnn::naive::Tensor **biases;\\n\"\n\n constructor_code = \"\"\n #constructor_code += \"Network::Network() {\\n\\n\"\n\n num_layers = 0\n num_kernels = 0\n num_biases = 0\n\n for node in graph.nodes:\n \"\"\"Do not count the reshape layers as the input tensor will only define the dimensions\"\"\"\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\n num_layers += 1\n for num, input in enumerate(node.input_tensors):\n if input in buffers_allocated:\n continue\n else:\n tensor = node.input_tensors[input]\n buffers_allocated.append(input)\n if len(tensor.shape) == 1:\n num_biases += 1\n else:\n num_kernels += 1\n\n \"\"\"The arrays kernels and biases will be used to pass only two variables to read_binary_weights\"\"\"\n constructor_code += \" kernels = new pico_cnn::naive::Tensor*[{}]();\\n\".format(num_kernels)\n constructor_code += \" biases = new pico_cnn::naive::Tensor*[{}]();\\n\\n\".format(num_biases)\n\n pos = -1\n pos_kernel = -1\n pos_bias = -1\n\n buffers_allocated.clear()\n\n \"\"\"Iterate over all nodes in the graph and generate the corresponding allocation code.\"\"\"\n for node_id, node in enumerate(graph.nodes):\n\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\n pos += 1\n\n buffer_declaration += \" // Layer: \" + node.name + \", Operation: \" + node.op_type + \"\\n\"\n constructor_code += \" // Layer: \" + node.name + \", Operation: \" + node.op_type + \"\\n\"\n\n # Allocate memory for kernels and biases\n buffer_declaration += \" // Inputs\\n\"\n constructor_code += \" // Inputs\\n\"\n for num, input in enumerate(node.input_tensors):\n\n if node.op_type in ops_to_ignore:\n continue\n\n if input in buffers_allocated:\n continue\n else:\n buffers_allocated.append(input)\n\n tensor = node.input_tensors[input]\n if len(tensor.shape) == 1:\n pos_bias += 1\n else:\n pos_kernel += 1\n\n buffer = memory_manager.get_buffer(graph, input)\n\n buffer_declaration += \" // \" + str(buffer.shape) + \"\\n\"\n\n pico_cnn_tensor = \" pico_cnn::naive::Tensor *\"\n\n buffer_declaration += pico_cnn_tensor + buffer.name + \";\\n\"\n\n constructor_code += \" // \" + str(buffer.shape) + \"\" # TODO maybe we sometimes need \\n\n\n functionality = CodeRegistry.get_funct(\"KernelAllocation\")\n impl = functionality[0].create(buffer, pos, pos_kernel, pos_bias)\n\n if impl:\n constructor_code += impl.generate_code()\n constructor_code += \"\\n\"\n\n buffer_declaration += \" // Outputs\\n\"\n constructor_code += \" // Outputs\\n\"\n for num, output in enumerate(node.outputs):\n\n buffer = memory_manager.get_buffer(graph, output)\n\n if output == output_buffer_name:\n buffer_declaration += \" // Output tensor {} with shape {} of network provided as argument of Network::run()\".format(buffer.name, str(buffer.shape))\n constructor_code += \" // Output tensor {} with shape {} of network provided as argument of Network::run()\".format(buffer.name, str(buffer.shape))\n continue\n\n buffer_declaration += \" // \" + str(buffer.shape) + \"\\n\"\n\n pico_cnn_tensor = \" pico_cnn::naive::Tensor *\"\n\n buffer_declaration += pico_cnn_tensor + buffer.name + \";\\n\"\n\n constructor_code += \" // \" + str(buffer.shape) + \"\" # TODO maybe we sometimes need \\n\n\n functionality = CodeRegistry.get_funct(\"OutputAllocation\")\n impl = functionality[0].create(buffer)\n\n if impl:\n constructor_code += impl.generate_code()\n constructor_code += \"\\n\"\n\n buffer_declaration += \"\\n\\n\"\n constructor_code += \"\\n\\n\"\n\n #constructor_code += \"}\\n\"\n\n self.buffer_declaration = buffer_declaration\n self.constructor_code = constructor_code","def default_weight_initializer(self):\n self.biases = [np.random.randn(y, 1) for y in self.sizes[1:]]\n self.weights = [np.random.randn(y, x)/np.sqrt(x)\n for x, y in zip(self.sizes[:-1], self.sizes[1:])]","def init_learner(self,**kwargs):\r\n \r\n if self.learn_type == 'nn':\r\n #initialize neural network\r\n shape = kwargs[\"shape\"]\r\n #initialize input layer\r\n model = Sequential() \r\n #add hidden layers\r\n for i in range(len(shape)):\r\n if i == 0:\r\n nb_input = self.size\r\n else:\r\n nb_input = shape[i -1]\r\n nb_output = shape[i]\r\n model.add(Dense(nb_input,nb_output,init=\"he_normal\",\r\n activation = \"tanh\"))\r\n model.add(Dropout(.5))\r\n model.add(Dense(shape[-1],1,init = \"he_normal\",\r\n activation = \"linear\"))\r\n model.compile(loss = 'mean_squared_error',optimizer = 'rmsprop')\r\n self.learner = model\r\n \r\n elif self.learn_type == 'linear':\r\n #initialize parameter\r\n self.learner = Linear(self.size,**kwargs)","def __init__(self, input_size, hidden_size, num_layers, nonlinearity=torch.tanh):\n super().__init__()\n self.input_size = input_size\n self.hidden_size = hidden_size\n\n # input weights\n self.weight_ih_l0 = Parameter(torch.Tensor(3*hidden_size, input_size))\n\n # hidden weights\n self.weight_hh_l0 = Parameter(torch.Tensor(3*hidden_size, hidden_size))\n\n # bias\n self.bias_ih_l0 = Parameter(torch.Tensor(3*hidden_size)) # input\n self.bias_hh_l0 = Parameter(torch.Tensor(3*hidden_size)) # hidden\n\n self.f = nonlinearity\n\n self.init_weights()","def __init__(self, neuron_count):\n # The current state of the thermal network.\n self.current_state = [0.0] * neuron_count\n\n # The weights.\n self.weights = np.zeros( [neuron_count*neuron_count] )\n\n # The neuron count.\n self.neuron_count = neuron_count","def __init__(self, layer_size, activation_function=linear,\n derivative_function=dlinear,\n forward_function=propagate_forward,\n backward_function=propagate_backward_irpropm,\n init_weights_function=fully_connected_weights, bias=True):\n self.forward_propagation = forward_function\n self.back_propagation = backward_function\n self.activation_function = activation_function\n self.derivative_function = derivative_function\n self.bias = bias\n\n # the activations of these nodes\n bias_add = 0\n if self.bias:\n bias_add = 1\n self.visible = numpy.ones(layer_size + bias_add)\n self.init_weights_function = init_weights_function","def __init__(self, hidden_dims, input_dim=3*32*32, num_classes=10,\n reg=0.0, weight_scale=1e-2, dtype=np.float32):\n self.reg = reg\n self.num_layers = 1 + len(hidden_dims)\n self.dtype = dtype\n self.params = {}\n\n ############################################################################\n # Initialize the network parameters with different weights and biases for #\n # network layers #\n ############################################################################\n \n key = ['W' + str(1), 'b' + str(1)]\n self.params[key[0]] = weight_scale * np.random.randn(input_dim, hidden_dims[0])\n self.params[key[1]] = np.zeros(hidden_dims[0])\n \n for i in range(1, len(hidden_dims)):\n key = ['W' + str(i+1), 'b' + str(i+1)]\n \n self.params[key[0]] = weight_scale * np.random.randn(hidden_dims[i-1], hidden_dims[i])\n self.params[key[1]] = np.zeros(hidden_dims[i])\n\n key = ['W' + str(self.num_layers), 'b' + str(self.num_layers)]\n self.params[key[0]] = weight_scale * np.random.randn(hidden_dims[len(hidden_dims)-1], num_classes)\n self.params[key[1]] = np.zeros(num_classes)\n\n\n # Cast all parameters to the correct datatype\n for k, v in self.params.items():\n self.params[k] = v.astype(dtype)","def __init__(self, dimensions=2):\n assert dimensions > 0\n for d in range(0,dimensions+1):\n self.weight.append(0)","def __init__(self, input_size, hidden_size, en_bias):\n self.en_bias = en_bias\n # weight matrix and bias vector\n self.u = self.random(-np.sqrt(1.0/input_size),\n np.sqrt(1.0/input_size), (hidden_size, input_size))\n self.w = self.random(-np.sqrt(1.0/hidden_size),\n np.sqrt(1.0/hidden_size), (hidden_size, hidden_size))\n self.v = self.random(-np.sqrt(1.0/hidden_size),\n np.sqrt(1.0/hidden_size), (hidden_size, hidden_size))\n if en_bias:\n self.b = self.random(-0.1, 0.1, (hidden_size,))\n else:\n self.b = np.zeros(hidden_size)\n # error gradient for weight matrix and bias vector\n self.dLdu = np.zeros(self.u.shape)\n self.dLdw = np.zeros(self.w.shape)\n self.dLdv = np.zeros(self.v.shape)\n self.dLdb = np.zeros(self.b.shape)","def __init__(self, sizes, beta=1, momentum=0.9):\n self.beta = beta\n self.momentum = momentum\n\n self.nin = sizes[0] # number of features in each sample\n self.nhidden1 = sizes[1] # number of neurons in the first hidden layer\n self.nhidden2 = sizes[2] # number of neurons in the second hidden layer\n self.nout = sizes[3] # number of classes / the number of neurons in the output layer\n\n\n # Initialise the network of two hidden layers\n self.weights1 = (np.random.rand(self.nin+1,self.nhidden1)-0.5)*2/np.sqrt(self.nin) # hidden layer 1\n self.weights2 = (np.random.rand(self.nhidden1+1,self.nhidden2)-0.5)*2/np.sqrt(self.nhidden1) # hidden layer 2\n self.weights3 = (np.random.rand(self.nhidden2+1,self.nout)-0.5)*2/np.sqrt(self.nhidden2) # output layer","def __init__(self, dims):\n\t\tself.layersNumber = len(dims) - 1\n\t\tself.weights = []\n\t\tself.biases = []\n\t\tnp.random.seed(42)\n\t\tfor d in range(self.layersNumber):\n\t\t\tself.weights.append(np.random.randn(dims[d+1], dims[d]))\n\t\t\tself.biases.append(np.random.randn(dims[d+1], 1))","def __init__(self, InputDimentions, OutputDimentions, numberOfLayers, WeightArray, BiasArray):\r\n self.WeightMatrixT = WeightArray\r\n self.WeightMatrixT.shape = (numberOfLayers, OutputDimentions, InputDimentions)\r\n self.BiasVector = BiasArray\r\n self.BiasVector.shape = (numberOfLayers, 1, OutputDimentions)","def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):\n super().__init__(inputnodes, hiddennodes, outputnodes, learningrate)\n\n # link weight matrices, wih and who\n # weights inside the arrays are w_i_j, where link is from node i to node i to j in the next layer\n # w11 w21\n # w12 w22 etc\n self.wih = cupy.random.normal(\n 0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))\n self.who = cupy.random.normal(\n 0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))\n\n #activation function is the sigmoid function\n self.activation_function = lambda x: 1 / (1 + cupy.exp(x) ** (-1))","def __init__(self, N):\n self.data = list(range(N))\n self.weights = [1]*N","def init_three_layer_neuralnet(weight_scale=1, bias_scale=0, input_feat_dim=786,\n num_classes=10, num_neurons=(20, 30)):\n \n assert len(num_neurons) == 2, 'You must provide number of neurons for two layers...'\n\n model = {}\n #model['W1'] = np.random.randn((num_neurons[0],(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)) # Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\n \n model['W1'] = (np.random.rand(input_feat_dim,num_neurons[0])*weight_scale) * math.sqrt(2.0/input_feat_dim)\n model['b1'] = np.zeros(num_neurons[0])# Initialize with zeros\n \n #model['W2'] = (np.random.randn(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)# Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\n #print ((model['W1'])[0,:]).shape\n #numcols = len(input[0])\n t=len((model['W1'])[0])\n #print t\n model['W2'] = (np.random.rand(num_neurons[0],num_neurons[1])*weight_scale) * math.sqrt(2.0/t)\n model['b2'] = np.zeros(num_neurons[1])# Initialize with zeros\n\n t=len((model['W2'])[0])\n #model['W3'] = (np.random.randn(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)# Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\n model['W3'] = (np.random.rand(num_neurons[1],num_classes)*weight_scale) * math.sqrt(2.0/t)\n model['b3'] = np.zeros(num_classes)# Initialize with zeros\n\n return model","def build_neural_net(net_def):\n\n populated_def = net_def.copy()\n\n for layer in populated_def['layers']:\n for n in range(0, layer['num_neurons']):\n weights = layer['weights'][n]\n bias = layer['bias'][n]\n\n neuron = Neuron(weights, bias, layer['activation'])\n layer['neurons'].append(neuron)\n\n\n return populated_def","def __init__(self, n=0, w=0, weighting=1):\n self.n = n\n self.w = w\n self.weighting = weighting\n self.timestep = 0\n self.Xw = np.zeros([n,w])\n self.Yw = np.zeros([n,w])\n self.A = np.zeros([n,n])\n self.P = np.zeros([n,n])","def build_neuron_network(nb_features_map: Union[Sequence[int], None] = None,\n size_linear_layers: Union[Sequence[int], None] = None,\n dropout_rate: Union[Tuple[float, float], float] = 0.3,\n conv_kernel_size: Union[Sequence[int], int] = 3,\n conv_stride: int = 1,\n conv_padding: int = 1,\n conv_activation: str = \"relu\",\n conv_architecture: str = \"CPD\",\n pool_kernel_size: int = 2,\n pool_stride: int = 2,\n dense_activation: str = \"relu\",\n pretrained: Union[str, None] = None,\n grayscale: bool = True,\n optimizer: str = \"Adam\",\n weight_decay: float = 0.,\n learning_rate: float = 0.001,\n ) -> Tuple[nn.Module, List, torch.optim.Optimizer]:\n # Initializations\n if pretrained is not None:\n grayscale = False\n if grayscale:\n channels = 1\n else:\n channels = 3\n if nb_features_map is None:\n nb_features_map = [8]\n if size_linear_layers is None:\n size_linear_layers = []\n height = 224\n width = 224\n module = nn.Module()\n shapes = [(\"input\", channels, height, width)]\n layers = {\"extractor\": [], \"regressor\": []}\n if not hasattr(dropout_rate, \"__len__\"):\n dropout_rate = (dropout_rate, 0.)\n next_dropout_rate = dropout_rate[0]\n # If a pretrained model is used:\n if pretrained is None:\n # Input checks\n if hasattr(conv_kernel_size, \"__len__\"):\n if len(conv_kernel_size) != len(nb_features_map):\n raise ValueError(\"The length of nb_features_map shall match the length of conv_kernel_size\")\n else:\n conv_kernel_size = [conv_kernel_size] * len(nb_features_map)\n # Feature extractor\n next_layer_type = itertools.cycle(conv_architecture)\n nb_feature_map = None\n i = 0\n while True:\n layer_type = next(next_layer_type)\n if layer_type == \"C\":\n # Convolutional layer\n try:\n nb_feature_map = nb_features_map[i]\n except IndexError:\n break\n name = \"conv2d-{:02d}\".format(i+1)\n conv = nn.Conv2d(shapes[-1][1], nb_feature_map, conv_kernel_size[i], stride=conv_stride,\n padding=conv_padding)\n layers[\"extractor\"].append((name, conv))\n h, w = output_shape_conv_and_pool_layer(rows=shapes[-1][2], columns=shapes[-1][3],\n kernel=conv_kernel_size[i], stride=conv_stride,\n padding=conv_padding)\n shapes.append((name, nb_feature_map, h, w))\n i += 1\n # Activation\n if conv_activation == \"relu\":\n activ = nn.ReLU()\n elif conv_activation == \"elu\":\n activ = nn.ELU(alpha=0.1)\n elif conv_activation == \"leaky\":\n activ = nn.LeakyReLU()\n else:\n activ = nn.ReLU()\n name = \"{}-{:02d}\".format(conv_activation, i)\n layers[\"extractor\"].append((name, activ))\n # activation does not change the size\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\n elif layer_type == \"P\":\n # Max-pooling\n name = \"maxpool2d-{:02d}\".format(i)\n pool = nn.MaxPool2d(pool_kernel_size, pool_stride)\n layers[\"extractor\"].append((name, pool))\n h, w = output_shape_conv_and_pool_layer(rows=shapes[-1][2], columns=shapes[-1][3],\n kernel=pool_kernel_size, stride=pool_stride)\n shapes.append((name, nb_feature_map, h, w))\n elif layer_type == \"D\":\n # Dropout\n if next_dropout_rate > 0.:\n name = \"dropout-{:02d}\".format(i)\n dropout = nn.Dropout(p=next_dropout_rate)\n layers[\"extractor\"].append((name, dropout))\n # Dropout does not change the size\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\n next_dropout_rate += dropout_rate[1]\n elif layer_type == \"B\":\n # Batch normalization\n name = \"batchnorm-{:02d}\".format(i)\n batch = nn.BatchNorm2d(shapes[-1][1])\n layers[\"extractor\"].append((name, batch))\n # Batch norm. does not change the size\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\n # Add a flatten layer\n name = \"flatten\"\n flatten = nn.Flatten(1)\n layers[\"extractor\"].append((name, flatten))\n shapes.append((name, shapes[-1][1] * shapes[-1][2] * shapes[-1][3]))\n # Create extractor module\n extractor = nn.Sequential(OrderedDict(layers[\"extractor\"]))\n module.add_module(\"extractor\", extractor)\n elif pretrained == \"VGG16\":\n pre_trained = models.vgg16(pretrained=True)\n modules = []\n for _name, _module in pre_trained.named_children():\n if _name != 'classifier':\n modules.append((_name, _module))\n modules.append((\"flatten\", nn.Flatten(1)))\n vgg16 = nn.Sequential(OrderedDict(modules))\n # Freeze all parameters in the pre-trained model\n # So we prevent gradients from being calculated, it will save computation time\n for param in vgg16.parameters():\n param.requires_grad = False\n module.add_module('extractor', vgg16)\n shapes.append((pretrained, 25088))\n else:\n raise ValueError(f\"Unknown pre-trained model '{pretrained}'.\")\n # Regressor\n for i, size_linear_layer in enumerate(size_linear_layers):\n # Add a linear layer\n name = \"linear-{:02d}\".format(i + 1)\n linear = nn.Linear(shapes[-1][1], size_linear_layer)\n layers[\"regressor\"].append((name, linear))\n shapes.append((name, size_linear_layer))\n # Activation\n if dense_activation == \"relu\":\n activ = nn.ReLU()\n elif dense_activation == \"elu\":\n activ = nn.ELU(alpha=0.1)\n elif dense_activation == \"leaky\":\n activ = nn.LeakyReLU()\n else:\n activ = nn.ReLU()\n name = \"{}-{:02d}\".format(dense_activation, i + 1)\n layers[\"regressor\"].append((name, activ))\n shapes.append((name, shapes[-1][1])) # activation does not change the size\n # Dropout\n if next_dropout_rate > 0.:\n name = \"dropout-{:02d}\".format(i + 1)\n dropout = nn.Dropout(p=next_dropout_rate)\n layers[\"regressor\"].append((name, dropout))\n shapes.append((name, shapes[-1][1])) # Dropout does not change the size of array\n next_dropout_rate += dropout_rate[1]\n # Add the final layer, the output size is fixed to 68 x 2 = 136\n name = \"output\"\n linear = nn.Linear(shapes[-1][1], 136)\n layers[\"regressor\"].append((name, linear))\n shapes.append((name, 136))\n # Create regressor module\n regressor = nn.Sequential(OrderedDict(layers[\"regressor\"]))\n module.add_module(\"regressor\", regressor)\n # Weight initialization\n module.apply(weight_initialization)\n # Optimizer\n if optimizer == \"Adam\":\n optim = torch.optim.Adam(module.parameters(), lr=learning_rate, weight_decay=weight_decay)\n elif optimizer == \"AdamW\":\n optim = torch.optim.AdamW(module.parameters(), lr=learning_rate, weight_decay=weight_decay)\n elif optimizer == \"SGD\":\n optim = torch.optim.SGD(module.parameters(), lr=learning_rate, weight_decay=weight_decay, momentum=0.9)\n else:\n raise ValueError(f\"Unknown optimizer {optimizer}.\")\n return module, shapes, optim","def __init__(self, num_inputs=3, hidden_layers=[3, 3], num_outputs=2):\n\n self.num_inputs = num_inputs\n self.hidden_layers = hidden_layers\n self.num_outputs = num_outputs\n\n # create a generic representation of the layers\n layers = [num_inputs] + hidden_layers + [num_outputs]\n\n # create random connection weights for the layers\n weights = []\n for i in range(len(layers) - 1):\n w = np.random.rand(layers[i], layers[i + 1])\n weights.append(w)\n self.weights = weights\n\n activations = []\n\n for i in range(len(layers)):\n a = np.zeros(layers[i])\n activations.append(a)\n self.activations = activations\n\n derivatives = []\n\n for i in range(len(layers) - 1):\n d = np.zeros(layers[i])\n derivatives.append(d)\n self.derivatives = derivatives","def create_params(self, layer_sizes):\n weights = [[None]]\n bias = []\n bias.append([1] * layer_sizes[0])\n\n for layer in range(1, len(layer_sizes)):\n weights.append(numpy.random.rand(layer_sizes[layer-1], layer_sizes[layer]))\n bias.append([0] * layer_sizes[layer])\n\n bias[len(layer_sizes)-1] = [0] * layer_sizes[-1]\n\n return weights, bias","def build(self, weight = 0.5):\n \n self.weight = weight\n \n # Defining weighting matrixes\n self.processing_fw = torch.randn((self._hidden_size, self._expansion_size), requires_grad = True).to(self.device)\n self.processing_bw = torch.randn((self._hidden_size, self._expansion_size), requires_grad = True).to(self.device)\n self.processing_last_ht = torch.randn((self._hidden_size*2, self._hidden_size*2), requires_grad = True).to(self.device)\n \n # These will only be applied to the intermediate hidden states\n self.linear_fw = nn.Linear(self._seqlen - 1, 1).to(self.device)\n self.linear_bw = nn.Linear(self._seqlen - 1, 1).to(self.device)\n \n self.compression = torch.randn((self._expansion_size*2, self._hidden_size*2), requires_grad = True).to(self.device)\n \n if self._activation_fn == 'tanh' or isinstance(self._activation_fn, torch.nn.modules.activation.Tanh):\n self._activation_fn = nn.Tanh()\n elif self._activation_fn == 'sigmoid' or isinstance(self._activation_fn, torch.nn.modules.activation.Sigmoid):\n self._activation_fn = nn.Sigmoid()\n elif self._activation_fn == 'leaky ReLU' or isinstance(self._activation_fn, torch.nn.modules.activation.LeakyReLU):\n self._activation_fn = nn.LeakyReLU()\n else:\n raise ValueError('Non-linear activation function must be \"tanh\", \"sigmoid\" or \"leaky ReLU\"')\n \n # Passing it onto the relevant device\n self._activation_fn = self._activation_fn.to(self.device)","def __init__(self, hidden_layers, input_size=784,\n num_classes=10, learning_rate=0.1):\n hidden_layers = [input_size] + hidden_layers + [num_classes]\n self.layers = []\n self.Layer = collections.namedtuple('Layer', ['weights', 'biases'])\n for i in range(len(hidden_layers) - 1):\n layer = self.Layer(np.random.randn(hidden_layers[i],\n hidden_layers[i + 1]).astype('float32'),\n np.random.randn(hidden_layers[i + 1]).astype('float32'))\n self.layers.append(layer)\n\n # normalization for stable training\n\n self.learning_rate = learning_rate","def __init__(self, in_features, out_features):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n mean = 0\n std_dev = 0.0001\n #print(in_features)\n #print(out_features)\n # create weight matrices\n weight = np.random.normal(mean, std_dev, (out_features, in_features))\n #print(weight.shape)\n grad_weight = np.zeros((in_features, out_features))\n\n # create biases (in batches)\n bias = np.zeros(out_features)\n grad_bias = np.zeros(out_features)\n\n self.params = {'weight': weight, 'bias': bias}\n self.grads = {'weight': bias, 'bias': grad_bias}\n\n ########################\n # END OF YOUR CODE #\n #######################","def create_neural_network():\n network_input = keras.layers.Input((NETWORK_INPUT_SIZE,))\n network_layer = keras.layers.Dense(100, kernel_initializer='random_uniform', activation='tanh')(network_input)\n network_layer = keras.layers.Dense(100, kernel_initializer='random_uniform', activation='tanh')(network_layer)\n network_output = keras.layers.Dense(NETWORK_OUTPUT_SIZE, kernel_initializer='random_uniform', activation='linear')(network_layer)\n network = keras.models.Model(inputs=network_input, outputs=network_output)\n network.compile(loss=\"mse\", optimizer=\"Adam\")\n return network","def __init__(self, num_learners: int):\n self.num_learners = num_learners\n self.learners = []\n self.learner_weights = np.ones(num_learners)","def build(self, input_shape):\n assert len(input_shape) == 4\n assert input_shape[1] == input_shape[2]\n self.out_channel = input_shape[3]\n # Create the weight vector\n self.W_shape = (input_shape[1], self.out_dim)\n if self.initial_weights is not None:\n self.set_weights(self.initial_weights)\n del self.initial_weights\n else:\n self.W = self.init(self.W_shape, name='{}_W'.format(self.name))\n self.trainable_weights = [self.W]\n self.built = True","def make_neural_net_basic():\n i0 = Input('i0', -1.0) # this input is immutable\n i1 = Input('i1', 0.0)\n i2 = Input('i2', 0.0)\n w1A = Weight('w1A', 1)\n w2A = Weight('w2A', 1)\n wA = Weight('wA', 1)\n\n # Inputs must be in the same order as their associated weights\n A = Neuron('A', [i1,i2,i0], [w1A,w2A,wA])\n P = PerformanceElem(A, 0.0)\n\n net = Network(P,[A])\n return net","def __init__(self, input_dim=(1, 28, 28), num_classes=10):\n self.params = {}\n\n #######################################################################\n # TODO: Initialize weights and biases for the convolutional neural #\n # network. Weights should be initialized from a Gaussian distribution;#\n # biases should be initialized to zero. All weights and biases should #\n # be stored in the dictionary self.params. #\n #######################################################################\n\n filter_size = 5\n weight_scale = 1e-2\n num_filters = 6\n hidden_dim = 784\n\n #****** THIS WAS TO TEST OUT FASTER NETWORKS *******\n\n self.params['W1'] = np.random.normal(scale=weight_scale, size=(num_filters, input_dim[0], filter_size, filter_size))\n # self.params['W2'] = np.random.normal(scale=weight_scale, size=(num_filters, 6, filter_size, filter_size))\n self.params['W3'] = np.random.normal(scale=weight_scale, size=(864, num_classes))\n\n # self.params['W3'] = np.random.normal(scale=weight_scale, size=(hidden_dim, num_classes))\n # self.params['W4'] = np.random.normal(scale=weight_scale, size=(hidden_dim, num_classes))\n\n self.params['b1'] = np.zeros(num_filters)\n # self.params['b2'] = np.zeros(num_filters)\n self.params['b3'] = np.zeros(num_classes)\n\n # self.params['b3'] = np.zeros(num_classes)\n # self.params['b4'] = np.zeros(num_classes)","def __init__(self, num_parameters=1, init=0.25):\n super(PReLU, self).__init__()\n self.num_parameters = num_parameters\n self.weight = Parameter(Tensor(num_parameters).fill_(init))","def init_weights(num_tilings, tiles_per_dim, num_dims, num_actions):\n weights = np.zeros((num_tilings*tiles_per_dim**num_dims*num_actions))\n return weights","def init_weights_(self):\n raise NotImplementedError","def __init__(self, structure, weights = [], activationType = \"sigmoid\"):\n self.weights = []\n self.activationType = activationType\n self.activations = []\n self.derivatives = []\n self.delta = []\n self.bias = []\n\n #Either randomises weights or uses starting weights that have been supplied. \n for i in range(len(structure)-1):\n if len(weights) != 0:\n w = np.zeros((structure[i], structure[i + 1]))\n for j in range(structure[i]):\n w[j, :] = weights[(j * structure[i + 1]) : (j * structure[i + 1]) + structure[i + 1]]\n else:\n w = np.random.rand(structure[i], structure[i + 1])\n self.weights.append(w)\n \n #Initialises activations array, delta array and bias array. \n for i in range(len(structure)):\n a = np.zeros(structure[i])\n self.activations.append(a)\n self.delta.append(a)\n self.bias.append(a)\n \n \n #Initialises derivatives array.\n for i in range(len(structure) - 1):\n d = np.zeros((structure[i], structure[i + 1]))\n self.derivatives.append(d)\n \n return","def __init__(self, num_visible, num_hidden, act_func='logistic'):\n\n print('Initializing network... ', end='')\n sys.stdout.flush()\n\n self.num_visible = num_visible\n self.num_hidden = num_hidden\n \n #self.reconstructed = np.zeros((self.num_examples, self.num_visible))\n\n self.weights = 0.1 * np.random.randn(num_visible, num_hidden)\n self.v_bias = np.zeros((1, num_visible))\n self.h_bias = -4.0 * np.ones((1, num_hidden))\n\n self.w_inc = np.zeros((num_visible, num_hidden))\n self.v_inc = np.zeros((1, num_visible))\n self.h_inc = np.zeros((1, num_hidden))\n\n if act_func == 'chaotic':\n self.act_func = self.chaotic_logistic\n else:\n self.act_func = self.logistic\n\n print('Done!')\n return","def __init__(self, input_nodes, hidden_nodes, hidden_layers, output_nodes):\n # Class members:\n # num_input_nodes\n # num_hidden_nodes\n # num_hidden_layers\n # num_output_nodes\n # weights = [[num_hidden_nodes, num_input_nodes],[num_hidden_nodes, num_hidden_nodes],[]<- for each hl,\n # [num_output_nodes, num_hidden_nodes]]\n # biases\n\n self.num_input_nodes = input_nodes\n self.num_hidden_nodes = hidden_nodes\n self.num_hidden_layers = hidden_layers\n self.num_output_nodes = output_nodes\n\n self.weights = []\n for i in range(self.num_hidden_layers + 1):\n if i is 0:\n # first weights array is input to hidden\n self.weights.append(.5 * np.random.rand(self.num_hidden_nodes, self.num_input_nodes) - .25)\n\n elif i < self.num_hidden_layers:\n # next weight array is hidden nodes to hidden nodes\n self.weights.append(.5 * np.random.rand(self.num_hidden_nodes, self.num_hidden_nodes) - .25)\n else:\n # last weight array is hidden nodes to output nodes\n self.weights.append(.5 * np.random.rand(self.num_output_nodes, self.num_hidden_nodes) - .25)\n\n self.biases = []\n for i in range(self.num_hidden_layers + 1):\n if i < self.num_hidden_layers:\n # for every hidden node there is a bias\n self.biases.append(0.5 * np.random.rand(self.num_hidden_nodes) - .25)\n else:\n # for the output node there is a bias as well\n self.biases.append(0.5 * np.random.rand(self.num_output_nodes) - .25)\n\n self.activation = np.vectorize(self.tanh, otypes=[float])","def __init__(self, input_size, hidden_sizes, output_size=1,\n batchnorm_bool=False,\n dropout_bool=False):\n super(NeuralNet, self).__init__()\n self.input_size = input_size\n sizes = [input_size] + hidden_sizes + [output_size]\n self.layers = nn.ModuleList(\n [nn.Linear(in_f, out_f) for in_f, out_f in zip(sizes, sizes[1:])])\n self.bns = nn.ModuleList(\n [nn.BatchNorm1d(out_f) for in_f, out_f in zip(sizes, sizes[1:])])\n self.dps = nn.ModuleList(\n [nn.Dropout(p=0.5) for _ in range(len(self.layers))])\n self.relus = nn.ModuleList(\n [nn.ReLU() for _ in range(len(self.layers))])\n self.sigmoid = nn.Sigmoid()\n\n self.batchnorm_bool = batchnorm_bool\n self.dropout_bool = dropout_bool","def _build_networks(self):\n self.online_convnet = self._create_network(name='Online')\n self.target_convnet = self._create_network(name='Target')\n self._net_outputs = self.online_convnet(self.state_ph, training=True)\n self._q_argmax = tf.argmax(self._net_outputs.q_values, axis=1)[0]\n self._replay_net_outputs = self.online_convnet(self._replay.states,\n training=True)\n self._replay_next_target_net_outputs = self.target_convnet(\n self._replay.next_states)","def __init__(self, nInputs, nOutputs, hiddenLayersDims, outputActivationFunctions = None, outputActivationDerivatives = None, hiddenActivationFunctions = None,\\\n\t\t\t\t hiddenActivationDerivatives = None): \n\n\t\tself._nInputs = nInputs\n\t\tself._nOutputs = nOutputs\n\n\t\tself._nHiddenLayers, self._nUnitsPerLayer = hiddenLayersDims\n\n\t\tself._outputActivationFunctions = outputActivationFunctions\n\t\tself._outputActivationDerivatives = outputActivationDerivatives\n\n\t\tself._hiddenActivationFunctions = hiddenActivationFunctions\n\t\tself._hiddenActivationDerivatives = hiddenActivationDerivatives\n\n\t\tself.initialiseActivationFunctions()\n\n\t\tself.initialiseNetwork()\n\n\t\tself._nBranches = len(self.collectAllBranches())","def __init__(self, batch_size=1, epochs=None, learning_rate=None, momentum=None, weights_name=''):\n self.batch_size = batch_size\n self.epochs = epochs\n self.model = None\n self.optimizer = None\n self.cb = None\n self.lr = learning_rate\n self.momentum = momentum\n self.weights_name = weights_name","def init_weights(n_layers, layer_sizes):\n\n params = {}\n\n for i in range(n_layers):\n wn = 'W{}'.format(i)\n bn = 'b{}'.format(i)\n\n params[wn] = tf.get_variable(\n name=wn,\n shape=layer_sizes[i * 2],\n initializer=tf.contrib.layers.xavier_initializer(seed=42)\n )\n\n params[bn] = tf.get_variable(\n name=bn,\n shape=layer_sizes[(i * 2) + 1],\n initializer=tf.zeros_initializer()\n )\n\n return params","def __init__(self, nx, nodes):\n if type(nx) is not int:\n raise TypeError(\"nx must be an integer\")\n if nx < 1:\n raise ValueError(\"nx must be a positive integer\")\n if type(nodes) is not int:\n raise TypeError(\"nodes must be an integer\")\n if nodes < 1:\n raise ValueError(\"nodes must be a positive integer\")\n # weights vector for the hidden layer\n # default mean is 0\n # default stddev is 1\n self.__W1 = np.random.normal(size=(nodes, nx))\n # The bias for the hidden layer. Upon instantiation,\n # it should be initialized with 0’s.\n self.__b1 = np.zeros((nodes, 1))\n # The activated output for the hidden layer. Upon instantiation,\n # it should be initialized to 0\n self.__A1 = 0\n # weights vector for the output neuron\n # default mean is 0\n # default stddev is 1\n self.__W2 = np.random.normal(size=(1, nodes))\n # bias for the output neuron\n self.__b2 = 0\n # activated output for the output neuron (prediction)\n self.__A2 = 0","def __init__(self, input_size, output_size, activation=torch.nn.functional.relu, left_to_right=True):\n super(GraphConvolutionalLayer, self).__init__()\n self.w = torch.nn.Parameter(torch.rand([input_size, output_size]))\n self.activation = activation\n self.left_to_right = left_to_right","def __init__(self, lengths):\n self.lengths = lengths\n\n # weights: index 1 = layer index, index 2 = feature index\n # last index in each layer is bias weight\n self.weights = np.array()\n self.activations = np.array()\n for i,length in enumerate(self.lengths):\n self.weights[i] = np.random.rand(1,length+1)\n self.activations[i] = np.random.rand(1,length+1)","def __init__(self, size, parameters):\n\n self.weights = self.init_weights(size)\n self.alpha = parameters['alpha']\n self.epsilon = parameters['epsilon']\n self.gamma = parameters['gamma']\n self.value = 0.0 #np.random.random()","def __init__(self, input_dims, output_dims, extra_dims):\n super().__init__()\n self.input_dims = input_dims\n self.output_dims = output_dims\n self.extra_dims = extra_dims\n\n self.weight = nn.Parameter(torch.zeros(*extra_dims, output_dims, input_dims))\n self.bias = nn.Parameter(torch.zeros(*extra_dims, output_dims))\n\n nn.init.kaiming_uniform_(self.weight, nonlinearity='relu')","def __init__(self, output_dim, adjecancies,\n init='glorot_uniform',\n weights=None, W_regularizer=None,\n b_regularizer=None, bias=False, **kwargs):\n\n self.init = initializers.get(init)\n self.output_dim = output_dim # number of features per node\n\n self.adjecancies = adjecancies\n\n allDst = set()\n allSrc = set()\n for rel in adjecancies:\n for (src, dest) in rel:\n allSrc.add(src)\n allDst.add(dest)\n allIndices = allSrc.union(allDst)\n\n self.allSrc = allSrc\n self.allDst = allDst\n\n if len(allIndices) > 0 and min(allIndices) < 0:\n raise Exception(\"Index lower than 0 in adjecancies\")\n self.maxIndexInAdjecencies = - \\\n 1 if len(allIndices) == 0 else max(allIndices)\n\n self.W_regularizer = regularizers.get(W_regularizer)\n self.b_regularizer = regularizers.get(b_regularizer)\n\n self.bias = bias\n self.initial_weights = weights\n\n # these will be defined during build()\n self.input_dim = None\n self.W = None\n self.W_comp = None\n self.b = None\n self.num_nodes = None\n\n super(GraphConvolution, self).__init__(**kwargs)"],"string":"[\n \"def __init__(self, sizes):\\r\\n self.num_layers = len(sizes)\\r\\n self.sizes = sizes\\r\\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\\r\\n self.weights = [np.random.randn(y, x)\\r\\n for x, y in zip(sizes[:-1], sizes[1:])]\",\n \"def __init__(self, sizes):\\n self.num_layers = len(sizes)\\n self.sizes = sizes\\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\\n self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]\",\n \"def __init__(self, sizes):\\r\\n self.num_layers = len(sizes)\\r\\n self.sizes = sizes\\r\\n\\r\\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\\r\\n self.weights = [np.random.randn(y, x)\\r\\n for x, y in zip(sizes[:-1], sizes[1:])]\",\n \"def __init__(self, sizes):\\n self.num_layers = len(sizes)\\n self.sizes = sizes\\n self.biases = [cp.array(cp.random.randn(y, 1)) for y in sizes[1:]]\\n self.weights = [cp.array(cp.random.randn(y, x))\\n for x, y in zip(sizes[:-1], sizes[1:])]\",\n \"def __init__(self, sizes: list):\\n self.num_layers = len(sizes)\\n self.sizes = sizes\\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\\n self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]\",\n \"def __init__(self, netSize):\\n\\t\\t\\n\\t\\t# TRY THIS FOR RANDOM!\\n\\t\\t#\\n\\t\\t#\\n\\t\\t#\\n\\t\\t\\n\\t\\tself.biases = [self.randomArray(i, 1) for i in netSize[1:]] # Biases do not exist for the first layer ! Those are inputs.\\n\\t\\tself.netSize = netSize\\n\\t\\t#Initialize Weights\\n\\t\\t#This initializes the weights for each layer based on the size. The number of rows should be\\n\\t\\t#the number of neurons for the current, and the number of columns should be the same as the number of neurons\\n\\t\\t#in the next layer. There are no weights for the last layer. That's the output layer.\\n\\t\\tself.weights \\t\\t = [self.randomArray(i, j) for i, j in zip(netSize[:-1], netSize[1:]) ]\",\n \"def __init__(self, input_size, neurons):\\n super().__init__()\\n self.input_size = input_size\\n self.neurons = neurons\\n self.params[\\\"w\\\"] = np.random.randn(input_size, neurons)\\n self.params[\\\"b\\\"] = np.random.randn(1, neurons)\\n self.grads = {}\",\n \"def __init__(self, layerNeurons, numberOfLayers, initialWeights = None, lowerBound = None, upperBound = None):\\r\\n \\r\\n # Ensure that there is at-least one input and one output layer in the network\\r\\n assert len(layerNeurons) > 1, \\\"At least one input layer and one output layer is needed\\\"\\r\\n \\r\\n # Get the total number of weights needed in the network\\r\\n totalWeightCount = NeuralNetwork.getSizeOfWeightVector(layerNeurons)*numberOfLayers\\r\\n \\r\\n # Initialise the weights with the initialiser or random values\\r\\n if initialWeights is None:\\r\\n if lowerBound is None:\\r\\n lowerBound=-1/np.sqrt(layerNeurons[0])\\r\\n if upperBound is None:\\r\\n upperBound=1/np.sqrt(layerNeurons[0])\\r\\n self.weights = np.random.uniform(lowerBound, upperBound, totalWeightCount)\\r\\n else:\\r\\n assert initialWeights.size == totalWeightCount, (\\\"Length of initial weight matrix incorrect. You need \\\"+str(totalWeightCount)+\\\" weights\\\")\\r\\n self.weights = initialWeights.view()\\r\\n \\r\\n self.weights.shape = (numberOfLayers, -1)\\r\\n # create an empty array of layers\\r\\n self.layers = []\\r\\n layerBlockStart = 0\\r\\n \\r\\n for layerInputDimention, layerOutputDimention in zip(layerNeurons, layerNeurons[1:]):\\r\\n # initialise each layer with its input and output dimentions and bi-directional pointers to the relivant weights\\r\\n layerBlockEnd = layerBlockStart+(layerInputDimention*layerOutputDimention)\\r\\n layerBiasEnd = layerBlockEnd+layerOutputDimention\\r\\n newLayer = batchNetworkLayer(layerInputDimention, layerOutputDimention, numberOfLayers, \\r\\n self.weights[..., :, layerBlockStart:layerBlockEnd], \\r\\n self.weights[..., :, layerBlockEnd:layerBiasEnd])\\r\\n self.layers.append(newLayer)\\r\\n \\r\\n layerBlockStart = layerBiasEnd\",\n \"def __init__(self, sizes, cost=CrossEntropyCost):\\n self.num_layers = len(sizes)\\n self.sizes = sizes\\n self.default_weight_initializer()\\n self.cost=cost\",\n \"def __init__(self, sizes):\\n self.sizes = sizes\\n self.biases = [random_matrix(1, y)[0] for y in sizes[1:]]\\n self.weights = [random_matrix(y, x)\\n for x, y in zip(sizes[:-1], sizes[1:])]\\n\\n self.weighted_layer = []\\n self.activations = []\",\n \"def __init__(self,\\n input_size,\\n output_size,\\n hidden_size=[50, 50],\\n weights_initializer=tf.initializers.glorot_uniform(),\\n bias_initializer=tf.initializers.zeros(),\\n optimizer=tf.optimizers.Adam,\\n **optimizer_kwargs):\\n self.input_size = input_size\\n self.output_size = output_size\\n self.hidden_size = hidden_size\\n\\n np.random.seed(41)\\n\\n self.initialize_weights(weights_initializer, bias_initializer)\\n self.optimizer = optimizer(**optimizer_kwargs)\",\n \"def __init__(self, input_size, hidden_sizes, output_size, std=1e-4, bstd=1e-4):\\r\\n num_hidden_layers = len(hidden_sizes)\\r\\n \\r\\n # initialize weight matrices\\r\\n self.weights = []\\r\\n if num_hidden_layers > 0:\\r\\n for i in xrange(num_hidden_layers):\\r\\n if i == 0:\\r\\n self.weights.append(std * np.random.randn(input_size, hidden_sizes[0]))\\r\\n else:\\r\\n self.weights.append(std * np.random.randn(hidden_sizes[i-1], hidden_sizes[i]))\\r\\n self.weights.append(std * np.random.randn(hidden_sizes[-1], output_size))\\r\\n else:\\r\\n self.weights.append(std * np.random.randn(input_size, output_size))\\r\\n \\r\\n # initialize bias vectors\\r\\n self.biases = []\\r\\n for i in xrange(num_hidden_layers):\\r\\n self.biases.append(bstd * np.random.randn(hidden_sizes[i]))\\r\\n self.biases.append(bstd * np.random.randn(output_size))\",\n \"def __init__(self, layerNeurons, initialWeights = None, layerTypes=None, **kwargs):\\r\\n \\r\\n # Ensure that there is at-least one input and one output layer in the network\\r\\n assert len(layerNeurons)>1, \\\"At least one input layer and one output layer is needed\\\"\\r\\n \\r\\n # Get the total number of weights needed in the network\\r\\n totalWeightCount = NeuralNetwork.getSizeOfWeightVector(layerNeurons)\\r\\n \\r\\n # Initialise the weights with the initializer or random values\\r\\n if initialWeights is None:\\r\\n self.weights = np.random.uniform(-1/np.sqrt(layerNeurons[0]), 1/np.sqrt(layerNeurons[0]), totalWeightCount)\\r\\n else:\\r\\n assert len(initialWeights) == totalWeightCount, (\\\"Length of initial weight matrix incorrect. You need \\\"+str(totalWeightCount)+\\\" weights\\\")\\r\\n self.weights = np.array(initialWeights, dtype = np.float64) \\r\\n \\r\\n # create an empty array of layers\\r\\n self.layers = []\\r\\n layerBlockStart = 0\\r\\n \\r\\n if layerTypes is None or len(layerTypes)<(len(layerNeurons)-1):\\r\\n layerTypes=[NetworkLayer]*(len(layerNeurons)-1)\\r\\n \\r\\n for layerInputDimention, layerOutputDimention, layerType in zip(layerNeurons, layerNeurons[1:], layerTypes):\\r\\n # initialise each layer with its input and output dimentions and bi-directional pointers to the relivant weights\\r\\n layerBlockEnd = layerBlockStart+(layerInputDimention*layerOutputDimention)\\r\\n layerBiasEnd = layerBlockEnd+layerOutputDimention\\r\\n newLayer = layerType(layerInputDimention, layerOutputDimention, \\r\\n self.weights[..., layerBlockStart:layerBlockEnd], \\r\\n self.weights[..., layerBlockEnd:layerBiasEnd], **kwargs)\\r\\n self.layers.append(newLayer)\\r\\n \\r\\n layerBlockStart = layerBiasEnd\\r\\n \\r\\n # Tell the output later to use a different function to calculate the delta \\r\\n newLayer.calcDelta = newLayer.calcDeltaOutputLayer\",\n \"def build(self,input_shape):\\n\\n self.w = self.add_weight(shape=(input_shape[-1],self.units),\\n initializer='random_normal',\\n trainable=True)\\n self.b = self.add_weight(shape=(self.units,),\\n initializer='random_normal',\\n trainable=True)\",\n \"def build(self):\\n\\n self.W = self.init([self.n_atom_input_feat, self.n_output])\\n self.b = model_ops.zeros(shape=[\\n self.n_output,\\n ])\\n\\n self.trainable_weights = self.W + self.b\",\n \"def __init__(self, *args, **kwargs):\\n self.params = kwargs\\n self.output_len = kwargs['num_neurons']\\n self.input_len = kwargs['input_len']\\n self.weights = Vector(data=np.random.randn(self.output_len, self.input_len))\\n self.biases = Vector(data=np.zeros((self.output_len, 1)))\\n self.input_activations = None\\n self.output_activations = Vector()\",\n \"def __init__(self, input_size, output_size, hidden_sizes=[],\\r\\n learning_rate=2.0, weight_scale=0.1, converge=0.01,\\r\\n random_seed=None):\\r\\n if random_seed is not None:\\r\\n seed(random_seed)\\r\\n\\r\\n weight_func = partial(normal, 0, weight_scale)\\r\\n self.converge = converge\\r\\n self.layers = []\\r\\n self.layers.append([InputNode(\\\"in_\\\" + str(i)) for i in range(input_size)])\\r\\n for i,layer_size in enumerate(hidden_sizes):\\r\\n self.layers.append([SigmoidNode(\\\"hidden_\\\"+str(i)+\\\"-\\\"+str(j),\\r\\n learning_rate) for j in range(layer_size)])\\r\\n self.layers.append([SigmoidNode(\\\"out_\\\"+str(i), learning_rate) for i\\r\\n in range(output_size)])\\r\\n\\r\\n # densely connect consecutive layers\\r\\n for source_layer, dest_layer in zip(self.layers, self.layers[1:]):\\r\\n for source, dest in product(source_layer, dest_layer):\\r\\n edge = Edge(source, dest, weight_func)\\r\\n source.out_edges.append(edge)\\r\\n dest.in_edges.append(edge)\\r\\n\\r\\n # connect each node to bias\\r\\n self.bias = BiasNode()\\r\\n for layer in self.layers[1:]:\\r\\n for node in layer:\\r\\n e = Edge(self.bias, node, weight_func)\\r\\n node.in_edges.append(e)\\r\\n self.bias.out_edges.append(e)\",\n \"def __init__(self, layer_sizes, act_func=Sigmoid, cost_func=CrossEntropy, metric=AccuracyMetric):\\n np.random.seed(1) # Used for constant weights and biases initialization. Fell free to change it.\\n\\n self.layers_num = len(layer_sizes)\\n self.act_func = act_func\\n self.cost_func = cost_func\\n self.metric = metric\\n self.biases = [np.random.random(i) for i in layer_sizes[1:]]\\n self.weights = [np.random.normal(loc=0, scale=(1 / np.sqrt(layer_sizes[0])), size=(j, i))\\n for j, i in zip(layer_sizes[1:], layer_sizes[:-1])]\\n self.costs = []\\n self.accuracies = []\\n self.eta = 0\\n self.lambda_r = 0\",\n \"def __init__(self, num_units, input_size=None,\\n nonlinearity=tf.nn.tanh,\\n W_init=tf.random_normal_initializer(stddev=0.15),\\n b_init=tf.constant_initializer(0.0, dtype=tf.float32),\\n weightnorm=False):\\n self._num_units = num_units\\n self._input_size = input_size or num_units\\n self._W_init = W_init\\n self._b_init = b_init\\n self._weightnorm = weightnorm\\n self._nonlin = nonlinearity\",\n \"def construct_network(self, n_units, n_samples=1, noise_dim=0,\\n keep_p=1., nonlinearity=True, init_params=None, name=\\\"\\\"):\\n print \\\"constructing network, n_units: \\\",n_units\\n # TODO use kwargs for more elagant solutions to being called by this \\n # base class\\n assert keep_p ==1. and nonlinearity and noise_dim == 0\\n\\n assert init_params is None # this is implemented only in the Bayesian flow version of this function\\n\\n ### Define parameters of the network\\n self.weights, self.biases, KL = {}, {}, 0.\\n self.layers = []\\n # Establish paramters of appromiate posterior over weights and\\n # biases.\\n for l in range(1, len(n_units)):\\n with tf.variable_scope(name+'Layer_%d'%l):\\n n_in, n_out = n_units[l-1], n_units[l]\\n\\n # use non neglidgible uncertainty if we are doing VI\\n sigma_init = self.init_sigma_params\\n\\n w_prior_sigma, b_prior_sigma = self.w_prior_sigma, self.w_prior_sigma\\n mu_init_sigma_w, mu_init_sigma_b = np.sqrt(1./(n_in)), 1.\\n\\n (w_mu, w_logstd), _, w_KL = utils.set_q(name+\\\"w_%d\\\"%l,\\n sigma_prior=w_prior_sigma, mu_init_sigma=mu_init_sigma_w,\\n sigma_init=sigma_init, n_samples=0,\\n size=[n_in, n_out], save_summary=True)\\n\\n # We use same init_sigma for weights and biases.\\n (b_mu, b_logstd), _, b_KL = utils.set_q(name+\\\"b_%d\\\"%l,\\n sigma_prior=b_prior_sigma, mu_init_sigma=mu_init_sigma_b,\\n sigma_init=sigma_init, n_samples=0,\\n size=[n_out], save_summary=True)\\n self.weights['w_%d_mu'%l], self.weights['w_%d_std'%l] = w_mu, tf.nn.softplus(w_logstd)\\n self.biases['b_%d_mu'%l], self.biases['b_%d_std'%l] = b_mu, tf.nn.softplus(b_logstd)\\n\\n self.params += [w_mu, b_mu, w_logstd, b_logstd]\\n KL += w_KL + b_KL\\n\\n # Add an extra dimension to correspond to samples.\\n prev_layer = tf.stack([self.x]*n_samples)\\n self.layers.append(prev_layer)\\n # shape is [n_samples, ?, dim(x)]\\n\\n ### Define activations in each layer\\n for l in range(1,len(n_units)):\\n print \\\"defining activations in layer %d\\\"%l\\n # Multiply with weight matrix and add bias\\n prev_layer = tf.reshape(prev_layer, [-1, n_units[l-1]])\\n layer_pre_bias = tf.matmul(prev_layer, self.weights['w_%d_mu'%l])\\n layer_pre_bias = tf.reshape(layer_pre_bias, [n_samples, -1, n_units[l]])\\n # Shape of layer_pre_bias is [n_samples, ?, n_units[l]]\\n\\n # add mean bias term\\n layer = tf.add(layer_pre_bias, self.biases['b_%d_mu'%l][None, None, :])\\n\\n # Calculate the noise in each hidden unit.\\n # must use absolute value of activation because final layer may\\n # have negative values.\\n layer_var = tf.matmul(tf.reshape(prev_layer**2,[-1,\\n n_units[l-1]]), self.weights['w_%d_std'%l]**2)\\n layer_var = tf.reshape(layer_var, [n_samples, -1, n_units[l]])\\n layer_var += self.biases['b_%d_std'%l]**2\\n\\n # Now sample noise and add scaled noise.\\n # This constitutes the local reparameterization trick.\\n eps = tf.random_normal(name='eps_%d'%l, mean=0.,\\n stddev=1.0, shape=[n_samples, 1, n_units[l]])\\n layer_sigma = tf.sqrt(layer_var)\\n layer += layer_sigma*eps\\n with tf.name_scope(name+\\\"Neural_Network_Activations_%d\\\"%l):\\n tf.summary.histogram(name+\\\"Layer_%d_sigmas\\\"%l, layer_sigma)\\n tf.summary.histogram(name+\\\"Layer_%d_activations_pre_tanh\\\"%l, layer)\\n\\n # Add tanh nonlinearity\\n if l != (len(n_units) - 1): layer = tf.nn.tanh(layer)\\n\\n with tf.name_scope(name+\\\"Neural_Network_Activations_%d\\\"%l):\\n tf.summary.histogram(name+\\\"Layer_%d_activations_post_tanh\\\"%l,layer)\\n\\n prev_layer = layer\\n self.layers.append(prev_layer)\\n self.KL_BNN = KL\\n return prev_layer\",\n \"def init_weights(self, load_weights=None):\\n if load_weights:\\n # TODO\\n pass\\n else:\\n # x: lower layer nodes n\\n # y: current layer nodes n\\n x = self.weights_shape[1]\\n y = self.weights_shape[0]\\n self.weights = np.random.randn(y, x) / np.sqrt(x) # pylint: disable=no-member\\n self.biases = np.random.randn(y, 1) # pylint: disable=no-member\",\n \"def __init__(\\n self,\\n input_size: int,\\n hidden_sizes: Sequence[int],\\n output_size: int,\\n num_layers: int,\\n optimizer: Type[Optimizer] = SGD(),\\n norm_weights: bool = False\\n ):\\n self.input_size = input_size\\n self.hidden_sizes = hidden_sizes\\n self.output_size = output_size\\n self.num_layers = num_layers\\n self.norm_weights = norm_weights\\n\\n assert len(hidden_sizes) == (num_layers - 1)\\n assert num_layers >= 1\\n\\n activated_layer_sizes = [input_size] + hidden_sizes\\n activated_layers = [LinearLayer(n_in, n_out, activation_func=ReLU) for n_in, n_out in zip(activated_layer_sizes, activated_layer_sizes[1:])]\\n final_layer = LinearLayer(activated_layer_sizes[-1], self.output_size, activation_func=Softmax)\\n self.layers = activated_layers + [final_layer]\\n\\n self.optimizer = optimizer\",\n \"def initialize_weights(self, weights_initializer, bias_initializer):\\n wshapes = [\\n [self.input_size, self.hidden_size[0]],\\n [self.hidden_size[0], self.hidden_size[1]],\\n [self.hidden_size[1], self.output_size]\\n ]\\n\\n bshapes = [\\n [1, self.hidden_size[0]],\\n [1, self.hidden_size[1]],\\n [1, self.output_size]\\n ]\\n\\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\\n\\n self.trainable_variables = self.weights + self.biases\",\n \"def __init__(self, weights, path, trained, asGraph):\\n \\n _weights = np.asarray(weights)\\n\\n numLayers = int(_weights.shape[0]/2)\\n wghts = []\\n biases = []\\n\\n for i in range(numLayers):\\n j = 2*i\\n# print(j,(_weights[j].T).shape)\\n wghts.append(_weights[j])\\n j = 2*i + 1\\n# print(j,(_weights[j].T).shape)\\n biases.append(_weights[j])\\n #enddo\\n\\n self.numLayers = numLayers\\n self.wghts = np.asarray(wghts)\\n self.asGraph = asGraph\\n self.wghts = wghts\\n self.path = path\\n self.trained = trained\",\n \"def __init__(self, inputSize, hiddenSize, outputSize, epochs = 100, debug = False):\\n self.inputSize = inputSize\\n self.hiddenSize = hiddenSize\\n self.outputSize = outputSize\\n self.epochs = epochs\\n self.debug = debug\\n\\n #weights\\n self.W1 = np.random.randn(self.inputSize, self.hiddenSize) \\n self.W2 = np.random.randn(self.hiddenSize, self.outputSize)\",\n \"def __init__(self, inputSize, outputSize, hiddenSize): \\n\\n self.inputSize = inputSize\\n self.outputSize = outputSize\\n self.hiddenSize = hiddenSize \\n \\n # Initialize random weight with range [-0.5, 0.5]\\n self.weight = np.matrix(np.random.uniform(-0.5, 0.5, (self.hiddenSize, self.inputSize)))\\n\\n # Initialize random bias with range [0, 1]\\n self.bias = np.matrix(np.random.uniform(0, 1, (1, self.hiddenSize)))\\n \\n self.H = 0\\n self.beta = 0\",\n \"def build_layer(self) :\\n inputsWithBias = self.input_count + 1\\n self.weights = np.random.rand(inputsWithBias, self.node_count)\\n self.weights_and_activations = (self.weights, self.activations)\",\n \"def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):\\n\\n self.params = {}\\n self.params['W1'] = weight_init_std * \\\\\\n np.random.randn(input_size, hidden_size)\\n self.params['b1'] = np.zeros(hidden_size)\\n self.params['W2'] = weight_init_std * \\\\\\n np.random.randn(hidden_size, output_size)\\n self.params['b2'] = np.zeros(output_size)\",\n \"def create_neural_network(mode, layer_sizes, use_stored_weights, weights_path):\\n\\n\\tif verbose: print('model_tensorflow.create_neural_network() called')\\n\\n\\tnum_layers = len(layer_sizes) - 1\\n\\tweights = {}\\n\\tbiases = {}\\n\\n\\tif verbose: print('creating a DNN with', str(num_layers-1), 'hidden layers of size', \\n\\t\\t\\t\\t\\t str(layer_sizes[1:len(layer_sizes)-1]))\\n\\n\\t# Initialise the weights\\n\\t# (a) Create new weights and biases\\n\\tif not use_stored_weights:\\n\\t\\tfor i in range(num_layers): \\n\\t\\t\\t# Layer l has dimensions (|l-1|, |l|) for weights and (|l|) for biases\\n\\t\\t\\tw_name = 'W' + str(i+1)\\n\\t\\t\\tweights[w_name] = tf.get_variable(w_name, [layer_sizes[i], layer_sizes[i+1]], \\n\\t\\t\\t\\tinitializer = tf.contrib.layers.xavier_initializer(), dtype=tf.float32)\\n\\t\\t\\tb_name = 'b' + str(i+1)\\n\\t\\t\\tbiases[b_name] = tf.get_variable(b_name, [layer_sizes[i+1]], \\n\\t\\t\\t\\tinitializer = tf.zeros_initializer(), dtype=tf.float32)\\n\\n\\t\\t# Initialise all existing global variables \\n\\t\\tsess.run(tf.global_variables_initializer())\\n\\n\\t\\t# Save weights and biases\\n\\t\\tsaver = tf.train.Saver()\\n\\t\\tsave_path = saver.save(sess, weights_path + 'weights/' + 'init.ckpt') \\n\\t# (b) Restore existing weights and biases\\n\\telse:\\n\\t\\tfor i in range(num_layers):\\n\\t\\t\\t# Prepare variable\\n\\t\\t\\tw_name = 'W' + str(i+1)\\n\\t\\t\\tb_name = 'b' + str(i+1)\\n\\t\\t\\tweights[w_name] = tf.get_variable(w_name, [layer_sizes[i], layer_sizes[i+1]], \\n\\t\\t\\t\\tinitializer = tf.zeros_initializer(), dtype=tf.float32)\\n\\t\\t\\tbiases[b_name] = tf.get_variable(b_name, [layer_sizes[i+1]], \\n\\t\\t\\t\\tinitializer = tf.zeros_initializer(), dtype=tf.float32)\\n\\n\\t\\t# Initialise all existing global variables \\n\\t\\tsess.run(tf.global_variables_initializer())\\n\\n\\t\\t# Restore weights and biases\\n\\t\\tsaver = tf.train.Saver()\\n\\t\\tif mode == trn:\\n\\t\\t\\tsaver.restore(sess, weights_path + 'weights/' + 'init.ckpt') \\n\\t\\telif mode == tst or mode == app:\\n\\t\\t\\tsaver.restore(sess, weights_path + 'weights/' + 'trained.ckpt')\\n\\n\\twb = {'weights': weights, 'biases': biases}\\n\\treturn wb\",\n \"def construct(self, weights):\\n in_weights = weights # first to append zero column as the last output (no out-degree)\\n weights = np.zeros((weights.shape[0], weights.shape[1]+1))\\n weights[:,:-1] = in_weights\\n din, dout, dhid = self.dim_in, self.dim_out, self.dim_hid # the max dim\\n hid = weights.shape[0] - dout # this hidden dim\\n if not (weights.shape[1]-din-dout==hid and (0<hid<=dhid)):\\n raise self.ANNException('weight matrix hidden nodes not matching')\\n if not (dout < weights.shape[0] <= hid+dout):\\n raise self.ANNException('weight matrix row shape not matching')\\n if not (din+dout < weights.shape[1] <= din+hid+dout):\\n raise self.ANNException('weight matrix column shape not matching')\\n\\n self.weight[din:din+hid,:din+hid] = weights[:hid,:din+hid]\\n self.weight[din:din+hid,din+dhid:] = weights[:hid,din+hid:]\\n self.weight[din+dhid:,:din+hid] = weights[hid:,:din+hid]\\n self.weight[din+dhid:,din+dhid:] = weights[hid:,din+hid:]\\n\\n for i in range(hid):\\n self.connectivity[din+i,:din+i] = True\\n self.connectivity[din+dhid:,:din+hid] = True\\n for i in range(dout):\\n self.connectivity[din+dhid+i,din+dhid:din+dhid+i] = True\\n\\n self.hidden[:hid] = True\",\n \"def __init__(self, sizes, afunc): \\n\\t\\tself.num_layers = len(sizes)\\n\\t\\tself.sizes = sizes\\n\\t\\tself.afunc = afunc;\\n\\t\\tself.initialize_weights_uniform()\\n\\t\\t#self.initialize_weights_gaussian(0.1)\\n\\t\\t#self.initialize_weights_xavier()\",\n \"def __init__(self, inputLayerSize, outputLayerSize, \\\\\\n hiddenLayerSize):\\n #Network hyperparameters - neurons per layer - **not altered by training**\\n self.inputLayerSize = inputLayerSize\\n self.outputLayerSize = outputLayerSize\\n self.hiddenLayerSize = hiddenLayerSize\\n self.num_params = inputLayerSize * hiddenLayerSize + \\\\\\n hiddenLayerSize * outputLayerSize + hiddenLayerSize \\\\\\n + outputLayerSize\\n #--Weights--\\n #w_ih - weights of synapses linking input -> hidden\\n self.w_ih = np.random.randn( self.inputLayerSize, \\\\\\n self.hiddenLayerSize)\\n #w_ho - weights of synapses linking hidden -> output\\n self.w_ho = np.random.randn( self.hiddenLayerSize, \\\\\\n self.outputLayerSize)\\n \\n #--Biases--\\n #b_h - biases of hidden layer\\n self.b_h = np.random.randn( self.hiddenLayerSize )\\n #b_o - biases of output layer\\n self.b_o = np.random.randn( self.outputLayerSize )\",\n \"def __init__(self):\\r\\n # A dummy layer does nothing\\r\\n self.weights = np.zeros(shape=(input.shape[1], 10))\\r\\n bias = np.zeros(shape=(10,))\\r\\n pass\",\n \"def construct(self):\\n self.input_size = self.numplanes * self.boardsize**2\\n \\n if self.hidden:\\n layers = [\\n torch.nn.Linear(self.input_size, self.hidden), \\n torch.nn.ReLU(),\\n torch.nn.Linear(self.hidden, self.boardsize**2)\\n ]\\n else:\\n layers = [torch.nn.Linear(self.input_size, self.boardsize**2)]\\n\\n self.layers = torch.nn.ModuleList(layers)\\n self.optimizer = torch.optim.Adam(self.parameters(), lr=1e-5)\\n logging.info(\\\"Model initialized: %s\\\", self)\",\n \"def __init__(self, weights, alphas):\\n self._neurons = [Neuron(a, w) for w, a in zip(weights, alphas)]\",\n \"def initialize(self, input_size, n_classes):\\n\\n self.n_classes = n_classes\\n self.input_size = input_size\\n\\n n_hidden_layers = len(self.sizes)\\n #############################################################################\\n # Allocate space for the hidden and output layers, as well as the gradients #\\n #############################################################################\\n self.hs = []\\n self.grad_hs = []\\n for h in range(n_hidden_layers):\\n self.hs += [np.zeros((self.sizes[h],))] # hidden layer\\n self.grad_hs += [np.zeros((self.sizes[h],))] # ... and gradient\\n self.hs += [np.zeros((self.n_classes,))] # output layer\\n self.grad_hs += [np.zeros((self.n_classes,))] # ... and gradient\\n\\n ##################################################################\\n # Allocate space for the neural network parameters and gradients #\\n ##################################################################\\n self.weights = [np.zeros((self.input_size, self.sizes[0]))] # input.csv to 1st hidden layer weights\\n self.grad_weights = [np.zeros((self.input_size, self.sizes[0]))] # ... and gradient\\n\\n self.biases = [np.zeros((self.sizes[0]))] # 1st hidden layer biases\\n self.grad_biases = [np.zeros((self.sizes[0]))] # ... and gradient\\n\\n for h in range(1, n_hidden_layers):\\n self.weights += [np.zeros((self.sizes[h - 1], self.sizes[h]))] # h-1 to h hidden layer weights\\n self.grad_weights += [np.zeros((self.sizes[h - 1], self.sizes[h]))] # ... and gradient\\n\\n self.biases += [np.zeros((self.sizes[h]))] # hth hidden layer biases\\n self.grad_biases += [np.zeros((self.sizes[h]))] # ... and gradient\\n\\n self.weights += [np.zeros((self.sizes[-1], self.n_classes))] # last hidden to output layer weights\\n self.grad_weights += [np.zeros((self.sizes[-1], self.n_classes))] # ... and gradient\\n\\n self.biases += [np.zeros((self.n_classes))] # output layer biases\\n self.grad_biases += [np.zeros((self.n_classes))] # ... and gradient\\n\\n #########################\\n # Initialize parameters #\\n #########################\\n\\n self.rng = np.random.mtrand.RandomState(self.seed) # create random number generator\\n # biases are initialized to zero\\n # ... and weights according to the slides\\n for m in range(len(self.weights)):\\n b = (6 ** 0.5) / ((self.weights[m].shape[0] + self.weights[m].shape[1]) ** 0.5)\\n for ind, val in np.ndenumerate(self.weights[m]):\\n self.weights[m][ind] = self.rng.uniform(-b, b, 1)\\n\\n\\n self.n_updates = 0 # To keep track of the number of updates, to decrease the learning rate\",\n \"def create_network(layers):\\r\\n return NeuronNetwork(layers)\",\n \"def __init__(self, n_layers, layers_sizes, activation='sigmoid', learning_rate=0.1, weight_init='normal', batch_size=1000, num_epochs=100):\\n self.layers_sizes=layers_sizes[1:]\\n self.activation=activation\\n self.learning_rate=learning_rate\\n self.weight_init=weight_init\\n self.batch_size=batch_size\\n self.num_epochs=num_epochs\\n self.weights={}\\n self.n_layers=len(self.layers_sizes)\\n self.num_samples=0\\n self.training_loss_values=[]\\n self.testing_loss_values=[]\\n self.gg=0.01\\n self.XTEST=None\\n self.YTEST=None\\n self.TTTT=None\\n\\n if activation not in self.acti_fns:\\n raise Exception('Incorrect Activation Function')\\n\\n if weight_init not in self.weight_inits:\\n raise Exception('Incorrect Weight Initialization Function')\\n pass\",\n \"def instantiate_weights(self):\\n self.product_embeddings = tf.get_variable(\\n name='product_embeddings',\\n shape=[50000, 300],\\n dtype=tf.float32\\n )\\n self.aisle_embeddings = tf.get_variable(\\n name='aisle_embeddings',\\n shape=[250, 50],\\n dtype=tf.float32\\n )\\n self.department_embeddings = tf.get_variable(\\n name='department_embeddings',\\n shape=[50, 10],\\n dtype=tf.float32\\n )\\n self.W_relu = tf.get_variable(\\\"W_relu\\\",shape=[670, 30]) #这个参数后续需要自适应\\n self.b_relu = tf.get_variable(\\\"bias_relu\\\",shape=[30]) \\n self.W_projection = tf.get_variable(\\\"W_projection\\\",shape=[30, 1]) \\n self.b_projection = tf.get_variable(\\\"bias_projection\\\",shape=[1])\",\n \"def __init__(self, N_sym, n_nodes, activations, N_element, bias = True, scaling = None):\\n super(MultiLayerNet, self).__init__()\\n N_layers = len(n_nodes)\\n if N_layers == 0:\\n self.net = torch.nn.Linear(N_sym, N_element, bias = bias)\\n else:\\n layers = []\\n for n in range(N_layers):\\n if n == 0:\\n layers += [torch.nn.Linear(N_sym, n_nodes[n], bias = bias)]\\n layers += [activations[n]]\\n else:\\n layers += [torch.nn.Linear(n_nodes[n-1], n_nodes[n], bias = bias)]\\n layers += [activations[n]]\\n layers += [torch.nn.Linear(n_nodes[-1], N_element, bias = bias)]\\n self.net = torch.nn.Sequential(*layers)\\n \\n self.scaling = scaling\",\n \"def _build_network(self, h_size=16, l_rate=0.001):\\n with tf.variable_scope(self.net_name):\\n self._X = tf.placeholder(tf.float32, [None, self.input_size], name=\\\"input_x\\\")\\n net = self._X\\n\\n net = tf.layers.dense(net, h_size, activation=tf.nn.relu)\\n net = tf.layers.dense(net, self.output_size)\\n self._Qpred = net\\n\\n self._Y = tf.placeholder(tf.float32, shape=[None, self.output_size])\\n self._loss = tf.losses.mean_squared_error(self._Y, self._Qpred)\\n\\n optimizer = tf.train.AdamOptimizer(learning_rate=l_rate)\\n self._train = optimizer.minimize(self._loss)\",\n \"def make_neural_net_challenging():\\n i0 = Input('i0', -1.0) # this input is immutable\\n i1 = Input('i1', 0.0)\\n i2 = Input('i2', 0.0)\\n seed_random()\\n wt1 = random_weight()\\n wt2 = random_weight()\\n wt3 = random_weight()\\n wt4 = random_weight()\\n wt5 = random_weight()\\n wt6 = random_weight()\\n wt7 = random_weight()\\n wt8 = random_weight()\\n wt9 = random_weight()\\n wt10 = random_weight()\\n\\t\\n w1A = Weight('w1A', wt1)\\n w2A = Weight('w2A', wt2)\\n w1B = Weight('w1B', wt3)\\n w2B = Weight('w2B', wt4)\\n wA = Weight('wA', -1)\\n wB = Weight('wB', -1)\\n wAC = Weight('wAC', wt5)\\n wBC = Weight('wBC', wt6)\\n wC = Weight('wC', -1)\\n wAD = Weight('wAD', wt7)\\n wBD = Weight('wBD', wt8)\\n wD = Weight('wD', -1)\\n wCE = Weight('wCE', wt9)\\n wDE = Weight('wDE', wt10)\\n wE = Weight('wE', -1)\\n\\n # Inputs must be in the same order as their associated weights\\n A = Neuron('A', [i1,i2,i0], [w1A,w2A,wA])\\n B = Neuron('B', [i1,i2,i0], [w1B,w2B,wB])\\n C = Neuron('C', [A,B,i0], [wAC,wBC,wC])\\n D = Neuron('D', [A,B,i0], [wAD,wBD,wD])\\n E = Neuron('D', [C,D,i0], [wCE,wDE,wE])\\n P = PerformanceElem(E, 0.0)\\n\\n net = Network(P,[A, B, C, D, E])\\n return net\",\n \"def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):\\n \\n super().__init__(inputnodes, hiddennodes, outputnodes, learningrate)\\n\\n # link weight matrices, wih and who\\n # weights inside the arrays are w_i_j, where link is from node i to node i to j in the next layer\\n # w11 w21\\n # w12 w22 etc\\n self.wih = numpy.random.normal(\\n 0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))\\n self.who = numpy.random.normal(\\n 0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))\\n\\n #activation function is the sigmoid function\\n self.activation_function = lambda x: scipy.special.expit(x)\\n\\n pass\",\n \"def __initialize_weights__(num_neurons: int) -> np.ndarray:\\n\\n weights = np.zeros((num_neurons, num_neurons))\\n\\n return weights\",\n \"def __init__(self, num_units, input_size=None,\\n nonlinearity=tf.nn.sigmoid,\\n initializer=tf.random_normal_initializer(0.0, 0.1)):\\n self._input_size = num_units if not input_size else input_size\\n self._num_units = num_units\\n self._nonlin = nonlinearity\\n self._initializer = initializer\",\n \"def __init__(self, input_dimensions=2, number_of_nodes=4, transfer_function=\\\"Hard_limit\\\"):\\r\\n self.input_dimensions = input_dimensions\\r\\n self.number_of_nodes = number_of_nodes\\r\\n self.transfer_function = transfer_function\\r\\n self.initialize_weights()\",\n \"def _setup(self) -> None:\\n #TODO: type\\n self.activation = self.params['activation']\\n\\n self.batchsize: int = self.params['batchsize']\\n\\n self.input_shape: Tuple[int,int,int] = self.params['input_shape']\\n\\n self.d: int = self.input_shape[1]\\n assert(not self.d == 0)\\n\\n self.n: int = int(sqrt(self.input_shape[2]))\\n assert(not self.n == 0)\\n\\n self.dtype: type = self.params['dtype']\\n\\n # initialize weights\\n self.W: List[tf.Tensor] = []\\n \\n for i in range(3):\\n #TODO: type\\n w_init = self.params['initializer_w']\\n if self.params['initializer_w' + str(i)] is not None:\\n w_init = self.params['initializer_w' + str(i)]\\n\\n w_stddev: float = self.params['stddev_w']\\n if self.params['stddev_w' + str(i)] is not None:\\n w_stddev = self.params['stddev_w' + str(i)]\\n\\n self.W.append(tf.get_variable(\\\"weights_\\\" + str(i),\\n shape = (self.d, (self.d if i < 2 else 2 * self.d)),\\n dtype = self.dtype,\\n initializer = w_init(stddev=w_stddev)))\\n\\n #TODO: type\\n b_init = self.params['initializer_b']\\n b_stddev = self.params['stddev_b']\\n self.B: tf.Tensor = tf.get_variable(\\\"biases\\\", shape = (1, self.d, 1),\\n dtype = self.dtype,\\n initializer = b_init(stddev=b_stddev))\\n\\n # create/load expand matrix\\n with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\\n self.expand: tf.Tensor = tf.get_variable(\\n \\\"expand\\\" + str(self.n),\\n shape = (self.n, self.n * self.n),\\n dtype = self.dtype,\\n initializer = tf.constant_initializer(make_expand(self.n)))\\n\\n # create/load tile matrix\\n tile: np.ndarray = np.array([([1] + [0]*(self.n-1))*self.n])\\n for i in range(1, self.n):\\n tile = np.append(tile, [([0]*i + [1] + [0]*(self.n-1-i))*self.n], 0)\\n\\n self.tile: tf.Tensor = tf.constant(tile, self.dtype)\",\n \"def _build_networks(self):\\n # Calling online_convnet will generate a new graph as defined in\\n # self._get_network_template using whatever input is passed, but will always\\n # share the same weights.\\n self.online_convnet = tf.make_template('Online', self._network_template)\\n self.target_convnet = tf.make_template('Target', self._network_template)\\n self._net_outputs = self.online_convnet(self.state_ph)\\n\\n self._replay_net_outputs = self.online_convnet(self._replay.states)\\n self._replay_next_target_net_outputs = self.target_convnet(\\n self._replay.next_states)\\n\\n if self.acting_policy == 'hyperbolic':\\n self._q_argmax = tf.argmax(self._net_outputs.hyp_q_value, axis=1)[0]\\n elif self.acting_policy == 'largest_gamma':\\n self._q_argmax = tf.argmax(self._net_outputs.q_values[-1], axis=1)[0]\\n else:\\n raise NotImplementedError\",\n \"def __init__(self, input_dimensions=2, number_of_nodes=4, transfer_function=\\\"Hard_limit\\\"):\\n self.input_dimensions = input_dimensions\\n self.number_of_nodes = number_of_nodes\\n self.transfer_function = transfer_function\\n self.initialize_weights()\",\n \"def __init__(self, emsize):\\n super(GatingNetwork, self).__init__()\\n self.weight = nn.Linear(emsize, 1)\",\n \"def __init__(self, params = None, layer_sizes = None, scale = 0.1, rs=npr.RandomState(0)):\\n self.layer_sizes = layer_sizes\\n\\n if params is not None:\\n self.param = params\\n else:\\n if layer_sizes is None:\\n raise Exception(\\\"Please provide the layer sizes\\\")\\n\\n self.params = [(scale * rs.randn(m, n), # weight matrix\\n scale * rs.randn(n)) # bias vector\\n for m, n in zip(layer_sizes[:-1], layer_sizes[1:])]\",\n \"def build_network(self, dimList, actType=\\\"Tanh\\\", verbose=True):\\n self.Q_network = Model(dimList, actType, verbose=verbose)\\n self.target_network = Model(dimList, actType)\\n\\n if self.device == torch.device(\\\"cuda\\\"):\\n self.Q_network.cuda()\\n self.target_network.cuda()\\n\\n self.build_optimizer()\",\n \"def __init__(self, weights, biases):\\n super().__init__()\\n\\n self.weights = weights\\n self.biases = biases\",\n \"def __init__(self, size: Tuple[int, int], is_output: bool) -> None:\\n self.g = Math.sigmoid if is_output else Math.relu\\n self.w: List[List[float]] = \\\\\\n [[random.random() * 0.1 for _ in range(size[1])]\\n for _ in range(size[0])]\\n self.b: List[float] = [0.0] * size[0]\\n\\n # use of below attributes is optional but recommended\\n self.z: List[float] = [0.0] * size[0]\\n self.a: List[float] = [0.0] * size[0]\\n self.dw: List[List[float]] = \\\\\\n [[0.0 for _ in range(size[1])] for _ in range(size[0])]\\n self.db: List[float] = [0.0] * size[0]\",\n \"def create_base_network(NumberOfFeatures, NumberOfClasses,init_mode='glorot_normal'):\\n network = Sequential()\\n network.add(Dense(44, activation='sigmoid', kernel_initializer=init_mode,input_dim=NumberOfFeatures))\\n# network.add(Dense(22, activation='sigmoid',kernel_initializer=init_mode))\\n network.add(Dense(NumberOfClasses, activation='softmax',kernel_initializer=init_mode))\\n return network\",\n \"def __init__(self, num_units, input_size=None,\\n nonlinearity=tf.nn.tanh,\\n hh_init=tf.random_normal_initializer(stddev=0.15),\\n xh_init=tf.random_normal_initializer(stddev=0.15),\\n b_init=tf.constant_initializer(0.0, dtype=tf.float32),\\n weight_noise=0.0,\\n keep_prob=1.0,\\n weightnorm=False,\\n orthreg=False):\\n self._num_units = num_units\\n self._input_size = input_size or num_units\\n self._nonlinearity = nonlinearity\\n self._hh_init = hh_init\\n self._xh_init = xh_init\\n self._b_init = b_init\\n self._weightnorm = weightnorm\\n self._keep_prob = keep_prob\\n self._weight_noise = weight_noise\\n self._orthreg = orthreg\",\n \"def _generate_network_initialization(self, graph, memory_manager):\\n\\n # TODO: To be changed if we want to support multiple outputs\\n output_buffer_name = graph.outputs[0].name\\n\\n ops_to_ignore = ['Reshape', 'Mul']\\n\\n buffers_allocated = []\\n\\n buffer_declaration = \\\"\\\"\\n buffer_declaration += \\\" pico_cnn::naive::Tensor **kernels;\\\\n\\\"\\n buffer_declaration += \\\" pico_cnn::naive::Tensor **biases;\\\\n\\\"\\n\\n constructor_code = \\\"\\\"\\n #constructor_code += \\\"Network::Network() {\\\\n\\\\n\\\"\\n\\n num_layers = 0\\n num_kernels = 0\\n num_biases = 0\\n\\n for node in graph.nodes:\\n \\\"\\\"\\\"Do not count the reshape layers as the input tensor will only define the dimensions\\\"\\\"\\\"\\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\\n num_layers += 1\\n for num, input in enumerate(node.input_tensors):\\n if input in buffers_allocated:\\n continue\\n else:\\n tensor = node.input_tensors[input]\\n buffers_allocated.append(input)\\n if len(tensor.shape) == 1:\\n num_biases += 1\\n else:\\n num_kernels += 1\\n\\n \\\"\\\"\\\"The arrays kernels and biases will be used to pass only two variables to read_binary_weights\\\"\\\"\\\"\\n constructor_code += \\\" kernels = new pico_cnn::naive::Tensor*[{}]();\\\\n\\\".format(num_kernels)\\n constructor_code += \\\" biases = new pico_cnn::naive::Tensor*[{}]();\\\\n\\\\n\\\".format(num_biases)\\n\\n pos = -1\\n pos_kernel = -1\\n pos_bias = -1\\n\\n buffers_allocated.clear()\\n\\n \\\"\\\"\\\"Iterate over all nodes in the graph and generate the corresponding allocation code.\\\"\\\"\\\"\\n for node_id, node in enumerate(graph.nodes):\\n\\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\\n pos += 1\\n\\n buffer_declaration += \\\" // Layer: \\\" + node.name + \\\", Operation: \\\" + node.op_type + \\\"\\\\n\\\"\\n constructor_code += \\\" // Layer: \\\" + node.name + \\\", Operation: \\\" + node.op_type + \\\"\\\\n\\\"\\n\\n # Allocate memory for kernels and biases\\n buffer_declaration += \\\" // Inputs\\\\n\\\"\\n constructor_code += \\\" // Inputs\\\\n\\\"\\n for num, input in enumerate(node.input_tensors):\\n\\n if node.op_type in ops_to_ignore:\\n continue\\n\\n if input in buffers_allocated:\\n continue\\n else:\\n buffers_allocated.append(input)\\n\\n tensor = node.input_tensors[input]\\n if len(tensor.shape) == 1:\\n pos_bias += 1\\n else:\\n pos_kernel += 1\\n\\n buffer = memory_manager.get_buffer(graph, input)\\n\\n buffer_declaration += \\\" // \\\" + str(buffer.shape) + \\\"\\\\n\\\"\\n\\n pico_cnn_tensor = \\\" pico_cnn::naive::Tensor *\\\"\\n\\n buffer_declaration += pico_cnn_tensor + buffer.name + \\\";\\\\n\\\"\\n\\n constructor_code += \\\" // \\\" + str(buffer.shape) + \\\"\\\" # TODO maybe we sometimes need \\\\n\\n\\n functionality = CodeRegistry.get_funct(\\\"KernelAllocation\\\")\\n impl = functionality[0].create(buffer, pos, pos_kernel, pos_bias)\\n\\n if impl:\\n constructor_code += impl.generate_code()\\n constructor_code += \\\"\\\\n\\\"\\n\\n buffer_declaration += \\\" // Outputs\\\\n\\\"\\n constructor_code += \\\" // Outputs\\\\n\\\"\\n for num, output in enumerate(node.outputs):\\n\\n buffer = memory_manager.get_buffer(graph, output)\\n\\n if output == output_buffer_name:\\n buffer_declaration += \\\" // Output tensor {} with shape {} of network provided as argument of Network::run()\\\".format(buffer.name, str(buffer.shape))\\n constructor_code += \\\" // Output tensor {} with shape {} of network provided as argument of Network::run()\\\".format(buffer.name, str(buffer.shape))\\n continue\\n\\n buffer_declaration += \\\" // \\\" + str(buffer.shape) + \\\"\\\\n\\\"\\n\\n pico_cnn_tensor = \\\" pico_cnn::naive::Tensor *\\\"\\n\\n buffer_declaration += pico_cnn_tensor + buffer.name + \\\";\\\\n\\\"\\n\\n constructor_code += \\\" // \\\" + str(buffer.shape) + \\\"\\\" # TODO maybe we sometimes need \\\\n\\n\\n functionality = CodeRegistry.get_funct(\\\"OutputAllocation\\\")\\n impl = functionality[0].create(buffer)\\n\\n if impl:\\n constructor_code += impl.generate_code()\\n constructor_code += \\\"\\\\n\\\"\\n\\n buffer_declaration += \\\"\\\\n\\\\n\\\"\\n constructor_code += \\\"\\\\n\\\\n\\\"\\n\\n #constructor_code += \\\"}\\\\n\\\"\\n\\n self.buffer_declaration = buffer_declaration\\n self.constructor_code = constructor_code\",\n \"def default_weight_initializer(self):\\n self.biases = [np.random.randn(y, 1) for y in self.sizes[1:]]\\n self.weights = [np.random.randn(y, x)/np.sqrt(x)\\n for x, y in zip(self.sizes[:-1], self.sizes[1:])]\",\n \"def init_learner(self,**kwargs):\\r\\n \\r\\n if self.learn_type == 'nn':\\r\\n #initialize neural network\\r\\n shape = kwargs[\\\"shape\\\"]\\r\\n #initialize input layer\\r\\n model = Sequential() \\r\\n #add hidden layers\\r\\n for i in range(len(shape)):\\r\\n if i == 0:\\r\\n nb_input = self.size\\r\\n else:\\r\\n nb_input = shape[i -1]\\r\\n nb_output = shape[i]\\r\\n model.add(Dense(nb_input,nb_output,init=\\\"he_normal\\\",\\r\\n activation = \\\"tanh\\\"))\\r\\n model.add(Dropout(.5))\\r\\n model.add(Dense(shape[-1],1,init = \\\"he_normal\\\",\\r\\n activation = \\\"linear\\\"))\\r\\n model.compile(loss = 'mean_squared_error',optimizer = 'rmsprop')\\r\\n self.learner = model\\r\\n \\r\\n elif self.learn_type == 'linear':\\r\\n #initialize parameter\\r\\n self.learner = Linear(self.size,**kwargs)\",\n \"def __init__(self, input_size, hidden_size, num_layers, nonlinearity=torch.tanh):\\n super().__init__()\\n self.input_size = input_size\\n self.hidden_size = hidden_size\\n\\n # input weights\\n self.weight_ih_l0 = Parameter(torch.Tensor(3*hidden_size, input_size))\\n\\n # hidden weights\\n self.weight_hh_l0 = Parameter(torch.Tensor(3*hidden_size, hidden_size))\\n\\n # bias\\n self.bias_ih_l0 = Parameter(torch.Tensor(3*hidden_size)) # input\\n self.bias_hh_l0 = Parameter(torch.Tensor(3*hidden_size)) # hidden\\n\\n self.f = nonlinearity\\n\\n self.init_weights()\",\n \"def __init__(self, neuron_count):\\n # The current state of the thermal network.\\n self.current_state = [0.0] * neuron_count\\n\\n # The weights.\\n self.weights = np.zeros( [neuron_count*neuron_count] )\\n\\n # The neuron count.\\n self.neuron_count = neuron_count\",\n \"def __init__(self, layer_size, activation_function=linear,\\n derivative_function=dlinear,\\n forward_function=propagate_forward,\\n backward_function=propagate_backward_irpropm,\\n init_weights_function=fully_connected_weights, bias=True):\\n self.forward_propagation = forward_function\\n self.back_propagation = backward_function\\n self.activation_function = activation_function\\n self.derivative_function = derivative_function\\n self.bias = bias\\n\\n # the activations of these nodes\\n bias_add = 0\\n if self.bias:\\n bias_add = 1\\n self.visible = numpy.ones(layer_size + bias_add)\\n self.init_weights_function = init_weights_function\",\n \"def __init__(self, hidden_dims, input_dim=3*32*32, num_classes=10,\\n reg=0.0, weight_scale=1e-2, dtype=np.float32):\\n self.reg = reg\\n self.num_layers = 1 + len(hidden_dims)\\n self.dtype = dtype\\n self.params = {}\\n\\n ############################################################################\\n # Initialize the network parameters with different weights and biases for #\\n # network layers #\\n ############################################################################\\n \\n key = ['W' + str(1), 'b' + str(1)]\\n self.params[key[0]] = weight_scale * np.random.randn(input_dim, hidden_dims[0])\\n self.params[key[1]] = np.zeros(hidden_dims[0])\\n \\n for i in range(1, len(hidden_dims)):\\n key = ['W' + str(i+1), 'b' + str(i+1)]\\n \\n self.params[key[0]] = weight_scale * np.random.randn(hidden_dims[i-1], hidden_dims[i])\\n self.params[key[1]] = np.zeros(hidden_dims[i])\\n\\n key = ['W' + str(self.num_layers), 'b' + str(self.num_layers)]\\n self.params[key[0]] = weight_scale * np.random.randn(hidden_dims[len(hidden_dims)-1], num_classes)\\n self.params[key[1]] = np.zeros(num_classes)\\n\\n\\n # Cast all parameters to the correct datatype\\n for k, v in self.params.items():\\n self.params[k] = v.astype(dtype)\",\n \"def __init__(self, dimensions=2):\\n assert dimensions > 0\\n for d in range(0,dimensions+1):\\n self.weight.append(0)\",\n \"def __init__(self, input_size, hidden_size, en_bias):\\n self.en_bias = en_bias\\n # weight matrix and bias vector\\n self.u = self.random(-np.sqrt(1.0/input_size),\\n np.sqrt(1.0/input_size), (hidden_size, input_size))\\n self.w = self.random(-np.sqrt(1.0/hidden_size),\\n np.sqrt(1.0/hidden_size), (hidden_size, hidden_size))\\n self.v = self.random(-np.sqrt(1.0/hidden_size),\\n np.sqrt(1.0/hidden_size), (hidden_size, hidden_size))\\n if en_bias:\\n self.b = self.random(-0.1, 0.1, (hidden_size,))\\n else:\\n self.b = np.zeros(hidden_size)\\n # error gradient for weight matrix and bias vector\\n self.dLdu = np.zeros(self.u.shape)\\n self.dLdw = np.zeros(self.w.shape)\\n self.dLdv = np.zeros(self.v.shape)\\n self.dLdb = np.zeros(self.b.shape)\",\n \"def __init__(self, sizes, beta=1, momentum=0.9):\\n self.beta = beta\\n self.momentum = momentum\\n\\n self.nin = sizes[0] # number of features in each sample\\n self.nhidden1 = sizes[1] # number of neurons in the first hidden layer\\n self.nhidden2 = sizes[2] # number of neurons in the second hidden layer\\n self.nout = sizes[3] # number of classes / the number of neurons in the output layer\\n\\n\\n # Initialise the network of two hidden layers\\n self.weights1 = (np.random.rand(self.nin+1,self.nhidden1)-0.5)*2/np.sqrt(self.nin) # hidden layer 1\\n self.weights2 = (np.random.rand(self.nhidden1+1,self.nhidden2)-0.5)*2/np.sqrt(self.nhidden1) # hidden layer 2\\n self.weights3 = (np.random.rand(self.nhidden2+1,self.nout)-0.5)*2/np.sqrt(self.nhidden2) # output layer\",\n \"def __init__(self, dims):\\n\\t\\tself.layersNumber = len(dims) - 1\\n\\t\\tself.weights = []\\n\\t\\tself.biases = []\\n\\t\\tnp.random.seed(42)\\n\\t\\tfor d in range(self.layersNumber):\\n\\t\\t\\tself.weights.append(np.random.randn(dims[d+1], dims[d]))\\n\\t\\t\\tself.biases.append(np.random.randn(dims[d+1], 1))\",\n \"def __init__(self, InputDimentions, OutputDimentions, numberOfLayers, WeightArray, BiasArray):\\r\\n self.WeightMatrixT = WeightArray\\r\\n self.WeightMatrixT.shape = (numberOfLayers, OutputDimentions, InputDimentions)\\r\\n self.BiasVector = BiasArray\\r\\n self.BiasVector.shape = (numberOfLayers, 1, OutputDimentions)\",\n \"def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):\\n super().__init__(inputnodes, hiddennodes, outputnodes, learningrate)\\n\\n # link weight matrices, wih and who\\n # weights inside the arrays are w_i_j, where link is from node i to node i to j in the next layer\\n # w11 w21\\n # w12 w22 etc\\n self.wih = cupy.random.normal(\\n 0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))\\n self.who = cupy.random.normal(\\n 0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))\\n\\n #activation function is the sigmoid function\\n self.activation_function = lambda x: 1 / (1 + cupy.exp(x) ** (-1))\",\n \"def __init__(self, N):\\n self.data = list(range(N))\\n self.weights = [1]*N\",\n \"def init_three_layer_neuralnet(weight_scale=1, bias_scale=0, input_feat_dim=786,\\n num_classes=10, num_neurons=(20, 30)):\\n \\n assert len(num_neurons) == 2, 'You must provide number of neurons for two layers...'\\n\\n model = {}\\n #model['W1'] = np.random.randn((num_neurons[0],(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)) # Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\\n \\n model['W1'] = (np.random.rand(input_feat_dim,num_neurons[0])*weight_scale) * math.sqrt(2.0/input_feat_dim)\\n model['b1'] = np.zeros(num_neurons[0])# Initialize with zeros\\n \\n #model['W2'] = (np.random.randn(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)# Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\\n #print ((model['W1'])[0,:]).shape\\n #numcols = len(input[0])\\n t=len((model['W1'])[0])\\n #print t\\n model['W2'] = (np.random.rand(num_neurons[0],num_neurons[1])*weight_scale) * math.sqrt(2.0/t)\\n model['b2'] = np.zeros(num_neurons[1])# Initialize with zeros\\n\\n t=len((model['W2'])[0])\\n #model['W3'] = (np.random.randn(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)# Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\\n model['W3'] = (np.random.rand(num_neurons[1],num_classes)*weight_scale) * math.sqrt(2.0/t)\\n model['b3'] = np.zeros(num_classes)# Initialize with zeros\\n\\n return model\",\n \"def build_neural_net(net_def):\\n\\n populated_def = net_def.copy()\\n\\n for layer in populated_def['layers']:\\n for n in range(0, layer['num_neurons']):\\n weights = layer['weights'][n]\\n bias = layer['bias'][n]\\n\\n neuron = Neuron(weights, bias, layer['activation'])\\n layer['neurons'].append(neuron)\\n\\n\\n return populated_def\",\n \"def __init__(self, n=0, w=0, weighting=1):\\n self.n = n\\n self.w = w\\n self.weighting = weighting\\n self.timestep = 0\\n self.Xw = np.zeros([n,w])\\n self.Yw = np.zeros([n,w])\\n self.A = np.zeros([n,n])\\n self.P = np.zeros([n,n])\",\n \"def build_neuron_network(nb_features_map: Union[Sequence[int], None] = None,\\n size_linear_layers: Union[Sequence[int], None] = None,\\n dropout_rate: Union[Tuple[float, float], float] = 0.3,\\n conv_kernel_size: Union[Sequence[int], int] = 3,\\n conv_stride: int = 1,\\n conv_padding: int = 1,\\n conv_activation: str = \\\"relu\\\",\\n conv_architecture: str = \\\"CPD\\\",\\n pool_kernel_size: int = 2,\\n pool_stride: int = 2,\\n dense_activation: str = \\\"relu\\\",\\n pretrained: Union[str, None] = None,\\n grayscale: bool = True,\\n optimizer: str = \\\"Adam\\\",\\n weight_decay: float = 0.,\\n learning_rate: float = 0.001,\\n ) -> Tuple[nn.Module, List, torch.optim.Optimizer]:\\n # Initializations\\n if pretrained is not None:\\n grayscale = False\\n if grayscale:\\n channels = 1\\n else:\\n channels = 3\\n if nb_features_map is None:\\n nb_features_map = [8]\\n if size_linear_layers is None:\\n size_linear_layers = []\\n height = 224\\n width = 224\\n module = nn.Module()\\n shapes = [(\\\"input\\\", channels, height, width)]\\n layers = {\\\"extractor\\\": [], \\\"regressor\\\": []}\\n if not hasattr(dropout_rate, \\\"__len__\\\"):\\n dropout_rate = (dropout_rate, 0.)\\n next_dropout_rate = dropout_rate[0]\\n # If a pretrained model is used:\\n if pretrained is None:\\n # Input checks\\n if hasattr(conv_kernel_size, \\\"__len__\\\"):\\n if len(conv_kernel_size) != len(nb_features_map):\\n raise ValueError(\\\"The length of nb_features_map shall match the length of conv_kernel_size\\\")\\n else:\\n conv_kernel_size = [conv_kernel_size] * len(nb_features_map)\\n # Feature extractor\\n next_layer_type = itertools.cycle(conv_architecture)\\n nb_feature_map = None\\n i = 0\\n while True:\\n layer_type = next(next_layer_type)\\n if layer_type == \\\"C\\\":\\n # Convolutional layer\\n try:\\n nb_feature_map = nb_features_map[i]\\n except IndexError:\\n break\\n name = \\\"conv2d-{:02d}\\\".format(i+1)\\n conv = nn.Conv2d(shapes[-1][1], nb_feature_map, conv_kernel_size[i], stride=conv_stride,\\n padding=conv_padding)\\n layers[\\\"extractor\\\"].append((name, conv))\\n h, w = output_shape_conv_and_pool_layer(rows=shapes[-1][2], columns=shapes[-1][3],\\n kernel=conv_kernel_size[i], stride=conv_stride,\\n padding=conv_padding)\\n shapes.append((name, nb_feature_map, h, w))\\n i += 1\\n # Activation\\n if conv_activation == \\\"relu\\\":\\n activ = nn.ReLU()\\n elif conv_activation == \\\"elu\\\":\\n activ = nn.ELU(alpha=0.1)\\n elif conv_activation == \\\"leaky\\\":\\n activ = nn.LeakyReLU()\\n else:\\n activ = nn.ReLU()\\n name = \\\"{}-{:02d}\\\".format(conv_activation, i)\\n layers[\\\"extractor\\\"].append((name, activ))\\n # activation does not change the size\\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\\n elif layer_type == \\\"P\\\":\\n # Max-pooling\\n name = \\\"maxpool2d-{:02d}\\\".format(i)\\n pool = nn.MaxPool2d(pool_kernel_size, pool_stride)\\n layers[\\\"extractor\\\"].append((name, pool))\\n h, w = output_shape_conv_and_pool_layer(rows=shapes[-1][2], columns=shapes[-1][3],\\n kernel=pool_kernel_size, stride=pool_stride)\\n shapes.append((name, nb_feature_map, h, w))\\n elif layer_type == \\\"D\\\":\\n # Dropout\\n if next_dropout_rate > 0.:\\n name = \\\"dropout-{:02d}\\\".format(i)\\n dropout = nn.Dropout(p=next_dropout_rate)\\n layers[\\\"extractor\\\"].append((name, dropout))\\n # Dropout does not change the size\\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\\n next_dropout_rate += dropout_rate[1]\\n elif layer_type == \\\"B\\\":\\n # Batch normalization\\n name = \\\"batchnorm-{:02d}\\\".format(i)\\n batch = nn.BatchNorm2d(shapes[-1][1])\\n layers[\\\"extractor\\\"].append((name, batch))\\n # Batch norm. does not change the size\\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\\n # Add a flatten layer\\n name = \\\"flatten\\\"\\n flatten = nn.Flatten(1)\\n layers[\\\"extractor\\\"].append((name, flatten))\\n shapes.append((name, shapes[-1][1] * shapes[-1][2] * shapes[-1][3]))\\n # Create extractor module\\n extractor = nn.Sequential(OrderedDict(layers[\\\"extractor\\\"]))\\n module.add_module(\\\"extractor\\\", extractor)\\n elif pretrained == \\\"VGG16\\\":\\n pre_trained = models.vgg16(pretrained=True)\\n modules = []\\n for _name, _module in pre_trained.named_children():\\n if _name != 'classifier':\\n modules.append((_name, _module))\\n modules.append((\\\"flatten\\\", nn.Flatten(1)))\\n vgg16 = nn.Sequential(OrderedDict(modules))\\n # Freeze all parameters in the pre-trained model\\n # So we prevent gradients from being calculated, it will save computation time\\n for param in vgg16.parameters():\\n param.requires_grad = False\\n module.add_module('extractor', vgg16)\\n shapes.append((pretrained, 25088))\\n else:\\n raise ValueError(f\\\"Unknown pre-trained model '{pretrained}'.\\\")\\n # Regressor\\n for i, size_linear_layer in enumerate(size_linear_layers):\\n # Add a linear layer\\n name = \\\"linear-{:02d}\\\".format(i + 1)\\n linear = nn.Linear(shapes[-1][1], size_linear_layer)\\n layers[\\\"regressor\\\"].append((name, linear))\\n shapes.append((name, size_linear_layer))\\n # Activation\\n if dense_activation == \\\"relu\\\":\\n activ = nn.ReLU()\\n elif dense_activation == \\\"elu\\\":\\n activ = nn.ELU(alpha=0.1)\\n elif dense_activation == \\\"leaky\\\":\\n activ = nn.LeakyReLU()\\n else:\\n activ = nn.ReLU()\\n name = \\\"{}-{:02d}\\\".format(dense_activation, i + 1)\\n layers[\\\"regressor\\\"].append((name, activ))\\n shapes.append((name, shapes[-1][1])) # activation does not change the size\\n # Dropout\\n if next_dropout_rate > 0.:\\n name = \\\"dropout-{:02d}\\\".format(i + 1)\\n dropout = nn.Dropout(p=next_dropout_rate)\\n layers[\\\"regressor\\\"].append((name, dropout))\\n shapes.append((name, shapes[-1][1])) # Dropout does not change the size of array\\n next_dropout_rate += dropout_rate[1]\\n # Add the final layer, the output size is fixed to 68 x 2 = 136\\n name = \\\"output\\\"\\n linear = nn.Linear(shapes[-1][1], 136)\\n layers[\\\"regressor\\\"].append((name, linear))\\n shapes.append((name, 136))\\n # Create regressor module\\n regressor = nn.Sequential(OrderedDict(layers[\\\"regressor\\\"]))\\n module.add_module(\\\"regressor\\\", regressor)\\n # Weight initialization\\n module.apply(weight_initialization)\\n # Optimizer\\n if optimizer == \\\"Adam\\\":\\n optim = torch.optim.Adam(module.parameters(), lr=learning_rate, weight_decay=weight_decay)\\n elif optimizer == \\\"AdamW\\\":\\n optim = torch.optim.AdamW(module.parameters(), lr=learning_rate, weight_decay=weight_decay)\\n elif optimizer == \\\"SGD\\\":\\n optim = torch.optim.SGD(module.parameters(), lr=learning_rate, weight_decay=weight_decay, momentum=0.9)\\n else:\\n raise ValueError(f\\\"Unknown optimizer {optimizer}.\\\")\\n return module, shapes, optim\",\n \"def __init__(self, num_inputs=3, hidden_layers=[3, 3], num_outputs=2):\\n\\n self.num_inputs = num_inputs\\n self.hidden_layers = hidden_layers\\n self.num_outputs = num_outputs\\n\\n # create a generic representation of the layers\\n layers = [num_inputs] + hidden_layers + [num_outputs]\\n\\n # create random connection weights for the layers\\n weights = []\\n for i in range(len(layers) - 1):\\n w = np.random.rand(layers[i], layers[i + 1])\\n weights.append(w)\\n self.weights = weights\\n\\n activations = []\\n\\n for i in range(len(layers)):\\n a = np.zeros(layers[i])\\n activations.append(a)\\n self.activations = activations\\n\\n derivatives = []\\n\\n for i in range(len(layers) - 1):\\n d = np.zeros(layers[i])\\n derivatives.append(d)\\n self.derivatives = derivatives\",\n \"def create_params(self, layer_sizes):\\n weights = [[None]]\\n bias = []\\n bias.append([1] * layer_sizes[0])\\n\\n for layer in range(1, len(layer_sizes)):\\n weights.append(numpy.random.rand(layer_sizes[layer-1], layer_sizes[layer]))\\n bias.append([0] * layer_sizes[layer])\\n\\n bias[len(layer_sizes)-1] = [0] * layer_sizes[-1]\\n\\n return weights, bias\",\n \"def build(self, weight = 0.5):\\n \\n self.weight = weight\\n \\n # Defining weighting matrixes\\n self.processing_fw = torch.randn((self._hidden_size, self._expansion_size), requires_grad = True).to(self.device)\\n self.processing_bw = torch.randn((self._hidden_size, self._expansion_size), requires_grad = True).to(self.device)\\n self.processing_last_ht = torch.randn((self._hidden_size*2, self._hidden_size*2), requires_grad = True).to(self.device)\\n \\n # These will only be applied to the intermediate hidden states\\n self.linear_fw = nn.Linear(self._seqlen - 1, 1).to(self.device)\\n self.linear_bw = nn.Linear(self._seqlen - 1, 1).to(self.device)\\n \\n self.compression = torch.randn((self._expansion_size*2, self._hidden_size*2), requires_grad = True).to(self.device)\\n \\n if self._activation_fn == 'tanh' or isinstance(self._activation_fn, torch.nn.modules.activation.Tanh):\\n self._activation_fn = nn.Tanh()\\n elif self._activation_fn == 'sigmoid' or isinstance(self._activation_fn, torch.nn.modules.activation.Sigmoid):\\n self._activation_fn = nn.Sigmoid()\\n elif self._activation_fn == 'leaky ReLU' or isinstance(self._activation_fn, torch.nn.modules.activation.LeakyReLU):\\n self._activation_fn = nn.LeakyReLU()\\n else:\\n raise ValueError('Non-linear activation function must be \\\"tanh\\\", \\\"sigmoid\\\" or \\\"leaky ReLU\\\"')\\n \\n # Passing it onto the relevant device\\n self._activation_fn = self._activation_fn.to(self.device)\",\n \"def __init__(self, hidden_layers, input_size=784,\\n num_classes=10, learning_rate=0.1):\\n hidden_layers = [input_size] + hidden_layers + [num_classes]\\n self.layers = []\\n self.Layer = collections.namedtuple('Layer', ['weights', 'biases'])\\n for i in range(len(hidden_layers) - 1):\\n layer = self.Layer(np.random.randn(hidden_layers[i],\\n hidden_layers[i + 1]).astype('float32'),\\n np.random.randn(hidden_layers[i + 1]).astype('float32'))\\n self.layers.append(layer)\\n\\n # normalization for stable training\\n\\n self.learning_rate = learning_rate\",\n \"def __init__(self, in_features, out_features):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n mean = 0\\n std_dev = 0.0001\\n #print(in_features)\\n #print(out_features)\\n # create weight matrices\\n weight = np.random.normal(mean, std_dev, (out_features, in_features))\\n #print(weight.shape)\\n grad_weight = np.zeros((in_features, out_features))\\n\\n # create biases (in batches)\\n bias = np.zeros(out_features)\\n grad_bias = np.zeros(out_features)\\n\\n self.params = {'weight': weight, 'bias': bias}\\n self.grads = {'weight': bias, 'bias': grad_bias}\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def create_neural_network():\\n network_input = keras.layers.Input((NETWORK_INPUT_SIZE,))\\n network_layer = keras.layers.Dense(100, kernel_initializer='random_uniform', activation='tanh')(network_input)\\n network_layer = keras.layers.Dense(100, kernel_initializer='random_uniform', activation='tanh')(network_layer)\\n network_output = keras.layers.Dense(NETWORK_OUTPUT_SIZE, kernel_initializer='random_uniform', activation='linear')(network_layer)\\n network = keras.models.Model(inputs=network_input, outputs=network_output)\\n network.compile(loss=\\\"mse\\\", optimizer=\\\"Adam\\\")\\n return network\",\n \"def __init__(self, num_learners: int):\\n self.num_learners = num_learners\\n self.learners = []\\n self.learner_weights = np.ones(num_learners)\",\n \"def build(self, input_shape):\\n assert len(input_shape) == 4\\n assert input_shape[1] == input_shape[2]\\n self.out_channel = input_shape[3]\\n # Create the weight vector\\n self.W_shape = (input_shape[1], self.out_dim)\\n if self.initial_weights is not None:\\n self.set_weights(self.initial_weights)\\n del self.initial_weights\\n else:\\n self.W = self.init(self.W_shape, name='{}_W'.format(self.name))\\n self.trainable_weights = [self.W]\\n self.built = True\",\n \"def make_neural_net_basic():\\n i0 = Input('i0', -1.0) # this input is immutable\\n i1 = Input('i1', 0.0)\\n i2 = Input('i2', 0.0)\\n w1A = Weight('w1A', 1)\\n w2A = Weight('w2A', 1)\\n wA = Weight('wA', 1)\\n\\n # Inputs must be in the same order as their associated weights\\n A = Neuron('A', [i1,i2,i0], [w1A,w2A,wA])\\n P = PerformanceElem(A, 0.0)\\n\\n net = Network(P,[A])\\n return net\",\n \"def __init__(self, input_dim=(1, 28, 28), num_classes=10):\\n self.params = {}\\n\\n #######################################################################\\n # TODO: Initialize weights and biases for the convolutional neural #\\n # network. Weights should be initialized from a Gaussian distribution;#\\n # biases should be initialized to zero. All weights and biases should #\\n # be stored in the dictionary self.params. #\\n #######################################################################\\n\\n filter_size = 5\\n weight_scale = 1e-2\\n num_filters = 6\\n hidden_dim = 784\\n\\n #****** THIS WAS TO TEST OUT FASTER NETWORKS *******\\n\\n self.params['W1'] = np.random.normal(scale=weight_scale, size=(num_filters, input_dim[0], filter_size, filter_size))\\n # self.params['W2'] = np.random.normal(scale=weight_scale, size=(num_filters, 6, filter_size, filter_size))\\n self.params['W3'] = np.random.normal(scale=weight_scale, size=(864, num_classes))\\n\\n # self.params['W3'] = np.random.normal(scale=weight_scale, size=(hidden_dim, num_classes))\\n # self.params['W4'] = np.random.normal(scale=weight_scale, size=(hidden_dim, num_classes))\\n\\n self.params['b1'] = np.zeros(num_filters)\\n # self.params['b2'] = np.zeros(num_filters)\\n self.params['b3'] = np.zeros(num_classes)\\n\\n # self.params['b3'] = np.zeros(num_classes)\\n # self.params['b4'] = np.zeros(num_classes)\",\n \"def __init__(self, num_parameters=1, init=0.25):\\n super(PReLU, self).__init__()\\n self.num_parameters = num_parameters\\n self.weight = Parameter(Tensor(num_parameters).fill_(init))\",\n \"def init_weights(num_tilings, tiles_per_dim, num_dims, num_actions):\\n weights = np.zeros((num_tilings*tiles_per_dim**num_dims*num_actions))\\n return weights\",\n \"def init_weights_(self):\\n raise NotImplementedError\",\n \"def __init__(self, structure, weights = [], activationType = \\\"sigmoid\\\"):\\n self.weights = []\\n self.activationType = activationType\\n self.activations = []\\n self.derivatives = []\\n self.delta = []\\n self.bias = []\\n\\n #Either randomises weights or uses starting weights that have been supplied. \\n for i in range(len(structure)-1):\\n if len(weights) != 0:\\n w = np.zeros((structure[i], structure[i + 1]))\\n for j in range(structure[i]):\\n w[j, :] = weights[(j * structure[i + 1]) : (j * structure[i + 1]) + structure[i + 1]]\\n else:\\n w = np.random.rand(structure[i], structure[i + 1])\\n self.weights.append(w)\\n \\n #Initialises activations array, delta array and bias array. \\n for i in range(len(structure)):\\n a = np.zeros(structure[i])\\n self.activations.append(a)\\n self.delta.append(a)\\n self.bias.append(a)\\n \\n \\n #Initialises derivatives array.\\n for i in range(len(structure) - 1):\\n d = np.zeros((structure[i], structure[i + 1]))\\n self.derivatives.append(d)\\n \\n return\",\n \"def __init__(self, num_visible, num_hidden, act_func='logistic'):\\n\\n print('Initializing network... ', end='')\\n sys.stdout.flush()\\n\\n self.num_visible = num_visible\\n self.num_hidden = num_hidden\\n \\n #self.reconstructed = np.zeros((self.num_examples, self.num_visible))\\n\\n self.weights = 0.1 * np.random.randn(num_visible, num_hidden)\\n self.v_bias = np.zeros((1, num_visible))\\n self.h_bias = -4.0 * np.ones((1, num_hidden))\\n\\n self.w_inc = np.zeros((num_visible, num_hidden))\\n self.v_inc = np.zeros((1, num_visible))\\n self.h_inc = np.zeros((1, num_hidden))\\n\\n if act_func == 'chaotic':\\n self.act_func = self.chaotic_logistic\\n else:\\n self.act_func = self.logistic\\n\\n print('Done!')\\n return\",\n \"def __init__(self, input_nodes, hidden_nodes, hidden_layers, output_nodes):\\n # Class members:\\n # num_input_nodes\\n # num_hidden_nodes\\n # num_hidden_layers\\n # num_output_nodes\\n # weights = [[num_hidden_nodes, num_input_nodes],[num_hidden_nodes, num_hidden_nodes],[]<- for each hl,\\n # [num_output_nodes, num_hidden_nodes]]\\n # biases\\n\\n self.num_input_nodes = input_nodes\\n self.num_hidden_nodes = hidden_nodes\\n self.num_hidden_layers = hidden_layers\\n self.num_output_nodes = output_nodes\\n\\n self.weights = []\\n for i in range(self.num_hidden_layers + 1):\\n if i is 0:\\n # first weights array is input to hidden\\n self.weights.append(.5 * np.random.rand(self.num_hidden_nodes, self.num_input_nodes) - .25)\\n\\n elif i < self.num_hidden_layers:\\n # next weight array is hidden nodes to hidden nodes\\n self.weights.append(.5 * np.random.rand(self.num_hidden_nodes, self.num_hidden_nodes) - .25)\\n else:\\n # last weight array is hidden nodes to output nodes\\n self.weights.append(.5 * np.random.rand(self.num_output_nodes, self.num_hidden_nodes) - .25)\\n\\n self.biases = []\\n for i in range(self.num_hidden_layers + 1):\\n if i < self.num_hidden_layers:\\n # for every hidden node there is a bias\\n self.biases.append(0.5 * np.random.rand(self.num_hidden_nodes) - .25)\\n else:\\n # for the output node there is a bias as well\\n self.biases.append(0.5 * np.random.rand(self.num_output_nodes) - .25)\\n\\n self.activation = np.vectorize(self.tanh, otypes=[float])\",\n \"def __init__(self, input_size, hidden_sizes, output_size=1,\\n batchnorm_bool=False,\\n dropout_bool=False):\\n super(NeuralNet, self).__init__()\\n self.input_size = input_size\\n sizes = [input_size] + hidden_sizes + [output_size]\\n self.layers = nn.ModuleList(\\n [nn.Linear(in_f, out_f) for in_f, out_f in zip(sizes, sizes[1:])])\\n self.bns = nn.ModuleList(\\n [nn.BatchNorm1d(out_f) for in_f, out_f in zip(sizes, sizes[1:])])\\n self.dps = nn.ModuleList(\\n [nn.Dropout(p=0.5) for _ in range(len(self.layers))])\\n self.relus = nn.ModuleList(\\n [nn.ReLU() for _ in range(len(self.layers))])\\n self.sigmoid = nn.Sigmoid()\\n\\n self.batchnorm_bool = batchnorm_bool\\n self.dropout_bool = dropout_bool\",\n \"def _build_networks(self):\\n self.online_convnet = self._create_network(name='Online')\\n self.target_convnet = self._create_network(name='Target')\\n self._net_outputs = self.online_convnet(self.state_ph, training=True)\\n self._q_argmax = tf.argmax(self._net_outputs.q_values, axis=1)[0]\\n self._replay_net_outputs = self.online_convnet(self._replay.states,\\n training=True)\\n self._replay_next_target_net_outputs = self.target_convnet(\\n self._replay.next_states)\",\n \"def __init__(self, nInputs, nOutputs, hiddenLayersDims, outputActivationFunctions = None, outputActivationDerivatives = None, hiddenActivationFunctions = None,\\\\\\n\\t\\t\\t\\t hiddenActivationDerivatives = None): \\n\\n\\t\\tself._nInputs = nInputs\\n\\t\\tself._nOutputs = nOutputs\\n\\n\\t\\tself._nHiddenLayers, self._nUnitsPerLayer = hiddenLayersDims\\n\\n\\t\\tself._outputActivationFunctions = outputActivationFunctions\\n\\t\\tself._outputActivationDerivatives = outputActivationDerivatives\\n\\n\\t\\tself._hiddenActivationFunctions = hiddenActivationFunctions\\n\\t\\tself._hiddenActivationDerivatives = hiddenActivationDerivatives\\n\\n\\t\\tself.initialiseActivationFunctions()\\n\\n\\t\\tself.initialiseNetwork()\\n\\n\\t\\tself._nBranches = len(self.collectAllBranches())\",\n \"def __init__(self, batch_size=1, epochs=None, learning_rate=None, momentum=None, weights_name=''):\\n self.batch_size = batch_size\\n self.epochs = epochs\\n self.model = None\\n self.optimizer = None\\n self.cb = None\\n self.lr = learning_rate\\n self.momentum = momentum\\n self.weights_name = weights_name\",\n \"def init_weights(n_layers, layer_sizes):\\n\\n params = {}\\n\\n for i in range(n_layers):\\n wn = 'W{}'.format(i)\\n bn = 'b{}'.format(i)\\n\\n params[wn] = tf.get_variable(\\n name=wn,\\n shape=layer_sizes[i * 2],\\n initializer=tf.contrib.layers.xavier_initializer(seed=42)\\n )\\n\\n params[bn] = tf.get_variable(\\n name=bn,\\n shape=layer_sizes[(i * 2) + 1],\\n initializer=tf.zeros_initializer()\\n )\\n\\n return params\",\n \"def __init__(self, nx, nodes):\\n if type(nx) is not int:\\n raise TypeError(\\\"nx must be an integer\\\")\\n if nx < 1:\\n raise ValueError(\\\"nx must be a positive integer\\\")\\n if type(nodes) is not int:\\n raise TypeError(\\\"nodes must be an integer\\\")\\n if nodes < 1:\\n raise ValueError(\\\"nodes must be a positive integer\\\")\\n # weights vector for the hidden layer\\n # default mean is 0\\n # default stddev is 1\\n self.__W1 = np.random.normal(size=(nodes, nx))\\n # The bias for the hidden layer. Upon instantiation,\\n # it should be initialized with 0’s.\\n self.__b1 = np.zeros((nodes, 1))\\n # The activated output for the hidden layer. Upon instantiation,\\n # it should be initialized to 0\\n self.__A1 = 0\\n # weights vector for the output neuron\\n # default mean is 0\\n # default stddev is 1\\n self.__W2 = np.random.normal(size=(1, nodes))\\n # bias for the output neuron\\n self.__b2 = 0\\n # activated output for the output neuron (prediction)\\n self.__A2 = 0\",\n \"def __init__(self, input_size, output_size, activation=torch.nn.functional.relu, left_to_right=True):\\n super(GraphConvolutionalLayer, self).__init__()\\n self.w = torch.nn.Parameter(torch.rand([input_size, output_size]))\\n self.activation = activation\\n self.left_to_right = left_to_right\",\n \"def __init__(self, lengths):\\n self.lengths = lengths\\n\\n # weights: index 1 = layer index, index 2 = feature index\\n # last index in each layer is bias weight\\n self.weights = np.array()\\n self.activations = np.array()\\n for i,length in enumerate(self.lengths):\\n self.weights[i] = np.random.rand(1,length+1)\\n self.activations[i] = np.random.rand(1,length+1)\",\n \"def __init__(self, size, parameters):\\n\\n self.weights = self.init_weights(size)\\n self.alpha = parameters['alpha']\\n self.epsilon = parameters['epsilon']\\n self.gamma = parameters['gamma']\\n self.value = 0.0 #np.random.random()\",\n \"def __init__(self, input_dims, output_dims, extra_dims):\\n super().__init__()\\n self.input_dims = input_dims\\n self.output_dims = output_dims\\n self.extra_dims = extra_dims\\n\\n self.weight = nn.Parameter(torch.zeros(*extra_dims, output_dims, input_dims))\\n self.bias = nn.Parameter(torch.zeros(*extra_dims, output_dims))\\n\\n nn.init.kaiming_uniform_(self.weight, nonlinearity='relu')\",\n \"def __init__(self, output_dim, adjecancies,\\n init='glorot_uniform',\\n weights=None, W_regularizer=None,\\n b_regularizer=None, bias=False, **kwargs):\\n\\n self.init = initializers.get(init)\\n self.output_dim = output_dim # number of features per node\\n\\n self.adjecancies = adjecancies\\n\\n allDst = set()\\n allSrc = set()\\n for rel in adjecancies:\\n for (src, dest) in rel:\\n allSrc.add(src)\\n allDst.add(dest)\\n allIndices = allSrc.union(allDst)\\n\\n self.allSrc = allSrc\\n self.allDst = allDst\\n\\n if len(allIndices) > 0 and min(allIndices) < 0:\\n raise Exception(\\\"Index lower than 0 in adjecancies\\\")\\n self.maxIndexInAdjecencies = - \\\\\\n 1 if len(allIndices) == 0 else max(allIndices)\\n\\n self.W_regularizer = regularizers.get(W_regularizer)\\n self.b_regularizer = regularizers.get(b_regularizer)\\n\\n self.bias = bias\\n self.initial_weights = weights\\n\\n # these will be defined during build()\\n self.input_dim = None\\n self.W = None\\n self.W_comp = None\\n self.b = None\\n self.num_nodes = None\\n\\n super(GraphConvolution, self).__init__(**kwargs)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7550142","0.7535491","0.75056463","0.74940723","0.7493714","0.7344416","0.7279779","0.7265629","0.7218069","0.72046214","0.71778685","0.71470296","0.7120793","0.70849985","0.7019694","0.70176697","0.69794846","0.69722265","0.6920543","0.6879415","0.6876073","0.68726945","0.6866499","0.6864688","0.68437016","0.68381244","0.67863643","0.6778829","0.67667735","0.6764995","0.6751022","0.67010856","0.6698876","0.6696529","0.6691007","0.66866696","0.66846126","0.6679412","0.667502","0.666627","0.66609716","0.6656913","0.6649386","0.66405845","0.6633995","0.66323686","0.661759","0.66086","0.66070163","0.66042805","0.65966916","0.6593298","0.65889704","0.6568752","0.656513","0.6563131","0.6562176","0.6561839","0.65594405","0.65392673","0.6529379","0.6525524","0.65232414","0.6521053","0.65173566","0.65153545","0.65150005","0.65120596","0.651083","0.65053177","0.6492661","0.647939","0.64676726","0.64634955","0.64606917","0.6452544","0.64515257","0.64460826","0.6441553","0.643813","0.6414887","0.6401515","0.63858724","0.6370019","0.63662416","0.6364602","0.63625604","0.63608056","0.6358678","0.6351422","0.63466585","0.6341455","0.63344973","0.633385","0.6324847","0.63139725","0.6313668","0.63021725","0.6301569","0.62915355","0.6289022"],"string":"[\n \"0.7550142\",\n \"0.7535491\",\n \"0.75056463\",\n \"0.74940723\",\n \"0.7493714\",\n \"0.7344416\",\n \"0.7279779\",\n \"0.7265629\",\n \"0.7218069\",\n \"0.72046214\",\n \"0.71778685\",\n \"0.71470296\",\n \"0.7120793\",\n \"0.70849985\",\n \"0.7019694\",\n \"0.70176697\",\n \"0.69794846\",\n \"0.69722265\",\n \"0.6920543\",\n \"0.6879415\",\n \"0.6876073\",\n \"0.68726945\",\n \"0.6866499\",\n \"0.6864688\",\n \"0.68437016\",\n \"0.68381244\",\n \"0.67863643\",\n \"0.6778829\",\n \"0.67667735\",\n \"0.6764995\",\n \"0.6751022\",\n \"0.67010856\",\n \"0.6698876\",\n \"0.6696529\",\n \"0.6691007\",\n \"0.66866696\",\n \"0.66846126\",\n \"0.6679412\",\n \"0.667502\",\n \"0.666627\",\n \"0.66609716\",\n \"0.6656913\",\n \"0.6649386\",\n \"0.66405845\",\n \"0.6633995\",\n \"0.66323686\",\n \"0.661759\",\n \"0.66086\",\n \"0.66070163\",\n \"0.66042805\",\n \"0.65966916\",\n \"0.6593298\",\n \"0.65889704\",\n \"0.6568752\",\n \"0.656513\",\n \"0.6563131\",\n \"0.6562176\",\n \"0.6561839\",\n \"0.65594405\",\n \"0.65392673\",\n \"0.6529379\",\n \"0.6525524\",\n \"0.65232414\",\n \"0.6521053\",\n \"0.65173566\",\n \"0.65153545\",\n \"0.65150005\",\n \"0.65120596\",\n \"0.651083\",\n \"0.65053177\",\n \"0.6492661\",\n \"0.647939\",\n \"0.64676726\",\n \"0.64634955\",\n \"0.64606917\",\n \"0.6452544\",\n \"0.64515257\",\n \"0.64460826\",\n \"0.6441553\",\n \"0.643813\",\n \"0.6414887\",\n \"0.6401515\",\n \"0.63858724\",\n \"0.6370019\",\n \"0.63662416\",\n \"0.6364602\",\n \"0.63625604\",\n \"0.63608056\",\n \"0.6358678\",\n \"0.6351422\",\n \"0.63466585\",\n \"0.6341455\",\n \"0.63344973\",\n \"0.633385\",\n \"0.6324847\",\n \"0.63139725\",\n \"0.6313668\",\n \"0.63021725\",\n \"0.6301569\",\n \"0.62915355\",\n \"0.6289022\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":95,"cells":{"query":{"kind":"string","value":"Initialize the neural network with the required layers, the weights and the biases. The input \"layers\" in an array that contains the number of nodes (neurons) in each layer."},"document":{"kind":"string","value":"def initialize_NN(self, m):\n\n if type(m) == nn.Linear:\n nn.init.xavier_uniform_(m.weight)\n # print(m.weight)"},"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 __init__(self, layerNeurons, initialWeights = None, layerTypes=None, **kwargs):\r\n \r\n # Ensure that there is at-least one input and one output layer in the network\r\n assert len(layerNeurons)>1, \"At least one input layer and one output layer is needed\"\r\n \r\n # Get the total number of weights needed in the network\r\n totalWeightCount = NeuralNetwork.getSizeOfWeightVector(layerNeurons)\r\n \r\n # Initialise the weights with the initializer or random values\r\n if initialWeights is None:\r\n self.weights = np.random.uniform(-1/np.sqrt(layerNeurons[0]), 1/np.sqrt(layerNeurons[0]), totalWeightCount)\r\n else:\r\n assert len(initialWeights) == totalWeightCount, (\"Length of initial weight matrix incorrect. You need \"+str(totalWeightCount)+\" weights\")\r\n self.weights = np.array(initialWeights, dtype = np.float64) \r\n \r\n # create an empty array of layers\r\n self.layers = []\r\n layerBlockStart = 0\r\n \r\n if layerTypes is None or len(layerTypes)<(len(layerNeurons)-1):\r\n layerTypes=[NetworkLayer]*(len(layerNeurons)-1)\r\n \r\n for layerInputDimention, layerOutputDimention, layerType in zip(layerNeurons, layerNeurons[1:], layerTypes):\r\n # initialise each layer with its input and output dimentions and bi-directional pointers to the relivant weights\r\n layerBlockEnd = layerBlockStart+(layerInputDimention*layerOutputDimention)\r\n layerBiasEnd = layerBlockEnd+layerOutputDimention\r\n newLayer = layerType(layerInputDimention, layerOutputDimention, \r\n self.weights[..., layerBlockStart:layerBlockEnd], \r\n self.weights[..., layerBlockEnd:layerBiasEnd], **kwargs)\r\n self.layers.append(newLayer)\r\n \r\n layerBlockStart = layerBiasEnd\r\n \r\n # Tell the output later to use a different function to calculate the delta \r\n newLayer.calcDelta = newLayer.calcDeltaOutputLayer","def _init_layers(self) -> None:\n weight_nums, bias_nums = [], []\n for i in range(self.num_layers):\n if i == 0:\n weight_nums.append((self.in_channels + 2) * self.feat_channels)\n bias_nums.append(self.feat_channels)\n elif i == self.num_layers - 1:\n weight_nums.append(self.feat_channels * 1)\n bias_nums.append(1)\n else:\n weight_nums.append(self.feat_channels * self.feat_channels)\n bias_nums.append(self.feat_channels)\n\n self.weight_nums = weight_nums\n self.bias_nums = bias_nums\n self.num_params = sum(weight_nums) + sum(bias_nums)","def __init__(self, layerNeurons, numberOfLayers, initialWeights = None, lowerBound = None, upperBound = None):\r\n \r\n # Ensure that there is at-least one input and one output layer in the network\r\n assert len(layerNeurons) > 1, \"At least one input layer and one output layer is needed\"\r\n \r\n # Get the total number of weights needed in the network\r\n totalWeightCount = NeuralNetwork.getSizeOfWeightVector(layerNeurons)*numberOfLayers\r\n \r\n # Initialise the weights with the initialiser or random values\r\n if initialWeights is None:\r\n if lowerBound is None:\r\n lowerBound=-1/np.sqrt(layerNeurons[0])\r\n if upperBound is None:\r\n upperBound=1/np.sqrt(layerNeurons[0])\r\n self.weights = np.random.uniform(lowerBound, upperBound, totalWeightCount)\r\n else:\r\n assert initialWeights.size == totalWeightCount, (\"Length of initial weight matrix incorrect. You need \"+str(totalWeightCount)+\" weights\")\r\n self.weights = initialWeights.view()\r\n \r\n self.weights.shape = (numberOfLayers, -1)\r\n # create an empty array of layers\r\n self.layers = []\r\n layerBlockStart = 0\r\n \r\n for layerInputDimention, layerOutputDimention in zip(layerNeurons, layerNeurons[1:]):\r\n # initialise each layer with its input and output dimentions and bi-directional pointers to the relivant weights\r\n layerBlockEnd = layerBlockStart+(layerInputDimention*layerOutputDimention)\r\n layerBiasEnd = layerBlockEnd+layerOutputDimention\r\n newLayer = batchNetworkLayer(layerInputDimention, layerOutputDimention, numberOfLayers, \r\n self.weights[..., :, layerBlockStart:layerBlockEnd], \r\n self.weights[..., :, layerBlockEnd:layerBiasEnd])\r\n self.layers.append(newLayer)\r\n \r\n layerBlockStart = layerBiasEnd","def create_network(layers):\r\n return NeuronNetwork(layers)","def __init__(self, weights, alphas):\n self._neurons = [Neuron(a, w) for w, a in zip(weights, alphas)]","def __init__(self, num_inputs=3, hidden_layers=[3, 3], num_outputs=2):\n\n self.num_inputs = num_inputs\n self.hidden_layers = hidden_layers\n self.num_outputs = num_outputs\n\n # create a generic representation of the layers\n layers = [num_inputs] + hidden_layers + [num_outputs]\n\n # create random connection weights for the layers\n weights = []\n for i in range(len(layers) - 1):\n w = np.random.rand(layers[i], layers[i + 1])\n weights.append(w)\n self.weights = weights\n\n activations = []\n\n for i in range(len(layers)):\n a = np.zeros(layers[i])\n activations.append(a)\n self.activations = activations\n\n derivatives = []\n\n for i in range(len(layers) - 1):\n d = np.zeros(layers[i])\n derivatives.append(d)\n self.derivatives = derivatives","def __init__(self, n_layers, layers_sizes, activation='sigmoid', learning_rate=0.1, weight_init='normal', batch_size=1000, num_epochs=100):\n self.layers_sizes=layers_sizes[1:]\n self.activation=activation\n self.learning_rate=learning_rate\n self.weight_init=weight_init\n self.batch_size=batch_size\n self.num_epochs=num_epochs\n self.weights={}\n self.n_layers=len(self.layers_sizes)\n self.num_samples=0\n self.training_loss_values=[]\n self.testing_loss_values=[]\n self.gg=0.01\n self.XTEST=None\n self.YTEST=None\n self.TTTT=None\n\n if activation not in self.acti_fns:\n raise Exception('Incorrect Activation Function')\n\n if weight_init not in self.weight_inits:\n raise Exception('Incorrect Weight Initialization Function')\n pass","def __init__(self, weights=[], alphas=[]):\n self._layers = [Layer(w, a) for w, a in zip(weights, alphas)]","def __init__(self, N_sym, n_nodes, activations, N_element, bias = True, scaling = None):\n super(MultiLayerNet, self).__init__()\n N_layers = len(n_nodes)\n if N_layers == 0:\n self.net = torch.nn.Linear(N_sym, N_element, bias = bias)\n else:\n layers = []\n for n in range(N_layers):\n if n == 0:\n layers += [torch.nn.Linear(N_sym, n_nodes[n], bias = bias)]\n layers += [activations[n]]\n else:\n layers += [torch.nn.Linear(n_nodes[n-1], n_nodes[n], bias = bias)]\n layers += [activations[n]]\n layers += [torch.nn.Linear(n_nodes[-1], N_element, bias = bias)]\n self.net = torch.nn.Sequential(*layers)\n \n self.scaling = scaling","def __init__(self, layers=[2, 2, 1], activation_function=\"bentidentity\"):\n self.layers = layers\n self.activation_function = th.activation_functions[activation_function]\n self.activation_derivative = th.activation_derivatives[\n activation_function]\n self.weights = self._generate_weights()","def __init__(self, netSize):\n\t\t\n\t\t# TRY THIS FOR RANDOM!\n\t\t#\n\t\t#\n\t\t#\n\t\t\n\t\tself.biases = [self.randomArray(i, 1) for i in netSize[1:]] # Biases do not exist for the first layer ! Those are inputs.\n\t\tself.netSize = netSize\n\t\t#Initialize Weights\n\t\t#This initializes the weights for each layer based on the size. The number of rows should be\n\t\t#the number of neurons for the current, and the number of columns should be the same as the number of neurons\n\t\t#in the next layer. There are no weights for the last layer. That's the output layer.\n\t\tself.weights \t\t = [self.randomArray(i, j) for i, j in zip(netSize[:-1], netSize[1:]) ]","def __init__(self, nInputs, nOutputs, hiddenLayersDims, outputActivationFunctions = None, outputActivationDerivatives = None, hiddenActivationFunctions = None,\\\n\t\t\t\t hiddenActivationDerivatives = None): \n\n\t\tself._nInputs = nInputs\n\t\tself._nOutputs = nOutputs\n\n\t\tself._nHiddenLayers, self._nUnitsPerLayer = hiddenLayersDims\n\n\t\tself._outputActivationFunctions = outputActivationFunctions\n\t\tself._outputActivationDerivatives = outputActivationDerivatives\n\n\t\tself._hiddenActivationFunctions = hiddenActivationFunctions\n\t\tself._hiddenActivationDerivatives = hiddenActivationDerivatives\n\n\t\tself.initialiseActivationFunctions()\n\n\t\tself.initialiseNetwork()\n\n\t\tself._nBranches = len(self.collectAllBranches())","def __init__(self, hidden_layers, input_size=784,\n num_classes=10, learning_rate=0.1):\n hidden_layers = [input_size] + hidden_layers + [num_classes]\n self.layers = []\n self.Layer = collections.namedtuple('Layer', ['weights', 'biases'])\n for i in range(len(hidden_layers) - 1):\n layer = self.Layer(np.random.randn(hidden_layers[i],\n hidden_layers[i + 1]).astype('float32'),\n np.random.randn(hidden_layers[i + 1]).astype('float32'))\n self.layers.append(layer)\n\n # normalization for stable training\n\n self.learning_rate = learning_rate","def __init__(self, layer_neuron):\n\n self.num_layers = len(layer_neuron)\n self.layer_neuron = layer_neuron\n #a list of numpy ndarrays\n self.weights = []\n self.input_len = 0\n self.target_vals = []\n self.current_guess = 0\n\n self.layer_inputs = [[]]*(len(layer_neuron))\n self.layer_outputs = [[]]*(len(layer_neuron))\n #deltas: don't include input layer but still put it in for spacing ie self.deltas[0] should always be empty\n self.deltas = [[]]*((len(layer_neuron)))\n\n #make the weight matrices, each matrix nXm matrix with m = # nodes in the ith layer (incl bias) and n = # nodes in the (i+1)th layer\n #each row represents the set of weights from all m neurons in the ith layer to a single neuron in the (i+1)th layer\n #conversely, each column is all the output weights from a node in the ith layer, to each n nodes in the (i+1)th layer\n #the right-most column represents output weights from the bias node\n for i in range(len(self.layer_neuron)-1 ):\n np.random.seed(0)\n self.weights.append(np.random.normal( scale = 0.2, size = (self.layer_neuron[i+1], self.layer_neuron[i] + 1)))","def initialize_weights(self, weights_initializer, bias_initializer):\n wshapes = [\n [self.input_size, self.hidden_size[0]],\n [self.hidden_size[0], self.hidden_size[1]],\n [self.hidden_size[1], self.output_size]\n ]\n\n bshapes = [\n [1, self.hidden_size[0]],\n [1, self.hidden_size[1]],\n [1, self.output_size]\n ]\n\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\n\n self.trainable_variables = self.weights + self.biases","def __init__(self, layers, r_min, r_max, learn_rate):\n\n if not isinstance(layers, list) or len(layers) < 3:\n raise ValueError('invalid layer parammeter')\n self.layers = layers\n n_layer = len(layers)\n self.n_layer = n_layer\n self.r_min = r_min\n self.r_max = r_max\n self.learn_rate = learn_rate\n\n # initialize ws\n self.ws = []\n for layer_idx in range(n_layer - 1):\n layer_size = (layers[layer_idx] + 1, layers[layer_idx + 1])\n w = self.init_w(layer_size)\n self.ws.append(w)","def initialize_weights(self):\n for layer in self._cnn_layers:\n weights_initializer.WeightsInitializer.initialize_layer_or_model(layer)","def connect_layers(self):\n if not self.check():\n msg = \"Failed to check neural network.\"\n print(msg)\n logging.error(msg)\n return\n\n # 1. set input layer\n pre_layer = self.input_layer\n for layer in self.hidden_layers:\n layer.set_input_layer(pre_layer)\n pre_layer = layer\n self.output_layer.set_input_layer(pre_layer)\n\n # 2. set output layer\n next_layer = self.output_layer\n for layer in reversed(self.hidden_layers):\n layer.set_next_layer(next_layer)\n next_layer = layer\n self.input_layer.set_next_layer(next_layer)\n\n # 3. call layer init\n self.input_layer.init()\n for layer in self.hidden_layers:\n layer.init()\n self.output_layer.init()\n\n return","def __init__(self):\r\n # A dummy layer does nothing\r\n self.weights = np.zeros(shape=(input.shape[1], 10))\r\n bias = np.zeros(shape=(10,))\r\n pass","def init_three_layer_neuralnet(weight_scale=1, bias_scale=0, input_feat_dim=786,\n num_classes=10, num_neurons=(20, 30)):\n \n assert len(num_neurons) == 2, 'You must provide number of neurons for two layers...'\n\n model = {}\n #model['W1'] = np.random.randn((num_neurons[0],(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)) # Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\n \n model['W1'] = (np.random.rand(input_feat_dim,num_neurons[0])*weight_scale) * math.sqrt(2.0/input_feat_dim)\n model['b1'] = np.zeros(num_neurons[0])# Initialize with zeros\n \n #model['W2'] = (np.random.randn(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)# Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\n #print ((model['W1'])[0,:]).shape\n #numcols = len(input[0])\n t=len((model['W1'])[0])\n #print t\n model['W2'] = (np.random.rand(num_neurons[0],num_neurons[1])*weight_scale) * math.sqrt(2.0/t)\n model['b2'] = np.zeros(num_neurons[1])# Initialize with zeros\n\n t=len((model['W2'])[0])\n #model['W3'] = (np.random.randn(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)# Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\n model['W3'] = (np.random.rand(num_neurons[1],num_classes)*weight_scale) * math.sqrt(2.0/t)\n model['b3'] = np.zeros(num_classes)# Initialize with zeros\n\n return model","def initialize_network(self, model, num_init=None, **net_args):\n\n self.net_args = net_args\n\n if num_init is None:\n self.num_init = 1\n else:\n self.num_init = num_init\n\n nets = []\n for i in range(self.num_init):\n nets.append( model(dim_inp=self.dim_inp, \n dim_out=self.dim_out, **net_args) )\n\n return nets","def init_weights(self, load_weights=None):\n if load_weights:\n # TODO\n pass\n else:\n # x: lower layer nodes n\n # y: current layer nodes n\n x = self.weights_shape[1]\n y = self.weights_shape[0]\n self.weights = np.random.randn(y, x) / np.sqrt(x) # pylint: disable=no-member\n self.biases = np.random.randn(y, 1) # pylint: disable=no-member","def create_base_network(NumberOfFeatures, NumberOfClasses,init_mode='glorot_normal'):\n network = Sequential()\n network.add(Dense(44, activation='sigmoid', kernel_initializer=init_mode,input_dim=NumberOfFeatures))\n# network.add(Dense(22, activation='sigmoid',kernel_initializer=init_mode))\n network.add(Dense(NumberOfClasses, activation='softmax',kernel_initializer=init_mode))\n return network","def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):\n # set number of nodes in each input, hidden, output layer\n self.inodes = inputnodes\n self.hnodes = hiddennodes\n self.onodes = outputnodes\n\n #learning rate\n self.lr = learningrate","def neural_net(self, layers):\n model = nn.Sequential()\n for l in range(0, len(layers) - 1):\n model.add_module(\"layer_\"+str(l), nn.Linear(layers[l],layers[l+1], bias=True))\n if l != len(layers) - 2:\n model.add_module(\"tanh_\"+str(l), nn.Tanh())\n\n return model","def __init__(self, n_classes, num_nodes=None, dropouts=None, activation=\"relu\"):\n # parameters initialization\n self.n_classes = n_classes\n if self.n_classes == 1:\n self.output_act = \"sigmoid\"\n else:\n self.output_act = \"softmax\"\n self.num_nodes = num_nodes if num_nodes != None else [1024, 512]\n self.dropouts = dropouts if dropouts != None else [0.5, 0.5]\n self.activation = activation\n\n # Check if number of layers and number of dropouts have same dimension\n if not len(self.num_nodes) == len(self.dropouts):\n raise AssertionError()","def init_layer(layer):\n \n if layer.weight.ndimension() == 4:\n (n_out, n_in, height, width) = layer.weight.size()\n n = n_in * height * width\n \n elif layer.weight.ndimension() == 2:\n (n_out, n) = layer.weight.size()\n\n std = math.sqrt(2. / n)\n scale = std * math.sqrt(3.)\n layer.weight.data.uniform_(-scale, scale)\n\n if layer.bias is not None:\n layer.bias.data.fill_(0.)","def build_cnn(input_var=None, w_init=None, n_layers=(4, 2, 1), n_filters_first=32, imsize=32, n_colors=3):\n weights = [] # Keeps the weights for all layers\n count = 0\n # If no initial weight is given, initialize with GlorotUniform\n if w_init is None:\n w_init = [lasagne.init.GlorotUniform()] * sum(n_layers)\n # Input layer\n network = InputLayer(shape=(None, n_colors, imsize, imsize),\n input_var=input_var)\n for i, s in enumerate(n_layers):\n for l in range(s):\n network = Conv2DLayer(network, num_filters=n_filters_first * (2 ** i), filter_size=(3, 3),\n W=w_init[count], pad='same')\n count += 1\n weights.append(network.W)\n network = MaxPool2DLayer(network, pool_size=(2, 2))\n return network, weights","def __init__(self, sizes: list):\n self.num_layers = len(sizes)\n self.sizes = sizes\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\n self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]","def __init__(self, input_nodes, hidden_nodes, hidden_layers, output_nodes):\n # Class members:\n # num_input_nodes\n # num_hidden_nodes\n # num_hidden_layers\n # num_output_nodes\n # weights = [[num_hidden_nodes, num_input_nodes],[num_hidden_nodes, num_hidden_nodes],[]<- for each hl,\n # [num_output_nodes, num_hidden_nodes]]\n # biases\n\n self.num_input_nodes = input_nodes\n self.num_hidden_nodes = hidden_nodes\n self.num_hidden_layers = hidden_layers\n self.num_output_nodes = output_nodes\n\n self.weights = []\n for i in range(self.num_hidden_layers + 1):\n if i is 0:\n # first weights array is input to hidden\n self.weights.append(.5 * np.random.rand(self.num_hidden_nodes, self.num_input_nodes) - .25)\n\n elif i < self.num_hidden_layers:\n # next weight array is hidden nodes to hidden nodes\n self.weights.append(.5 * np.random.rand(self.num_hidden_nodes, self.num_hidden_nodes) - .25)\n else:\n # last weight array is hidden nodes to output nodes\n self.weights.append(.5 * np.random.rand(self.num_output_nodes, self.num_hidden_nodes) - .25)\n\n self.biases = []\n for i in range(self.num_hidden_layers + 1):\n if i < self.num_hidden_layers:\n # for every hidden node there is a bias\n self.biases.append(0.5 * np.random.rand(self.num_hidden_nodes) - .25)\n else:\n # for the output node there is a bias as well\n self.biases.append(0.5 * np.random.rand(self.num_output_nodes) - .25)\n\n self.activation = np.vectorize(self.tanh, otypes=[float])","def __initialize_weights__(num_neurons: int) -> np.ndarray:\n\n weights = np.zeros((num_neurons, num_neurons))\n\n return weights","def __init__(self, layer_size, activation_function=linear,\n derivative_function=dlinear,\n forward_function=propagate_forward,\n backward_function=propagate_backward_irpropm,\n init_weights_function=fully_connected_weights, bias=True):\n self.forward_propagation = forward_function\n self.back_propagation = backward_function\n self.activation_function = activation_function\n self.derivative_function = derivative_function\n self.bias = bias\n\n # the activations of these nodes\n bias_add = 0\n if self.bias:\n bias_add = 1\n self.visible = numpy.ones(layer_size + bias_add)\n self.init_weights_function = init_weights_function","def __init__(self, n_input, n_output, hidden_layer_size, reg):\n self.reg = reg\n self.input_layer = FullyConnectedLayer(n_input, hidden_layer_size)\n self.relu = ReLULayer()\n self.output_layer = FullyConnectedLayer(hidden_layer_size, n_output)\n self.W_in = None\n self.W_out = None\n self.B_in = None\n self.B_out = None\n # TODO Create necessary layers","def test_init_net_simple(self):\n net = ecn.NeuralNet(2, (2,), 1)\n self.assertEqual(2, len(net.weights.keys()))\n self.assertEqual((2, 3), np.shape(net.weights['h0']))\n self.assertEqual((1, 3), np.shape(net.weights['y']))\n print('Finished testing simple neural net init\\n')","def init_weights(net, init_gain=0.02):\n def init_func(m): # define the initialization function\n classname = m.__class__.__name__\n if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1):\n init.normal_(m.weight.data, 0.0, init_gain)\n if hasattr(m, 'bias') and m.bias is not None:\n init.constant_(m.bias.data, 0.0)\n\n print('initialize network')\n net.apply(init_func) # apply the initialization function <init_func>","def __init__(self, nx, nodes):\n if type(nx) is not int:\n raise TypeError(\"nx must be an integer\")\n if nx < 1:\n raise ValueError(\"nx must be a positive integer\")\n if type(nodes) is not int:\n raise TypeError(\"nodes must be an integer\")\n if nodes < 1:\n raise ValueError(\"nodes must be a positive integer\")\n # weights vector for the hidden layer\n # default mean is 0\n # default stddev is 1\n self.__W1 = np.random.normal(size=(nodes, nx))\n # The bias for the hidden layer. Upon instantiation,\n # it should be initialized with 0’s.\n self.__b1 = np.zeros((nodes, 1))\n # The activated output for the hidden layer. Upon instantiation,\n # it should be initialized to 0\n self.__A1 = 0\n # weights vector for the output neuron\n # default mean is 0\n # default stddev is 1\n self.__W2 = np.random.normal(size=(1, nodes))\n # bias for the output neuron\n self.__b2 = 0\n # activated output for the output neuron (prediction)\n self.__A2 = 0","def init_learner(self,**kwargs):\r\n \r\n if self.learn_type == 'nn':\r\n #initialize neural network\r\n shape = kwargs[\"shape\"]\r\n #initialize input layer\r\n model = Sequential() \r\n #add hidden layers\r\n for i in range(len(shape)):\r\n if i == 0:\r\n nb_input = self.size\r\n else:\r\n nb_input = shape[i -1]\r\n nb_output = shape[i]\r\n model.add(Dense(nb_input,nb_output,init=\"he_normal\",\r\n activation = \"tanh\"))\r\n model.add(Dropout(.5))\r\n model.add(Dense(shape[-1],1,init = \"he_normal\",\r\n activation = \"linear\"))\r\n model.compile(loss = 'mean_squared_error',optimizer = 'rmsprop')\r\n self.learner = model\r\n \r\n elif self.learn_type == 'linear':\r\n #initialize parameter\r\n self.learner = Linear(self.size,**kwargs)","def construct_network(self, n_units, n_samples=1, noise_dim=0,\n keep_p=1., nonlinearity=True, init_params=None, name=\"\"):\n print \"constructing network, n_units: \",n_units\n # TODO use kwargs for more elagant solutions to being called by this \n # base class\n assert keep_p ==1. and nonlinearity and noise_dim == 0\n\n assert init_params is None # this is implemented only in the Bayesian flow version of this function\n\n ### Define parameters of the network\n self.weights, self.biases, KL = {}, {}, 0.\n self.layers = []\n # Establish paramters of appromiate posterior over weights and\n # biases.\n for l in range(1, len(n_units)):\n with tf.variable_scope(name+'Layer_%d'%l):\n n_in, n_out = n_units[l-1], n_units[l]\n\n # use non neglidgible uncertainty if we are doing VI\n sigma_init = self.init_sigma_params\n\n w_prior_sigma, b_prior_sigma = self.w_prior_sigma, self.w_prior_sigma\n mu_init_sigma_w, mu_init_sigma_b = np.sqrt(1./(n_in)), 1.\n\n (w_mu, w_logstd), _, w_KL = utils.set_q(name+\"w_%d\"%l,\n sigma_prior=w_prior_sigma, mu_init_sigma=mu_init_sigma_w,\n sigma_init=sigma_init, n_samples=0,\n size=[n_in, n_out], save_summary=True)\n\n # We use same init_sigma for weights and biases.\n (b_mu, b_logstd), _, b_KL = utils.set_q(name+\"b_%d\"%l,\n sigma_prior=b_prior_sigma, mu_init_sigma=mu_init_sigma_b,\n sigma_init=sigma_init, n_samples=0,\n size=[n_out], save_summary=True)\n self.weights['w_%d_mu'%l], self.weights['w_%d_std'%l] = w_mu, tf.nn.softplus(w_logstd)\n self.biases['b_%d_mu'%l], self.biases['b_%d_std'%l] = b_mu, tf.nn.softplus(b_logstd)\n\n self.params += [w_mu, b_mu, w_logstd, b_logstd]\n KL += w_KL + b_KL\n\n # Add an extra dimension to correspond to samples.\n prev_layer = tf.stack([self.x]*n_samples)\n self.layers.append(prev_layer)\n # shape is [n_samples, ?, dim(x)]\n\n ### Define activations in each layer\n for l in range(1,len(n_units)):\n print \"defining activations in layer %d\"%l\n # Multiply with weight matrix and add bias\n prev_layer = tf.reshape(prev_layer, [-1, n_units[l-1]])\n layer_pre_bias = tf.matmul(prev_layer, self.weights['w_%d_mu'%l])\n layer_pre_bias = tf.reshape(layer_pre_bias, [n_samples, -1, n_units[l]])\n # Shape of layer_pre_bias is [n_samples, ?, n_units[l]]\n\n # add mean bias term\n layer = tf.add(layer_pre_bias, self.biases['b_%d_mu'%l][None, None, :])\n\n # Calculate the noise in each hidden unit.\n # must use absolute value of activation because final layer may\n # have negative values.\n layer_var = tf.matmul(tf.reshape(prev_layer**2,[-1,\n n_units[l-1]]), self.weights['w_%d_std'%l]**2)\n layer_var = tf.reshape(layer_var, [n_samples, -1, n_units[l]])\n layer_var += self.biases['b_%d_std'%l]**2\n\n # Now sample noise and add scaled noise.\n # This constitutes the local reparameterization trick.\n eps = tf.random_normal(name='eps_%d'%l, mean=0.,\n stddev=1.0, shape=[n_samples, 1, n_units[l]])\n layer_sigma = tf.sqrt(layer_var)\n layer += layer_sigma*eps\n with tf.name_scope(name+\"Neural_Network_Activations_%d\"%l):\n tf.summary.histogram(name+\"Layer_%d_sigmas\"%l, layer_sigma)\n tf.summary.histogram(name+\"Layer_%d_activations_pre_tanh\"%l, layer)\n\n # Add tanh nonlinearity\n if l != (len(n_units) - 1): layer = tf.nn.tanh(layer)\n\n with tf.name_scope(name+\"Neural_Network_Activations_%d\"%l):\n tf.summary.histogram(name+\"Layer_%d_activations_post_tanh\"%l,layer)\n\n prev_layer = layer\n self.layers.append(prev_layer)\n self.KL_BNN = KL\n return prev_layer","def __init__(self, sizes):\n self.num_layers = len(sizes)\n self.sizes = sizes\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\n self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]","def __init__(self, sizes):\r\n self.num_layers = len(sizes)\r\n self.sizes = sizes\r\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\r\n self.weights = [np.random.randn(y, x)\r\n for x, y in zip(sizes[:-1], sizes[1:])]","def __init__(self, num_units=512, num_layers=4):\n\n self.num_units = num_units\n self.num_layers = num_layers\n \n self.layers = []\n for idx in range(self.num_layers):\n lstm_layer = tf.contrib.cudnn_rnn.CudnnLSTM(num_units=self.num_units,\n direction='unidirectional',\n num_layers=1)\n self.layers.append(lstm_layer)","def init(self,topology,learningRate=0.01,momentum=0.1,name='Network',add_bias=True):\n self.topology = topology\n self.learningRate = learningRate\n self.momentum = momentum\n self.name = name\n self.size = len(self.topology)-1 #The size of the network will be the number of weeight matrices between layers, instead of the number of layers itself\n #self._hiddenActiv_fun_key = 'tanh'\n #self._outActiv_fun_key = 'tanh'\n #self.output_activation = self.set_outActivation_fun(func=self._outActiv_fun_key)\n #self.hidden_activation = self.set_hiddenactivation_fun(func=self._hiddenActiv_fun_key)\n\n # Initialize random weights, and create empty matrices to store the previous changes in weight (for momentum):\n if add_bias:\n #self.weights = [np.random.normal(loc=0,scale=0.6,size=(topology[i]+1, topology[i+1])) for i in range(self.size)]\n self.weights = [np.random.normal(loc=0,\n scale=0.6,\n size=(topology[i]+1, topology[i+1]+1)) for i in range(self.size-1)] #we are only generating matrices for inital and hidden layers\n #Create matrix for output layer\n f_idx = self.size-1 #use this index for the final layer matrix below\n self.weights.append(np.random.normal(loc=0,\n scale=0.6,\n size=(topology[f_idx]+1,topology[f_idx+1])))\n else:\n raise NotImplemented(\"Currently the network only works when bias nodes are used\")\n self.weights = [np.random.normal(loc=0,scale=0.6,size=(topology[i], topology[i])) for i in range(self.size)]\n\n self.Gradients = [None] * self.size","def __init__(self, input_size, hidden_size, num_layers, nonlinearity=torch.tanh):\n super().__init__()\n self.input_size = input_size\n self.hidden_size = hidden_size\n\n # input weights\n self.weight_ih_l0 = Parameter(torch.Tensor(3*hidden_size, input_size))\n\n # hidden weights\n self.weight_hh_l0 = Parameter(torch.Tensor(3*hidden_size, hidden_size))\n\n # bias\n self.bias_ih_l0 = Parameter(torch.Tensor(3*hidden_size)) # input\n self.bias_hh_l0 = Parameter(torch.Tensor(3*hidden_size)) # hidden\n\n self.f = nonlinearity\n\n self.init_weights()","def __init__(self, *args, **kwargs):\n self.params = kwargs\n self.output_len = kwargs['num_neurons']\n self.input_len = kwargs['input_len']\n self.weights = Vector(data=np.random.randn(self.output_len, self.input_len))\n self.biases = Vector(data=np.zeros((self.output_len, 1)))\n self.input_activations = None\n self.output_activations = Vector()","def initialize(self, input_size, n_classes):\n\n self.n_classes = n_classes\n self.input_size = input_size\n\n n_hidden_layers = len(self.sizes)\n #############################################################################\n # Allocate space for the hidden and output layers, as well as the gradients #\n #############################################################################\n self.hs = []\n self.grad_hs = []\n for h in range(n_hidden_layers):\n self.hs += [np.zeros((self.sizes[h],))] # hidden layer\n self.grad_hs += [np.zeros((self.sizes[h],))] # ... and gradient\n self.hs += [np.zeros((self.n_classes,))] # output layer\n self.grad_hs += [np.zeros((self.n_classes,))] # ... and gradient\n\n ##################################################################\n # Allocate space for the neural network parameters and gradients #\n ##################################################################\n self.weights = [np.zeros((self.input_size, self.sizes[0]))] # input.csv to 1st hidden layer weights\n self.grad_weights = [np.zeros((self.input_size, self.sizes[0]))] # ... and gradient\n\n self.biases = [np.zeros((self.sizes[0]))] # 1st hidden layer biases\n self.grad_biases = [np.zeros((self.sizes[0]))] # ... and gradient\n\n for h in range(1, n_hidden_layers):\n self.weights += [np.zeros((self.sizes[h - 1], self.sizes[h]))] # h-1 to h hidden layer weights\n self.grad_weights += [np.zeros((self.sizes[h - 1], self.sizes[h]))] # ... and gradient\n\n self.biases += [np.zeros((self.sizes[h]))] # hth hidden layer biases\n self.grad_biases += [np.zeros((self.sizes[h]))] # ... and gradient\n\n self.weights += [np.zeros((self.sizes[-1], self.n_classes))] # last hidden to output layer weights\n self.grad_weights += [np.zeros((self.sizes[-1], self.n_classes))] # ... and gradient\n\n self.biases += [np.zeros((self.n_classes))] # output layer biases\n self.grad_biases += [np.zeros((self.n_classes))] # ... and gradient\n\n #########################\n # Initialize parameters #\n #########################\n\n self.rng = np.random.mtrand.RandomState(self.seed) # create random number generator\n # biases are initialized to zero\n # ... and weights according to the slides\n for m in range(len(self.weights)):\n b = (6 ** 0.5) / ((self.weights[m].shape[0] + self.weights[m].shape[1]) ** 0.5)\n for ind, val in np.ndenumerate(self.weights[m]):\n self.weights[m][ind] = self.rng.uniform(-b, b, 1)\n\n\n self.n_updates = 0 # To keep track of the number of updates, to decrease the learning rate","def __init__(self, sizes):\n self.num_layers = len(sizes)\n self.sizes = sizes\n self.biases = [cp.array(cp.random.randn(y, 1)) for y in sizes[1:]]\n self.weights = [cp.array(cp.random.randn(y, x))\n for x, y in zip(sizes[:-1], sizes[1:])]","def __init__(self, sizes):\r\n self.num_layers = len(sizes)\r\n self.sizes = sizes\r\n\r\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\r\n self.weights = [np.random.randn(y, x)\r\n for x, y in zip(sizes[:-1], sizes[1:])]","def init_weight(self):\n init_layer(self.conv1)\n init_layer(self.conv2)\n init_bn(self.norm1)\n init_bn(self.norm2)","def initialize_network(self):\n # intermediate layer size\n ils = int((self.specbinnum + self.numfilters) / 2)\n\n network = lasagne.layers.InputLayer((None, 1, self.specbinnum, self.numtimebins), self.input_var)\n\n network = NormalisationLayer(network, self.specbinnum)\n self.normlayer = network\n\n network, _ = custom_convlayer_2(network, in_num_chans=self.specbinnum, out_num_chans=ils)\n network = batch_norm(network)\n network, _ = custom_convlayer_2(network, in_num_chans=ils, out_num_chans=self.numfilters)\n network = batch_norm(network)\n\n network = lasagne.layers.NonlinearityLayer(network, nonlinearity=elu)\n self.latents = network\n network = ZeroOutBackgroundLatentsLayer(self.latents,\n mp_down_factor=self.mp_down_factor,\n numfilters=self.numfilters,\n numtimebins=self.numtimebins,\n background_latents_factor=self.background_latents_factor,\n use_maxpool=self.use_maxpool)\n network, _ = custom_convlayer_2(network, in_num_chans=self.numfilters, out_num_chans=ils)\n network = batch_norm(network)\n network, _ = custom_convlayer_2(network, in_num_chans=ils, out_num_chans=self.specbinnum)\n network = batch_norm(network)\n\n # output_size\n num_time_samples = int(audioframe_len/2 * (self.numtimebins + 1))\n # network = batch_norm(DenseLayer(network, num_time_samples)) # MemoryError\n network, _ = custom_convlayer_2(network, in_num_chans=self.specbinnum, out_num_chans=num_time_samples)\n network, _ = batch_norm(network)\n network, _ = custom_convlayer_2(network, in_num_chans=num_time_samples, out_num_chans=1)\n network, _ = batch_norm(network)\n\n self.network = network","def __init__(self,layers,activations):\n model = utils.buildMLP(layers, activations)\n super().__init__(torch.nn.Sequential(model), nnType='dnn')","def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):\n \n super().__init__(inputnodes, hiddennodes, outputnodes, learningrate)\n\n # link weight matrices, wih and who\n # weights inside the arrays are w_i_j, where link is from node i to node i to j in the next layer\n # w11 w21\n # w12 w22 etc\n self.wih = numpy.random.normal(\n 0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))\n self.who = numpy.random.normal(\n 0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))\n\n #activation function is the sigmoid function\n self.activation_function = lambda x: scipy.special.expit(x)\n\n pass","def _generate_network_initialization(self, graph, memory_manager):\n\n # TODO: To be changed if we want to support multiple outputs\n output_buffer_name = graph.outputs[0].name\n\n ops_to_ignore = ['Reshape', 'Mul']\n\n buffers_allocated = []\n\n buffer_declaration = \"\"\n buffer_declaration += \" pico_cnn::naive::Tensor **kernels;\\n\"\n buffer_declaration += \" pico_cnn::naive::Tensor **biases;\\n\"\n\n constructor_code = \"\"\n #constructor_code += \"Network::Network() {\\n\\n\"\n\n num_layers = 0\n num_kernels = 0\n num_biases = 0\n\n for node in graph.nodes:\n \"\"\"Do not count the reshape layers as the input tensor will only define the dimensions\"\"\"\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\n num_layers += 1\n for num, input in enumerate(node.input_tensors):\n if input in buffers_allocated:\n continue\n else:\n tensor = node.input_tensors[input]\n buffers_allocated.append(input)\n if len(tensor.shape) == 1:\n num_biases += 1\n else:\n num_kernels += 1\n\n \"\"\"The arrays kernels and biases will be used to pass only two variables to read_binary_weights\"\"\"\n constructor_code += \" kernels = new pico_cnn::naive::Tensor*[{}]();\\n\".format(num_kernels)\n constructor_code += \" biases = new pico_cnn::naive::Tensor*[{}]();\\n\\n\".format(num_biases)\n\n pos = -1\n pos_kernel = -1\n pos_bias = -1\n\n buffers_allocated.clear()\n\n \"\"\"Iterate over all nodes in the graph and generate the corresponding allocation code.\"\"\"\n for node_id, node in enumerate(graph.nodes):\n\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\n pos += 1\n\n buffer_declaration += \" // Layer: \" + node.name + \", Operation: \" + node.op_type + \"\\n\"\n constructor_code += \" // Layer: \" + node.name + \", Operation: \" + node.op_type + \"\\n\"\n\n # Allocate memory for kernels and biases\n buffer_declaration += \" // Inputs\\n\"\n constructor_code += \" // Inputs\\n\"\n for num, input in enumerate(node.input_tensors):\n\n if node.op_type in ops_to_ignore:\n continue\n\n if input in buffers_allocated:\n continue\n else:\n buffers_allocated.append(input)\n\n tensor = node.input_tensors[input]\n if len(tensor.shape) == 1:\n pos_bias += 1\n else:\n pos_kernel += 1\n\n buffer = memory_manager.get_buffer(graph, input)\n\n buffer_declaration += \" // \" + str(buffer.shape) + \"\\n\"\n\n pico_cnn_tensor = \" pico_cnn::naive::Tensor *\"\n\n buffer_declaration += pico_cnn_tensor + buffer.name + \";\\n\"\n\n constructor_code += \" // \" + str(buffer.shape) + \"\" # TODO maybe we sometimes need \\n\n\n functionality = CodeRegistry.get_funct(\"KernelAllocation\")\n impl = functionality[0].create(buffer, pos, pos_kernel, pos_bias)\n\n if impl:\n constructor_code += impl.generate_code()\n constructor_code += \"\\n\"\n\n buffer_declaration += \" // Outputs\\n\"\n constructor_code += \" // Outputs\\n\"\n for num, output in enumerate(node.outputs):\n\n buffer = memory_manager.get_buffer(graph, output)\n\n if output == output_buffer_name:\n buffer_declaration += \" // Output tensor {} with shape {} of network provided as argument of Network::run()\".format(buffer.name, str(buffer.shape))\n constructor_code += \" // Output tensor {} with shape {} of network provided as argument of Network::run()\".format(buffer.name, str(buffer.shape))\n continue\n\n buffer_declaration += \" // \" + str(buffer.shape) + \"\\n\"\n\n pico_cnn_tensor = \" pico_cnn::naive::Tensor *\"\n\n buffer_declaration += pico_cnn_tensor + buffer.name + \";\\n\"\n\n constructor_code += \" // \" + str(buffer.shape) + \"\" # TODO maybe we sometimes need \\n\n\n functionality = CodeRegistry.get_funct(\"OutputAllocation\")\n impl = functionality[0].create(buffer)\n\n if impl:\n constructor_code += impl.generate_code()\n constructor_code += \"\\n\"\n\n buffer_declaration += \"\\n\\n\"\n constructor_code += \"\\n\\n\"\n\n #constructor_code += \"}\\n\"\n\n self.buffer_declaration = buffer_declaration\n self.constructor_code = constructor_code","def test_init(self):\n network = PerceptronNetwork(\n [\n PerceptronLayer.blank(4, 2, 'layer1', ['a', 'b', 'c', 'd']),\n PerceptronLayer.blank(2, 2, 'layer2', ['a', 'b', 'c', 'd'])\n ]\n )\n self.assertIsNotNone(network)","def construct(self):\n self.input_size = self.numplanes * self.boardsize**2\n \n if self.hidden:\n layers = [\n torch.nn.Linear(self.input_size, self.hidden), \n torch.nn.ReLU(),\n torch.nn.Linear(self.hidden, self.boardsize**2)\n ]\n else:\n layers = [torch.nn.Linear(self.input_size, self.boardsize**2)]\n\n self.layers = torch.nn.ModuleList(layers)\n self.optimizer = torch.optim.Adam(self.parameters(), lr=1e-5)\n logging.info(\"Model initialized: %s\", self)","def lenet_network(name, input_shape, output_count):\n network = NeuralNetwork(name, input_shape, output_count)\n\n # normal distribution parameters for random weights\n mean = 0.0\n stddev = 0.1\n\n # General convolution shapes and parameters common to all convolutional layers\n conv_stride_shape = (1, 1)\n conv_pad_shape = (0, 0)\n conv_pad_type = 'VALID'\n\n pool_stride_shape = (2, 2)\n pool_shape = (2, 2)\n pool_pad_type = 'VALID'\n\n activation = 'relu'\n\n # Kernel depths and sizes for each convolution layer\n depths = [6, 16]\n kernel_shapes = [(5, 5, depths[0]), (5, 5, depths[1])]\n conv_layer_count = len(depths)\n\n # Create convolutional layers\n conv = None\n for i in range(conv_layer_count):\n name = 'l{:d}'.format(i)\n if i > 0:\n input_shape = conv.output_shape\n conv = ConvolutionalLayer(name, input_shape, kernel_shapes[i], conv_stride_shape, \\\n conv_pad_shape, conv_pad_type, activation)\n conv.add_pooling('max', pool_shape, pool_stride_shape, pool_pad_type)\n network.add_layer(conv, mean, stddev)\n\n # Linear layer dimensions\n linear_input_sizes = [400, 120, 84]\n linear_output_sizes = [120, 84, 10]\n linear_activations = ['relu', 'relu', None]\n\n # Create linear layers\n for i, input_size in enumerate(linear_input_sizes):\n layer_index = i + conv_layer_count\n name = 'l{:d}'.format(layer_index)\n linear = LinearLayer(name, input_size, linear_output_sizes[i], linear_activations[i])\n linear.init_weights_and_biases(mean, stddev)\n network.add_layer(linear, mean, stddev)\n\n network.define_network()\n\n learning_rate = 0.001\n network.define_operations(learning_rate, 'adam')\n\n return network","def _build_network(self,\n input_dim,\n dense_layers,\n nodes_per_layer=None,\n hidden_act='relu',\n output_act='sigmoid',\n dropout_layers=None):\n\n if nodes_per_layer is None:\n nodes = [10] * dense_layers\n else:\n nodes = nodes_per_layer\n\n if dropout_layers is None:\n do_layers = [0] * dense_layers\n else:\n do_layers = dropout_layers\n\n self.model.add(Dense(nodes[0], input_dim=input_dim,\n activation=hidden_act))\n\n if dense_layers > 1:\n for l in range(1, dense_layers - 1):\n if do_layers[l - 1] != 0:\n self.model.add(Dropout(do_layers[l - 1]))\n\n self.model.add(Dense(nodes[l], activation=hidden_act))\n\n self.model.add(Dense(1, activation=output_act))","def test_init() -> None:\n neural_net = NeuralNetwork()\n assert neural_net.model.get_layer('output_layer').output_shape, (None, 4)","def __init__(self, inputLayerSize, outputLayerSize, \\\n hiddenLayerSize):\n #Network hyperparameters - neurons per layer - **not altered by training**\n self.inputLayerSize = inputLayerSize\n self.outputLayerSize = outputLayerSize\n self.hiddenLayerSize = hiddenLayerSize\n self.num_params = inputLayerSize * hiddenLayerSize + \\\n hiddenLayerSize * outputLayerSize + hiddenLayerSize \\\n + outputLayerSize\n #--Weights--\n #w_ih - weights of synapses linking input -> hidden\n self.w_ih = np.random.randn( self.inputLayerSize, \\\n self.hiddenLayerSize)\n #w_ho - weights of synapses linking hidden -> output\n self.w_ho = np.random.randn( self.hiddenLayerSize, \\\n self.outputLayerSize)\n \n #--Biases--\n #b_h - biases of hidden layer\n self.b_h = np.random.randn( self.hiddenLayerSize )\n #b_o - biases of output layer\n self.b_o = np.random.randn( self.outputLayerSize )","def __init__(self, number_of_neurons: int, activation_function, inputs=None):\n self.uid = None\n self.number_of_neurons = number_of_neurons\n self.activation_function = activation_function\n self.inputs = inputs\n self.shape = None\n self.data_shape = None\n self.weights = None\n self.__set_weights()","def setupNetwork(self):\n\t\tin_layer = Input(shape=(28, ))\n\t\td1 = Dense(40, activation='relu')(in_layer)\n\t\td2 = Dense(10, activation='relu')(d1)\n\t\tout = Dense(1, activation='sigmoid')(d2)\n\n\t\tself.model = tf.keras.Model(inputs=in_layer, outputs=out)","def build_neural_net(net_def):\n\n populated_def = net_def.copy()\n\n for layer in populated_def['layers']:\n for n in range(0, layer['num_neurons']):\n weights = layer['weights'][n]\n bias = layer['bias'][n]\n\n neuron = Neuron(weights, bias, layer['activation'])\n layer['neurons'].append(neuron)\n\n\n return populated_def","def set_layers(self, sizes, init='random'):\n\t\tself.init_weights(sizes, init, None, None)","def __init__(self, rate, sigmoid, hidden, examples, variables, layers, rule, dropout):\n self.rate = rate\n self.sigmoid = sigmoid\n self.inputs = variables \n self.vis_layer = []\n self.hidden_layers = []\n self.hidden = hidden\n self.variables = variables\n self.data = BOOLEAN(examples, self.variables)\n self.layers = layers-1\n self.rule = rule\n self.dropout = dropout\n self.length = int(math.pow(2, self.variables))\n for _ in xrange(self.hidden):\n self.vis_layer.append(Neuron(self.rate, self.sigmoid, self.inputs+1, dropout))\n for layer in xrange(self.layers):\n self.hidden_layers.append([])\n for _ in xrange(self.hidden):\n self.hidden_layers[layer].append(Neuron(self.rate, self.sigmoid, self.hidden+1, dropout))\n if self.hidden > 0:\n self.output_neuron = Neuron(self.rate, self.sigmoid, self.hidden+1, dropout)\n else:\n self.output_neuron = Neuron(self.rate, self.sigmoid, self.inputs+1, dropout)","def _init_layers(self):\n self.relu = nn.ReLU(inplace=True)\n self.cls_convs = nn.ModuleList()\n self.reg_convs = nn.ModuleList()\n for i in range(self.stacked_convs):\n chn = self.in_channels if i == 0 else self.feat_channels\n self.cls_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=self.conv_cfg,\n norm_cfg=self.norm_cfg))\n self.reg_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=self.conv_cfg,\n norm_cfg=self.norm_cfg))\n self.retina_cls = nn.Conv2d(\n self.feat_channels,\n self.num_anchors * self.cls_out_channels,\n 3,\n padding=1)\n self.retina_reg = nn.Conv2d(\n self.feat_channels, self.num_anchors * 4, 3, padding=1)","def __init__(self, z_dim, initailize_weights=True):\n super().__init__()\n self.z_dim = z_dim\n\n self.img_conv1 = conv2d(3, 16, kernel_size=7, stride=2)\n self.img_conv2 = conv2d(16, 32, kernel_size=5, stride=2)\n self.img_conv3 = conv2d(32, 64, kernel_size=5, stride=2)\n self.img_conv4 = conv2d(64, 64, stride=2)\n self.img_conv5 = conv2d(64, 128, stride=2)\n self.img_conv6 = conv2d(128, self.z_dim, stride=2)\n self.img_encoder = nn.Linear(4 * self.z_dim, 2 * self.z_dim)\n self.flatten = Flatten()\n\n if initailize_weights:\n init_weights(self.modules())","def __init__(self,\n neurons_list: list,\n hidden_activation: str = None,\n out_activation: str = None,\n error_func: str = None):\n self.__layers = []\n for i in range(1, len(neurons_list)):\n prev_layer = neurons_list[i - 1]\n cur_layer = neurons_list[i]\n\n out_activ = lin\n out_activ_deriv = lin_deriv\n\n if out_activation == \"sigmoid\":\n out_activ = sigmoid\n out_activ_deriv = sigmoid_deriv\n elif out_activation == \"relu\":\n out_activ = relu\n out_activ_deriv = relu_deriv\n elif out_activation == \"l_relu\":\n out_activ = l_relu\n out_activ_deriv = l_relu_deriv\n\n hidden_activ = lin\n hidden_activ_deriv = lin_deriv\n\n if hidden_activation == \"sigmoid\":\n hidden_activ = sigmoid\n hidden_activ_deriv = sigmoid_deriv\n elif hidden_activation == \"relu\":\n hidden_activ = relu\n hidden_activ_deriv = relu_deriv\n elif hidden_activation == \"l_relu\":\n hidden_activ = l_relu\n hidden_activ_deriv = l_relu_deriv\n\n if i == len(neurons_list) - 1:\n layer = NeuralNetLayer(cur_layer, prev_layer, out_activ, out_activ_deriv)\n else:\n layer = NeuralNetLayer(cur_layer, prev_layer, hidden_activ, hidden_activ_deriv)\n self.__layers.append(layer)\n\n error_func_f = squared_error\n error_deriv = squared_error_der\n\n if error_func == \"mse\":\n error_func_f = squared_error\n error_deriv = squared_error_der\n elif error_func == \"kl\":\n error_func_f = kl_divergence\n error_deriv = kl_divergence_der\n\n self.__error_func = error_func_f\n self.__error_deriv = error_deriv","def __init__(self, z_dim, initailize_weights=True):\n super().__init__()\n self.z_dim = z_dim\n\n self.depth_conv1 = conv2d(1, 32, kernel_size=3, stride=2)\n self.depth_conv2 = conv2d(32, 64, kernel_size=3, stride=2)\n self.depth_conv3 = conv2d(64, 64, kernel_size=4, stride=2)\n self.depth_conv4 = conv2d(64, 64, stride=2)\n self.depth_conv5 = conv2d(64, 128, stride=2)\n self.depth_conv6 = conv2d(128, self.z_dim, stride=2)\n\n self.depth_encoder = nn.Linear(4 * self.z_dim, 2 * self.z_dim)\n self.flatten = Flatten()\n\n if initailize_weights:\n init_weights(self.modules())","def _nn_initial_values(structure):\n\n # Use Xavier uniform initializer\n initializer=tf.glorot_uniform_initializer()\n\n output=[]\n last_width=None\n\n # Add biases & weights per layer\n for l in structure:\n output.append(tf.zeros(shape=[l])) # layer l biases\n if last_width is not None: # Exclude weights from layer 0\n output.append(initializer(shape=[last_width, l])) # layer l weights\n last_width=l\n\n return output","def initialize_parameters_for_layers(layer_list, training_examples):\n W = [None] * len(layer_list)\n B = [None] * len(layer_list)\n X = np.random.randn(layer_list[0], training_examples)\n for j in range(1, len(layer_list)):\n W[j] = np.random.randn(layer_list[j], layer_list[j-1])\n B[j] = np.random.randn(layer_list[j], 1)\n return X, W, B","def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):\n super().__init__(inputnodes, hiddennodes, outputnodes, learningrate)\n\n # link weight matrices, wih and who\n # weights inside the arrays are w_i_j, where link is from node i to node i to j in the next layer\n # w11 w21\n # w12 w22 etc\n self.wih = cupy.random.normal(\n 0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))\n self.who = cupy.random.normal(\n 0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))\n\n #activation function is the sigmoid function\n self.activation_function = lambda x: 1 / (1 + cupy.exp(x) ** (-1))","def __init__(self, num_units, input_size=None,\n nonlinearity=tf.nn.tanh,\n W_init=tf.random_normal_initializer(stddev=0.15),\n b_init=tf.constant_initializer(0.0, dtype=tf.float32),\n weightnorm=False):\n self._num_units = num_units\n self._input_size = input_size or num_units\n self._W_init = W_init\n self._b_init = b_init\n self._weightnorm = weightnorm\n self._nonlin = nonlinearity","def build(self):\n\n self.W = self.init([self.n_atom_input_feat, self.n_output])\n self.b = model_ops.zeros(shape=[\n self.n_output,\n ])\n\n self.trainable_weights = self.W + self.b","def build_layer(self) :\n inputsWithBias = self.input_count + 1\n self.weights = np.random.rand(inputsWithBias, self.node_count)\n self.weights_and_activations = (self.weights, self.activations)","def initialize_layers(self, layers_config: dict, inputs=None):\n layers_config = layers_config.copy()\n input_lyrs = []\n initiated_layers = OrderedDict()\n wrp_layer = None # indicator for wrapper layers\n first_layer = True\n\n for lyr, lyr_args in layers_config.items():\n\n lyr_config, lyr_inputs, named_outs, call_args = self.deconstruct_lyr_args(lyr, lyr_args)\n\n lyr_name, args, lyr_config, activation = self.check_lyr_config(lyr, lyr_config)\n\n if K.BACKEND == 'pytorch':\n\n if first_layer:\n first_layer = False\n\n if callable(lyr_config):\n lyr_initiated = lyr_config\n else:\n lyr_initiated = TORCH_LAYERS[lyr_name](**lyr_config)\n setattr(self, lyr, lyr_initiated)\n initiated_layers[lyr] = {\"layer\": lyr_initiated, \"named_outs\": named_outs, 'call_args': call_args,\n 'inputs': lyr_inputs}\n\n else:\n # may be user has defined layers without input layer, in this case add Input layer as first layer\n if first_layer:\n if inputs is not None: # This method was called by providing it inputs.\n assert isinstance(inputs, tf.Tensor)\n # since inputs have been defined, all the layers that will be added will be next to first layer\n first_layer = False\n layer_outputs = inputs\n initiated_layers[layer_outputs.name] = {'layer': layer_outputs, 'tf_name': lyr_name}\n\n elif lyr_name != \"Input\":\n if 'input_shape' in lyr_config: # input_shape is given in the first layer so make input layer\n initialized_layer = LAYERS[\"Input\"](shape=lyr_config['input_shape'])\n else:\n # for simple dense layer based models, lookback will not be used\n def_shape = (self.num_ins,) if self.lookback == 1 else (self.lookback, self.num_ins)\n initialized_layer = LAYERS[\"Input\"](shape=def_shape)\n\n # first layer is built so next iterations will not be for first layer\n first_layer = False\n # put the first layer in memory to be used for model compilation\n # add th layer which the user had specified as first layer\n initiated_layers[initialized_layer.name] = {'layer': initialized_layer,\n 'tf_name': lyr_name}\n input_lyrs.append(initialized_layer)\n\n # The inputs to the layer have not been specified, so either it is an Input layer\n if lyr_inputs is None:\n # or it uses the previous outputs as inputs\n if lyr_name == \"Input\":\n # it is an Input layer, hence should not be called\n initialized_layer = LAYERS[lyr_name](*args, **lyr_config)\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\n 'tf_name': lyr_name}\n input_lyrs.append(initialized_layer)\n else:\n # it is executable and uses previous outputs as inputs\n if lyr_name in ACTIVATION_LAYERS:\n layer_outputs = ACTIVATION_LAYERS[lyr_name](name=lyr_config['name'])\n initiated_layers[lyr_config['name']] = {'layer': layer_outputs,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n elif lyr_name in ['TimeDistributed', 'Bidirectional']:\n wrp_layer = LAYERS[lyr_name]\n # because wrapper layer name is property\n initiated_layers[lyr_config['name']] = {'layer': wrp_layer,\n 'tf_name': lyr_name}\n continue\n elif \"LAMBDA\" in lyr_name.upper():\n # lyr_config is serialized lambda layer, which needs to be deserialized\n initialized_layer = tf.keras.layers.deserialize(lyr_config)\n # layers_config['lambda']['config'] still contails lambda, so we need to replace the python\n # object (lambda) with the serialized version (lyr_config) so that it can be saved as json file.\n layers_config[lyr]['config'] = lyr_config\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n else:\n if wrp_layer is not None:\n initialized_layer = wrp_layer(LAYERS[lyr_name](*args, **lyr_config))\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n wrp_layer = None\n else:\n if lyr_name == \"TemporalFusionTransformer\":\n lyr_config['return_attention_components'] = True\n initialized_layer = LAYERS[lyr_name](*args, **lyr_config)\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n\n else: # The inputs to this layer have been specified so they must exist in lyr_cache.\n # it is an executable\n if lyr_name in ACTIVATION_LAYERS:\n\n layer_outputs = ACTIVATION_LAYERS[lyr_name](name=lyr_config['name'])\n initiated_layers[lyr_config['name']] = {'layer': layer_outputs,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n elif lyr_name in ['TimeDistributed', 'Bidirectional']:\n wrp_layer = LAYERS[lyr_name]\n # because wrapper layer name is property\n initiated_layers[lyr_config['name']] = {'layer': wrp_layer,\n 'tf_name': lyr_name}\n continue\n elif \"LAMBDA\" in lyr_name.upper():\n initialized_layer = tf.keras.layers.deserialize(lyr_config)\n layers_config[lyr]['config'] = lyr_config\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n else:\n if wrp_layer is not None:\n initialized_layer = wrp_layer(LAYERS[lyr_name](*args, **lyr_config))\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n wrp_layer = None\n else:\n layer_initialized = LAYERS[lyr_name](*args, **lyr_config)\n initiated_layers[lyr_config['name']] = {'layer': layer_initialized,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n\n if activation is not None: # put the string back to dictionary to be saved in config file\n lyr_config['activation'] = activation\n\n first_layer = False\n\n self.jsonize_lyr_config(lyr_config)\n\n # inputs = [] todo, indentify input layers\n # for k,v in lyr_cache.items():\n # since the model is not build yet and we have access to only output tensors of each list, this is probably\n # # the only way to know that how many `Input` layers were encountered during the run of this method. Each\n # tensor (except TimeDistributed) has .op.inputs attribute, which is empty if a tensor represents output of Input layer.\n # if int(''.join(tf.__version__.split('.')[0:2]).ljust(3, '0')) < 240:\n # if k.upper() != \"TIMEDISTRIBUTED\" and hasattr(v, 'op'):\n # if hasattr(v.op, 'inputs'):\n # _ins = v.op.inputs\n # if len(_ins) == 0:\n # inputs.append(v)\n # else: # not sure if this is the proper way of checking if a layer receives an input or not!\n # if hasattr(v, '_keras_mask'):\n # inputs.append(v)\n\n setattr(self, 'initiated_layers', initiated_layers)\n setattr(self, 'input_lyrs', input_lyrs)\n\n\n # todo,\n # # for case when {Input -> Dense, Input_1}, this method wrongly makes Input_1 as output so in such case use\n # # {Input_1, Input -> Dense }, thus it makes Dense as output and first 2 as inputs, so throwing warning\n # if int(''.join(tf.__version__.split('.')[0:2]).ljust(3, '0')) < 240:\n # if len(layer_outputs.op.inputs) < 1:\n # print(\"Warning: the output is of Input tensor class type\")\n # else:\n # if 'op' not in dir(layer_outputs): # layer_outputs does not have `op`, which means it has no incoming node\n # print(\"Warning: the output is of Input tensor class type\")\n\n # outs = None\n #if BACKEND == 'tensorflow':\n # outs = self.call(input_lyrs)\n # setattr(self, 'output_lyrs', outs)\n # if BACKEND == 'tensorflow':\n # ## Reinitial\n # super(Model, self).__init__(\n # inputs=input_lyrs,\n # outputs=outs)\n #MODEL.__init__(self, inputs=inputs, outputs=outs)\n\n return input_lyrs # , outs","def _init_layers(self) -> None:\n self.self_attn = MultiheadAttention(**self.self_attn_cfg)\n self.cross_attn = MultiheadAttention(**self.cross_attn_cfg)\n self.embed_dims = self.self_attn.embed_dims\n self.ffn = FFN(**self.ffn_cfg)\n norms_list = [\n build_norm_layer(self.norm_cfg, self.embed_dims)[1]\n for _ in range(3)\n ]\n self.norms = ModuleList(norms_list)","def bnn_serial(*layers):\n nlayers = len(layers)\n init_funs, apply_funs = zip(*layers)\n\n def init_fun(rng, input_shape):\n params = []\n for init_fun in init_funs:\n rng, layer_rng = jax.random.split(rng)\n input_shape, param = init_fun(layer_rng, input_shape)\n params.append(param)\n return input_shape, params\n\n def apply_fun(params, inputs, **kwargs):\n rng = kwargs.pop('rng', None)\n rngs = jax.random.split(rng, nlayers) if rng is not None else (None,) * nlayers\n total_kl = 0\n infodict = {}\n for fun, param, rng in zip(apply_funs, params, rngs):\n output = fun(param, inputs, rng=rng, **kwargs)\n if len(output) == 2:\n inputs, layer_kl = output\n elif len(output) == 3:\n inputs, layer_kl, info = output\n infodict.update(info)\n else:\n raise RuntimeError(f\"Expected 2 or 3 outputs but got {len(output)}.\")\n total_kl = total_kl + layer_kl\n return inputs, total_kl, infodict\n\n return Layer(init_fun, apply_fun)","def __init__(self, n_input, n_output, hidden_layer_size, reg):\n self.reg = reg\n self.fulllayer1 = FullyConnectedLayer(n_input, hidden_layer_size)\n self.reglayer1 = ReLULayer()\n self.fulllayer2 = FullyConnectedLayer(hidden_layer_size, n_output)","def initialize_network(self):\n self.sess = tf.InteractiveSession()\n sys.stderr.write(\"------\\n\")\n self.model.create_model()\n self._initialize_trainer()\n self.sess.run(tf.initialize_all_variables())\n self.saver = tf.train.Saver()","def init(InputUnits, OutputUnits, numHiddenLayer, HiddenUnits=None):\n global HiddenUnit\n all_weights = []\n if HiddenUnits is None:\n HiddenUnits = []\n elif isinstance(HiddenUnits, int):\n HiddenUnits = [HiddenUnits]\n\n # for InputLayer\n\n parameters = generate(HiddenUnits[0], InputUnits)\n allWeights = mat.r_[parameters.flatten()]\n\n if numHiddenLayer > 1:\n for i in range(numHiddenLayer):\n if i < numHiddenLayer-1:\n parameters = generate(HiddenUnits[i+1], HiddenUnits[i])\n allWeights = mat.r_[allWeights, parameters.flatten()]\n else:\n parameters = generate(OutputUnits, HiddenUnits[i])\n allWeights = mat.r_[allWeights, parameters.flatten()]\n\n else:\n # for output layer\n parameters = generate( OutputUnits, HiddenUnits[0])\n allWeights = mat.r_[allWeights, parameters.flatten()]\n\n return allWeights","def __init__(self, layers = (1, 1), speed = 0.5):\n \n self.structure = layers # Structure of each layer\n self.activationFunc = np.vectorize(lambda x: 1.0 / (1 + np.exp(-x))); # Activatin function\n self.derivativeFunc = lambda x: x * (1 - x) # Derivative from activation function\n self.theta = [None] # Matrix of weights for each layer\n self.a = None # Activation level from each layer\n self.delta = None # Error rate for each level\n self.speed = speed # Speed of learning\n \n # for each layer exclude input layer\n for i in xrange(1, len(layers)):\n # create n * (M+1) matrix (+1 = adding bias) with random floats in range [-1; 1]\n self.theta.append(np.mat(np.random.uniform(-1, 1, (layers[i], layers[i - 1] + 1))))\n #self.theta.append(np.matrix(np.ones((layers[i], layers[i - 1] + 1))))\n \n return","def __init__(self, neuron_count):\n # The current state of the thermal network.\n self.current_state = [0.0] * neuron_count\n\n # The weights.\n self.weights = np.zeros( [neuron_count*neuron_count] )\n\n # The neuron count.\n self.neuron_count = neuron_count","def init():\n global neural_network\n global labels\n\n # load objects required by run() for inferencing\n model_dir = Model.get_model_path(\"mnist-fashion\")\n # neural model\n neural_network = keras.models.load_model(f\"{model_dir}/neural-network.h5\")\n # labels\n with open(f\"{model_dir}/labels.jsonpickle\", \"r\") as labels_file:\n labels = jsonpickle.decode(labels_file.read())","def __init__(self, dims):\n\t\tself.layersNumber = len(dims) - 1\n\t\tself.weights = []\n\t\tself.biases = []\n\t\tnp.random.seed(42)\n\t\tfor d in range(self.layersNumber):\n\t\t\tself.weights.append(np.random.randn(dims[d+1], dims[d]))\n\t\t\tself.biases.append(np.random.randn(dims[d+1], 1))","def init_bias(n_hidden_layer, n_hidden_layer_2, n_output_layer):\n bias_W1, bias_W2, bias_W3 = None, None, None\n\n # Create empty arrays of the desired size given by the number of neurons per layer\n # Arrays are populated with 0's\n if n_hidden_layer > 0:\n bias_W1 = np.zeros((n_hidden_layer,1))\n\n if n_hidden_layer_2 > 0:\n bias_W2=np.zeros((n_hidden_layer_2,1)) \n bias_W3=np.zeros((n_output_layer,1))\n\n else:\n bias_W2 = np.zeros((n_output_layer,1))\n\n else:\n bias_W1 = np.zeros((n_output_layer,1))\n\n return bias_W1, bias_W2, bias_W3","def __init__(self, input_size, neurons):\n super().__init__()\n self.input_size = input_size\n self.neurons = neurons\n self.params[\"w\"] = np.random.randn(input_size, neurons)\n self.params[\"b\"] = np.random.randn(1, neurons)\n self.grads = {}","def __init__(self, layer_dims=(5, 1), learning_rate=0.005, max_iter=500, activate_fn='relu', init_weights_coef=0.01,\n regularization=\"l2\", lambd=0.5, keep_prob=0.9, random_state=None, verbose=True):\n self.layer_dims = layer_dims\n self.learning_rate = learning_rate\n self.max_iter = max_iter\n self.activate_fn = activate_fn\n self.activate_fns = {\n \"sigmoid\": self.__sigmoid,\n \"tanh\": self.__tanh,\n \"relu\": self.__relu,\n \"lrelu\": self.__leaky_relu\n }\n self.derivative_activate_fns = {\n \"sigmoid\": self.__derivative_sigmoid,\n \"tanh\": self.__derivative_tanh,\n \"relu\": self.__derivative_relu,\n \"lrelu\": self.__derivative_leaky_relu\n }\n self.init_weights_coef = init_weights_coef\n self.regularization = regularization\n self.lambd = lambd\n self.keep_prob = keep_prob\n self.random_state = random_state\n self.verbose = verbose\n self.weights = defaultdict()\n\n self.costs = [] # 记录训练过程的损失","def __init__(self, layer_sizes, act_func=Sigmoid, cost_func=CrossEntropy, metric=AccuracyMetric):\n np.random.seed(1) # Used for constant weights and biases initialization. Fell free to change it.\n\n self.layers_num = len(layer_sizes)\n self.act_func = act_func\n self.cost_func = cost_func\n self.metric = metric\n self.biases = [np.random.random(i) for i in layer_sizes[1:]]\n self.weights = [np.random.normal(loc=0, scale=(1 / np.sqrt(layer_sizes[0])), size=(j, i))\n for j, i in zip(layer_sizes[1:], layer_sizes[:-1])]\n self.costs = []\n self.accuracies = []\n self.eta = 0\n self.lambda_r = 0","def __init__(\n self,\n input_size: int,\n hidden_sizes: Sequence[int],\n output_size: int,\n num_layers: int,\n optimizer: Type[Optimizer] = SGD(),\n norm_weights: bool = False\n ):\n self.input_size = input_size\n self.hidden_sizes = hidden_sizes\n self.output_size = output_size\n self.num_layers = num_layers\n self.norm_weights = norm_weights\n\n assert len(hidden_sizes) == (num_layers - 1)\n assert num_layers >= 1\n\n activated_layer_sizes = [input_size] + hidden_sizes\n activated_layers = [LinearLayer(n_in, n_out, activation_func=ReLU) for n_in, n_out in zip(activated_layer_sizes, activated_layer_sizes[1:])]\n final_layer = LinearLayer(activated_layer_sizes[-1], self.output_size, activation_func=Softmax)\n self.layers = activated_layers + [final_layer]\n\n self.optimizer = optimizer","def new_initial_layer(self, nodes, inputs, alpha=0.1):\n weights = [[1 for _ in range(inputs)] for i in range(nodes)]\n alphas = [alpha for _ in range(nodes)]\n self._layers.insert(0, Layer(weights, alphas))","def initialize_weights(self):\n tf.nest.map_structure(\n weights_initializer.WeightsInitializer.initialize_layer_or_model,\n self._layer_nest)","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 __init__(self, hidden_layer_sizes, activation='relu', reg=0.001, k_fold=5, random_state=0):\n print(\"Initialize model Multi-layer Perceptron\")\n self.hidden_layer_sizes = hidden_layer_sizes\n self.activation = activation\n self.reg = reg\n self.k_fold = k_fold\n self.random_state = random_state\n self.model = sklearn.neural_network.MLPClassifier(self.hidden_layer_sizes,\n activation=self.activation,\n alpha=self.reg, max_iter=1000, \n random_state=self.random_state)","def __init__(self, num_learners: int):\n self.num_learners = num_learners\n self.learners = []\n self.learner_weights = np.ones(num_learners)","def _initialize_cnn(image_size, action_size, learning_rate=None):\n\n # All layers are randomly initialized using Glorot initializer\n\n # Create the Inputs of the Neural Network\n image_input = Input(shape=(image_size, image_size, 1))\n scalar_input = Input(shape=(2,))\n\n # Create the first layer of convolution\n conv1 = Conv2D(filters=16,\n kernel_size=5,\n activation=\"relu\")(image_input)\n\n pool1 = MaxPooling2D(pool_size=3)(conv1)\n\n # Create the second layer of convolution\n conv2 = Conv2D(filters=16,\n kernel_size=3,\n activation=\"relu\")(pool1)\n pool2 = MaxPooling2D(pool_size=3)(conv2)\n\n # Create the third layer of convolution\n conv3 = Conv2D(filters=16,\n kernel_size=3,\n activation=\"relu\")(pool2)\n pool3 = MaxPooling2D(pool_size=2)(conv3)\n\n # Flatten the input, so it can be used with dense layers\n flatten = Flatten()(pool3)\n\n # Merge the results of the convolutional layers with the scalar input\n merge = concatenate([flatten, scalar_input])\n\n # Create the dense layers\n # (256 neurons, ReLU)\n dense1 = Dense(256,\n activation=\"relu\",\n kernel_initializer=\"glorot_uniform\")(merge)\n dense2 = Dense(256,\n activation=\"relu\",\n kernel_initializer=\"glorot_uniform\")(dense1)\n\n # Create the output layer (action_size outputs, Lineal)\n # Note that the output MUST be lineal (instead of the typical sigmoid function)\n # for Deep Reinforcement Learning\n output = Dense(action_size,\n activation=\"linear\",\n kernel_initializer=\"glorot_uniform\")(dense2)\n\n # Create and compile the model of the full CNN (Adam optimizer, MSE)\n # Mean Square Error is used (instead of more typical cross-entropy values) due to Deep Reinforcement Learning\n # (since MSE is the value trying to be minimized)\n model = Model(inputs=[image_input, scalar_input],\n outputs=output)\n\n # Note that beta_1 is set to 0.99 to improve the GPU performance while training\n model.compile(optimizer=Adam(beta_1=0.99,\n learning_rate=learning_rate) if learning_rate\n else Adam(beta_1=0.99),\n loss=\"mse\",\n run_eagerly=True)\n\n return model","def __init__(self, input_dimensions=2, number_of_nodes=4, transfer_function=\"Hard_limit\"):\n self.input_dimensions = input_dimensions\n self.number_of_nodes = number_of_nodes\n self.transfer_function = transfer_function\n self.initialize_weights()","def __init__(self, number_hidden_layers=1, n_inputs=0, input_dim=1, output_dim=1, init_fs=None, act_fs=None, dropout=(), dropout_probs=(), batch_norm=()):\n self.number_hidden_layers = number_hidden_layers\n self.input_dim = input_dim\n self.output_dim = output_dim\n self.init_functions = init_fs\n self.act_functions = act_fs\n self.batch_norm = batch_norm\n self.dropout = dropout\n self.dropout_probs = dropout_probs\n self.n_inputs = n_inputs","def make_neural_net_basic():\n i0 = Input('i0', -1.0) # this input is immutable\n i1 = Input('i1', 0.0)\n i2 = Input('i2', 0.0)\n w1A = Weight('w1A', 1)\n w2A = Weight('w2A', 1)\n wA = Weight('wA', 1)\n\n # Inputs must be in the same order as their associated weights\n A = Neuron('A', [i1,i2,i0], [w1A,w2A,wA])\n P = PerformanceElem(A, 0.0)\n\n net = Network(P,[A])\n return net","def build_neuron_network(nb_features_map: Union[Sequence[int], None] = None,\n size_linear_layers: Union[Sequence[int], None] = None,\n dropout_rate: Union[Tuple[float, float], float] = 0.3,\n conv_kernel_size: Union[Sequence[int], int] = 3,\n conv_stride: int = 1,\n conv_padding: int = 1,\n conv_activation: str = \"relu\",\n conv_architecture: str = \"CPD\",\n pool_kernel_size: int = 2,\n pool_stride: int = 2,\n dense_activation: str = \"relu\",\n pretrained: Union[str, None] = None,\n grayscale: bool = True,\n optimizer: str = \"Adam\",\n weight_decay: float = 0.,\n learning_rate: float = 0.001,\n ) -> Tuple[nn.Module, List, torch.optim.Optimizer]:\n # Initializations\n if pretrained is not None:\n grayscale = False\n if grayscale:\n channels = 1\n else:\n channels = 3\n if nb_features_map is None:\n nb_features_map = [8]\n if size_linear_layers is None:\n size_linear_layers = []\n height = 224\n width = 224\n module = nn.Module()\n shapes = [(\"input\", channels, height, width)]\n layers = {\"extractor\": [], \"regressor\": []}\n if not hasattr(dropout_rate, \"__len__\"):\n dropout_rate = (dropout_rate, 0.)\n next_dropout_rate = dropout_rate[0]\n # If a pretrained model is used:\n if pretrained is None:\n # Input checks\n if hasattr(conv_kernel_size, \"__len__\"):\n if len(conv_kernel_size) != len(nb_features_map):\n raise ValueError(\"The length of nb_features_map shall match the length of conv_kernel_size\")\n else:\n conv_kernel_size = [conv_kernel_size] * len(nb_features_map)\n # Feature extractor\n next_layer_type = itertools.cycle(conv_architecture)\n nb_feature_map = None\n i = 0\n while True:\n layer_type = next(next_layer_type)\n if layer_type == \"C\":\n # Convolutional layer\n try:\n nb_feature_map = nb_features_map[i]\n except IndexError:\n break\n name = \"conv2d-{:02d}\".format(i+1)\n conv = nn.Conv2d(shapes[-1][1], nb_feature_map, conv_kernel_size[i], stride=conv_stride,\n padding=conv_padding)\n layers[\"extractor\"].append((name, conv))\n h, w = output_shape_conv_and_pool_layer(rows=shapes[-1][2], columns=shapes[-1][3],\n kernel=conv_kernel_size[i], stride=conv_stride,\n padding=conv_padding)\n shapes.append((name, nb_feature_map, h, w))\n i += 1\n # Activation\n if conv_activation == \"relu\":\n activ = nn.ReLU()\n elif conv_activation == \"elu\":\n activ = nn.ELU(alpha=0.1)\n elif conv_activation == \"leaky\":\n activ = nn.LeakyReLU()\n else:\n activ = nn.ReLU()\n name = \"{}-{:02d}\".format(conv_activation, i)\n layers[\"extractor\"].append((name, activ))\n # activation does not change the size\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\n elif layer_type == \"P\":\n # Max-pooling\n name = \"maxpool2d-{:02d}\".format(i)\n pool = nn.MaxPool2d(pool_kernel_size, pool_stride)\n layers[\"extractor\"].append((name, pool))\n h, w = output_shape_conv_and_pool_layer(rows=shapes[-1][2], columns=shapes[-1][3],\n kernel=pool_kernel_size, stride=pool_stride)\n shapes.append((name, nb_feature_map, h, w))\n elif layer_type == \"D\":\n # Dropout\n if next_dropout_rate > 0.:\n name = \"dropout-{:02d}\".format(i)\n dropout = nn.Dropout(p=next_dropout_rate)\n layers[\"extractor\"].append((name, dropout))\n # Dropout does not change the size\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\n next_dropout_rate += dropout_rate[1]\n elif layer_type == \"B\":\n # Batch normalization\n name = \"batchnorm-{:02d}\".format(i)\n batch = nn.BatchNorm2d(shapes[-1][1])\n layers[\"extractor\"].append((name, batch))\n # Batch norm. does not change the size\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\n # Add a flatten layer\n name = \"flatten\"\n flatten = nn.Flatten(1)\n layers[\"extractor\"].append((name, flatten))\n shapes.append((name, shapes[-1][1] * shapes[-1][2] * shapes[-1][3]))\n # Create extractor module\n extractor = nn.Sequential(OrderedDict(layers[\"extractor\"]))\n module.add_module(\"extractor\", extractor)\n elif pretrained == \"VGG16\":\n pre_trained = models.vgg16(pretrained=True)\n modules = []\n for _name, _module in pre_trained.named_children():\n if _name != 'classifier':\n modules.append((_name, _module))\n modules.append((\"flatten\", nn.Flatten(1)))\n vgg16 = nn.Sequential(OrderedDict(modules))\n # Freeze all parameters in the pre-trained model\n # So we prevent gradients from being calculated, it will save computation time\n for param in vgg16.parameters():\n param.requires_grad = False\n module.add_module('extractor', vgg16)\n shapes.append((pretrained, 25088))\n else:\n raise ValueError(f\"Unknown pre-trained model '{pretrained}'.\")\n # Regressor\n for i, size_linear_layer in enumerate(size_linear_layers):\n # Add a linear layer\n name = \"linear-{:02d}\".format(i + 1)\n linear = nn.Linear(shapes[-1][1], size_linear_layer)\n layers[\"regressor\"].append((name, linear))\n shapes.append((name, size_linear_layer))\n # Activation\n if dense_activation == \"relu\":\n activ = nn.ReLU()\n elif dense_activation == \"elu\":\n activ = nn.ELU(alpha=0.1)\n elif dense_activation == \"leaky\":\n activ = nn.LeakyReLU()\n else:\n activ = nn.ReLU()\n name = \"{}-{:02d}\".format(dense_activation, i + 1)\n layers[\"regressor\"].append((name, activ))\n shapes.append((name, shapes[-1][1])) # activation does not change the size\n # Dropout\n if next_dropout_rate > 0.:\n name = \"dropout-{:02d}\".format(i + 1)\n dropout = nn.Dropout(p=next_dropout_rate)\n layers[\"regressor\"].append((name, dropout))\n shapes.append((name, shapes[-1][1])) # Dropout does not change the size of array\n next_dropout_rate += dropout_rate[1]\n # Add the final layer, the output size is fixed to 68 x 2 = 136\n name = \"output\"\n linear = nn.Linear(shapes[-1][1], 136)\n layers[\"regressor\"].append((name, linear))\n shapes.append((name, 136))\n # Create regressor module\n regressor = nn.Sequential(OrderedDict(layers[\"regressor\"]))\n module.add_module(\"regressor\", regressor)\n # Weight initialization\n module.apply(weight_initialization)\n # Optimizer\n if optimizer == \"Adam\":\n optim = torch.optim.Adam(module.parameters(), lr=learning_rate, weight_decay=weight_decay)\n elif optimizer == \"AdamW\":\n optim = torch.optim.AdamW(module.parameters(), lr=learning_rate, weight_decay=weight_decay)\n elif optimizer == \"SGD\":\n optim = torch.optim.SGD(module.parameters(), lr=learning_rate, weight_decay=weight_decay, momentum=0.9)\n else:\n raise ValueError(f\"Unknown optimizer {optimizer}.\")\n return module, shapes, optim","def _init_layers(self) -> None:\n self.self_attn = MultiheadAttention(**self.self_attn_cfg)\n self.embed_dims = self.self_attn.embed_dims\n self.ffn = FFN(**self.ffn_cfg)\n norms_list = [\n build_norm_layer(self.norm_cfg, self.embed_dims)[1]\n for _ in range(2)\n ]\n self.norms = ModuleList(norms_list)","def __init__(self, layers):\n\n\t\tself.layers = layers","def __init__(self, weights, path, trained, asGraph):\n \n _weights = np.asarray(weights)\n\n numLayers = int(_weights.shape[0]/2)\n wghts = []\n biases = []\n\n for i in range(numLayers):\n j = 2*i\n# print(j,(_weights[j].T).shape)\n wghts.append(_weights[j])\n j = 2*i + 1\n# print(j,(_weights[j].T).shape)\n biases.append(_weights[j])\n #enddo\n\n self.numLayers = numLayers\n self.wghts = np.asarray(wghts)\n self.asGraph = asGraph\n self.wghts = wghts\n self.path = path\n self.trained = trained"],"string":"[\n \"def __init__(self, layerNeurons, initialWeights = None, layerTypes=None, **kwargs):\\r\\n \\r\\n # Ensure that there is at-least one input and one output layer in the network\\r\\n assert len(layerNeurons)>1, \\\"At least one input layer and one output layer is needed\\\"\\r\\n \\r\\n # Get the total number of weights needed in the network\\r\\n totalWeightCount = NeuralNetwork.getSizeOfWeightVector(layerNeurons)\\r\\n \\r\\n # Initialise the weights with the initializer or random values\\r\\n if initialWeights is None:\\r\\n self.weights = np.random.uniform(-1/np.sqrt(layerNeurons[0]), 1/np.sqrt(layerNeurons[0]), totalWeightCount)\\r\\n else:\\r\\n assert len(initialWeights) == totalWeightCount, (\\\"Length of initial weight matrix incorrect. You need \\\"+str(totalWeightCount)+\\\" weights\\\")\\r\\n self.weights = np.array(initialWeights, dtype = np.float64) \\r\\n \\r\\n # create an empty array of layers\\r\\n self.layers = []\\r\\n layerBlockStart = 0\\r\\n \\r\\n if layerTypes is None or len(layerTypes)<(len(layerNeurons)-1):\\r\\n layerTypes=[NetworkLayer]*(len(layerNeurons)-1)\\r\\n \\r\\n for layerInputDimention, layerOutputDimention, layerType in zip(layerNeurons, layerNeurons[1:], layerTypes):\\r\\n # initialise each layer with its input and output dimentions and bi-directional pointers to the relivant weights\\r\\n layerBlockEnd = layerBlockStart+(layerInputDimention*layerOutputDimention)\\r\\n layerBiasEnd = layerBlockEnd+layerOutputDimention\\r\\n newLayer = layerType(layerInputDimention, layerOutputDimention, \\r\\n self.weights[..., layerBlockStart:layerBlockEnd], \\r\\n self.weights[..., layerBlockEnd:layerBiasEnd], **kwargs)\\r\\n self.layers.append(newLayer)\\r\\n \\r\\n layerBlockStart = layerBiasEnd\\r\\n \\r\\n # Tell the output later to use a different function to calculate the delta \\r\\n newLayer.calcDelta = newLayer.calcDeltaOutputLayer\",\n \"def _init_layers(self) -> None:\\n weight_nums, bias_nums = [], []\\n for i in range(self.num_layers):\\n if i == 0:\\n weight_nums.append((self.in_channels + 2) * self.feat_channels)\\n bias_nums.append(self.feat_channels)\\n elif i == self.num_layers - 1:\\n weight_nums.append(self.feat_channels * 1)\\n bias_nums.append(1)\\n else:\\n weight_nums.append(self.feat_channels * self.feat_channels)\\n bias_nums.append(self.feat_channels)\\n\\n self.weight_nums = weight_nums\\n self.bias_nums = bias_nums\\n self.num_params = sum(weight_nums) + sum(bias_nums)\",\n \"def __init__(self, layerNeurons, numberOfLayers, initialWeights = None, lowerBound = None, upperBound = None):\\r\\n \\r\\n # Ensure that there is at-least one input and one output layer in the network\\r\\n assert len(layerNeurons) > 1, \\\"At least one input layer and one output layer is needed\\\"\\r\\n \\r\\n # Get the total number of weights needed in the network\\r\\n totalWeightCount = NeuralNetwork.getSizeOfWeightVector(layerNeurons)*numberOfLayers\\r\\n \\r\\n # Initialise the weights with the initialiser or random values\\r\\n if initialWeights is None:\\r\\n if lowerBound is None:\\r\\n lowerBound=-1/np.sqrt(layerNeurons[0])\\r\\n if upperBound is None:\\r\\n upperBound=1/np.sqrt(layerNeurons[0])\\r\\n self.weights = np.random.uniform(lowerBound, upperBound, totalWeightCount)\\r\\n else:\\r\\n assert initialWeights.size == totalWeightCount, (\\\"Length of initial weight matrix incorrect. You need \\\"+str(totalWeightCount)+\\\" weights\\\")\\r\\n self.weights = initialWeights.view()\\r\\n \\r\\n self.weights.shape = (numberOfLayers, -1)\\r\\n # create an empty array of layers\\r\\n self.layers = []\\r\\n layerBlockStart = 0\\r\\n \\r\\n for layerInputDimention, layerOutputDimention in zip(layerNeurons, layerNeurons[1:]):\\r\\n # initialise each layer with its input and output dimentions and bi-directional pointers to the relivant weights\\r\\n layerBlockEnd = layerBlockStart+(layerInputDimention*layerOutputDimention)\\r\\n layerBiasEnd = layerBlockEnd+layerOutputDimention\\r\\n newLayer = batchNetworkLayer(layerInputDimention, layerOutputDimention, numberOfLayers, \\r\\n self.weights[..., :, layerBlockStart:layerBlockEnd], \\r\\n self.weights[..., :, layerBlockEnd:layerBiasEnd])\\r\\n self.layers.append(newLayer)\\r\\n \\r\\n layerBlockStart = layerBiasEnd\",\n \"def create_network(layers):\\r\\n return NeuronNetwork(layers)\",\n \"def __init__(self, weights, alphas):\\n self._neurons = [Neuron(a, w) for w, a in zip(weights, alphas)]\",\n \"def __init__(self, num_inputs=3, hidden_layers=[3, 3], num_outputs=2):\\n\\n self.num_inputs = num_inputs\\n self.hidden_layers = hidden_layers\\n self.num_outputs = num_outputs\\n\\n # create a generic representation of the layers\\n layers = [num_inputs] + hidden_layers + [num_outputs]\\n\\n # create random connection weights for the layers\\n weights = []\\n for i in range(len(layers) - 1):\\n w = np.random.rand(layers[i], layers[i + 1])\\n weights.append(w)\\n self.weights = weights\\n\\n activations = []\\n\\n for i in range(len(layers)):\\n a = np.zeros(layers[i])\\n activations.append(a)\\n self.activations = activations\\n\\n derivatives = []\\n\\n for i in range(len(layers) - 1):\\n d = np.zeros(layers[i])\\n derivatives.append(d)\\n self.derivatives = derivatives\",\n \"def __init__(self, n_layers, layers_sizes, activation='sigmoid', learning_rate=0.1, weight_init='normal', batch_size=1000, num_epochs=100):\\n self.layers_sizes=layers_sizes[1:]\\n self.activation=activation\\n self.learning_rate=learning_rate\\n self.weight_init=weight_init\\n self.batch_size=batch_size\\n self.num_epochs=num_epochs\\n self.weights={}\\n self.n_layers=len(self.layers_sizes)\\n self.num_samples=0\\n self.training_loss_values=[]\\n self.testing_loss_values=[]\\n self.gg=0.01\\n self.XTEST=None\\n self.YTEST=None\\n self.TTTT=None\\n\\n if activation not in self.acti_fns:\\n raise Exception('Incorrect Activation Function')\\n\\n if weight_init not in self.weight_inits:\\n raise Exception('Incorrect Weight Initialization Function')\\n pass\",\n \"def __init__(self, weights=[], alphas=[]):\\n self._layers = [Layer(w, a) for w, a in zip(weights, alphas)]\",\n \"def __init__(self, N_sym, n_nodes, activations, N_element, bias = True, scaling = None):\\n super(MultiLayerNet, self).__init__()\\n N_layers = len(n_nodes)\\n if N_layers == 0:\\n self.net = torch.nn.Linear(N_sym, N_element, bias = bias)\\n else:\\n layers = []\\n for n in range(N_layers):\\n if n == 0:\\n layers += [torch.nn.Linear(N_sym, n_nodes[n], bias = bias)]\\n layers += [activations[n]]\\n else:\\n layers += [torch.nn.Linear(n_nodes[n-1], n_nodes[n], bias = bias)]\\n layers += [activations[n]]\\n layers += [torch.nn.Linear(n_nodes[-1], N_element, bias = bias)]\\n self.net = torch.nn.Sequential(*layers)\\n \\n self.scaling = scaling\",\n \"def __init__(self, layers=[2, 2, 1], activation_function=\\\"bentidentity\\\"):\\n self.layers = layers\\n self.activation_function = th.activation_functions[activation_function]\\n self.activation_derivative = th.activation_derivatives[\\n activation_function]\\n self.weights = self._generate_weights()\",\n \"def __init__(self, netSize):\\n\\t\\t\\n\\t\\t# TRY THIS FOR RANDOM!\\n\\t\\t#\\n\\t\\t#\\n\\t\\t#\\n\\t\\t\\n\\t\\tself.biases = [self.randomArray(i, 1) for i in netSize[1:]] # Biases do not exist for the first layer ! Those are inputs.\\n\\t\\tself.netSize = netSize\\n\\t\\t#Initialize Weights\\n\\t\\t#This initializes the weights for each layer based on the size. The number of rows should be\\n\\t\\t#the number of neurons for the current, and the number of columns should be the same as the number of neurons\\n\\t\\t#in the next layer. There are no weights for the last layer. That's the output layer.\\n\\t\\tself.weights \\t\\t = [self.randomArray(i, j) for i, j in zip(netSize[:-1], netSize[1:]) ]\",\n \"def __init__(self, nInputs, nOutputs, hiddenLayersDims, outputActivationFunctions = None, outputActivationDerivatives = None, hiddenActivationFunctions = None,\\\\\\n\\t\\t\\t\\t hiddenActivationDerivatives = None): \\n\\n\\t\\tself._nInputs = nInputs\\n\\t\\tself._nOutputs = nOutputs\\n\\n\\t\\tself._nHiddenLayers, self._nUnitsPerLayer = hiddenLayersDims\\n\\n\\t\\tself._outputActivationFunctions = outputActivationFunctions\\n\\t\\tself._outputActivationDerivatives = outputActivationDerivatives\\n\\n\\t\\tself._hiddenActivationFunctions = hiddenActivationFunctions\\n\\t\\tself._hiddenActivationDerivatives = hiddenActivationDerivatives\\n\\n\\t\\tself.initialiseActivationFunctions()\\n\\n\\t\\tself.initialiseNetwork()\\n\\n\\t\\tself._nBranches = len(self.collectAllBranches())\",\n \"def __init__(self, hidden_layers, input_size=784,\\n num_classes=10, learning_rate=0.1):\\n hidden_layers = [input_size] + hidden_layers + [num_classes]\\n self.layers = []\\n self.Layer = collections.namedtuple('Layer', ['weights', 'biases'])\\n for i in range(len(hidden_layers) - 1):\\n layer = self.Layer(np.random.randn(hidden_layers[i],\\n hidden_layers[i + 1]).astype('float32'),\\n np.random.randn(hidden_layers[i + 1]).astype('float32'))\\n self.layers.append(layer)\\n\\n # normalization for stable training\\n\\n self.learning_rate = learning_rate\",\n \"def __init__(self, layer_neuron):\\n\\n self.num_layers = len(layer_neuron)\\n self.layer_neuron = layer_neuron\\n #a list of numpy ndarrays\\n self.weights = []\\n self.input_len = 0\\n self.target_vals = []\\n self.current_guess = 0\\n\\n self.layer_inputs = [[]]*(len(layer_neuron))\\n self.layer_outputs = [[]]*(len(layer_neuron))\\n #deltas: don't include input layer but still put it in for spacing ie self.deltas[0] should always be empty\\n self.deltas = [[]]*((len(layer_neuron)))\\n\\n #make the weight matrices, each matrix nXm matrix with m = # nodes in the ith layer (incl bias) and n = # nodes in the (i+1)th layer\\n #each row represents the set of weights from all m neurons in the ith layer to a single neuron in the (i+1)th layer\\n #conversely, each column is all the output weights from a node in the ith layer, to each n nodes in the (i+1)th layer\\n #the right-most column represents output weights from the bias node\\n for i in range(len(self.layer_neuron)-1 ):\\n np.random.seed(0)\\n self.weights.append(np.random.normal( scale = 0.2, size = (self.layer_neuron[i+1], self.layer_neuron[i] + 1)))\",\n \"def initialize_weights(self, weights_initializer, bias_initializer):\\n wshapes = [\\n [self.input_size, self.hidden_size[0]],\\n [self.hidden_size[0], self.hidden_size[1]],\\n [self.hidden_size[1], self.output_size]\\n ]\\n\\n bshapes = [\\n [1, self.hidden_size[0]],\\n [1, self.hidden_size[1]],\\n [1, self.output_size]\\n ]\\n\\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\\n\\n self.trainable_variables = self.weights + self.biases\",\n \"def __init__(self, layers, r_min, r_max, learn_rate):\\n\\n if not isinstance(layers, list) or len(layers) < 3:\\n raise ValueError('invalid layer parammeter')\\n self.layers = layers\\n n_layer = len(layers)\\n self.n_layer = n_layer\\n self.r_min = r_min\\n self.r_max = r_max\\n self.learn_rate = learn_rate\\n\\n # initialize ws\\n self.ws = []\\n for layer_idx in range(n_layer - 1):\\n layer_size = (layers[layer_idx] + 1, layers[layer_idx + 1])\\n w = self.init_w(layer_size)\\n self.ws.append(w)\",\n \"def initialize_weights(self):\\n for layer in self._cnn_layers:\\n weights_initializer.WeightsInitializer.initialize_layer_or_model(layer)\",\n \"def connect_layers(self):\\n if not self.check():\\n msg = \\\"Failed to check neural network.\\\"\\n print(msg)\\n logging.error(msg)\\n return\\n\\n # 1. set input layer\\n pre_layer = self.input_layer\\n for layer in self.hidden_layers:\\n layer.set_input_layer(pre_layer)\\n pre_layer = layer\\n self.output_layer.set_input_layer(pre_layer)\\n\\n # 2. set output layer\\n next_layer = self.output_layer\\n for layer in reversed(self.hidden_layers):\\n layer.set_next_layer(next_layer)\\n next_layer = layer\\n self.input_layer.set_next_layer(next_layer)\\n\\n # 3. call layer init\\n self.input_layer.init()\\n for layer in self.hidden_layers:\\n layer.init()\\n self.output_layer.init()\\n\\n return\",\n \"def __init__(self):\\r\\n # A dummy layer does nothing\\r\\n self.weights = np.zeros(shape=(input.shape[1], 10))\\r\\n bias = np.zeros(shape=(10,))\\r\\n pass\",\n \"def init_three_layer_neuralnet(weight_scale=1, bias_scale=0, input_feat_dim=786,\\n num_classes=10, num_neurons=(20, 30)):\\n \\n assert len(num_neurons) == 2, 'You must provide number of neurons for two layers...'\\n\\n model = {}\\n #model['W1'] = np.random.randn((num_neurons[0],(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)) # Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\\n \\n model['W1'] = (np.random.rand(input_feat_dim,num_neurons[0])*weight_scale) * math.sqrt(2.0/input_feat_dim)\\n model['b1'] = np.zeros(num_neurons[0])# Initialize with zeros\\n \\n #model['W2'] = (np.random.randn(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)# Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\\n #print ((model['W1'])[0,:]).shape\\n #numcols = len(input[0])\\n t=len((model['W1'])[0])\\n #print t\\n model['W2'] = (np.random.rand(num_neurons[0],num_neurons[1])*weight_scale) * math.sqrt(2.0/t)\\n model['b2'] = np.zeros(num_neurons[1])# Initialize with zeros\\n\\n t=len((model['W2'])[0])\\n #model['W3'] = (np.random.randn(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)# Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\\n model['W3'] = (np.random.rand(num_neurons[1],num_classes)*weight_scale) * math.sqrt(2.0/t)\\n model['b3'] = np.zeros(num_classes)# Initialize with zeros\\n\\n return model\",\n \"def initialize_network(self, model, num_init=None, **net_args):\\n\\n self.net_args = net_args\\n\\n if num_init is None:\\n self.num_init = 1\\n else:\\n self.num_init = num_init\\n\\n nets = []\\n for i in range(self.num_init):\\n nets.append( model(dim_inp=self.dim_inp, \\n dim_out=self.dim_out, **net_args) )\\n\\n return nets\",\n \"def init_weights(self, load_weights=None):\\n if load_weights:\\n # TODO\\n pass\\n else:\\n # x: lower layer nodes n\\n # y: current layer nodes n\\n x = self.weights_shape[1]\\n y = self.weights_shape[0]\\n self.weights = np.random.randn(y, x) / np.sqrt(x) # pylint: disable=no-member\\n self.biases = np.random.randn(y, 1) # pylint: disable=no-member\",\n \"def create_base_network(NumberOfFeatures, NumberOfClasses,init_mode='glorot_normal'):\\n network = Sequential()\\n network.add(Dense(44, activation='sigmoid', kernel_initializer=init_mode,input_dim=NumberOfFeatures))\\n# network.add(Dense(22, activation='sigmoid',kernel_initializer=init_mode))\\n network.add(Dense(NumberOfClasses, activation='softmax',kernel_initializer=init_mode))\\n return network\",\n \"def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):\\n # set number of nodes in each input, hidden, output layer\\n self.inodes = inputnodes\\n self.hnodes = hiddennodes\\n self.onodes = outputnodes\\n\\n #learning rate\\n self.lr = learningrate\",\n \"def neural_net(self, layers):\\n model = nn.Sequential()\\n for l in range(0, len(layers) - 1):\\n model.add_module(\\\"layer_\\\"+str(l), nn.Linear(layers[l],layers[l+1], bias=True))\\n if l != len(layers) - 2:\\n model.add_module(\\\"tanh_\\\"+str(l), nn.Tanh())\\n\\n return model\",\n \"def __init__(self, n_classes, num_nodes=None, dropouts=None, activation=\\\"relu\\\"):\\n # parameters initialization\\n self.n_classes = n_classes\\n if self.n_classes == 1:\\n self.output_act = \\\"sigmoid\\\"\\n else:\\n self.output_act = \\\"softmax\\\"\\n self.num_nodes = num_nodes if num_nodes != None else [1024, 512]\\n self.dropouts = dropouts if dropouts != None else [0.5, 0.5]\\n self.activation = activation\\n\\n # Check if number of layers and number of dropouts have same dimension\\n if not len(self.num_nodes) == len(self.dropouts):\\n raise AssertionError()\",\n \"def init_layer(layer):\\n \\n if layer.weight.ndimension() == 4:\\n (n_out, n_in, height, width) = layer.weight.size()\\n n = n_in * height * width\\n \\n elif layer.weight.ndimension() == 2:\\n (n_out, n) = layer.weight.size()\\n\\n std = math.sqrt(2. / n)\\n scale = std * math.sqrt(3.)\\n layer.weight.data.uniform_(-scale, scale)\\n\\n if layer.bias is not None:\\n layer.bias.data.fill_(0.)\",\n \"def build_cnn(input_var=None, w_init=None, n_layers=(4, 2, 1), n_filters_first=32, imsize=32, n_colors=3):\\n weights = [] # Keeps the weights for all layers\\n count = 0\\n # If no initial weight is given, initialize with GlorotUniform\\n if w_init is None:\\n w_init = [lasagne.init.GlorotUniform()] * sum(n_layers)\\n # Input layer\\n network = InputLayer(shape=(None, n_colors, imsize, imsize),\\n input_var=input_var)\\n for i, s in enumerate(n_layers):\\n for l in range(s):\\n network = Conv2DLayer(network, num_filters=n_filters_first * (2 ** i), filter_size=(3, 3),\\n W=w_init[count], pad='same')\\n count += 1\\n weights.append(network.W)\\n network = MaxPool2DLayer(network, pool_size=(2, 2))\\n return network, weights\",\n \"def __init__(self, sizes: list):\\n self.num_layers = len(sizes)\\n self.sizes = sizes\\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\\n self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]\",\n \"def __init__(self, input_nodes, hidden_nodes, hidden_layers, output_nodes):\\n # Class members:\\n # num_input_nodes\\n # num_hidden_nodes\\n # num_hidden_layers\\n # num_output_nodes\\n # weights = [[num_hidden_nodes, num_input_nodes],[num_hidden_nodes, num_hidden_nodes],[]<- for each hl,\\n # [num_output_nodes, num_hidden_nodes]]\\n # biases\\n\\n self.num_input_nodes = input_nodes\\n self.num_hidden_nodes = hidden_nodes\\n self.num_hidden_layers = hidden_layers\\n self.num_output_nodes = output_nodes\\n\\n self.weights = []\\n for i in range(self.num_hidden_layers + 1):\\n if i is 0:\\n # first weights array is input to hidden\\n self.weights.append(.5 * np.random.rand(self.num_hidden_nodes, self.num_input_nodes) - .25)\\n\\n elif i < self.num_hidden_layers:\\n # next weight array is hidden nodes to hidden nodes\\n self.weights.append(.5 * np.random.rand(self.num_hidden_nodes, self.num_hidden_nodes) - .25)\\n else:\\n # last weight array is hidden nodes to output nodes\\n self.weights.append(.5 * np.random.rand(self.num_output_nodes, self.num_hidden_nodes) - .25)\\n\\n self.biases = []\\n for i in range(self.num_hidden_layers + 1):\\n if i < self.num_hidden_layers:\\n # for every hidden node there is a bias\\n self.biases.append(0.5 * np.random.rand(self.num_hidden_nodes) - .25)\\n else:\\n # for the output node there is a bias as well\\n self.biases.append(0.5 * np.random.rand(self.num_output_nodes) - .25)\\n\\n self.activation = np.vectorize(self.tanh, otypes=[float])\",\n \"def __initialize_weights__(num_neurons: int) -> np.ndarray:\\n\\n weights = np.zeros((num_neurons, num_neurons))\\n\\n return weights\",\n \"def __init__(self, layer_size, activation_function=linear,\\n derivative_function=dlinear,\\n forward_function=propagate_forward,\\n backward_function=propagate_backward_irpropm,\\n init_weights_function=fully_connected_weights, bias=True):\\n self.forward_propagation = forward_function\\n self.back_propagation = backward_function\\n self.activation_function = activation_function\\n self.derivative_function = derivative_function\\n self.bias = bias\\n\\n # the activations of these nodes\\n bias_add = 0\\n if self.bias:\\n bias_add = 1\\n self.visible = numpy.ones(layer_size + bias_add)\\n self.init_weights_function = init_weights_function\",\n \"def __init__(self, n_input, n_output, hidden_layer_size, reg):\\n self.reg = reg\\n self.input_layer = FullyConnectedLayer(n_input, hidden_layer_size)\\n self.relu = ReLULayer()\\n self.output_layer = FullyConnectedLayer(hidden_layer_size, n_output)\\n self.W_in = None\\n self.W_out = None\\n self.B_in = None\\n self.B_out = None\\n # TODO Create necessary layers\",\n \"def test_init_net_simple(self):\\n net = ecn.NeuralNet(2, (2,), 1)\\n self.assertEqual(2, len(net.weights.keys()))\\n self.assertEqual((2, 3), np.shape(net.weights['h0']))\\n self.assertEqual((1, 3), np.shape(net.weights['y']))\\n print('Finished testing simple neural net init\\\\n')\",\n \"def init_weights(net, init_gain=0.02):\\n def init_func(m): # define the initialization function\\n classname = m.__class__.__name__\\n if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1):\\n init.normal_(m.weight.data, 0.0, init_gain)\\n if hasattr(m, 'bias') and m.bias is not None:\\n init.constant_(m.bias.data, 0.0)\\n\\n print('initialize network')\\n net.apply(init_func) # apply the initialization function <init_func>\",\n \"def __init__(self, nx, nodes):\\n if type(nx) is not int:\\n raise TypeError(\\\"nx must be an integer\\\")\\n if nx < 1:\\n raise ValueError(\\\"nx must be a positive integer\\\")\\n if type(nodes) is not int:\\n raise TypeError(\\\"nodes must be an integer\\\")\\n if nodes < 1:\\n raise ValueError(\\\"nodes must be a positive integer\\\")\\n # weights vector for the hidden layer\\n # default mean is 0\\n # default stddev is 1\\n self.__W1 = np.random.normal(size=(nodes, nx))\\n # The bias for the hidden layer. Upon instantiation,\\n # it should be initialized with 0’s.\\n self.__b1 = np.zeros((nodes, 1))\\n # The activated output for the hidden layer. Upon instantiation,\\n # it should be initialized to 0\\n self.__A1 = 0\\n # weights vector for the output neuron\\n # default mean is 0\\n # default stddev is 1\\n self.__W2 = np.random.normal(size=(1, nodes))\\n # bias for the output neuron\\n self.__b2 = 0\\n # activated output for the output neuron (prediction)\\n self.__A2 = 0\",\n \"def init_learner(self,**kwargs):\\r\\n \\r\\n if self.learn_type == 'nn':\\r\\n #initialize neural network\\r\\n shape = kwargs[\\\"shape\\\"]\\r\\n #initialize input layer\\r\\n model = Sequential() \\r\\n #add hidden layers\\r\\n for i in range(len(shape)):\\r\\n if i == 0:\\r\\n nb_input = self.size\\r\\n else:\\r\\n nb_input = shape[i -1]\\r\\n nb_output = shape[i]\\r\\n model.add(Dense(nb_input,nb_output,init=\\\"he_normal\\\",\\r\\n activation = \\\"tanh\\\"))\\r\\n model.add(Dropout(.5))\\r\\n model.add(Dense(shape[-1],1,init = \\\"he_normal\\\",\\r\\n activation = \\\"linear\\\"))\\r\\n model.compile(loss = 'mean_squared_error',optimizer = 'rmsprop')\\r\\n self.learner = model\\r\\n \\r\\n elif self.learn_type == 'linear':\\r\\n #initialize parameter\\r\\n self.learner = Linear(self.size,**kwargs)\",\n \"def construct_network(self, n_units, n_samples=1, noise_dim=0,\\n keep_p=1., nonlinearity=True, init_params=None, name=\\\"\\\"):\\n print \\\"constructing network, n_units: \\\",n_units\\n # TODO use kwargs for more elagant solutions to being called by this \\n # base class\\n assert keep_p ==1. and nonlinearity and noise_dim == 0\\n\\n assert init_params is None # this is implemented only in the Bayesian flow version of this function\\n\\n ### Define parameters of the network\\n self.weights, self.biases, KL = {}, {}, 0.\\n self.layers = []\\n # Establish paramters of appromiate posterior over weights and\\n # biases.\\n for l in range(1, len(n_units)):\\n with tf.variable_scope(name+'Layer_%d'%l):\\n n_in, n_out = n_units[l-1], n_units[l]\\n\\n # use non neglidgible uncertainty if we are doing VI\\n sigma_init = self.init_sigma_params\\n\\n w_prior_sigma, b_prior_sigma = self.w_prior_sigma, self.w_prior_sigma\\n mu_init_sigma_w, mu_init_sigma_b = np.sqrt(1./(n_in)), 1.\\n\\n (w_mu, w_logstd), _, w_KL = utils.set_q(name+\\\"w_%d\\\"%l,\\n sigma_prior=w_prior_sigma, mu_init_sigma=mu_init_sigma_w,\\n sigma_init=sigma_init, n_samples=0,\\n size=[n_in, n_out], save_summary=True)\\n\\n # We use same init_sigma for weights and biases.\\n (b_mu, b_logstd), _, b_KL = utils.set_q(name+\\\"b_%d\\\"%l,\\n sigma_prior=b_prior_sigma, mu_init_sigma=mu_init_sigma_b,\\n sigma_init=sigma_init, n_samples=0,\\n size=[n_out], save_summary=True)\\n self.weights['w_%d_mu'%l], self.weights['w_%d_std'%l] = w_mu, tf.nn.softplus(w_logstd)\\n self.biases['b_%d_mu'%l], self.biases['b_%d_std'%l] = b_mu, tf.nn.softplus(b_logstd)\\n\\n self.params += [w_mu, b_mu, w_logstd, b_logstd]\\n KL += w_KL + b_KL\\n\\n # Add an extra dimension to correspond to samples.\\n prev_layer = tf.stack([self.x]*n_samples)\\n self.layers.append(prev_layer)\\n # shape is [n_samples, ?, dim(x)]\\n\\n ### Define activations in each layer\\n for l in range(1,len(n_units)):\\n print \\\"defining activations in layer %d\\\"%l\\n # Multiply with weight matrix and add bias\\n prev_layer = tf.reshape(prev_layer, [-1, n_units[l-1]])\\n layer_pre_bias = tf.matmul(prev_layer, self.weights['w_%d_mu'%l])\\n layer_pre_bias = tf.reshape(layer_pre_bias, [n_samples, -1, n_units[l]])\\n # Shape of layer_pre_bias is [n_samples, ?, n_units[l]]\\n\\n # add mean bias term\\n layer = tf.add(layer_pre_bias, self.biases['b_%d_mu'%l][None, None, :])\\n\\n # Calculate the noise in each hidden unit.\\n # must use absolute value of activation because final layer may\\n # have negative values.\\n layer_var = tf.matmul(tf.reshape(prev_layer**2,[-1,\\n n_units[l-1]]), self.weights['w_%d_std'%l]**2)\\n layer_var = tf.reshape(layer_var, [n_samples, -1, n_units[l]])\\n layer_var += self.biases['b_%d_std'%l]**2\\n\\n # Now sample noise and add scaled noise.\\n # This constitutes the local reparameterization trick.\\n eps = tf.random_normal(name='eps_%d'%l, mean=0.,\\n stddev=1.0, shape=[n_samples, 1, n_units[l]])\\n layer_sigma = tf.sqrt(layer_var)\\n layer += layer_sigma*eps\\n with tf.name_scope(name+\\\"Neural_Network_Activations_%d\\\"%l):\\n tf.summary.histogram(name+\\\"Layer_%d_sigmas\\\"%l, layer_sigma)\\n tf.summary.histogram(name+\\\"Layer_%d_activations_pre_tanh\\\"%l, layer)\\n\\n # Add tanh nonlinearity\\n if l != (len(n_units) - 1): layer = tf.nn.tanh(layer)\\n\\n with tf.name_scope(name+\\\"Neural_Network_Activations_%d\\\"%l):\\n tf.summary.histogram(name+\\\"Layer_%d_activations_post_tanh\\\"%l,layer)\\n\\n prev_layer = layer\\n self.layers.append(prev_layer)\\n self.KL_BNN = KL\\n return prev_layer\",\n \"def __init__(self, sizes):\\n self.num_layers = len(sizes)\\n self.sizes = sizes\\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\\n self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]\",\n \"def __init__(self, sizes):\\r\\n self.num_layers = len(sizes)\\r\\n self.sizes = sizes\\r\\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\\r\\n self.weights = [np.random.randn(y, x)\\r\\n for x, y in zip(sizes[:-1], sizes[1:])]\",\n \"def __init__(self, num_units=512, num_layers=4):\\n\\n self.num_units = num_units\\n self.num_layers = num_layers\\n \\n self.layers = []\\n for idx in range(self.num_layers):\\n lstm_layer = tf.contrib.cudnn_rnn.CudnnLSTM(num_units=self.num_units,\\n direction='unidirectional',\\n num_layers=1)\\n self.layers.append(lstm_layer)\",\n \"def init(self,topology,learningRate=0.01,momentum=0.1,name='Network',add_bias=True):\\n self.topology = topology\\n self.learningRate = learningRate\\n self.momentum = momentum\\n self.name = name\\n self.size = len(self.topology)-1 #The size of the network will be the number of weeight matrices between layers, instead of the number of layers itself\\n #self._hiddenActiv_fun_key = 'tanh'\\n #self._outActiv_fun_key = 'tanh'\\n #self.output_activation = self.set_outActivation_fun(func=self._outActiv_fun_key)\\n #self.hidden_activation = self.set_hiddenactivation_fun(func=self._hiddenActiv_fun_key)\\n\\n # Initialize random weights, and create empty matrices to store the previous changes in weight (for momentum):\\n if add_bias:\\n #self.weights = [np.random.normal(loc=0,scale=0.6,size=(topology[i]+1, topology[i+1])) for i in range(self.size)]\\n self.weights = [np.random.normal(loc=0,\\n scale=0.6,\\n size=(topology[i]+1, topology[i+1]+1)) for i in range(self.size-1)] #we are only generating matrices for inital and hidden layers\\n #Create matrix for output layer\\n f_idx = self.size-1 #use this index for the final layer matrix below\\n self.weights.append(np.random.normal(loc=0,\\n scale=0.6,\\n size=(topology[f_idx]+1,topology[f_idx+1])))\\n else:\\n raise NotImplemented(\\\"Currently the network only works when bias nodes are used\\\")\\n self.weights = [np.random.normal(loc=0,scale=0.6,size=(topology[i], topology[i])) for i in range(self.size)]\\n\\n self.Gradients = [None] * self.size\",\n \"def __init__(self, input_size, hidden_size, num_layers, nonlinearity=torch.tanh):\\n super().__init__()\\n self.input_size = input_size\\n self.hidden_size = hidden_size\\n\\n # input weights\\n self.weight_ih_l0 = Parameter(torch.Tensor(3*hidden_size, input_size))\\n\\n # hidden weights\\n self.weight_hh_l0 = Parameter(torch.Tensor(3*hidden_size, hidden_size))\\n\\n # bias\\n self.bias_ih_l0 = Parameter(torch.Tensor(3*hidden_size)) # input\\n self.bias_hh_l0 = Parameter(torch.Tensor(3*hidden_size)) # hidden\\n\\n self.f = nonlinearity\\n\\n self.init_weights()\",\n \"def __init__(self, *args, **kwargs):\\n self.params = kwargs\\n self.output_len = kwargs['num_neurons']\\n self.input_len = kwargs['input_len']\\n self.weights = Vector(data=np.random.randn(self.output_len, self.input_len))\\n self.biases = Vector(data=np.zeros((self.output_len, 1)))\\n self.input_activations = None\\n self.output_activations = Vector()\",\n \"def initialize(self, input_size, n_classes):\\n\\n self.n_classes = n_classes\\n self.input_size = input_size\\n\\n n_hidden_layers = len(self.sizes)\\n #############################################################################\\n # Allocate space for the hidden and output layers, as well as the gradients #\\n #############################################################################\\n self.hs = []\\n self.grad_hs = []\\n for h in range(n_hidden_layers):\\n self.hs += [np.zeros((self.sizes[h],))] # hidden layer\\n self.grad_hs += [np.zeros((self.sizes[h],))] # ... and gradient\\n self.hs += [np.zeros((self.n_classes,))] # output layer\\n self.grad_hs += [np.zeros((self.n_classes,))] # ... and gradient\\n\\n ##################################################################\\n # Allocate space for the neural network parameters and gradients #\\n ##################################################################\\n self.weights = [np.zeros((self.input_size, self.sizes[0]))] # input.csv to 1st hidden layer weights\\n self.grad_weights = [np.zeros((self.input_size, self.sizes[0]))] # ... and gradient\\n\\n self.biases = [np.zeros((self.sizes[0]))] # 1st hidden layer biases\\n self.grad_biases = [np.zeros((self.sizes[0]))] # ... and gradient\\n\\n for h in range(1, n_hidden_layers):\\n self.weights += [np.zeros((self.sizes[h - 1], self.sizes[h]))] # h-1 to h hidden layer weights\\n self.grad_weights += [np.zeros((self.sizes[h - 1], self.sizes[h]))] # ... and gradient\\n\\n self.biases += [np.zeros((self.sizes[h]))] # hth hidden layer biases\\n self.grad_biases += [np.zeros((self.sizes[h]))] # ... and gradient\\n\\n self.weights += [np.zeros((self.sizes[-1], self.n_classes))] # last hidden to output layer weights\\n self.grad_weights += [np.zeros((self.sizes[-1], self.n_classes))] # ... and gradient\\n\\n self.biases += [np.zeros((self.n_classes))] # output layer biases\\n self.grad_biases += [np.zeros((self.n_classes))] # ... and gradient\\n\\n #########################\\n # Initialize parameters #\\n #########################\\n\\n self.rng = np.random.mtrand.RandomState(self.seed) # create random number generator\\n # biases are initialized to zero\\n # ... and weights according to the slides\\n for m in range(len(self.weights)):\\n b = (6 ** 0.5) / ((self.weights[m].shape[0] + self.weights[m].shape[1]) ** 0.5)\\n for ind, val in np.ndenumerate(self.weights[m]):\\n self.weights[m][ind] = self.rng.uniform(-b, b, 1)\\n\\n\\n self.n_updates = 0 # To keep track of the number of updates, to decrease the learning rate\",\n \"def __init__(self, sizes):\\n self.num_layers = len(sizes)\\n self.sizes = sizes\\n self.biases = [cp.array(cp.random.randn(y, 1)) for y in sizes[1:]]\\n self.weights = [cp.array(cp.random.randn(y, x))\\n for x, y in zip(sizes[:-1], sizes[1:])]\",\n \"def __init__(self, sizes):\\r\\n self.num_layers = len(sizes)\\r\\n self.sizes = sizes\\r\\n\\r\\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\\r\\n self.weights = [np.random.randn(y, x)\\r\\n for x, y in zip(sizes[:-1], sizes[1:])]\",\n \"def init_weight(self):\\n init_layer(self.conv1)\\n init_layer(self.conv2)\\n init_bn(self.norm1)\\n init_bn(self.norm2)\",\n \"def initialize_network(self):\\n # intermediate layer size\\n ils = int((self.specbinnum + self.numfilters) / 2)\\n\\n network = lasagne.layers.InputLayer((None, 1, self.specbinnum, self.numtimebins), self.input_var)\\n\\n network = NormalisationLayer(network, self.specbinnum)\\n self.normlayer = network\\n\\n network, _ = custom_convlayer_2(network, in_num_chans=self.specbinnum, out_num_chans=ils)\\n network = batch_norm(network)\\n network, _ = custom_convlayer_2(network, in_num_chans=ils, out_num_chans=self.numfilters)\\n network = batch_norm(network)\\n\\n network = lasagne.layers.NonlinearityLayer(network, nonlinearity=elu)\\n self.latents = network\\n network = ZeroOutBackgroundLatentsLayer(self.latents,\\n mp_down_factor=self.mp_down_factor,\\n numfilters=self.numfilters,\\n numtimebins=self.numtimebins,\\n background_latents_factor=self.background_latents_factor,\\n use_maxpool=self.use_maxpool)\\n network, _ = custom_convlayer_2(network, in_num_chans=self.numfilters, out_num_chans=ils)\\n network = batch_norm(network)\\n network, _ = custom_convlayer_2(network, in_num_chans=ils, out_num_chans=self.specbinnum)\\n network = batch_norm(network)\\n\\n # output_size\\n num_time_samples = int(audioframe_len/2 * (self.numtimebins + 1))\\n # network = batch_norm(DenseLayer(network, num_time_samples)) # MemoryError\\n network, _ = custom_convlayer_2(network, in_num_chans=self.specbinnum, out_num_chans=num_time_samples)\\n network, _ = batch_norm(network)\\n network, _ = custom_convlayer_2(network, in_num_chans=num_time_samples, out_num_chans=1)\\n network, _ = batch_norm(network)\\n\\n self.network = network\",\n \"def __init__(self,layers,activations):\\n model = utils.buildMLP(layers, activations)\\n super().__init__(torch.nn.Sequential(model), nnType='dnn')\",\n \"def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):\\n \\n super().__init__(inputnodes, hiddennodes, outputnodes, learningrate)\\n\\n # link weight matrices, wih and who\\n # weights inside the arrays are w_i_j, where link is from node i to node i to j in the next layer\\n # w11 w21\\n # w12 w22 etc\\n self.wih = numpy.random.normal(\\n 0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))\\n self.who = numpy.random.normal(\\n 0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))\\n\\n #activation function is the sigmoid function\\n self.activation_function = lambda x: scipy.special.expit(x)\\n\\n pass\",\n \"def _generate_network_initialization(self, graph, memory_manager):\\n\\n # TODO: To be changed if we want to support multiple outputs\\n output_buffer_name = graph.outputs[0].name\\n\\n ops_to_ignore = ['Reshape', 'Mul']\\n\\n buffers_allocated = []\\n\\n buffer_declaration = \\\"\\\"\\n buffer_declaration += \\\" pico_cnn::naive::Tensor **kernels;\\\\n\\\"\\n buffer_declaration += \\\" pico_cnn::naive::Tensor **biases;\\\\n\\\"\\n\\n constructor_code = \\\"\\\"\\n #constructor_code += \\\"Network::Network() {\\\\n\\\\n\\\"\\n\\n num_layers = 0\\n num_kernels = 0\\n num_biases = 0\\n\\n for node in graph.nodes:\\n \\\"\\\"\\\"Do not count the reshape layers as the input tensor will only define the dimensions\\\"\\\"\\\"\\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\\n num_layers += 1\\n for num, input in enumerate(node.input_tensors):\\n if input in buffers_allocated:\\n continue\\n else:\\n tensor = node.input_tensors[input]\\n buffers_allocated.append(input)\\n if len(tensor.shape) == 1:\\n num_biases += 1\\n else:\\n num_kernels += 1\\n\\n \\\"\\\"\\\"The arrays kernels and biases will be used to pass only two variables to read_binary_weights\\\"\\\"\\\"\\n constructor_code += \\\" kernels = new pico_cnn::naive::Tensor*[{}]();\\\\n\\\".format(num_kernels)\\n constructor_code += \\\" biases = new pico_cnn::naive::Tensor*[{}]();\\\\n\\\\n\\\".format(num_biases)\\n\\n pos = -1\\n pos_kernel = -1\\n pos_bias = -1\\n\\n buffers_allocated.clear()\\n\\n \\\"\\\"\\\"Iterate over all nodes in the graph and generate the corresponding allocation code.\\\"\\\"\\\"\\n for node_id, node in enumerate(graph.nodes):\\n\\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\\n pos += 1\\n\\n buffer_declaration += \\\" // Layer: \\\" + node.name + \\\", Operation: \\\" + node.op_type + \\\"\\\\n\\\"\\n constructor_code += \\\" // Layer: \\\" + node.name + \\\", Operation: \\\" + node.op_type + \\\"\\\\n\\\"\\n\\n # Allocate memory for kernels and biases\\n buffer_declaration += \\\" // Inputs\\\\n\\\"\\n constructor_code += \\\" // Inputs\\\\n\\\"\\n for num, input in enumerate(node.input_tensors):\\n\\n if node.op_type in ops_to_ignore:\\n continue\\n\\n if input in buffers_allocated:\\n continue\\n else:\\n buffers_allocated.append(input)\\n\\n tensor = node.input_tensors[input]\\n if len(tensor.shape) == 1:\\n pos_bias += 1\\n else:\\n pos_kernel += 1\\n\\n buffer = memory_manager.get_buffer(graph, input)\\n\\n buffer_declaration += \\\" // \\\" + str(buffer.shape) + \\\"\\\\n\\\"\\n\\n pico_cnn_tensor = \\\" pico_cnn::naive::Tensor *\\\"\\n\\n buffer_declaration += pico_cnn_tensor + buffer.name + \\\";\\\\n\\\"\\n\\n constructor_code += \\\" // \\\" + str(buffer.shape) + \\\"\\\" # TODO maybe we sometimes need \\\\n\\n\\n functionality = CodeRegistry.get_funct(\\\"KernelAllocation\\\")\\n impl = functionality[0].create(buffer, pos, pos_kernel, pos_bias)\\n\\n if impl:\\n constructor_code += impl.generate_code()\\n constructor_code += \\\"\\\\n\\\"\\n\\n buffer_declaration += \\\" // Outputs\\\\n\\\"\\n constructor_code += \\\" // Outputs\\\\n\\\"\\n for num, output in enumerate(node.outputs):\\n\\n buffer = memory_manager.get_buffer(graph, output)\\n\\n if output == output_buffer_name:\\n buffer_declaration += \\\" // Output tensor {} with shape {} of network provided as argument of Network::run()\\\".format(buffer.name, str(buffer.shape))\\n constructor_code += \\\" // Output tensor {} with shape {} of network provided as argument of Network::run()\\\".format(buffer.name, str(buffer.shape))\\n continue\\n\\n buffer_declaration += \\\" // \\\" + str(buffer.shape) + \\\"\\\\n\\\"\\n\\n pico_cnn_tensor = \\\" pico_cnn::naive::Tensor *\\\"\\n\\n buffer_declaration += pico_cnn_tensor + buffer.name + \\\";\\\\n\\\"\\n\\n constructor_code += \\\" // \\\" + str(buffer.shape) + \\\"\\\" # TODO maybe we sometimes need \\\\n\\n\\n functionality = CodeRegistry.get_funct(\\\"OutputAllocation\\\")\\n impl = functionality[0].create(buffer)\\n\\n if impl:\\n constructor_code += impl.generate_code()\\n constructor_code += \\\"\\\\n\\\"\\n\\n buffer_declaration += \\\"\\\\n\\\\n\\\"\\n constructor_code += \\\"\\\\n\\\\n\\\"\\n\\n #constructor_code += \\\"}\\\\n\\\"\\n\\n self.buffer_declaration = buffer_declaration\\n self.constructor_code = constructor_code\",\n \"def test_init(self):\\n network = PerceptronNetwork(\\n [\\n PerceptronLayer.blank(4, 2, 'layer1', ['a', 'b', 'c', 'd']),\\n PerceptronLayer.blank(2, 2, 'layer2', ['a', 'b', 'c', 'd'])\\n ]\\n )\\n self.assertIsNotNone(network)\",\n \"def construct(self):\\n self.input_size = self.numplanes * self.boardsize**2\\n \\n if self.hidden:\\n layers = [\\n torch.nn.Linear(self.input_size, self.hidden), \\n torch.nn.ReLU(),\\n torch.nn.Linear(self.hidden, self.boardsize**2)\\n ]\\n else:\\n layers = [torch.nn.Linear(self.input_size, self.boardsize**2)]\\n\\n self.layers = torch.nn.ModuleList(layers)\\n self.optimizer = torch.optim.Adam(self.parameters(), lr=1e-5)\\n logging.info(\\\"Model initialized: %s\\\", self)\",\n \"def lenet_network(name, input_shape, output_count):\\n network = NeuralNetwork(name, input_shape, output_count)\\n\\n # normal distribution parameters for random weights\\n mean = 0.0\\n stddev = 0.1\\n\\n # General convolution shapes and parameters common to all convolutional layers\\n conv_stride_shape = (1, 1)\\n conv_pad_shape = (0, 0)\\n conv_pad_type = 'VALID'\\n\\n pool_stride_shape = (2, 2)\\n pool_shape = (2, 2)\\n pool_pad_type = 'VALID'\\n\\n activation = 'relu'\\n\\n # Kernel depths and sizes for each convolution layer\\n depths = [6, 16]\\n kernel_shapes = [(5, 5, depths[0]), (5, 5, depths[1])]\\n conv_layer_count = len(depths)\\n\\n # Create convolutional layers\\n conv = None\\n for i in range(conv_layer_count):\\n name = 'l{:d}'.format(i)\\n if i > 0:\\n input_shape = conv.output_shape\\n conv = ConvolutionalLayer(name, input_shape, kernel_shapes[i], conv_stride_shape, \\\\\\n conv_pad_shape, conv_pad_type, activation)\\n conv.add_pooling('max', pool_shape, pool_stride_shape, pool_pad_type)\\n network.add_layer(conv, mean, stddev)\\n\\n # Linear layer dimensions\\n linear_input_sizes = [400, 120, 84]\\n linear_output_sizes = [120, 84, 10]\\n linear_activations = ['relu', 'relu', None]\\n\\n # Create linear layers\\n for i, input_size in enumerate(linear_input_sizes):\\n layer_index = i + conv_layer_count\\n name = 'l{:d}'.format(layer_index)\\n linear = LinearLayer(name, input_size, linear_output_sizes[i], linear_activations[i])\\n linear.init_weights_and_biases(mean, stddev)\\n network.add_layer(linear, mean, stddev)\\n\\n network.define_network()\\n\\n learning_rate = 0.001\\n network.define_operations(learning_rate, 'adam')\\n\\n return network\",\n \"def _build_network(self,\\n input_dim,\\n dense_layers,\\n nodes_per_layer=None,\\n hidden_act='relu',\\n output_act='sigmoid',\\n dropout_layers=None):\\n\\n if nodes_per_layer is None:\\n nodes = [10] * dense_layers\\n else:\\n nodes = nodes_per_layer\\n\\n if dropout_layers is None:\\n do_layers = [0] * dense_layers\\n else:\\n do_layers = dropout_layers\\n\\n self.model.add(Dense(nodes[0], input_dim=input_dim,\\n activation=hidden_act))\\n\\n if dense_layers > 1:\\n for l in range(1, dense_layers - 1):\\n if do_layers[l - 1] != 0:\\n self.model.add(Dropout(do_layers[l - 1]))\\n\\n self.model.add(Dense(nodes[l], activation=hidden_act))\\n\\n self.model.add(Dense(1, activation=output_act))\",\n \"def test_init() -> None:\\n neural_net = NeuralNetwork()\\n assert neural_net.model.get_layer('output_layer').output_shape, (None, 4)\",\n \"def __init__(self, inputLayerSize, outputLayerSize, \\\\\\n hiddenLayerSize):\\n #Network hyperparameters - neurons per layer - **not altered by training**\\n self.inputLayerSize = inputLayerSize\\n self.outputLayerSize = outputLayerSize\\n self.hiddenLayerSize = hiddenLayerSize\\n self.num_params = inputLayerSize * hiddenLayerSize + \\\\\\n hiddenLayerSize * outputLayerSize + hiddenLayerSize \\\\\\n + outputLayerSize\\n #--Weights--\\n #w_ih - weights of synapses linking input -> hidden\\n self.w_ih = np.random.randn( self.inputLayerSize, \\\\\\n self.hiddenLayerSize)\\n #w_ho - weights of synapses linking hidden -> output\\n self.w_ho = np.random.randn( self.hiddenLayerSize, \\\\\\n self.outputLayerSize)\\n \\n #--Biases--\\n #b_h - biases of hidden layer\\n self.b_h = np.random.randn( self.hiddenLayerSize )\\n #b_o - biases of output layer\\n self.b_o = np.random.randn( self.outputLayerSize )\",\n \"def __init__(self, number_of_neurons: int, activation_function, inputs=None):\\n self.uid = None\\n self.number_of_neurons = number_of_neurons\\n self.activation_function = activation_function\\n self.inputs = inputs\\n self.shape = None\\n self.data_shape = None\\n self.weights = None\\n self.__set_weights()\",\n \"def setupNetwork(self):\\n\\t\\tin_layer = Input(shape=(28, ))\\n\\t\\td1 = Dense(40, activation='relu')(in_layer)\\n\\t\\td2 = Dense(10, activation='relu')(d1)\\n\\t\\tout = Dense(1, activation='sigmoid')(d2)\\n\\n\\t\\tself.model = tf.keras.Model(inputs=in_layer, outputs=out)\",\n \"def build_neural_net(net_def):\\n\\n populated_def = net_def.copy()\\n\\n for layer in populated_def['layers']:\\n for n in range(0, layer['num_neurons']):\\n weights = layer['weights'][n]\\n bias = layer['bias'][n]\\n\\n neuron = Neuron(weights, bias, layer['activation'])\\n layer['neurons'].append(neuron)\\n\\n\\n return populated_def\",\n \"def set_layers(self, sizes, init='random'):\\n\\t\\tself.init_weights(sizes, init, None, None)\",\n \"def __init__(self, rate, sigmoid, hidden, examples, variables, layers, rule, dropout):\\n self.rate = rate\\n self.sigmoid = sigmoid\\n self.inputs = variables \\n self.vis_layer = []\\n self.hidden_layers = []\\n self.hidden = hidden\\n self.variables = variables\\n self.data = BOOLEAN(examples, self.variables)\\n self.layers = layers-1\\n self.rule = rule\\n self.dropout = dropout\\n self.length = int(math.pow(2, self.variables))\\n for _ in xrange(self.hidden):\\n self.vis_layer.append(Neuron(self.rate, self.sigmoid, self.inputs+1, dropout))\\n for layer in xrange(self.layers):\\n self.hidden_layers.append([])\\n for _ in xrange(self.hidden):\\n self.hidden_layers[layer].append(Neuron(self.rate, self.sigmoid, self.hidden+1, dropout))\\n if self.hidden > 0:\\n self.output_neuron = Neuron(self.rate, self.sigmoid, self.hidden+1, dropout)\\n else:\\n self.output_neuron = Neuron(self.rate, self.sigmoid, self.inputs+1, dropout)\",\n \"def _init_layers(self):\\n self.relu = nn.ReLU(inplace=True)\\n self.cls_convs = nn.ModuleList()\\n self.reg_convs = nn.ModuleList()\\n for i in range(self.stacked_convs):\\n chn = self.in_channels if i == 0 else self.feat_channels\\n self.cls_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n self.reg_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n self.retina_cls = nn.Conv2d(\\n self.feat_channels,\\n self.num_anchors * self.cls_out_channels,\\n 3,\\n padding=1)\\n self.retina_reg = nn.Conv2d(\\n self.feat_channels, self.num_anchors * 4, 3, padding=1)\",\n \"def __init__(self, z_dim, initailize_weights=True):\\n super().__init__()\\n self.z_dim = z_dim\\n\\n self.img_conv1 = conv2d(3, 16, kernel_size=7, stride=2)\\n self.img_conv2 = conv2d(16, 32, kernel_size=5, stride=2)\\n self.img_conv3 = conv2d(32, 64, kernel_size=5, stride=2)\\n self.img_conv4 = conv2d(64, 64, stride=2)\\n self.img_conv5 = conv2d(64, 128, stride=2)\\n self.img_conv6 = conv2d(128, self.z_dim, stride=2)\\n self.img_encoder = nn.Linear(4 * self.z_dim, 2 * self.z_dim)\\n self.flatten = Flatten()\\n\\n if initailize_weights:\\n init_weights(self.modules())\",\n \"def __init__(self,\\n neurons_list: list,\\n hidden_activation: str = None,\\n out_activation: str = None,\\n error_func: str = None):\\n self.__layers = []\\n for i in range(1, len(neurons_list)):\\n prev_layer = neurons_list[i - 1]\\n cur_layer = neurons_list[i]\\n\\n out_activ = lin\\n out_activ_deriv = lin_deriv\\n\\n if out_activation == \\\"sigmoid\\\":\\n out_activ = sigmoid\\n out_activ_deriv = sigmoid_deriv\\n elif out_activation == \\\"relu\\\":\\n out_activ = relu\\n out_activ_deriv = relu_deriv\\n elif out_activation == \\\"l_relu\\\":\\n out_activ = l_relu\\n out_activ_deriv = l_relu_deriv\\n\\n hidden_activ = lin\\n hidden_activ_deriv = lin_deriv\\n\\n if hidden_activation == \\\"sigmoid\\\":\\n hidden_activ = sigmoid\\n hidden_activ_deriv = sigmoid_deriv\\n elif hidden_activation == \\\"relu\\\":\\n hidden_activ = relu\\n hidden_activ_deriv = relu_deriv\\n elif hidden_activation == \\\"l_relu\\\":\\n hidden_activ = l_relu\\n hidden_activ_deriv = l_relu_deriv\\n\\n if i == len(neurons_list) - 1:\\n layer = NeuralNetLayer(cur_layer, prev_layer, out_activ, out_activ_deriv)\\n else:\\n layer = NeuralNetLayer(cur_layer, prev_layer, hidden_activ, hidden_activ_deriv)\\n self.__layers.append(layer)\\n\\n error_func_f = squared_error\\n error_deriv = squared_error_der\\n\\n if error_func == \\\"mse\\\":\\n error_func_f = squared_error\\n error_deriv = squared_error_der\\n elif error_func == \\\"kl\\\":\\n error_func_f = kl_divergence\\n error_deriv = kl_divergence_der\\n\\n self.__error_func = error_func_f\\n self.__error_deriv = error_deriv\",\n \"def __init__(self, z_dim, initailize_weights=True):\\n super().__init__()\\n self.z_dim = z_dim\\n\\n self.depth_conv1 = conv2d(1, 32, kernel_size=3, stride=2)\\n self.depth_conv2 = conv2d(32, 64, kernel_size=3, stride=2)\\n self.depth_conv3 = conv2d(64, 64, kernel_size=4, stride=2)\\n self.depth_conv4 = conv2d(64, 64, stride=2)\\n self.depth_conv5 = conv2d(64, 128, stride=2)\\n self.depth_conv6 = conv2d(128, self.z_dim, stride=2)\\n\\n self.depth_encoder = nn.Linear(4 * self.z_dim, 2 * self.z_dim)\\n self.flatten = Flatten()\\n\\n if initailize_weights:\\n init_weights(self.modules())\",\n \"def _nn_initial_values(structure):\\n\\n # Use Xavier uniform initializer\\n initializer=tf.glorot_uniform_initializer()\\n\\n output=[]\\n last_width=None\\n\\n # Add biases & weights per layer\\n for l in structure:\\n output.append(tf.zeros(shape=[l])) # layer l biases\\n if last_width is not None: # Exclude weights from layer 0\\n output.append(initializer(shape=[last_width, l])) # layer l weights\\n last_width=l\\n\\n return output\",\n \"def initialize_parameters_for_layers(layer_list, training_examples):\\n W = [None] * len(layer_list)\\n B = [None] * len(layer_list)\\n X = np.random.randn(layer_list[0], training_examples)\\n for j in range(1, len(layer_list)):\\n W[j] = np.random.randn(layer_list[j], layer_list[j-1])\\n B[j] = np.random.randn(layer_list[j], 1)\\n return X, W, B\",\n \"def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):\\n super().__init__(inputnodes, hiddennodes, outputnodes, learningrate)\\n\\n # link weight matrices, wih and who\\n # weights inside the arrays are w_i_j, where link is from node i to node i to j in the next layer\\n # w11 w21\\n # w12 w22 etc\\n self.wih = cupy.random.normal(\\n 0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))\\n self.who = cupy.random.normal(\\n 0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))\\n\\n #activation function is the sigmoid function\\n self.activation_function = lambda x: 1 / (1 + cupy.exp(x) ** (-1))\",\n \"def __init__(self, num_units, input_size=None,\\n nonlinearity=tf.nn.tanh,\\n W_init=tf.random_normal_initializer(stddev=0.15),\\n b_init=tf.constant_initializer(0.0, dtype=tf.float32),\\n weightnorm=False):\\n self._num_units = num_units\\n self._input_size = input_size or num_units\\n self._W_init = W_init\\n self._b_init = b_init\\n self._weightnorm = weightnorm\\n self._nonlin = nonlinearity\",\n \"def build(self):\\n\\n self.W = self.init([self.n_atom_input_feat, self.n_output])\\n self.b = model_ops.zeros(shape=[\\n self.n_output,\\n ])\\n\\n self.trainable_weights = self.W + self.b\",\n \"def build_layer(self) :\\n inputsWithBias = self.input_count + 1\\n self.weights = np.random.rand(inputsWithBias, self.node_count)\\n self.weights_and_activations = (self.weights, self.activations)\",\n \"def initialize_layers(self, layers_config: dict, inputs=None):\\n layers_config = layers_config.copy()\\n input_lyrs = []\\n initiated_layers = OrderedDict()\\n wrp_layer = None # indicator for wrapper layers\\n first_layer = True\\n\\n for lyr, lyr_args in layers_config.items():\\n\\n lyr_config, lyr_inputs, named_outs, call_args = self.deconstruct_lyr_args(lyr, lyr_args)\\n\\n lyr_name, args, lyr_config, activation = self.check_lyr_config(lyr, lyr_config)\\n\\n if K.BACKEND == 'pytorch':\\n\\n if first_layer:\\n first_layer = False\\n\\n if callable(lyr_config):\\n lyr_initiated = lyr_config\\n else:\\n lyr_initiated = TORCH_LAYERS[lyr_name](**lyr_config)\\n setattr(self, lyr, lyr_initiated)\\n initiated_layers[lyr] = {\\\"layer\\\": lyr_initiated, \\\"named_outs\\\": named_outs, 'call_args': call_args,\\n 'inputs': lyr_inputs}\\n\\n else:\\n # may be user has defined layers without input layer, in this case add Input layer as first layer\\n if first_layer:\\n if inputs is not None: # This method was called by providing it inputs.\\n assert isinstance(inputs, tf.Tensor)\\n # since inputs have been defined, all the layers that will be added will be next to first layer\\n first_layer = False\\n layer_outputs = inputs\\n initiated_layers[layer_outputs.name] = {'layer': layer_outputs, 'tf_name': lyr_name}\\n\\n elif lyr_name != \\\"Input\\\":\\n if 'input_shape' in lyr_config: # input_shape is given in the first layer so make input layer\\n initialized_layer = LAYERS[\\\"Input\\\"](shape=lyr_config['input_shape'])\\n else:\\n # for simple dense layer based models, lookback will not be used\\n def_shape = (self.num_ins,) if self.lookback == 1 else (self.lookback, self.num_ins)\\n initialized_layer = LAYERS[\\\"Input\\\"](shape=def_shape)\\n\\n # first layer is built so next iterations will not be for first layer\\n first_layer = False\\n # put the first layer in memory to be used for model compilation\\n # add th layer which the user had specified as first layer\\n initiated_layers[initialized_layer.name] = {'layer': initialized_layer,\\n 'tf_name': lyr_name}\\n input_lyrs.append(initialized_layer)\\n\\n # The inputs to the layer have not been specified, so either it is an Input layer\\n if lyr_inputs is None:\\n # or it uses the previous outputs as inputs\\n if lyr_name == \\\"Input\\\":\\n # it is an Input layer, hence should not be called\\n initialized_layer = LAYERS[lyr_name](*args, **lyr_config)\\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\\n 'tf_name': lyr_name}\\n input_lyrs.append(initialized_layer)\\n else:\\n # it is executable and uses previous outputs as inputs\\n if lyr_name in ACTIVATION_LAYERS:\\n layer_outputs = ACTIVATION_LAYERS[lyr_name](name=lyr_config['name'])\\n initiated_layers[lyr_config['name']] = {'layer': layer_outputs,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n elif lyr_name in ['TimeDistributed', 'Bidirectional']:\\n wrp_layer = LAYERS[lyr_name]\\n # because wrapper layer name is property\\n initiated_layers[lyr_config['name']] = {'layer': wrp_layer,\\n 'tf_name': lyr_name}\\n continue\\n elif \\\"LAMBDA\\\" in lyr_name.upper():\\n # lyr_config is serialized lambda layer, which needs to be deserialized\\n initialized_layer = tf.keras.layers.deserialize(lyr_config)\\n # layers_config['lambda']['config'] still contails lambda, so we need to replace the python\\n # object (lambda) with the serialized version (lyr_config) so that it can be saved as json file.\\n layers_config[lyr]['config'] = lyr_config\\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n else:\\n if wrp_layer is not None:\\n initialized_layer = wrp_layer(LAYERS[lyr_name](*args, **lyr_config))\\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n wrp_layer = None\\n else:\\n if lyr_name == \\\"TemporalFusionTransformer\\\":\\n lyr_config['return_attention_components'] = True\\n initialized_layer = LAYERS[lyr_name](*args, **lyr_config)\\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n\\n else: # The inputs to this layer have been specified so they must exist in lyr_cache.\\n # it is an executable\\n if lyr_name in ACTIVATION_LAYERS:\\n\\n layer_outputs = ACTIVATION_LAYERS[lyr_name](name=lyr_config['name'])\\n initiated_layers[lyr_config['name']] = {'layer': layer_outputs,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n elif lyr_name in ['TimeDistributed', 'Bidirectional']:\\n wrp_layer = LAYERS[lyr_name]\\n # because wrapper layer name is property\\n initiated_layers[lyr_config['name']] = {'layer': wrp_layer,\\n 'tf_name': lyr_name}\\n continue\\n elif \\\"LAMBDA\\\" in lyr_name.upper():\\n initialized_layer = tf.keras.layers.deserialize(lyr_config)\\n layers_config[lyr]['config'] = lyr_config\\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n else:\\n if wrp_layer is not None:\\n initialized_layer = wrp_layer(LAYERS[lyr_name](*args, **lyr_config))\\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n wrp_layer = None\\n else:\\n layer_initialized = LAYERS[lyr_name](*args, **lyr_config)\\n initiated_layers[lyr_config['name']] = {'layer': layer_initialized,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n\\n if activation is not None: # put the string back to dictionary to be saved in config file\\n lyr_config['activation'] = activation\\n\\n first_layer = False\\n\\n self.jsonize_lyr_config(lyr_config)\\n\\n # inputs = [] todo, indentify input layers\\n # for k,v in lyr_cache.items():\\n # since the model is not build yet and we have access to only output tensors of each list, this is probably\\n # # the only way to know that how many `Input` layers were encountered during the run of this method. Each\\n # tensor (except TimeDistributed) has .op.inputs attribute, which is empty if a tensor represents output of Input layer.\\n # if int(''.join(tf.__version__.split('.')[0:2]).ljust(3, '0')) < 240:\\n # if k.upper() != \\\"TIMEDISTRIBUTED\\\" and hasattr(v, 'op'):\\n # if hasattr(v.op, 'inputs'):\\n # _ins = v.op.inputs\\n # if len(_ins) == 0:\\n # inputs.append(v)\\n # else: # not sure if this is the proper way of checking if a layer receives an input or not!\\n # if hasattr(v, '_keras_mask'):\\n # inputs.append(v)\\n\\n setattr(self, 'initiated_layers', initiated_layers)\\n setattr(self, 'input_lyrs', input_lyrs)\\n\\n\\n # todo,\\n # # for case when {Input -> Dense, Input_1}, this method wrongly makes Input_1 as output so in such case use\\n # # {Input_1, Input -> Dense }, thus it makes Dense as output and first 2 as inputs, so throwing warning\\n # if int(''.join(tf.__version__.split('.')[0:2]).ljust(3, '0')) < 240:\\n # if len(layer_outputs.op.inputs) < 1:\\n # print(\\\"Warning: the output is of Input tensor class type\\\")\\n # else:\\n # if 'op' not in dir(layer_outputs): # layer_outputs does not have `op`, which means it has no incoming node\\n # print(\\\"Warning: the output is of Input tensor class type\\\")\\n\\n # outs = None\\n #if BACKEND == 'tensorflow':\\n # outs = self.call(input_lyrs)\\n # setattr(self, 'output_lyrs', outs)\\n # if BACKEND == 'tensorflow':\\n # ## Reinitial\\n # super(Model, self).__init__(\\n # inputs=input_lyrs,\\n # outputs=outs)\\n #MODEL.__init__(self, inputs=inputs, outputs=outs)\\n\\n return input_lyrs # , outs\",\n \"def _init_layers(self) -> None:\\n self.self_attn = MultiheadAttention(**self.self_attn_cfg)\\n self.cross_attn = MultiheadAttention(**self.cross_attn_cfg)\\n self.embed_dims = self.self_attn.embed_dims\\n self.ffn = FFN(**self.ffn_cfg)\\n norms_list = [\\n build_norm_layer(self.norm_cfg, self.embed_dims)[1]\\n for _ in range(3)\\n ]\\n self.norms = ModuleList(norms_list)\",\n \"def bnn_serial(*layers):\\n nlayers = len(layers)\\n init_funs, apply_funs = zip(*layers)\\n\\n def init_fun(rng, input_shape):\\n params = []\\n for init_fun in init_funs:\\n rng, layer_rng = jax.random.split(rng)\\n input_shape, param = init_fun(layer_rng, input_shape)\\n params.append(param)\\n return input_shape, params\\n\\n def apply_fun(params, inputs, **kwargs):\\n rng = kwargs.pop('rng', None)\\n rngs = jax.random.split(rng, nlayers) if rng is not None else (None,) * nlayers\\n total_kl = 0\\n infodict = {}\\n for fun, param, rng in zip(apply_funs, params, rngs):\\n output = fun(param, inputs, rng=rng, **kwargs)\\n if len(output) == 2:\\n inputs, layer_kl = output\\n elif len(output) == 3:\\n inputs, layer_kl, info = output\\n infodict.update(info)\\n else:\\n raise RuntimeError(f\\\"Expected 2 or 3 outputs but got {len(output)}.\\\")\\n total_kl = total_kl + layer_kl\\n return inputs, total_kl, infodict\\n\\n return Layer(init_fun, apply_fun)\",\n \"def __init__(self, n_input, n_output, hidden_layer_size, reg):\\n self.reg = reg\\n self.fulllayer1 = FullyConnectedLayer(n_input, hidden_layer_size)\\n self.reglayer1 = ReLULayer()\\n self.fulllayer2 = FullyConnectedLayer(hidden_layer_size, n_output)\",\n \"def initialize_network(self):\\n self.sess = tf.InteractiveSession()\\n sys.stderr.write(\\\"------\\\\n\\\")\\n self.model.create_model()\\n self._initialize_trainer()\\n self.sess.run(tf.initialize_all_variables())\\n self.saver = tf.train.Saver()\",\n \"def init(InputUnits, OutputUnits, numHiddenLayer, HiddenUnits=None):\\n global HiddenUnit\\n all_weights = []\\n if HiddenUnits is None:\\n HiddenUnits = []\\n elif isinstance(HiddenUnits, int):\\n HiddenUnits = [HiddenUnits]\\n\\n # for InputLayer\\n\\n parameters = generate(HiddenUnits[0], InputUnits)\\n allWeights = mat.r_[parameters.flatten()]\\n\\n if numHiddenLayer > 1:\\n for i in range(numHiddenLayer):\\n if i < numHiddenLayer-1:\\n parameters = generate(HiddenUnits[i+1], HiddenUnits[i])\\n allWeights = mat.r_[allWeights, parameters.flatten()]\\n else:\\n parameters = generate(OutputUnits, HiddenUnits[i])\\n allWeights = mat.r_[allWeights, parameters.flatten()]\\n\\n else:\\n # for output layer\\n parameters = generate( OutputUnits, HiddenUnits[0])\\n allWeights = mat.r_[allWeights, parameters.flatten()]\\n\\n return allWeights\",\n \"def __init__(self, layers = (1, 1), speed = 0.5):\\n \\n self.structure = layers # Structure of each layer\\n self.activationFunc = np.vectorize(lambda x: 1.0 / (1 + np.exp(-x))); # Activatin function\\n self.derivativeFunc = lambda x: x * (1 - x) # Derivative from activation function\\n self.theta = [None] # Matrix of weights for each layer\\n self.a = None # Activation level from each layer\\n self.delta = None # Error rate for each level\\n self.speed = speed # Speed of learning\\n \\n # for each layer exclude input layer\\n for i in xrange(1, len(layers)):\\n # create n * (M+1) matrix (+1 = adding bias) with random floats in range [-1; 1]\\n self.theta.append(np.mat(np.random.uniform(-1, 1, (layers[i], layers[i - 1] + 1))))\\n #self.theta.append(np.matrix(np.ones((layers[i], layers[i - 1] + 1))))\\n \\n return\",\n \"def __init__(self, neuron_count):\\n # The current state of the thermal network.\\n self.current_state = [0.0] * neuron_count\\n\\n # The weights.\\n self.weights = np.zeros( [neuron_count*neuron_count] )\\n\\n # The neuron count.\\n self.neuron_count = neuron_count\",\n \"def init():\\n global neural_network\\n global labels\\n\\n # load objects required by run() for inferencing\\n model_dir = Model.get_model_path(\\\"mnist-fashion\\\")\\n # neural model\\n neural_network = keras.models.load_model(f\\\"{model_dir}/neural-network.h5\\\")\\n # labels\\n with open(f\\\"{model_dir}/labels.jsonpickle\\\", \\\"r\\\") as labels_file:\\n labels = jsonpickle.decode(labels_file.read())\",\n \"def __init__(self, dims):\\n\\t\\tself.layersNumber = len(dims) - 1\\n\\t\\tself.weights = []\\n\\t\\tself.biases = []\\n\\t\\tnp.random.seed(42)\\n\\t\\tfor d in range(self.layersNumber):\\n\\t\\t\\tself.weights.append(np.random.randn(dims[d+1], dims[d]))\\n\\t\\t\\tself.biases.append(np.random.randn(dims[d+1], 1))\",\n \"def init_bias(n_hidden_layer, n_hidden_layer_2, n_output_layer):\\n bias_W1, bias_W2, bias_W3 = None, None, None\\n\\n # Create empty arrays of the desired size given by the number of neurons per layer\\n # Arrays are populated with 0's\\n if n_hidden_layer > 0:\\n bias_W1 = np.zeros((n_hidden_layer,1))\\n\\n if n_hidden_layer_2 > 0:\\n bias_W2=np.zeros((n_hidden_layer_2,1)) \\n bias_W3=np.zeros((n_output_layer,1))\\n\\n else:\\n bias_W2 = np.zeros((n_output_layer,1))\\n\\n else:\\n bias_W1 = np.zeros((n_output_layer,1))\\n\\n return bias_W1, bias_W2, bias_W3\",\n \"def __init__(self, input_size, neurons):\\n super().__init__()\\n self.input_size = input_size\\n self.neurons = neurons\\n self.params[\\\"w\\\"] = np.random.randn(input_size, neurons)\\n self.params[\\\"b\\\"] = np.random.randn(1, neurons)\\n self.grads = {}\",\n \"def __init__(self, layer_dims=(5, 1), learning_rate=0.005, max_iter=500, activate_fn='relu', init_weights_coef=0.01,\\n regularization=\\\"l2\\\", lambd=0.5, keep_prob=0.9, random_state=None, verbose=True):\\n self.layer_dims = layer_dims\\n self.learning_rate = learning_rate\\n self.max_iter = max_iter\\n self.activate_fn = activate_fn\\n self.activate_fns = {\\n \\\"sigmoid\\\": self.__sigmoid,\\n \\\"tanh\\\": self.__tanh,\\n \\\"relu\\\": self.__relu,\\n \\\"lrelu\\\": self.__leaky_relu\\n }\\n self.derivative_activate_fns = {\\n \\\"sigmoid\\\": self.__derivative_sigmoid,\\n \\\"tanh\\\": self.__derivative_tanh,\\n \\\"relu\\\": self.__derivative_relu,\\n \\\"lrelu\\\": self.__derivative_leaky_relu\\n }\\n self.init_weights_coef = init_weights_coef\\n self.regularization = regularization\\n self.lambd = lambd\\n self.keep_prob = keep_prob\\n self.random_state = random_state\\n self.verbose = verbose\\n self.weights = defaultdict()\\n\\n self.costs = [] # 记录训练过程的损失\",\n \"def __init__(self, layer_sizes, act_func=Sigmoid, cost_func=CrossEntropy, metric=AccuracyMetric):\\n np.random.seed(1) # Used for constant weights and biases initialization. Fell free to change it.\\n\\n self.layers_num = len(layer_sizes)\\n self.act_func = act_func\\n self.cost_func = cost_func\\n self.metric = metric\\n self.biases = [np.random.random(i) for i in layer_sizes[1:]]\\n self.weights = [np.random.normal(loc=0, scale=(1 / np.sqrt(layer_sizes[0])), size=(j, i))\\n for j, i in zip(layer_sizes[1:], layer_sizes[:-1])]\\n self.costs = []\\n self.accuracies = []\\n self.eta = 0\\n self.lambda_r = 0\",\n \"def __init__(\\n self,\\n input_size: int,\\n hidden_sizes: Sequence[int],\\n output_size: int,\\n num_layers: int,\\n optimizer: Type[Optimizer] = SGD(),\\n norm_weights: bool = False\\n ):\\n self.input_size = input_size\\n self.hidden_sizes = hidden_sizes\\n self.output_size = output_size\\n self.num_layers = num_layers\\n self.norm_weights = norm_weights\\n\\n assert len(hidden_sizes) == (num_layers - 1)\\n assert num_layers >= 1\\n\\n activated_layer_sizes = [input_size] + hidden_sizes\\n activated_layers = [LinearLayer(n_in, n_out, activation_func=ReLU) for n_in, n_out in zip(activated_layer_sizes, activated_layer_sizes[1:])]\\n final_layer = LinearLayer(activated_layer_sizes[-1], self.output_size, activation_func=Softmax)\\n self.layers = activated_layers + [final_layer]\\n\\n self.optimizer = optimizer\",\n \"def new_initial_layer(self, nodes, inputs, alpha=0.1):\\n weights = [[1 for _ in range(inputs)] for i in range(nodes)]\\n alphas = [alpha for _ in range(nodes)]\\n self._layers.insert(0, Layer(weights, alphas))\",\n \"def initialize_weights(self):\\n tf.nest.map_structure(\\n weights_initializer.WeightsInitializer.initialize_layer_or_model,\\n self._layer_nest)\",\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 __init__(self, hidden_layer_sizes, activation='relu', reg=0.001, k_fold=5, random_state=0):\\n print(\\\"Initialize model Multi-layer Perceptron\\\")\\n self.hidden_layer_sizes = hidden_layer_sizes\\n self.activation = activation\\n self.reg = reg\\n self.k_fold = k_fold\\n self.random_state = random_state\\n self.model = sklearn.neural_network.MLPClassifier(self.hidden_layer_sizes,\\n activation=self.activation,\\n alpha=self.reg, max_iter=1000, \\n random_state=self.random_state)\",\n \"def __init__(self, num_learners: int):\\n self.num_learners = num_learners\\n self.learners = []\\n self.learner_weights = np.ones(num_learners)\",\n \"def _initialize_cnn(image_size, action_size, learning_rate=None):\\n\\n # All layers are randomly initialized using Glorot initializer\\n\\n # Create the Inputs of the Neural Network\\n image_input = Input(shape=(image_size, image_size, 1))\\n scalar_input = Input(shape=(2,))\\n\\n # Create the first layer of convolution\\n conv1 = Conv2D(filters=16,\\n kernel_size=5,\\n activation=\\\"relu\\\")(image_input)\\n\\n pool1 = MaxPooling2D(pool_size=3)(conv1)\\n\\n # Create the second layer of convolution\\n conv2 = Conv2D(filters=16,\\n kernel_size=3,\\n activation=\\\"relu\\\")(pool1)\\n pool2 = MaxPooling2D(pool_size=3)(conv2)\\n\\n # Create the third layer of convolution\\n conv3 = Conv2D(filters=16,\\n kernel_size=3,\\n activation=\\\"relu\\\")(pool2)\\n pool3 = MaxPooling2D(pool_size=2)(conv3)\\n\\n # Flatten the input, so it can be used with dense layers\\n flatten = Flatten()(pool3)\\n\\n # Merge the results of the convolutional layers with the scalar input\\n merge = concatenate([flatten, scalar_input])\\n\\n # Create the dense layers\\n # (256 neurons, ReLU)\\n dense1 = Dense(256,\\n activation=\\\"relu\\\",\\n kernel_initializer=\\\"glorot_uniform\\\")(merge)\\n dense2 = Dense(256,\\n activation=\\\"relu\\\",\\n kernel_initializer=\\\"glorot_uniform\\\")(dense1)\\n\\n # Create the output layer (action_size outputs, Lineal)\\n # Note that the output MUST be lineal (instead of the typical sigmoid function)\\n # for Deep Reinforcement Learning\\n output = Dense(action_size,\\n activation=\\\"linear\\\",\\n kernel_initializer=\\\"glorot_uniform\\\")(dense2)\\n\\n # Create and compile the model of the full CNN (Adam optimizer, MSE)\\n # Mean Square Error is used (instead of more typical cross-entropy values) due to Deep Reinforcement Learning\\n # (since MSE is the value trying to be minimized)\\n model = Model(inputs=[image_input, scalar_input],\\n outputs=output)\\n\\n # Note that beta_1 is set to 0.99 to improve the GPU performance while training\\n model.compile(optimizer=Adam(beta_1=0.99,\\n learning_rate=learning_rate) if learning_rate\\n else Adam(beta_1=0.99),\\n loss=\\\"mse\\\",\\n run_eagerly=True)\\n\\n return model\",\n \"def __init__(self, input_dimensions=2, number_of_nodes=4, transfer_function=\\\"Hard_limit\\\"):\\n self.input_dimensions = input_dimensions\\n self.number_of_nodes = number_of_nodes\\n self.transfer_function = transfer_function\\n self.initialize_weights()\",\n \"def __init__(self, number_hidden_layers=1, n_inputs=0, input_dim=1, output_dim=1, init_fs=None, act_fs=None, dropout=(), dropout_probs=(), batch_norm=()):\\n self.number_hidden_layers = number_hidden_layers\\n self.input_dim = input_dim\\n self.output_dim = output_dim\\n self.init_functions = init_fs\\n self.act_functions = act_fs\\n self.batch_norm = batch_norm\\n self.dropout = dropout\\n self.dropout_probs = dropout_probs\\n self.n_inputs = n_inputs\",\n \"def make_neural_net_basic():\\n i0 = Input('i0', -1.0) # this input is immutable\\n i1 = Input('i1', 0.0)\\n i2 = Input('i2', 0.0)\\n w1A = Weight('w1A', 1)\\n w2A = Weight('w2A', 1)\\n wA = Weight('wA', 1)\\n\\n # Inputs must be in the same order as their associated weights\\n A = Neuron('A', [i1,i2,i0], [w1A,w2A,wA])\\n P = PerformanceElem(A, 0.0)\\n\\n net = Network(P,[A])\\n return net\",\n \"def build_neuron_network(nb_features_map: Union[Sequence[int], None] = None,\\n size_linear_layers: Union[Sequence[int], None] = None,\\n dropout_rate: Union[Tuple[float, float], float] = 0.3,\\n conv_kernel_size: Union[Sequence[int], int] = 3,\\n conv_stride: int = 1,\\n conv_padding: int = 1,\\n conv_activation: str = \\\"relu\\\",\\n conv_architecture: str = \\\"CPD\\\",\\n pool_kernel_size: int = 2,\\n pool_stride: int = 2,\\n dense_activation: str = \\\"relu\\\",\\n pretrained: Union[str, None] = None,\\n grayscale: bool = True,\\n optimizer: str = \\\"Adam\\\",\\n weight_decay: float = 0.,\\n learning_rate: float = 0.001,\\n ) -> Tuple[nn.Module, List, torch.optim.Optimizer]:\\n # Initializations\\n if pretrained is not None:\\n grayscale = False\\n if grayscale:\\n channels = 1\\n else:\\n channels = 3\\n if nb_features_map is None:\\n nb_features_map = [8]\\n if size_linear_layers is None:\\n size_linear_layers = []\\n height = 224\\n width = 224\\n module = nn.Module()\\n shapes = [(\\\"input\\\", channels, height, width)]\\n layers = {\\\"extractor\\\": [], \\\"regressor\\\": []}\\n if not hasattr(dropout_rate, \\\"__len__\\\"):\\n dropout_rate = (dropout_rate, 0.)\\n next_dropout_rate = dropout_rate[0]\\n # If a pretrained model is used:\\n if pretrained is None:\\n # Input checks\\n if hasattr(conv_kernel_size, \\\"__len__\\\"):\\n if len(conv_kernel_size) != len(nb_features_map):\\n raise ValueError(\\\"The length of nb_features_map shall match the length of conv_kernel_size\\\")\\n else:\\n conv_kernel_size = [conv_kernel_size] * len(nb_features_map)\\n # Feature extractor\\n next_layer_type = itertools.cycle(conv_architecture)\\n nb_feature_map = None\\n i = 0\\n while True:\\n layer_type = next(next_layer_type)\\n if layer_type == \\\"C\\\":\\n # Convolutional layer\\n try:\\n nb_feature_map = nb_features_map[i]\\n except IndexError:\\n break\\n name = \\\"conv2d-{:02d}\\\".format(i+1)\\n conv = nn.Conv2d(shapes[-1][1], nb_feature_map, conv_kernel_size[i], stride=conv_stride,\\n padding=conv_padding)\\n layers[\\\"extractor\\\"].append((name, conv))\\n h, w = output_shape_conv_and_pool_layer(rows=shapes[-1][2], columns=shapes[-1][3],\\n kernel=conv_kernel_size[i], stride=conv_stride,\\n padding=conv_padding)\\n shapes.append((name, nb_feature_map, h, w))\\n i += 1\\n # Activation\\n if conv_activation == \\\"relu\\\":\\n activ = nn.ReLU()\\n elif conv_activation == \\\"elu\\\":\\n activ = nn.ELU(alpha=0.1)\\n elif conv_activation == \\\"leaky\\\":\\n activ = nn.LeakyReLU()\\n else:\\n activ = nn.ReLU()\\n name = \\\"{}-{:02d}\\\".format(conv_activation, i)\\n layers[\\\"extractor\\\"].append((name, activ))\\n # activation does not change the size\\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\\n elif layer_type == \\\"P\\\":\\n # Max-pooling\\n name = \\\"maxpool2d-{:02d}\\\".format(i)\\n pool = nn.MaxPool2d(pool_kernel_size, pool_stride)\\n layers[\\\"extractor\\\"].append((name, pool))\\n h, w = output_shape_conv_and_pool_layer(rows=shapes[-1][2], columns=shapes[-1][3],\\n kernel=pool_kernel_size, stride=pool_stride)\\n shapes.append((name, nb_feature_map, h, w))\\n elif layer_type == \\\"D\\\":\\n # Dropout\\n if next_dropout_rate > 0.:\\n name = \\\"dropout-{:02d}\\\".format(i)\\n dropout = nn.Dropout(p=next_dropout_rate)\\n layers[\\\"extractor\\\"].append((name, dropout))\\n # Dropout does not change the size\\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\\n next_dropout_rate += dropout_rate[1]\\n elif layer_type == \\\"B\\\":\\n # Batch normalization\\n name = \\\"batchnorm-{:02d}\\\".format(i)\\n batch = nn.BatchNorm2d(shapes[-1][1])\\n layers[\\\"extractor\\\"].append((name, batch))\\n # Batch norm. does not change the size\\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\\n # Add a flatten layer\\n name = \\\"flatten\\\"\\n flatten = nn.Flatten(1)\\n layers[\\\"extractor\\\"].append((name, flatten))\\n shapes.append((name, shapes[-1][1] * shapes[-1][2] * shapes[-1][3]))\\n # Create extractor module\\n extractor = nn.Sequential(OrderedDict(layers[\\\"extractor\\\"]))\\n module.add_module(\\\"extractor\\\", extractor)\\n elif pretrained == \\\"VGG16\\\":\\n pre_trained = models.vgg16(pretrained=True)\\n modules = []\\n for _name, _module in pre_trained.named_children():\\n if _name != 'classifier':\\n modules.append((_name, _module))\\n modules.append((\\\"flatten\\\", nn.Flatten(1)))\\n vgg16 = nn.Sequential(OrderedDict(modules))\\n # Freeze all parameters in the pre-trained model\\n # So we prevent gradients from being calculated, it will save computation time\\n for param in vgg16.parameters():\\n param.requires_grad = False\\n module.add_module('extractor', vgg16)\\n shapes.append((pretrained, 25088))\\n else:\\n raise ValueError(f\\\"Unknown pre-trained model '{pretrained}'.\\\")\\n # Regressor\\n for i, size_linear_layer in enumerate(size_linear_layers):\\n # Add a linear layer\\n name = \\\"linear-{:02d}\\\".format(i + 1)\\n linear = nn.Linear(shapes[-1][1], size_linear_layer)\\n layers[\\\"regressor\\\"].append((name, linear))\\n shapes.append((name, size_linear_layer))\\n # Activation\\n if dense_activation == \\\"relu\\\":\\n activ = nn.ReLU()\\n elif dense_activation == \\\"elu\\\":\\n activ = nn.ELU(alpha=0.1)\\n elif dense_activation == \\\"leaky\\\":\\n activ = nn.LeakyReLU()\\n else:\\n activ = nn.ReLU()\\n name = \\\"{}-{:02d}\\\".format(dense_activation, i + 1)\\n layers[\\\"regressor\\\"].append((name, activ))\\n shapes.append((name, shapes[-1][1])) # activation does not change the size\\n # Dropout\\n if next_dropout_rate > 0.:\\n name = \\\"dropout-{:02d}\\\".format(i + 1)\\n dropout = nn.Dropout(p=next_dropout_rate)\\n layers[\\\"regressor\\\"].append((name, dropout))\\n shapes.append((name, shapes[-1][1])) # Dropout does not change the size of array\\n next_dropout_rate += dropout_rate[1]\\n # Add the final layer, the output size is fixed to 68 x 2 = 136\\n name = \\\"output\\\"\\n linear = nn.Linear(shapes[-1][1], 136)\\n layers[\\\"regressor\\\"].append((name, linear))\\n shapes.append((name, 136))\\n # Create regressor module\\n regressor = nn.Sequential(OrderedDict(layers[\\\"regressor\\\"]))\\n module.add_module(\\\"regressor\\\", regressor)\\n # Weight initialization\\n module.apply(weight_initialization)\\n # Optimizer\\n if optimizer == \\\"Adam\\\":\\n optim = torch.optim.Adam(module.parameters(), lr=learning_rate, weight_decay=weight_decay)\\n elif optimizer == \\\"AdamW\\\":\\n optim = torch.optim.AdamW(module.parameters(), lr=learning_rate, weight_decay=weight_decay)\\n elif optimizer == \\\"SGD\\\":\\n optim = torch.optim.SGD(module.parameters(), lr=learning_rate, weight_decay=weight_decay, momentum=0.9)\\n else:\\n raise ValueError(f\\\"Unknown optimizer {optimizer}.\\\")\\n return module, shapes, optim\",\n \"def _init_layers(self) -> None:\\n self.self_attn = MultiheadAttention(**self.self_attn_cfg)\\n self.embed_dims = self.self_attn.embed_dims\\n self.ffn = FFN(**self.ffn_cfg)\\n norms_list = [\\n build_norm_layer(self.norm_cfg, self.embed_dims)[1]\\n for _ in range(2)\\n ]\\n self.norms = ModuleList(norms_list)\",\n \"def __init__(self, layers):\\n\\n\\t\\tself.layers = layers\",\n \"def __init__(self, weights, path, trained, asGraph):\\n \\n _weights = np.asarray(weights)\\n\\n numLayers = int(_weights.shape[0]/2)\\n wghts = []\\n biases = []\\n\\n for i in range(numLayers):\\n j = 2*i\\n# print(j,(_weights[j].T).shape)\\n wghts.append(_weights[j])\\n j = 2*i + 1\\n# print(j,(_weights[j].T).shape)\\n biases.append(_weights[j])\\n #enddo\\n\\n self.numLayers = numLayers\\n self.wghts = np.asarray(wghts)\\n self.asGraph = asGraph\\n self.wghts = wghts\\n self.path = path\\n self.trained = trained\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7665592","0.75891453","0.7549877","0.7288455","0.7238649","0.72074854","0.7202781","0.71520114","0.7109726","0.70575273","0.6969205","0.69633704","0.68633807","0.6848898","0.6821339","0.68000925","0.677125","0.67679054","0.6746093","0.6742651","0.6729055","0.6666361","0.6662787","0.66476506","0.6646941","0.6638234","0.6634028","0.6603814","0.65982187","0.6594358","0.6585001","0.6581009","0.6575865","0.65739566","0.6569843","0.6567062","0.6548683","0.65439975","0.6538684","0.6535428","0.6529185","0.65281767","0.6527593","0.6512578","0.65079015","0.6499464","0.6498534","0.6498499","0.6478818","0.6478449","0.64643586","0.6464072","0.64588547","0.64576095","0.64449865","0.64446276","0.6437191","0.64316356","0.6431304","0.6428258","0.64184","0.64147735","0.641303","0.64026666","0.63971806","0.6390459","0.6385555","0.63847315","0.63833493","0.63811773","0.63803136","0.6377859","0.6372071","0.63591164","0.6355802","0.6354959","0.6353455","0.6343021","0.6341547","0.6337963","0.633549","0.6327923","0.6319723","0.63107425","0.6297358","0.62895703","0.62871516","0.62858903","0.6284418","0.62623817","0.626232","0.6259826","0.6259492","0.6257664","0.6246019","0.62457883","0.62441903","0.6243202","0.62394774","0.6237711","0.6236991"],"string":"[\n \"0.7665592\",\n \"0.75891453\",\n \"0.7549877\",\n \"0.7288455\",\n \"0.7238649\",\n \"0.72074854\",\n \"0.7202781\",\n \"0.71520114\",\n \"0.7109726\",\n \"0.70575273\",\n \"0.6969205\",\n \"0.69633704\",\n \"0.68633807\",\n \"0.6848898\",\n \"0.6821339\",\n \"0.68000925\",\n \"0.677125\",\n \"0.67679054\",\n \"0.6746093\",\n \"0.6742651\",\n \"0.6729055\",\n \"0.6666361\",\n \"0.6662787\",\n \"0.66476506\",\n \"0.6646941\",\n \"0.6638234\",\n \"0.6634028\",\n \"0.6603814\",\n \"0.65982187\",\n \"0.6594358\",\n \"0.6585001\",\n \"0.6581009\",\n \"0.6575865\",\n \"0.65739566\",\n \"0.6569843\",\n \"0.6567062\",\n \"0.6548683\",\n \"0.65439975\",\n \"0.6538684\",\n \"0.6535428\",\n \"0.6529185\",\n \"0.65281767\",\n \"0.6527593\",\n \"0.6512578\",\n \"0.65079015\",\n \"0.6499464\",\n \"0.6498534\",\n \"0.6498499\",\n \"0.6478818\",\n \"0.6478449\",\n \"0.64643586\",\n \"0.6464072\",\n \"0.64588547\",\n \"0.64576095\",\n \"0.64449865\",\n \"0.64446276\",\n \"0.6437191\",\n \"0.64316356\",\n \"0.6431304\",\n \"0.6428258\",\n \"0.64184\",\n \"0.64147735\",\n \"0.641303\",\n \"0.64026666\",\n \"0.63971806\",\n \"0.6390459\",\n \"0.6385555\",\n \"0.63847315\",\n \"0.63833493\",\n \"0.63811773\",\n \"0.63803136\",\n \"0.6377859\",\n \"0.6372071\",\n \"0.63591164\",\n \"0.6355802\",\n \"0.6354959\",\n \"0.6353455\",\n \"0.6343021\",\n \"0.6341547\",\n \"0.6337963\",\n \"0.633549\",\n \"0.6327923\",\n \"0.6319723\",\n \"0.63107425\",\n \"0.6297358\",\n \"0.62895703\",\n \"0.62871516\",\n \"0.62858903\",\n \"0.6284418\",\n \"0.62623817\",\n \"0.626232\",\n \"0.6259826\",\n \"0.6259492\",\n \"0.6257664\",\n \"0.6246019\",\n \"0.62457883\",\n \"0.62441903\",\n \"0.6243202\",\n \"0.62394774\",\n \"0.6237711\",\n \"0.6236991\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":96,"cells":{"query":{"kind":"string","value":"Forward pass through the network to obtain the U field."},"document":{"kind":"string","value":"def net_u(self, x, t):\n\n u = self.model(torch.cat((x,t),1))\n return u"},"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 U(self):\n return self._U","def forward(self, u):\n self.pop(u)\n return self.read(1.)","def get_U(self):\n if self.U is not None:\n return self.U\n return self.calc_Uiso()","def forward(self, inputs):\n\n down0 = self.layer_0(inputs=inputs)\n down1 = self.layer_1(inputs=down0)\n down2 = self.layer_2(inputs=down1)\n down3 = self.layer_3(inputs=down2)\n down4 = self.layer_4(inputs=down3)\n\n up1 = self.layer_7(down4, down3)\n\n up2 = self.layer_8(up1, down2)\n\n up3 = self.layer_9(up2, down1)\n\n up4 = self.layer_10(up3, down0)\n\n up5 = self.layer_11(up4)\n return up5","def forward(self, x):\n return self.net(x)","def u(self):\n return self.__u","def forward(self, x):\n x, self.hidden = self.gru(x, self.hidden)\n self.detach_hidden()\n x = self.dropout(x)\n x = self.out(x)\n return x","def u2fkn( self , u ):","def UFFind(UFP, u):\n if not (UFP[u] == u):\n UFP[u] = UFFind(UFP, UFP[u])\n return UFP[u]","def forward(self, input_):\n out = self.fc(input_)\n out = self.bn(out)\n out = self.relu(out)\n return torch.cat([out, input_], dim=1)","def forward(self, input):\n\n return self.network(input)","def forward(self, input):\n\n return self.network(input)","def forward(self, input):\n\n return self.network(input)","def relu_forward(x):\n ############################################################################\n # TODO: Implement the ReLU forward pass. #\n ############################################################################\n ############################################################################\n # START OF YOUR CODE #\n ############################################################################\n out = x\n out[out<0] = 0\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n return out","def eval_forward(self, u):\n\n if self.eval_forward_f is None:\n\n # masked random numbers\n tt_u = tt.matrix('u')\n mu = self.mask * tt_u\n\n # scale net\n s_net = nn.FeedforwardNet(self.n_inputs, mu)\n for h in self.s_hiddens:\n s_net.addLayer(h, self.s_act)\n s_net.addLayer(self.n_inputs, 'linear')\n util.copy_model_parms(self.s_net, s_net)\n s = s_net.output\n\n # translate net\n t_net = nn.FeedforwardNet(self.n_inputs, mu)\n for h in self.t_hiddens:\n t_net.addLayer(h, self.t_act)\n t_net.addLayer(self.n_inputs, 'linear')\n util.copy_model_parms(self.t_net, t_net)\n t = t_net.output\n\n # transform u -> x\n x = mu + (1.0 - self.mask) * (tt_u * tt.exp(s) + t)\n\n # compile theano function\n self.eval_forward_f = theano.function(\n inputs=[tt_u],\n outputs=x\n )\n\n return self.eval_forward_f(u.astype(dtype))","def forward_once(self, x):\n\t\t#x = F.normalize(self.network(x), p=2)\n\t\tx = self.network(x)\n\t\treturn x","def forward(self, inp):\n return inp.dot(self.W) + self.b","def forward(self, state):\n\n # connect layers to each other and put relu activations between them\n for layer in self.hidden_layers:\n state = layer(state)\n state = F.relu(state)\n value = self.value_layer(state)\n return value","def relu_forward(self, x):\n #out = None\n #############################################################################\n # TODO: Implement the ReLU forward pass. #\n #############################################################################\n out = np.array(x, copy=True)\n out[out <= 0] = 0\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n cache = x\n return out, cache","def z2u(self, z):\n raise NotImplementedError","def forward(self, x):\n assert not torch.isnan(x).any(), f\"NaN in input {x}\"\n x = F.relu(self.l1(x))\n x = F.relu(self.l2(x))\n x = self.l3(x)\n return x","def U(self, p):\n re = self._re(p)\n Le = self._Le(p)\n wf = self._wf(p)\n rf = self._rf(p)\n A = row_wise_dot(re, np.einsum('...ij,...j', self.Ee, re)) @ Le\n B = row_wise_dot(rf, np.einsum('...ij,...j', self.Ff, rf)) @ wf\n return (B - A) * G * self.d * 0.5","def forward(self, t_local, z, backwards = False):\n self.nfe += 1\n\n\n node_attributes = z[:self.K_N,:]\n edge_attributes = z[self.K_N:,:]\n assert (not torch.isnan(node_attributes).any())\n assert (not torch.isnan(edge_attributes).any())\n\n #grad_edge, edge_value = self.edge_ode_func_net(node_attributes,self.num_atom) # [K*N*N,D],[K,N*N], edge value are non-negative by using relu.\n grad_edge, edge_value = self.edge_ode_func_net(node_attributes,edge_attributes,self.num_atom) # [K*N*N,D],[K,N*N], edge value are non-negative by using relu.todo:with self-evolution\n edge_value = self.normalize_graph(edge_value,self.K_N)\n assert (not torch.isnan(edge_value).any())\n grad_node = self.node_ode_func_net(node_attributes,edge_value,self.node_z0) # [K*N,D]\n assert (not torch.isnan(grad_node).any())\n assert (not torch.isinf(grad_edge).any())\n\n assert (not torch.isnan(grad_node).any())\n assert (not torch.isinf(grad_edge).any())\n\n # Concat two grad\n grad = self.dropout(torch.cat([grad_node,grad_edge],0)) # [K*N + K*N*N, D]\n\n\n return grad","def u(self, point = -1):\n return self.solution('u', point)","def forward(self, state):\n x = self.forward_to_var(state)\n return x.data[0]","def forward(self, src=None, rec=None, u=None, vp=None, save=None, **kwargs):\n # Source term is read-only, so re-use the default\n src = src or self.geometry.src\n # Create a new receiver object to store the result\n rec = rec or self.geometry.rec\n\n # Create the forward wavefield if not provided\n u = u or TimeFunction(name='u', grid=self.model.grid,\n save=self.geometry.nt if save else None,\n time_order=2, space_order=self.space_order)\n\n # Pick vp from model unless explicitly provided\n vp = vp or self.model.vp\n\n print(\"====Forward norm(u)\", norm(u))\n # Execute operator and return wavefield and receiver data\n # summary = self.op_fwd(save).apply(src=src, rec=rec, u=u, vp=vp,\n summary = self.op_fwd(save).apply(src=src, u=u, vp=vp,\n dt=kwargs.pop('dt', self.dt), **kwargs)\n print(\"====Forward norm(u)\", norm(u))\n \n\n regnormu = norm(u)\n if 0:\n cmap = plt.cm.get_cmap(\"viridis\")\n values = u.data[0, :, :, :]\n vistagrid = pv.UniformGrid()\n vistagrid.dimensions = np.array(values.shape) + 1\n vistagrid.spacing = (1, 1, 1)\n vistagrid.origin = (0, 0, 0) # The bottom left corner of the data set\n vistagrid.cell_arrays[\"values\"] = values.flatten(order=\"F\")\n vistaslices = vistagrid.slice_orthogonal()\n vistagrid.plot(show_edges=True)\n vistaslices.plot(cmap=cmap)\n\n print(\"Norm u:\", regnormu)\n\n s_u = TimeFunction(name='s_u', grid=self.model.grid, space_order=self.space_order, time_order=2)\n src_u = src.inject(field=s_u.forward, expr=src * self.model.grid.time_dim.spacing**2 / self.model.m)\n\n\n op_f = Operator([src_u])\n op_f.apply(src=src, dt=kwargs.pop('dt', self.dt))\n\n # import pdb;pdb.set_trace()\n print(\"Norm s_u\", norm(s_u))\n\n # Get the nonzero indices\n nzinds = np.nonzero(s_u.data[0]) # nzinds is a tuple\n assert len(nzinds) == len(self.model.grid.shape)\n shape = self.model.grid.shape\n x, y, z = self.model.grid.dimensions\n time = self.model.grid.time_dim\n t = self.model.grid.stepping_dim\n\n source_mask = Function(name='source_mask', shape=self.model.grid.shape, dimensions=(x, y, z), space_order=0, dtype=np.int32)\n\n source_id = Function(name='source_id', shape=shape, dimensions=(x, y, z), space_order=0, dtype=np.int32)\n print(\"source_id data indexes start from 0 now !!!\")\n\n # source_id.data[nzinds[0], nzinds[1], nzinds[2]] = tuple(np.arange(1, len(nzinds[0])+1))\n source_id.data[nzinds[0], nzinds[1], nzinds[2]] = tuple(np.arange(len(nzinds[0])))\n\n source_mask.data[nzinds[0], nzinds[1], nzinds[2]] = 1\n\n print(\"Number of unique affected points is:\", len(nzinds[0]))\n\n # Assert that first and last index are as expected\n assert(source_id.data[nzinds[0][0], nzinds[1][0], nzinds[2][0]] == 0)\n assert(source_id.data[nzinds[0][-1], nzinds[1][-1], nzinds[2][-1]] == len(nzinds[0])-1)\n assert(source_id.data[nzinds[0][len(nzinds[0])-1], nzinds[1][len(nzinds[0])-1], nzinds[2][len(nzinds[0])-1]] == len(nzinds[0])-1)\n\n assert(np.all(np.nonzero(source_id.data)) == np.all(np.nonzero(source_mask.data)))\n assert(np.all(np.nonzero(source_id.data)) == np.all(np.nonzero(s_u.data[0])))\n\n print(\"-At this point source_mask and source_id have been populated correctly-\")\n\n nnz_shape = (self.model.grid.shape[0], self.model.grid.shape[1])\n\n nnz_sp_source_mask = Function(name='nnz_sp_source_mask', shape=(list(nnz_shape)), dimensions=(x,y ), space_order=0, dtype=np.int32)\n\n nnz_sp_source_mask.data[:, :] = source_mask.data[:, :, :].sum(2)\n inds = np.where(source_mask.data == 1.)\n print(\"Grid - source positions:\", inds)\n maxz = len(np.unique(inds[-1]))\n # Change only 3rd dim\n sparse_shape = (self.model.grid.shape[0], self.model.grid.shape[1], maxz)\n\n assert(len(nnz_sp_source_mask.dimensions) == (len(source_mask.dimensions)-1))\n\n # Note : sparse_source_id is not needed as long as sparse info is kept in mask\n # sp_source_id.data[inds[0],inds[1],:] = inds[2][:maxz]\n\n id_dim = Dimension(name='id_dim')\n b_dim = Dimension(name='b_dim')\n\n save_src_u = TimeFunction(name='save_src_u', shape=(src.shape[0],\n nzinds[1].shape[0]), dimensions=(src.dimensions[0],\n id_dim))\n\n save_src_u_term = src.inject(field=save_src_u[src.dimensions[0], source_id], expr=src * self.model.grid.time_dim.spacing**2 / self.model.m)\n\n print(\"Injecting to empty grids\")\n op1 = Operator([save_src_u_term])\n op1.apply(src=src, dt=kwargs.pop('dt', self.dt))\n print(\"Injecting to empty grids finished\")\n sp_zi = Dimension(name='sp_zi')\n\n\n sp_source_id = Function(name='sp_source_id', shape=(list(sparse_shape)),\n dimensions=(x, y, sp_zi), space_order=0, dtype=np.int32)\n\n # Now holds IDs\n sp_source_id.data[inds[0], inds[1], :] = tuple(inds[-1][:len(np.unique(inds[-1]))])\n\n assert(np.count_nonzero(sp_source_id.data) == len(nzinds[0]))\n assert(len(sp_source_id.dimensions) == 3)\n\n # import pdb;pdb.set_trace()\n\n zind = Scalar(name='zind', dtype=np.int32)\n xb_size = Scalar(name='xb_size', dtype=np.int32)\n yb_size = Scalar(name='yb_size', dtype=np.int32)\n x0_blk0_size = Scalar(name='x0_blk0_size', dtype=np.int32)\n y0_blk0_size = Scalar(name='y0_blk0_size', dtype=np.int32)\n\n block_sizes = Function(name='block_sizes', shape=(4, ), dimensions=(b_dim,),\n space_order=0, dtype=np.int32)\n\n bsizes = (8, 8, 32, 32)\n block_sizes.data[:] = bsizes\n\n # eqxb = Eq(xb_size, block_sizes[0])\n # eqyb = Eq(yb_size, block_sizes[1])\n # eqxb2 = Eq(x0_blk0_size, block_sizes[2])\n # eqyb2 = Eq(y0_blk0_size, block_sizes[3])\n\n eq0 = Eq(sp_zi.symbolic_max, nnz_sp_source_mask[x, y] - 1,\n implicit_dims=(time, x, y))\n\n eq1 = Eq(zind, sp_source_id[x, y, sp_zi], implicit_dims=(time, x, y, sp_zi))\n\n # inj_u = source_mask[x, y, zind] * save_src_u[time, source_id[x, y, zind]]\n # Is source_mask needed /\n inj_u = save_src_u[time, source_id[x, y, zind]]\n\n eq_u = Inc(u.forward[t+1, x, y, zind], inj_u, implicit_dims=(time, x, y, sp_zi))\n\n # The additional time-tiling equations\n # tteqs = (eqxb, eqyb, eqxb2, eqyb2, eq0, eq1, eq_u, eq_v)\n\n performance_map = np.array([[0, 0, 0, 0, 0]])\n\n bxstart = 4\n bxend = 9\n bystart = 4\n byend = 9\n bstep = 4\n\n txstart = 32\n txend = 65\n tystart = 32\n tyend = 65\n\n tstep = 32\n # Temporal autotuning\n for tx in range(txstart, txend, tstep):\n # import pdb; pdb.set_trace()\n for ty in range(tystart, tyend, tstep):\n for bx in range(bxstart, bxend, bstep):\n for by in range(bystart, byend, bstep):\n\n block_sizes.data[:] = [tx, ty, bx, by]\n\n eqxb = Eq(xb_size, block_sizes[0])\n eqyb = Eq(yb_size, block_sizes[1])\n eqxb2 = Eq(x0_blk0_size, block_sizes[2])\n eqyb2 = Eq(y0_blk0_size, block_sizes[3])\n\n u.data[:] = 0\n print(\"-----\")\n tteqs = (eqxb, eqyb, eqxb2, eqyb2, eq0, eq1, eq_u)\n\n # import pdb; pdb.set_trace()\n\n # Execute operator and return wavefield and receiver data\n print(\"TT====Forward norm(u)\", norm(u))\n summary_tt = self.op_fwd(save, tteqs).apply(u=u, vp=vp,\n dt=kwargs.pop('dt', self.dt), **kwargs)\n print(\"TT====Forward norm(u)\", norm(u))\n # op_tt = self.op_fwd(save, tteqs)\n\n # Execute operator and return wavefield and receiver data\n #summary_tt = self.op_fwd(save).apply(src=src, rec=rec, u=u, vp=vp,\n # dt=kwargs.pop('dt', self.dt), **kwargs)\n\n # op_tt = self.op_fwd(kernel, save, tteqs)\n # summary_tt = op_tt.apply(u=u, dt=kwargs.pop('dt', self.dt), **kwargs)\n configuration['jit-backdoor'] = False\n norm_tt_u = norm(u)\n print(\"Norm u:\", regnormu)\n print(\"Norm(tt_u):\", norm_tt_u)\n configuration['jit-backdoor'] = True\n\n print(\"===Temporal blocking======================================\")\n\n performance_map = np.append(performance_map, [[tx, ty, bx, by, summary_tt.globals['fdlike'].gpointss]], 0)\n \n print(performance_map)\n # tids = np.unique(performance_map[:, 0])\n\n #for tid in tids:\n bids = np.where((performance_map[:, 0] == tx) & (performance_map[:, 1] == ty))\n bx_data = np.unique(performance_map[bids, 2])\n by_data = np.unique(performance_map[bids, 3])\n gptss_data = performance_map[bids, 4]\n gptss_data = gptss_data.reshape(len(bx_data), len(by_data))\n\n fig, ax = plt.subplots()\n im = ax.imshow(gptss_data); #pause(2)\n # We want to show all ticks...\n ax.set_xticks(np.arange(len(bx_data)))\n ax.set_yticks(np.arange(len(by_data)))\n # ... and label them with the respective list entries\n ax.set_xticklabels(bx_data)\n ax.set_yticklabels(by_data)\n\n ax.set_title(\"Gpts/s for fixed tile size. (Sweeping block sizes)\")\n fig.tight_layout()\n\n fig.colorbar(im, ax=ax)\n # ax = sns.heatmap(gptss_data, linewidth=0.5)\n plt.savefig(str(shape[0]) + str(np.int32(tx)) + str(np.int32(ty)) + \".pdf\")\n\n\n if 1:\n cmap = plt.cm.get_cmap(\"viridis\")\n values = u.data[0, :, :, :]\n vistagrid = pv.UniformGrid()\n vistagrid.dimensions = np.array(values.shape) + 1\n vistagrid.spacing = (1, 1, 1)\n vistagrid.origin = (0, 0, 0) # The bottom left corner of the data set\n vistagrid.cell_arrays[\"values\"] = values.flatten(order=\"F\")\n vistaslices = vistagrid.slice_orthogonal()\n vistagrid.plot(show_edges=True)\n vistaslices.plot(cmap=cmap)\n\n # import pdb;pdb.set_trace()\n return rec, u, summary","def forward(self, x):\n self.save_net()\n self.perturb_tensors()\n out = self.net.forward(x)\n return out","def forward(self, x):\n x = self.efficient_net(x)\n return x","def forward(self, x):\n x = x.float()\n n, c, t, v, m = x.size()\n x = x.permute(0, 4, 3, 1, 2).contiguous()\n x = x.view(n * m, v * c, t)\n x = self.data_bn(x)\n x = x.view(n, m, v, c, t)\n x = x.permute(0, 1, 3, 4, 2).contiguous()\n x = x.view(n * m, c, t, v)\n for gcn in self.agcn_networks:\n x = gcn(x)\n return x","def relu_forward(x):\n out = None\n ###########################################################################\n # TODO: Implement the ReLU forward pass. #\n ###########################################################################\n out = x.copy()\n out[x<=0] = 0\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n cache = x\n return out, cache","def forward(self, x):\n if len(self.convs) == 0:\n return x\n x = x.contiguous()\n for c, n in zip(self.convs, self.norms):\n x = c(x.permute(0, 2, 1)) # (B, C, T)\n x = n(x.permute(0, 2, 1)) # (B, T, C)\n d = torch.nn.functional.dropout(x, p=self.dropout, training=self.training)\n x = torch.relu(d)\n return d","def euler_forward(self, u, v, I):\n # The constants 0.04, 5, 140 are the one fits all parameters from Simple Model of Spiking Neurons E. Izhikevich.\n # These constants are justified when simulating large networks of neurons.\n # TODO: Parameterise the four constants 0.04, 5, 140.\n _v = v + self.dt * (0.04 * v ** 2 + 5 * v + 140 - u + I)\n _u = u + self.dt * (self.a * (self.b * v - u))\n return _v, _u","def forward(self, input=None):\n if (input is not None) and (self.result is None):\n self.result = self.drop(self.node(input))\n\n # Pull the input from previous network layers\n elif self.result is None:\n in_result = []\n for n in self.input:\n in_result.append( n() )\n\n # Concatenate input along the last dim\n self.result = self.drop(self.node(torch.cat(in_result, in_result[0].dim()-1).type(_tensor(\"LongTensor\"))))\n\n return self.result.view(*self.G.d_out)","def forward(self, x):\r\n x = self.conv1(x)\r\n x = self.conv1_BN(x)\r\n x = F.relu(x)\r\n x = self.conv1_dp(x)\r\n x = self.Block2_1(x)\r\n x = self.Block2_2(x)\r\n x = self.Block3_1(x)\r\n x = self.Block3_2(x)\r\n x = self.Block3_3(x)\r\n x = self.Block3_4(x)\r\n x = self.Block4_1(x)\r\n x = self.Block4_2(x)\r\n x = self.Block4_3(x)\r\n x = self.Block4_4(x)\r\n x = self.Block5_1(x)\r\n x = self.Block5_2(x)\r\n x = self.MP(x)\r\n x = x.view(x.size(0),-1)\r\n x = self.fc(x)\r\n \r\n return x","def _forward(self, x, X, upto=None):\n if upto is not None: # cannot use 'if upto' here since it is 0-indexed\n # and layer0 is the first layer\n assert 0<=upto<=self._layer_counter\n counter = upto + 1\n else: counter = self._layer_counter\n\n y_previous, Y_previous = x, X\n # TODO: because we always need to compute F_i(X) at each layer i, this\n # is a huge overhead\n # feedforward\n for i in range(counter):\n layer = getattr(self, 'layer'+str(i))\n y, Y = layer(y_previous, Y_previous), layer(Y_previous, Y_previous)\n y_previous, Y_previous = y, Y\n\n return y","def forward(self, x):\r\n x = x.reshape(x.shape[0], x.shape[1], 1 , 1)\r\n x = self.input(x)\r\n x = self.bn(x)\r\n x = F.relu(x)\r\n for i in range(len(self.DV)-1, -1, -1):\r\n x = self.DV[i](x)\r\n if i != 0:\r\n x = self.BN[i](x)\r\n x = F.relu(x)\r\n for col, t in enumerate(self.col_type):\r\n i = int(col/self.shape)\r\n j = col % self.shape\r\n if t == \"binary\":\r\n x[:,:,i,j] = torch.sigmoid(x[:,:,i,j])\r\n elif t == \"normalize\":\r\n x[:,:,i,j] = torch.tanh(x[:,:,i,j])\r\n else:\r\n x[:,:,i,j] = torch.relu(x[:,:,i,j])\r\n return x","def forward(self, inputs):\n\n down1, indices_1, unpool_shape1 = self.layer_1(inputs=inputs,\n layer_size=2)\n down2, indices_2, unpool_shape2 = self.layer_2(inputs=down1,\n layer_size=2)\n down3, indices_3, unpool_shape3 = self.layer_3(inputs=down2,\n layer_size=3)\n down4, indices_4, unpool_shape4 = self.layer_4(inputs=down3,\n layer_size=3)\n down5, indices_5, unpool_shape5 = self.layer_6(inputs=down4,\n layer_size=3)\n\n inter = self.layer_inter(down5)\n\n up1 = self.layer_7(inputs=inter, indices=indices_5, layer_size=3)\n\n up2 = self.layer_8(inputs=up1, indices=indices_4, layer_size=3)\n\n up3 = self.layer_9(inputs=up2, indices=indices_3, layer_size=3)\n\n up4 = self.layer_10(inputs=up3, indices=indices_2, layer_size=2)\n\n up5 = self.layer_11(inputs=up4, indices=indices_1, layer_size=2)\n return up5","def _layer_forward(self, z_prev, layer, use_relu=True):\n\n self.__dict__['z_prev_'+layer] = z_prev\n b = self.__getattribute__('b_'+layer)\n w = self.__getattribute__('w_'+layer)\n\n dim_out = w.shape[0]\n\n # simplification due to np broadcasting\n a = z_prev@w.T + b\n\n z = relu(a) if use_relu else a\n\n return (a, z)","def forward(self, x):\n return x","def t2u( self , t ):\n \n # Default is a constant signal\n u = self.ubar\n \n return u","def relu(input, inplace=False):\n return FunctionLib.apply(\n 'Relu', input.device, [input],\n outputs=[input if inplace else None], alpha=0.)","def forward(self, input):\n if isinstance(input.data, torch.cuda.FloatTensor) and \\\n self.num_gpu > 1:\n out = nn.parallel.data_parallel(\n self.layer, input, range(self.num_gpu))\n else:\n out = self.layer(input)\n\n return out.view(-1)","def forward(self, x):\n # x = state\n \n x = F.relu(self.input(x))\n x = self.output(x)\n \n return x","def forward(self, x):\n x = F.relu(self.fc1(x))\n x = F.relu(self.fc2(x))\n x = self.fc3(x)\n return x","def u2z(self, u):\n raise NotImplementedError","def u(self):\n return (self.u_edges[1:] + self.u_edges[:-1]) / 2","def forward(self, **kwargs):\n return self.a","def forward(self, x):\n assert not torch.isnan(x).any(), f\"NaN in input {x}\"\n x = F.relu(self.l1(x))\n x = F.relu(self.l2(x))\n x = self.l3(x)\n return torch.clamp(x, -1, 1)","def postprocess(self, U):\n # de-normalize so to say\n U = self.scalarU.inverse_transform(U.reshape(1, -1))\n U = U.ravel()\n return np.array(U)","def _forward(self, z):\n raise NotImplementedError(\"Forward shouldn't be called!\")","def eval_forward(self, x, u):\n\n if self.eval_forward_f is None:\n\n # conditional input\n tt_x = tt.matrix('x')\n\n # masked random numbers\n tt_u = tt.matrix('u')\n mu = self.mask * tt_u\n\n # scale net\n s_net = nn.FeedforwardNet(self.n_inputs + self.n_outputs, tt.concatenate([tt_x, mu], axis=1))\n for h in self.s_hiddens:\n s_net.addLayer(h, self.s_act)\n s_net.addLayer(self.n_outputs, 'linear')\n util.copy_model_parms(self.s_net, s_net)\n s = s_net.output\n\n # translate net\n t_net = nn.FeedforwardNet(self.n_inputs + self.n_outputs, tt.concatenate([tt_x, mu], axis=1))\n for h in self.t_hiddens:\n t_net.addLayer(h, self.t_act)\n t_net.addLayer(self.n_outputs, 'linear')\n util.copy_model_parms(self.t_net, t_net)\n t = t_net.output\n\n # transform (x,u) -> y\n y = mu + (1.0 - self.mask) * (tt_u * tt.exp(s) + t)\n\n # compile theano function\n self.eval_forward_f = theano.function(\n inputs=[tt_x, tt_u],\n outputs=y\n )\n\n return self.eval_forward_f(x.astype(dtype), u.astype(dtype))","def forward(self, input):\n if isinstance(input.data, torch.cuda.FloatTensor) and \\\n self.num_gpu > 1:\n out = nn.parallel.data_parallel(\n self.layer, input, range(self.num_gpu))\n else:\n out = self.layer(input)\n return out.view(-1, 1).squeeze(1)","def get_u(self, e):\n e_p = e - self.old_e\n\n self.old_e = self.e\n self.e = e\n\n self.sum_e += e\n\n # PID controller.\n u = - self.k_p * e - self.k_d * e_p - self.k_i * self.sum_e\n\n return u","def forward(self, input_x):\n return self.net(input_x.float())","def sum_u(self):\r\n try:\r\n # add the velocity to the sum\r\n self.usum.vector()[:] += self.u.vector()[:]\r\n except AttributeError:\r\n # initialize the sum\r\n self.usum = self.u.copy(deepcopy=True)","def calc_adv_U(self):\n num_U = 0\n adv_U = numpy.zeros((3,3), float)\n\n for atm in self:\n ## use the atom's U matrix if it exists, otherwise use the\n ## temperature factor\n\n if atm.U is not None:\n adv_U += atm.U\n num_U += 1\n\n return adv_U / num_U","def forward(self, input=None):\n if (input is not None) and (self.result is None):\n self.result = self.act(self.drop(self.node(input.view(*self.G.d_in))))\n\n # Pull the input from previous network layers\n elif self.result is None:\n in_result = []\n for n in self.input:\n in_result.append( n() )\n\n # Concatenate input along the last dim\n self.result = self.act(self.drop(self.node(torch.cat(in_result, in_result[0].dim() - 1))))\n\n return self.result.view(*self.G.d_out)","def forward(self,x):\n x = x.transpose(1,2).contiguous()\n x = F.leaky_relu(self.fc1(x), 0.2)\n x = F.leaky_relu(self.bn2(self.fc2(x)), 0.2)\n x = F.leaky_relu(self.bn3(self.fc3(x)), 0.2)\n x = torch.sigmoid(self.fc4(x))\n return x.transpose(1,2)","def forward(self,z):\n z = z.float().transpose(1,2).contiguous()\n x = F.relu(self.bn1(self.fc1(z)))\n x = F.relu(self.bn1(x))\n x = F.relu(self.bn2(self.fc2(x)))\n x = F.relu(self.bn3(self.fc3(x)))\n vocal = torch.exp(self.fc4_1(x))\n noise = torch.exp(self.fc4_2(x))\n return vocal.transpose(1,2), noise.transpose(1,2)","def forward(self, x):\n for i, layer in enumerate(self.layers):\n x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x)\n return x.squeeze(0)","def order_u(self):\n return self._degree_u + 1","def x(self):\r\n return self.unif[0]","def forward(self, x):\n res = self.residual(x)\n x = self.gcn(x)\n x = self.tcn(x) + res\n return self.relu(x)","def update_relus(self):\n\n def relu_backward_hook_function(module, grad_in, grad_out):\n \"\"\"\n If there is a negative gradient, change it to zero\n \"\"\"\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)\n\n def relu_forward_hook_function(module, ten_in, ten_out):\n \"\"\"\n Store results of forward pass\n \"\"\"\n self.forward_relu_outputs.append(ten_out)\n\n # Loop through layers, hook up ReLUs","def forward(self, x):\n x=T.div(x,255.0)\n \n #print(state[20:,20:,0])\n #print(state[:,0,:,:])\n conv1 = F.relu(self.conv1(x))\n conv2 = F.relu(self.conv2(conv1))\n conv3 = F.relu(self.conv3(conv2))\n ###\n conv_state = conv3.view(conv3.size()[0], -1)\n flat1 = F.relu(self.fc1(conv_state))\n flat2 = F.relu(self.fc2(flat1))\n\n V = self.V(flat2)\n A = self.A(flat2)\n\n return V, A\n return x","def relu6(input, inplace=False):\n return FunctionLib.apply(\n 'Relu', input.device, [input],\n outputs=[input if inplace else None], alpha=0., max_value=6.)","def forward(self):\n self.value = np.dot(self.x_node.value, self.w_node.value) + self.b_node.value","def forward(self, x):\n pass","def forward(self)->None:","def forward(self, x):\n return self.l1(x)","def forward(self, x):\n out = self.conv1(x)\n out = self.bn1(out)\n out = self.relu(out)\n out = self.maxpool(out)\n out = self.avgpool(out)\n out = self.layer1(out)\n out = self.layer2(out)\n out = self.layer3(out)\n out = self.layer4(out)\n out = self.avgpool(out)\n out = torch.flatten(out, 1)\n out = self.fc(out)\n return out","def forward(self, x):\n # Pass the input through all the layers apllying ReLU activation, but the last\n for layer in self.fc_layers[:-1]:\n x = F.relu(layer(x))\n # Pass the result through the output layer apllying hyperbolic tangent function\n x = torch.tanh(self.fc_layers[-1](x))\n # Return the better action for the input state\n return x","def forward(self, X):\n X = self._normalize(X)\n h_relu1 = self.slice1(X)\n h_relu2 = self.slice2(h_relu1)\n h_relu3 = self.slice3(h_relu2)\n h_relu4 = self.slice4(h_relu3)\n h_relu5 = self.slice5(h_relu4)\n out = [h_relu1, h_relu2, h_relu3, h_relu4, h_relu5]\n return out","def forward(self):\n R = self.LP.cost.R\n A = self.LP.dyn.A\n B = self.LP.dyn.B\n\n x = self.LP.x0\n self.x[0] = x\n for i in range(self.LP.N):\n u = - np.linalg.inv(R+B.T.dot(self.V[i+1]).dot(B)).dot(.5*B.T.dot(self.W[i+1]) \\\n + B.T.dot(self.V[i+1]).dot(A).dot(x))\n if self.LP.dyn.u_dim == 1:\n self.u[i] = float(u)\n else:\n self.u[i] = u\n self.J_star[i] = float(x.T.dot(self.V[i]).dot(x) + self.W[i].T.dot(x)) #up to constant\n\n if i == 0:\n self.J[i] = self.LP.cost.loss(x, u, i)\n else:\n self.J[i] = self.J[i-1] + self.LP.cost.loss(x, u, i)\n x = self.LP.dyn.next_state(x, u)\n self.x[i+1] = x\n\n self.J[self.LP.N] = self.J[self.LP.N-1] + self.LP.cost.loss(x, 0, self.LP.N)\n\n self.J_star[self.LP.N] = float(x.T.dot(self.V[self.LP.N]).dot(x) \\\n + self.W[self.LP.N].T.dot(x)) #up to constant","def forward(self, x):\n h = self.relu(self.en_x_1(self.dropout(x)))\n h = self.relu(self.en_x_2(self.dropout(h)))\n h = self.relu(self.en_x_3(self.dropout(h)))\n return self.en_x_4_mu(self.dropout(h)), self.en_x_4_sigma(self.dropout(h))","def relu_forward(x):\n out = None\n ###########################################################################\n # TODO: Implement the ReLU forward pass. #\n ###########################################################################\n #out = np.zeros(x.shape)\n #np.clip(x, 0, None, out)\n out = np.empty_like(x) #faster than zeros\n np.clip(x, 0, None, out)\n #out = x\n #out [out < 0] = 0\n #print(x)\n #print(out)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n cache = x\n return out, cache","def relu_forward(x):\n out = None\n ###########################################################################\n # TODO: Implement the ReLU forward pass. #\n ###########################################################################\n out = x * (x > 0)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n cache = x\n return out, cache","def degree_u(self):\n return self._degree_u","def _nn_forward(self, x_joined):\n out = self.nn(x_joined).squeeze(0).detach().numpy()\n output = out[:-self.update_size()]\n update_vector = out[-self.update_size():]\n return output, update_vector","def forward(self, input=None):\n if (input is not None) and (self.result is None):\n self.result = self.act(input)\n\n # Pull the input from previous network layers\n elif self.result is None:\n in_result = []\n\n # Apply a separate activation to each resulting input if applicable\n if self.G.in_activation:\n for i, n in enumerate(self.input):\n in_result.append( self.G.in_activation[i](n()).type(_tensor(\"FloatTensor\")) )\n\n else:\n for n in self.input:\n in_result.append( n() )\n\n # Concatenate input along the lat dim\n self.result = self.act(torch.cat(in_result, in_result[0].dim() - 1))\n\n return self.result.view(*self.G.d_out)","def forward(self, state):\n x = state\n for layer in self.linear_layers[:-1]:\n x = F.relu(layer(x))\n x = self.linear_layers[-1](x)\n return x","def relu_forward(x):\n out = None\n ###########################################################################\n # TODO: Implement the ReLU forward pass. #\n ###########################################################################\n out = np.maximum(0, x)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n cache = x\n return out, cache","def forward(self, input):\n input, _ = input\n bs = input.shape[0]\n d1 = self.relu1(self.fc1(input))\n d2 = self.relu2(self.fc2(d1))\n d3 = self.fc3(d2)\n out = self.sigmoid(d3)\n\n out = out.view(bs, 17, 3)\n return out","def forward(self,i,direction):\n \"\"\"the direction argument is used to dertermine the direcrtion of the forward function, designed for the equilibrium of the two classes of the datasets\"\"\"\n if(direction):\n self.mask_A = self.netG_Amask[self.orders[i]](self.real_A)\n self.A = self.netG_A[self.orders[i]](self.real_A)\n self.fake_B = self.A.mul(self.mask_A\n )+(1-self.mask_A).mul(self.real_A) # G_A(A)\n self.mask_B = self.netG_Bmask[self.orders[i]](self.fake_B)\n self.B = self.netG_B[self.orders[i]](self.fake_B)\n self.rec_A = self.B.mul(self.mask_B)+(1-self.mask_B).mul(self.fake_B) # G_B(G_A(A))\n else:\n self.mask_A = self.netG_Bmask[self.orders_rev[i]](self.real_A)\n self.A = self.netG_B[self.orders_rev[i]](self.real_A)\n self.fake_B = self.A.mul(self.mask_A\n )+(1-self.mask_A).mul(self.real_A) # G_A(A)\n self.mask_B = self.netG_Amask[self.orders_rev[i]](self.fake_B)\n self.B = self.netG_A[self.orders_rev[i]](self.fake_B)\n self.rec_A = self.B.mul(\n self.mask_B)+(self.mask_B).mul(1-self.fake_B) # G_B(G_A(A))","def forward(self, x):\n # Get results of encoder network\n h1 = self.encode_nn(x)\n\n # latent space\n mu = self.encode_mu(h1)\n log_var = self.encode_log_var(h1)\n\n # Reparameterize\n z = self.reparameterize(mu, log_var)\n return z, mu, log_var","def forward(self, x):\n # Get results of encoder network\n h1 = self.encode_nn(x)\n\n # latent space\n mu = self.encode_mu(h1)\n log_var = self.encode_log_var(h1)\n\n # Reparameterize\n z = self.reparameterize(mu, log_var)\n return z, mu, log_var","def forward(self, x):\n x = self.conv_layer(x)\n\n self.gru.flatten_parameters()\n memory, out = self.gru(x)\n\n if self.phoneme_level:\n pv_forward = memory[:, :, :self.E//2]\n pv_backward = memory[:, :, self.E//2:]\n prosody_vector = torch.cat((pv_forward, pv_backward), dim=-1)\n else:\n out = out.transpose(0, 1)\n prosody_vector = torch.cat((out[:, 0], out[:, 1]), dim=-1).unsqueeze(1)\n prosody_vector = self.predictor_bottleneck(prosody_vector)\n\n return prosody_vector","def forward(self, U, V):\n raise NotImplementedError(\"Please do not use the Kernel class directly\")","def forward(self, x):\n residues = []\n # Downward Pass\n x = self.layers[0](x.unsqueeze(1))\n for layer in self.layers[1:self.half]:\n x = layer(x)\n residues.insert(0, x)\n\n # Upward Pass\n for idx, layer in enumerate(self.layers[self.half:(len(self.layers)-1)]):\n x = layer(x, residues[idx])\n x = self.layers[-1](x)\n\n return(x)","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n x = F.relu(self.fc3(x))\n return self.fc4(x)","def forward(self, state, action): #concatenate the action -value\n\n xu = torch.cat([state, action], 1)\n\n x1 = F.relu(self.fc1(xu))\n x1 = F.relu(self.fc2(x1))\n x1 = self.fc3(x1)\n\n x2 = F.relu(self.fc4(xu))\n x2 = F.relu(self.fc5(x2))\n x2 = self.fc6(x2)\n \n return x1, x2","def lu(self):\n if not self.domain.is_Field:\n raise DMNotAField('Not a field')\n L, U, swaps = self.rep.lu()\n return self.from_rep(L), self.from_rep(U), swaps","def uf(self):\n return self._uf","def get_u(r_div_R, z_div_L, k, Bp, Bm, gp, gm, lam1, int_Y):\n \n # uR = (lam1/2.)*(1. + r_div_R)*int_Y\n # uR = (1. + r_div_R)*int_Y\n uR = (1. + r_div_R)*int_Y\n \n uZ_out = -k*(exp(k*z_div_L)*(Bp + gm) \\\n - exp(-k*z_div_L)*(Bm + gp))\n\n return uZ_out * uR","def relu_forward(x):\n out = None\n ###########################################################################\n # TODO: Implement the ReLU forward pass. #\n ###########################################################################\n out = np.maximum(x,0)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n cache = x\n return out, cache","def forward(self, x):\n\n out = torch.relu(self.conv1(x))\n out = torch.relu(self.conv2(out))\n\n out = torch.relu(self.resnet_block(out))\n\n out = torch.relu(self.deconv1(out))\n out = torch.tanh(self.deconv2(out))\n\n return out","def forward(self, x):\n\t\t#######################################################################\n\t\t# ** START OF YOUR CODE **\n\t\t#######################################################################\n\n\t\toutput = self._layers[0].forward(x)\n\t\tfor i in range(1, len(self._layers)):\n\t\t\toutput = self._layers[i].forward(output)\n\t\treturn output\n\n\t\t#######################################################################\n\t\t# ** END OF YOUR CODE **\n\t\t#######################################################################","def forward(self, state):#forward pass\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n return torch.tanh(self.fc3(x))","def forward(self, state):\n\n x = state # Careful: deepcopy bug?\n # Intermediate Layers\n for layer in self.layers[:-1]:\n\n x = nn.ReLU()(layer(x))\n\n x = nn.Tanh()(self.layers[-1](x))\n return x","def forward(self, x):\n return self.relu(self.conv(x))"],"string":"[\n \"def U(self):\\n return self._U\",\n \"def forward(self, u):\\n self.pop(u)\\n return self.read(1.)\",\n \"def get_U(self):\\n if self.U is not None:\\n return self.U\\n return self.calc_Uiso()\",\n \"def forward(self, inputs):\\n\\n down0 = self.layer_0(inputs=inputs)\\n down1 = self.layer_1(inputs=down0)\\n down2 = self.layer_2(inputs=down1)\\n down3 = self.layer_3(inputs=down2)\\n down4 = self.layer_4(inputs=down3)\\n\\n up1 = self.layer_7(down4, down3)\\n\\n up2 = self.layer_8(up1, down2)\\n\\n up3 = self.layer_9(up2, down1)\\n\\n up4 = self.layer_10(up3, down0)\\n\\n up5 = self.layer_11(up4)\\n return up5\",\n \"def forward(self, x):\\n return self.net(x)\",\n \"def u(self):\\n return self.__u\",\n \"def forward(self, x):\\n x, self.hidden = self.gru(x, self.hidden)\\n self.detach_hidden()\\n x = self.dropout(x)\\n x = self.out(x)\\n return x\",\n \"def u2fkn( self , u ):\",\n \"def UFFind(UFP, u):\\n if not (UFP[u] == u):\\n UFP[u] = UFFind(UFP, UFP[u])\\n return UFP[u]\",\n \"def forward(self, input_):\\n out = self.fc(input_)\\n out = self.bn(out)\\n out = self.relu(out)\\n return torch.cat([out, input_], dim=1)\",\n \"def forward(self, input):\\n\\n return self.network(input)\",\n \"def forward(self, input):\\n\\n return self.network(input)\",\n \"def forward(self, input):\\n\\n return self.network(input)\",\n \"def relu_forward(x):\\n ############################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ############################################################################\\n ############################################################################\\n # START OF YOUR CODE #\\n ############################################################################\\n out = x\\n out[out<0] = 0\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n return out\",\n \"def eval_forward(self, u):\\n\\n if self.eval_forward_f is None:\\n\\n # masked random numbers\\n tt_u = tt.matrix('u')\\n mu = self.mask * tt_u\\n\\n # scale net\\n s_net = nn.FeedforwardNet(self.n_inputs, mu)\\n for h in self.s_hiddens:\\n s_net.addLayer(h, self.s_act)\\n s_net.addLayer(self.n_inputs, 'linear')\\n util.copy_model_parms(self.s_net, s_net)\\n s = s_net.output\\n\\n # translate net\\n t_net = nn.FeedforwardNet(self.n_inputs, mu)\\n for h in self.t_hiddens:\\n t_net.addLayer(h, self.t_act)\\n t_net.addLayer(self.n_inputs, 'linear')\\n util.copy_model_parms(self.t_net, t_net)\\n t = t_net.output\\n\\n # transform u -> x\\n x = mu + (1.0 - self.mask) * (tt_u * tt.exp(s) + t)\\n\\n # compile theano function\\n self.eval_forward_f = theano.function(\\n inputs=[tt_u],\\n outputs=x\\n )\\n\\n return self.eval_forward_f(u.astype(dtype))\",\n \"def forward_once(self, x):\\n\\t\\t#x = F.normalize(self.network(x), p=2)\\n\\t\\tx = self.network(x)\\n\\t\\treturn x\",\n \"def forward(self, inp):\\n return inp.dot(self.W) + self.b\",\n \"def forward(self, state):\\n\\n # connect layers to each other and put relu activations between them\\n for layer in self.hidden_layers:\\n state = layer(state)\\n state = F.relu(state)\\n value = self.value_layer(state)\\n return value\",\n \"def relu_forward(self, x):\\n #out = None\\n #############################################################################\\n # TODO: Implement the ReLU forward pass. #\\n #############################################################################\\n out = np.array(x, copy=True)\\n out[out <= 0] = 0\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n cache = x\\n return out, cache\",\n \"def z2u(self, z):\\n raise NotImplementedError\",\n \"def forward(self, x):\\n assert not torch.isnan(x).any(), f\\\"NaN in input {x}\\\"\\n x = F.relu(self.l1(x))\\n x = F.relu(self.l2(x))\\n x = self.l3(x)\\n return x\",\n \"def U(self, p):\\n re = self._re(p)\\n Le = self._Le(p)\\n wf = self._wf(p)\\n rf = self._rf(p)\\n A = row_wise_dot(re, np.einsum('...ij,...j', self.Ee, re)) @ Le\\n B = row_wise_dot(rf, np.einsum('...ij,...j', self.Ff, rf)) @ wf\\n return (B - A) * G * self.d * 0.5\",\n \"def forward(self, t_local, z, backwards = False):\\n self.nfe += 1\\n\\n\\n node_attributes = z[:self.K_N,:]\\n edge_attributes = z[self.K_N:,:]\\n assert (not torch.isnan(node_attributes).any())\\n assert (not torch.isnan(edge_attributes).any())\\n\\n #grad_edge, edge_value = self.edge_ode_func_net(node_attributes,self.num_atom) # [K*N*N,D],[K,N*N], edge value are non-negative by using relu.\\n grad_edge, edge_value = self.edge_ode_func_net(node_attributes,edge_attributes,self.num_atom) # [K*N*N,D],[K,N*N], edge value are non-negative by using relu.todo:with self-evolution\\n edge_value = self.normalize_graph(edge_value,self.K_N)\\n assert (not torch.isnan(edge_value).any())\\n grad_node = self.node_ode_func_net(node_attributes,edge_value,self.node_z0) # [K*N,D]\\n assert (not torch.isnan(grad_node).any())\\n assert (not torch.isinf(grad_edge).any())\\n\\n assert (not torch.isnan(grad_node).any())\\n assert (not torch.isinf(grad_edge).any())\\n\\n # Concat two grad\\n grad = self.dropout(torch.cat([grad_node,grad_edge],0)) # [K*N + K*N*N, D]\\n\\n\\n return grad\",\n \"def u(self, point = -1):\\n return self.solution('u', point)\",\n \"def forward(self, state):\\n x = self.forward_to_var(state)\\n return x.data[0]\",\n \"def forward(self, src=None, rec=None, u=None, vp=None, save=None, **kwargs):\\n # Source term is read-only, so re-use the default\\n src = src or self.geometry.src\\n # Create a new receiver object to store the result\\n rec = rec or self.geometry.rec\\n\\n # Create the forward wavefield if not provided\\n u = u or TimeFunction(name='u', grid=self.model.grid,\\n save=self.geometry.nt if save else None,\\n time_order=2, space_order=self.space_order)\\n\\n # Pick vp from model unless explicitly provided\\n vp = vp or self.model.vp\\n\\n print(\\\"====Forward norm(u)\\\", norm(u))\\n # Execute operator and return wavefield and receiver data\\n # summary = self.op_fwd(save).apply(src=src, rec=rec, u=u, vp=vp,\\n summary = self.op_fwd(save).apply(src=src, u=u, vp=vp,\\n dt=kwargs.pop('dt', self.dt), **kwargs)\\n print(\\\"====Forward norm(u)\\\", norm(u))\\n \\n\\n regnormu = norm(u)\\n if 0:\\n cmap = plt.cm.get_cmap(\\\"viridis\\\")\\n values = u.data[0, :, :, :]\\n vistagrid = pv.UniformGrid()\\n vistagrid.dimensions = np.array(values.shape) + 1\\n vistagrid.spacing = (1, 1, 1)\\n vistagrid.origin = (0, 0, 0) # The bottom left corner of the data set\\n vistagrid.cell_arrays[\\\"values\\\"] = values.flatten(order=\\\"F\\\")\\n vistaslices = vistagrid.slice_orthogonal()\\n vistagrid.plot(show_edges=True)\\n vistaslices.plot(cmap=cmap)\\n\\n print(\\\"Norm u:\\\", regnormu)\\n\\n s_u = TimeFunction(name='s_u', grid=self.model.grid, space_order=self.space_order, time_order=2)\\n src_u = src.inject(field=s_u.forward, expr=src * self.model.grid.time_dim.spacing**2 / self.model.m)\\n\\n\\n op_f = Operator([src_u])\\n op_f.apply(src=src, dt=kwargs.pop('dt', self.dt))\\n\\n # import pdb;pdb.set_trace()\\n print(\\\"Norm s_u\\\", norm(s_u))\\n\\n # Get the nonzero indices\\n nzinds = np.nonzero(s_u.data[0]) # nzinds is a tuple\\n assert len(nzinds) == len(self.model.grid.shape)\\n shape = self.model.grid.shape\\n x, y, z = self.model.grid.dimensions\\n time = self.model.grid.time_dim\\n t = self.model.grid.stepping_dim\\n\\n source_mask = Function(name='source_mask', shape=self.model.grid.shape, dimensions=(x, y, z), space_order=0, dtype=np.int32)\\n\\n source_id = Function(name='source_id', shape=shape, dimensions=(x, y, z), space_order=0, dtype=np.int32)\\n print(\\\"source_id data indexes start from 0 now !!!\\\")\\n\\n # source_id.data[nzinds[0], nzinds[1], nzinds[2]] = tuple(np.arange(1, len(nzinds[0])+1))\\n source_id.data[nzinds[0], nzinds[1], nzinds[2]] = tuple(np.arange(len(nzinds[0])))\\n\\n source_mask.data[nzinds[0], nzinds[1], nzinds[2]] = 1\\n\\n print(\\\"Number of unique affected points is:\\\", len(nzinds[0]))\\n\\n # Assert that first and last index are as expected\\n assert(source_id.data[nzinds[0][0], nzinds[1][0], nzinds[2][0]] == 0)\\n assert(source_id.data[nzinds[0][-1], nzinds[1][-1], nzinds[2][-1]] == len(nzinds[0])-1)\\n assert(source_id.data[nzinds[0][len(nzinds[0])-1], nzinds[1][len(nzinds[0])-1], nzinds[2][len(nzinds[0])-1]] == len(nzinds[0])-1)\\n\\n assert(np.all(np.nonzero(source_id.data)) == np.all(np.nonzero(source_mask.data)))\\n assert(np.all(np.nonzero(source_id.data)) == np.all(np.nonzero(s_u.data[0])))\\n\\n print(\\\"-At this point source_mask and source_id have been populated correctly-\\\")\\n\\n nnz_shape = (self.model.grid.shape[0], self.model.grid.shape[1])\\n\\n nnz_sp_source_mask = Function(name='nnz_sp_source_mask', shape=(list(nnz_shape)), dimensions=(x,y ), space_order=0, dtype=np.int32)\\n\\n nnz_sp_source_mask.data[:, :] = source_mask.data[:, :, :].sum(2)\\n inds = np.where(source_mask.data == 1.)\\n print(\\\"Grid - source positions:\\\", inds)\\n maxz = len(np.unique(inds[-1]))\\n # Change only 3rd dim\\n sparse_shape = (self.model.grid.shape[0], self.model.grid.shape[1], maxz)\\n\\n assert(len(nnz_sp_source_mask.dimensions) == (len(source_mask.dimensions)-1))\\n\\n # Note : sparse_source_id is not needed as long as sparse info is kept in mask\\n # sp_source_id.data[inds[0],inds[1],:] = inds[2][:maxz]\\n\\n id_dim = Dimension(name='id_dim')\\n b_dim = Dimension(name='b_dim')\\n\\n save_src_u = TimeFunction(name='save_src_u', shape=(src.shape[0],\\n nzinds[1].shape[0]), dimensions=(src.dimensions[0],\\n id_dim))\\n\\n save_src_u_term = src.inject(field=save_src_u[src.dimensions[0], source_id], expr=src * self.model.grid.time_dim.spacing**2 / self.model.m)\\n\\n print(\\\"Injecting to empty grids\\\")\\n op1 = Operator([save_src_u_term])\\n op1.apply(src=src, dt=kwargs.pop('dt', self.dt))\\n print(\\\"Injecting to empty grids finished\\\")\\n sp_zi = Dimension(name='sp_zi')\\n\\n\\n sp_source_id = Function(name='sp_source_id', shape=(list(sparse_shape)),\\n dimensions=(x, y, sp_zi), space_order=0, dtype=np.int32)\\n\\n # Now holds IDs\\n sp_source_id.data[inds[0], inds[1], :] = tuple(inds[-1][:len(np.unique(inds[-1]))])\\n\\n assert(np.count_nonzero(sp_source_id.data) == len(nzinds[0]))\\n assert(len(sp_source_id.dimensions) == 3)\\n\\n # import pdb;pdb.set_trace()\\n\\n zind = Scalar(name='zind', dtype=np.int32)\\n xb_size = Scalar(name='xb_size', dtype=np.int32)\\n yb_size = Scalar(name='yb_size', dtype=np.int32)\\n x0_blk0_size = Scalar(name='x0_blk0_size', dtype=np.int32)\\n y0_blk0_size = Scalar(name='y0_blk0_size', dtype=np.int32)\\n\\n block_sizes = Function(name='block_sizes', shape=(4, ), dimensions=(b_dim,),\\n space_order=0, dtype=np.int32)\\n\\n bsizes = (8, 8, 32, 32)\\n block_sizes.data[:] = bsizes\\n\\n # eqxb = Eq(xb_size, block_sizes[0])\\n # eqyb = Eq(yb_size, block_sizes[1])\\n # eqxb2 = Eq(x0_blk0_size, block_sizes[2])\\n # eqyb2 = Eq(y0_blk0_size, block_sizes[3])\\n\\n eq0 = Eq(sp_zi.symbolic_max, nnz_sp_source_mask[x, y] - 1,\\n implicit_dims=(time, x, y))\\n\\n eq1 = Eq(zind, sp_source_id[x, y, sp_zi], implicit_dims=(time, x, y, sp_zi))\\n\\n # inj_u = source_mask[x, y, zind] * save_src_u[time, source_id[x, y, zind]]\\n # Is source_mask needed /\\n inj_u = save_src_u[time, source_id[x, y, zind]]\\n\\n eq_u = Inc(u.forward[t+1, x, y, zind], inj_u, implicit_dims=(time, x, y, sp_zi))\\n\\n # The additional time-tiling equations\\n # tteqs = (eqxb, eqyb, eqxb2, eqyb2, eq0, eq1, eq_u, eq_v)\\n\\n performance_map = np.array([[0, 0, 0, 0, 0]])\\n\\n bxstart = 4\\n bxend = 9\\n bystart = 4\\n byend = 9\\n bstep = 4\\n\\n txstart = 32\\n txend = 65\\n tystart = 32\\n tyend = 65\\n\\n tstep = 32\\n # Temporal autotuning\\n for tx in range(txstart, txend, tstep):\\n # import pdb; pdb.set_trace()\\n for ty in range(tystart, tyend, tstep):\\n for bx in range(bxstart, bxend, bstep):\\n for by in range(bystart, byend, bstep):\\n\\n block_sizes.data[:] = [tx, ty, bx, by]\\n\\n eqxb = Eq(xb_size, block_sizes[0])\\n eqyb = Eq(yb_size, block_sizes[1])\\n eqxb2 = Eq(x0_blk0_size, block_sizes[2])\\n eqyb2 = Eq(y0_blk0_size, block_sizes[3])\\n\\n u.data[:] = 0\\n print(\\\"-----\\\")\\n tteqs = (eqxb, eqyb, eqxb2, eqyb2, eq0, eq1, eq_u)\\n\\n # import pdb; pdb.set_trace()\\n\\n # Execute operator and return wavefield and receiver data\\n print(\\\"TT====Forward norm(u)\\\", norm(u))\\n summary_tt = self.op_fwd(save, tteqs).apply(u=u, vp=vp,\\n dt=kwargs.pop('dt', self.dt), **kwargs)\\n print(\\\"TT====Forward norm(u)\\\", norm(u))\\n # op_tt = self.op_fwd(save, tteqs)\\n\\n # Execute operator and return wavefield and receiver data\\n #summary_tt = self.op_fwd(save).apply(src=src, rec=rec, u=u, vp=vp,\\n # dt=kwargs.pop('dt', self.dt), **kwargs)\\n\\n # op_tt = self.op_fwd(kernel, save, tteqs)\\n # summary_tt = op_tt.apply(u=u, dt=kwargs.pop('dt', self.dt), **kwargs)\\n configuration['jit-backdoor'] = False\\n norm_tt_u = norm(u)\\n print(\\\"Norm u:\\\", regnormu)\\n print(\\\"Norm(tt_u):\\\", norm_tt_u)\\n configuration['jit-backdoor'] = True\\n\\n print(\\\"===Temporal blocking======================================\\\")\\n\\n performance_map = np.append(performance_map, [[tx, ty, bx, by, summary_tt.globals['fdlike'].gpointss]], 0)\\n \\n print(performance_map)\\n # tids = np.unique(performance_map[:, 0])\\n\\n #for tid in tids:\\n bids = np.where((performance_map[:, 0] == tx) & (performance_map[:, 1] == ty))\\n bx_data = np.unique(performance_map[bids, 2])\\n by_data = np.unique(performance_map[bids, 3])\\n gptss_data = performance_map[bids, 4]\\n gptss_data = gptss_data.reshape(len(bx_data), len(by_data))\\n\\n fig, ax = plt.subplots()\\n im = ax.imshow(gptss_data); #pause(2)\\n # We want to show all ticks...\\n ax.set_xticks(np.arange(len(bx_data)))\\n ax.set_yticks(np.arange(len(by_data)))\\n # ... and label them with the respective list entries\\n ax.set_xticklabels(bx_data)\\n ax.set_yticklabels(by_data)\\n\\n ax.set_title(\\\"Gpts/s for fixed tile size. (Sweeping block sizes)\\\")\\n fig.tight_layout()\\n\\n fig.colorbar(im, ax=ax)\\n # ax = sns.heatmap(gptss_data, linewidth=0.5)\\n plt.savefig(str(shape[0]) + str(np.int32(tx)) + str(np.int32(ty)) + \\\".pdf\\\")\\n\\n\\n if 1:\\n cmap = plt.cm.get_cmap(\\\"viridis\\\")\\n values = u.data[0, :, :, :]\\n vistagrid = pv.UniformGrid()\\n vistagrid.dimensions = np.array(values.shape) + 1\\n vistagrid.spacing = (1, 1, 1)\\n vistagrid.origin = (0, 0, 0) # The bottom left corner of the data set\\n vistagrid.cell_arrays[\\\"values\\\"] = values.flatten(order=\\\"F\\\")\\n vistaslices = vistagrid.slice_orthogonal()\\n vistagrid.plot(show_edges=True)\\n vistaslices.plot(cmap=cmap)\\n\\n # import pdb;pdb.set_trace()\\n return rec, u, summary\",\n \"def forward(self, x):\\n self.save_net()\\n self.perturb_tensors()\\n out = self.net.forward(x)\\n return out\",\n \"def forward(self, x):\\n x = self.efficient_net(x)\\n return x\",\n \"def forward(self, x):\\n x = x.float()\\n n, c, t, v, m = x.size()\\n x = x.permute(0, 4, 3, 1, 2).contiguous()\\n x = x.view(n * m, v * c, t)\\n x = self.data_bn(x)\\n x = x.view(n, m, v, c, t)\\n x = x.permute(0, 1, 3, 4, 2).contiguous()\\n x = x.view(n * m, c, t, v)\\n for gcn in self.agcn_networks:\\n x = gcn(x)\\n return x\",\n \"def relu_forward(x):\\n out = None\\n ###########################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ###########################################################################\\n out = x.copy()\\n out[x<=0] = 0\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n cache = x\\n return out, cache\",\n \"def forward(self, x):\\n if len(self.convs) == 0:\\n return x\\n x = x.contiguous()\\n for c, n in zip(self.convs, self.norms):\\n x = c(x.permute(0, 2, 1)) # (B, C, T)\\n x = n(x.permute(0, 2, 1)) # (B, T, C)\\n d = torch.nn.functional.dropout(x, p=self.dropout, training=self.training)\\n x = torch.relu(d)\\n return d\",\n \"def euler_forward(self, u, v, I):\\n # The constants 0.04, 5, 140 are the one fits all parameters from Simple Model of Spiking Neurons E. Izhikevich.\\n # These constants are justified when simulating large networks of neurons.\\n # TODO: Parameterise the four constants 0.04, 5, 140.\\n _v = v + self.dt * (0.04 * v ** 2 + 5 * v + 140 - u + I)\\n _u = u + self.dt * (self.a * (self.b * v - u))\\n return _v, _u\",\n \"def forward(self, input=None):\\n if (input is not None) and (self.result is None):\\n self.result = self.drop(self.node(input))\\n\\n # Pull the input from previous network layers\\n elif self.result is None:\\n in_result = []\\n for n in self.input:\\n in_result.append( n() )\\n\\n # Concatenate input along the last dim\\n self.result = self.drop(self.node(torch.cat(in_result, in_result[0].dim()-1).type(_tensor(\\\"LongTensor\\\"))))\\n\\n return self.result.view(*self.G.d_out)\",\n \"def forward(self, x):\\r\\n x = self.conv1(x)\\r\\n x = self.conv1_BN(x)\\r\\n x = F.relu(x)\\r\\n x = self.conv1_dp(x)\\r\\n x = self.Block2_1(x)\\r\\n x = self.Block2_2(x)\\r\\n x = self.Block3_1(x)\\r\\n x = self.Block3_2(x)\\r\\n x = self.Block3_3(x)\\r\\n x = self.Block3_4(x)\\r\\n x = self.Block4_1(x)\\r\\n x = self.Block4_2(x)\\r\\n x = self.Block4_3(x)\\r\\n x = self.Block4_4(x)\\r\\n x = self.Block5_1(x)\\r\\n x = self.Block5_2(x)\\r\\n x = self.MP(x)\\r\\n x = x.view(x.size(0),-1)\\r\\n x = self.fc(x)\\r\\n \\r\\n return x\",\n \"def _forward(self, x, X, upto=None):\\n if upto is not None: # cannot use 'if upto' here since it is 0-indexed\\n # and layer0 is the first layer\\n assert 0<=upto<=self._layer_counter\\n counter = upto + 1\\n else: counter = self._layer_counter\\n\\n y_previous, Y_previous = x, X\\n # TODO: because we always need to compute F_i(X) at each layer i, this\\n # is a huge overhead\\n # feedforward\\n for i in range(counter):\\n layer = getattr(self, 'layer'+str(i))\\n y, Y = layer(y_previous, Y_previous), layer(Y_previous, Y_previous)\\n y_previous, Y_previous = y, Y\\n\\n return y\",\n \"def forward(self, x):\\r\\n x = x.reshape(x.shape[0], x.shape[1], 1 , 1)\\r\\n x = self.input(x)\\r\\n x = self.bn(x)\\r\\n x = F.relu(x)\\r\\n for i in range(len(self.DV)-1, -1, -1):\\r\\n x = self.DV[i](x)\\r\\n if i != 0:\\r\\n x = self.BN[i](x)\\r\\n x = F.relu(x)\\r\\n for col, t in enumerate(self.col_type):\\r\\n i = int(col/self.shape)\\r\\n j = col % self.shape\\r\\n if t == \\\"binary\\\":\\r\\n x[:,:,i,j] = torch.sigmoid(x[:,:,i,j])\\r\\n elif t == \\\"normalize\\\":\\r\\n x[:,:,i,j] = torch.tanh(x[:,:,i,j])\\r\\n else:\\r\\n x[:,:,i,j] = torch.relu(x[:,:,i,j])\\r\\n return x\",\n \"def forward(self, inputs):\\n\\n down1, indices_1, unpool_shape1 = self.layer_1(inputs=inputs,\\n layer_size=2)\\n down2, indices_2, unpool_shape2 = self.layer_2(inputs=down1,\\n layer_size=2)\\n down3, indices_3, unpool_shape3 = self.layer_3(inputs=down2,\\n layer_size=3)\\n down4, indices_4, unpool_shape4 = self.layer_4(inputs=down3,\\n layer_size=3)\\n down5, indices_5, unpool_shape5 = self.layer_6(inputs=down4,\\n layer_size=3)\\n\\n inter = self.layer_inter(down5)\\n\\n up1 = self.layer_7(inputs=inter, indices=indices_5, layer_size=3)\\n\\n up2 = self.layer_8(inputs=up1, indices=indices_4, layer_size=3)\\n\\n up3 = self.layer_9(inputs=up2, indices=indices_3, layer_size=3)\\n\\n up4 = self.layer_10(inputs=up3, indices=indices_2, layer_size=2)\\n\\n up5 = self.layer_11(inputs=up4, indices=indices_1, layer_size=2)\\n return up5\",\n \"def _layer_forward(self, z_prev, layer, use_relu=True):\\n\\n self.__dict__['z_prev_'+layer] = z_prev\\n b = self.__getattribute__('b_'+layer)\\n w = self.__getattribute__('w_'+layer)\\n\\n dim_out = w.shape[0]\\n\\n # simplification due to np broadcasting\\n a = z_prev@w.T + b\\n\\n z = relu(a) if use_relu else a\\n\\n return (a, z)\",\n \"def forward(self, x):\\n return x\",\n \"def t2u( self , t ):\\n \\n # Default is a constant signal\\n u = self.ubar\\n \\n return u\",\n \"def relu(input, inplace=False):\\n return FunctionLib.apply(\\n 'Relu', input.device, [input],\\n outputs=[input if inplace else None], alpha=0.)\",\n \"def forward(self, input):\\n if isinstance(input.data, torch.cuda.FloatTensor) and \\\\\\n self.num_gpu > 1:\\n out = nn.parallel.data_parallel(\\n self.layer, input, range(self.num_gpu))\\n else:\\n out = self.layer(input)\\n\\n return out.view(-1)\",\n \"def forward(self, x):\\n # x = state\\n \\n x = F.relu(self.input(x))\\n x = self.output(x)\\n \\n return x\",\n \"def forward(self, x):\\n x = F.relu(self.fc1(x))\\n x = F.relu(self.fc2(x))\\n x = self.fc3(x)\\n return x\",\n \"def u2z(self, u):\\n raise NotImplementedError\",\n \"def u(self):\\n return (self.u_edges[1:] + self.u_edges[:-1]) / 2\",\n \"def forward(self, **kwargs):\\n return self.a\",\n \"def forward(self, x):\\n assert not torch.isnan(x).any(), f\\\"NaN in input {x}\\\"\\n x = F.relu(self.l1(x))\\n x = F.relu(self.l2(x))\\n x = self.l3(x)\\n return torch.clamp(x, -1, 1)\",\n \"def postprocess(self, U):\\n # de-normalize so to say\\n U = self.scalarU.inverse_transform(U.reshape(1, -1))\\n U = U.ravel()\\n return np.array(U)\",\n \"def _forward(self, z):\\n raise NotImplementedError(\\\"Forward shouldn't be called!\\\")\",\n \"def eval_forward(self, x, u):\\n\\n if self.eval_forward_f is None:\\n\\n # conditional input\\n tt_x = tt.matrix('x')\\n\\n # masked random numbers\\n tt_u = tt.matrix('u')\\n mu = self.mask * tt_u\\n\\n # scale net\\n s_net = nn.FeedforwardNet(self.n_inputs + self.n_outputs, tt.concatenate([tt_x, mu], axis=1))\\n for h in self.s_hiddens:\\n s_net.addLayer(h, self.s_act)\\n s_net.addLayer(self.n_outputs, 'linear')\\n util.copy_model_parms(self.s_net, s_net)\\n s = s_net.output\\n\\n # translate net\\n t_net = nn.FeedforwardNet(self.n_inputs + self.n_outputs, tt.concatenate([tt_x, mu], axis=1))\\n for h in self.t_hiddens:\\n t_net.addLayer(h, self.t_act)\\n t_net.addLayer(self.n_outputs, 'linear')\\n util.copy_model_parms(self.t_net, t_net)\\n t = t_net.output\\n\\n # transform (x,u) -> y\\n y = mu + (1.0 - self.mask) * (tt_u * tt.exp(s) + t)\\n\\n # compile theano function\\n self.eval_forward_f = theano.function(\\n inputs=[tt_x, tt_u],\\n outputs=y\\n )\\n\\n return self.eval_forward_f(x.astype(dtype), u.astype(dtype))\",\n \"def forward(self, input):\\n if isinstance(input.data, torch.cuda.FloatTensor) and \\\\\\n self.num_gpu > 1:\\n out = nn.parallel.data_parallel(\\n self.layer, input, range(self.num_gpu))\\n else:\\n out = self.layer(input)\\n return out.view(-1, 1).squeeze(1)\",\n \"def get_u(self, e):\\n e_p = e - self.old_e\\n\\n self.old_e = self.e\\n self.e = e\\n\\n self.sum_e += e\\n\\n # PID controller.\\n u = - self.k_p * e - self.k_d * e_p - self.k_i * self.sum_e\\n\\n return u\",\n \"def forward(self, input_x):\\n return self.net(input_x.float())\",\n \"def sum_u(self):\\r\\n try:\\r\\n # add the velocity to the sum\\r\\n self.usum.vector()[:] += self.u.vector()[:]\\r\\n except AttributeError:\\r\\n # initialize the sum\\r\\n self.usum = self.u.copy(deepcopy=True)\",\n \"def calc_adv_U(self):\\n num_U = 0\\n adv_U = numpy.zeros((3,3), float)\\n\\n for atm in self:\\n ## use the atom's U matrix if it exists, otherwise use the\\n ## temperature factor\\n\\n if atm.U is not None:\\n adv_U += atm.U\\n num_U += 1\\n\\n return adv_U / num_U\",\n \"def forward(self, input=None):\\n if (input is not None) and (self.result is None):\\n self.result = self.act(self.drop(self.node(input.view(*self.G.d_in))))\\n\\n # Pull the input from previous network layers\\n elif self.result is None:\\n in_result = []\\n for n in self.input:\\n in_result.append( n() )\\n\\n # Concatenate input along the last dim\\n self.result = self.act(self.drop(self.node(torch.cat(in_result, in_result[0].dim() - 1))))\\n\\n return self.result.view(*self.G.d_out)\",\n \"def forward(self,x):\\n x = x.transpose(1,2).contiguous()\\n x = F.leaky_relu(self.fc1(x), 0.2)\\n x = F.leaky_relu(self.bn2(self.fc2(x)), 0.2)\\n x = F.leaky_relu(self.bn3(self.fc3(x)), 0.2)\\n x = torch.sigmoid(self.fc4(x))\\n return x.transpose(1,2)\",\n \"def forward(self,z):\\n z = z.float().transpose(1,2).contiguous()\\n x = F.relu(self.bn1(self.fc1(z)))\\n x = F.relu(self.bn1(x))\\n x = F.relu(self.bn2(self.fc2(x)))\\n x = F.relu(self.bn3(self.fc3(x)))\\n vocal = torch.exp(self.fc4_1(x))\\n noise = torch.exp(self.fc4_2(x))\\n return vocal.transpose(1,2), noise.transpose(1,2)\",\n \"def forward(self, x):\\n for i, layer in enumerate(self.layers):\\n x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x)\\n return x.squeeze(0)\",\n \"def order_u(self):\\n return self._degree_u + 1\",\n \"def x(self):\\r\\n return self.unif[0]\",\n \"def forward(self, x):\\n res = self.residual(x)\\n x = self.gcn(x)\\n x = self.tcn(x) + res\\n return self.relu(x)\",\n \"def update_relus(self):\\n\\n def relu_backward_hook_function(module, grad_in, grad_out):\\n \\\"\\\"\\\"\\n If there is a negative gradient, change it to zero\\n \\\"\\\"\\\"\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\\n\\n def relu_forward_hook_function(module, ten_in, ten_out):\\n \\\"\\\"\\\"\\n Store results of forward pass\\n \\\"\\\"\\\"\\n self.forward_relu_outputs.append(ten_out)\\n\\n # Loop through layers, hook up ReLUs\",\n \"def forward(self, x):\\n x=T.div(x,255.0)\\n \\n #print(state[20:,20:,0])\\n #print(state[:,0,:,:])\\n conv1 = F.relu(self.conv1(x))\\n conv2 = F.relu(self.conv2(conv1))\\n conv3 = F.relu(self.conv3(conv2))\\n ###\\n conv_state = conv3.view(conv3.size()[0], -1)\\n flat1 = F.relu(self.fc1(conv_state))\\n flat2 = F.relu(self.fc2(flat1))\\n\\n V = self.V(flat2)\\n A = self.A(flat2)\\n\\n return V, A\\n return x\",\n \"def relu6(input, inplace=False):\\n return FunctionLib.apply(\\n 'Relu', input.device, [input],\\n outputs=[input if inplace else None], alpha=0., max_value=6.)\",\n \"def forward(self):\\n self.value = np.dot(self.x_node.value, self.w_node.value) + self.b_node.value\",\n \"def forward(self, x):\\n pass\",\n \"def forward(self)->None:\",\n \"def forward(self, x):\\n return self.l1(x)\",\n \"def forward(self, x):\\n out = self.conv1(x)\\n out = self.bn1(out)\\n out = self.relu(out)\\n out = self.maxpool(out)\\n out = self.avgpool(out)\\n out = self.layer1(out)\\n out = self.layer2(out)\\n out = self.layer3(out)\\n out = self.layer4(out)\\n out = self.avgpool(out)\\n out = torch.flatten(out, 1)\\n out = self.fc(out)\\n return out\",\n \"def forward(self, x):\\n # Pass the input through all the layers apllying ReLU activation, but the last\\n for layer in self.fc_layers[:-1]:\\n x = F.relu(layer(x))\\n # Pass the result through the output layer apllying hyperbolic tangent function\\n x = torch.tanh(self.fc_layers[-1](x))\\n # Return the better action for the input state\\n return x\",\n \"def forward(self, X):\\n X = self._normalize(X)\\n h_relu1 = self.slice1(X)\\n h_relu2 = self.slice2(h_relu1)\\n h_relu3 = self.slice3(h_relu2)\\n h_relu4 = self.slice4(h_relu3)\\n h_relu5 = self.slice5(h_relu4)\\n out = [h_relu1, h_relu2, h_relu3, h_relu4, h_relu5]\\n return out\",\n \"def forward(self):\\n R = self.LP.cost.R\\n A = self.LP.dyn.A\\n B = self.LP.dyn.B\\n\\n x = self.LP.x0\\n self.x[0] = x\\n for i in range(self.LP.N):\\n u = - np.linalg.inv(R+B.T.dot(self.V[i+1]).dot(B)).dot(.5*B.T.dot(self.W[i+1]) \\\\\\n + B.T.dot(self.V[i+1]).dot(A).dot(x))\\n if self.LP.dyn.u_dim == 1:\\n self.u[i] = float(u)\\n else:\\n self.u[i] = u\\n self.J_star[i] = float(x.T.dot(self.V[i]).dot(x) + self.W[i].T.dot(x)) #up to constant\\n\\n if i == 0:\\n self.J[i] = self.LP.cost.loss(x, u, i)\\n else:\\n self.J[i] = self.J[i-1] + self.LP.cost.loss(x, u, i)\\n x = self.LP.dyn.next_state(x, u)\\n self.x[i+1] = x\\n\\n self.J[self.LP.N] = self.J[self.LP.N-1] + self.LP.cost.loss(x, 0, self.LP.N)\\n\\n self.J_star[self.LP.N] = float(x.T.dot(self.V[self.LP.N]).dot(x) \\\\\\n + self.W[self.LP.N].T.dot(x)) #up to constant\",\n \"def forward(self, x):\\n h = self.relu(self.en_x_1(self.dropout(x)))\\n h = self.relu(self.en_x_2(self.dropout(h)))\\n h = self.relu(self.en_x_3(self.dropout(h)))\\n return self.en_x_4_mu(self.dropout(h)), self.en_x_4_sigma(self.dropout(h))\",\n \"def relu_forward(x):\\n out = None\\n ###########################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ###########################################################################\\n #out = np.zeros(x.shape)\\n #np.clip(x, 0, None, out)\\n out = np.empty_like(x) #faster than zeros\\n np.clip(x, 0, None, out)\\n #out = x\\n #out [out < 0] = 0\\n #print(x)\\n #print(out)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n cache = x\\n return out, cache\",\n \"def relu_forward(x):\\n out = None\\n ###########################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ###########################################################################\\n out = x * (x > 0)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n cache = x\\n return out, cache\",\n \"def degree_u(self):\\n return self._degree_u\",\n \"def _nn_forward(self, x_joined):\\n out = self.nn(x_joined).squeeze(0).detach().numpy()\\n output = out[:-self.update_size()]\\n update_vector = out[-self.update_size():]\\n return output, update_vector\",\n \"def forward(self, input=None):\\n if (input is not None) and (self.result is None):\\n self.result = self.act(input)\\n\\n # Pull the input from previous network layers\\n elif self.result is None:\\n in_result = []\\n\\n # Apply a separate activation to each resulting input if applicable\\n if self.G.in_activation:\\n for i, n in enumerate(self.input):\\n in_result.append( self.G.in_activation[i](n()).type(_tensor(\\\"FloatTensor\\\")) )\\n\\n else:\\n for n in self.input:\\n in_result.append( n() )\\n\\n # Concatenate input along the lat dim\\n self.result = self.act(torch.cat(in_result, in_result[0].dim() - 1))\\n\\n return self.result.view(*self.G.d_out)\",\n \"def forward(self, state):\\n x = state\\n for layer in self.linear_layers[:-1]:\\n x = F.relu(layer(x))\\n x = self.linear_layers[-1](x)\\n return x\",\n \"def relu_forward(x):\\n out = None\\n ###########################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ###########################################################################\\n out = np.maximum(0, x)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n cache = x\\n return out, cache\",\n \"def forward(self, input):\\n input, _ = input\\n bs = input.shape[0]\\n d1 = self.relu1(self.fc1(input))\\n d2 = self.relu2(self.fc2(d1))\\n d3 = self.fc3(d2)\\n out = self.sigmoid(d3)\\n\\n out = out.view(bs, 17, 3)\\n return out\",\n \"def forward(self,i,direction):\\n \\\"\\\"\\\"the direction argument is used to dertermine the direcrtion of the forward function, designed for the equilibrium of the two classes of the datasets\\\"\\\"\\\"\\n if(direction):\\n self.mask_A = self.netG_Amask[self.orders[i]](self.real_A)\\n self.A = self.netG_A[self.orders[i]](self.real_A)\\n self.fake_B = self.A.mul(self.mask_A\\n )+(1-self.mask_A).mul(self.real_A) # G_A(A)\\n self.mask_B = self.netG_Bmask[self.orders[i]](self.fake_B)\\n self.B = self.netG_B[self.orders[i]](self.fake_B)\\n self.rec_A = self.B.mul(self.mask_B)+(1-self.mask_B).mul(self.fake_B) # G_B(G_A(A))\\n else:\\n self.mask_A = self.netG_Bmask[self.orders_rev[i]](self.real_A)\\n self.A = self.netG_B[self.orders_rev[i]](self.real_A)\\n self.fake_B = self.A.mul(self.mask_A\\n )+(1-self.mask_A).mul(self.real_A) # G_A(A)\\n self.mask_B = self.netG_Amask[self.orders_rev[i]](self.fake_B)\\n self.B = self.netG_A[self.orders_rev[i]](self.fake_B)\\n self.rec_A = self.B.mul(\\n self.mask_B)+(self.mask_B).mul(1-self.fake_B) # G_B(G_A(A))\",\n \"def forward(self, x):\\n # Get results of encoder network\\n h1 = self.encode_nn(x)\\n\\n # latent space\\n mu = self.encode_mu(h1)\\n log_var = self.encode_log_var(h1)\\n\\n # Reparameterize\\n z = self.reparameterize(mu, log_var)\\n return z, mu, log_var\",\n \"def forward(self, x):\\n # Get results of encoder network\\n h1 = self.encode_nn(x)\\n\\n # latent space\\n mu = self.encode_mu(h1)\\n log_var = self.encode_log_var(h1)\\n\\n # Reparameterize\\n z = self.reparameterize(mu, log_var)\\n return z, mu, log_var\",\n \"def forward(self, x):\\n x = self.conv_layer(x)\\n\\n self.gru.flatten_parameters()\\n memory, out = self.gru(x)\\n\\n if self.phoneme_level:\\n pv_forward = memory[:, :, :self.E//2]\\n pv_backward = memory[:, :, self.E//2:]\\n prosody_vector = torch.cat((pv_forward, pv_backward), dim=-1)\\n else:\\n out = out.transpose(0, 1)\\n prosody_vector = torch.cat((out[:, 0], out[:, 1]), dim=-1).unsqueeze(1)\\n prosody_vector = self.predictor_bottleneck(prosody_vector)\\n\\n return prosody_vector\",\n \"def forward(self, U, V):\\n raise NotImplementedError(\\\"Please do not use the Kernel class directly\\\")\",\n \"def forward(self, x):\\n residues = []\\n # Downward Pass\\n x = self.layers[0](x.unsqueeze(1))\\n for layer in self.layers[1:self.half]:\\n x = layer(x)\\n residues.insert(0, x)\\n\\n # Upward Pass\\n for idx, layer in enumerate(self.layers[self.half:(len(self.layers)-1)]):\\n x = layer(x, residues[idx])\\n x = self.layers[-1](x)\\n\\n return(x)\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n x = F.relu(self.fc3(x))\\n return self.fc4(x)\",\n \"def forward(self, state, action): #concatenate the action -value\\n\\n xu = torch.cat([state, action], 1)\\n\\n x1 = F.relu(self.fc1(xu))\\n x1 = F.relu(self.fc2(x1))\\n x1 = self.fc3(x1)\\n\\n x2 = F.relu(self.fc4(xu))\\n x2 = F.relu(self.fc5(x2))\\n x2 = self.fc6(x2)\\n \\n return x1, x2\",\n \"def lu(self):\\n if not self.domain.is_Field:\\n raise DMNotAField('Not a field')\\n L, U, swaps = self.rep.lu()\\n return self.from_rep(L), self.from_rep(U), swaps\",\n \"def uf(self):\\n return self._uf\",\n \"def get_u(r_div_R, z_div_L, k, Bp, Bm, gp, gm, lam1, int_Y):\\n \\n # uR = (lam1/2.)*(1. + r_div_R)*int_Y\\n # uR = (1. + r_div_R)*int_Y\\n uR = (1. + r_div_R)*int_Y\\n \\n uZ_out = -k*(exp(k*z_div_L)*(Bp + gm) \\\\\\n - exp(-k*z_div_L)*(Bm + gp))\\n\\n return uZ_out * uR\",\n \"def relu_forward(x):\\n out = None\\n ###########################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ###########################################################################\\n out = np.maximum(x,0)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n cache = x\\n return out, cache\",\n \"def forward(self, x):\\n\\n out = torch.relu(self.conv1(x))\\n out = torch.relu(self.conv2(out))\\n\\n out = torch.relu(self.resnet_block(out))\\n\\n out = torch.relu(self.deconv1(out))\\n out = torch.tanh(self.deconv2(out))\\n\\n return out\",\n \"def forward(self, x):\\n\\t\\t#######################################################################\\n\\t\\t# ** START OF YOUR CODE **\\n\\t\\t#######################################################################\\n\\n\\t\\toutput = self._layers[0].forward(x)\\n\\t\\tfor i in range(1, len(self._layers)):\\n\\t\\t\\toutput = self._layers[i].forward(output)\\n\\t\\treturn output\\n\\n\\t\\t#######################################################################\\n\\t\\t# ** END OF YOUR CODE **\\n\\t\\t#######################################################################\",\n \"def forward(self, state):#forward pass\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n return torch.tanh(self.fc3(x))\",\n \"def forward(self, state):\\n\\n x = state # Careful: deepcopy bug?\\n # Intermediate Layers\\n for layer in self.layers[:-1]:\\n\\n x = nn.ReLU()(layer(x))\\n\\n x = nn.Tanh()(self.layers[-1](x))\\n return x\",\n \"def forward(self, x):\\n return self.relu(self.conv(x))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6244465","0.6143601","0.61348015","0.60307336","0.5914714","0.586357","0.5847307","0.5737416","0.57315356","0.5697165","0.5688825","0.5688825","0.5688825","0.56794524","0.56679034","0.5638842","0.5594738","0.55896443","0.5576749","0.5571661","0.5566135","0.55470383","0.55427605","0.55363","0.5533603","0.5511647","0.5506512","0.5505972","0.5497721","0.5486407","0.548037","0.5476035","0.54685867","0.5468541","0.5467939","0.54578525","0.5452075","0.54466486","0.5445254","0.54385006","0.542862","0.54209685","0.5416206","0.54059947","0.5404547","0.539713","0.53939366","0.539324","0.53845215","0.5381983","0.53802574","0.5377551","0.537401","0.5359855","0.53598505","0.5346049","0.5337342","0.5337006","0.53349125","0.5331081","0.53269154","0.53198904","0.5314291","0.5304881","0.5301916","0.5288876","0.52844673","0.527676","0.5275084","0.5266523","0.5246314","0.52454597","0.52436614","0.52405983","0.5240039","0.52320546","0.522516","0.5224297","0.52206016","0.5217984","0.5204504","0.52011865","0.5196571","0.5195059","0.5186499","0.5186499","0.51855266","0.51777923","0.5175602","0.5172361","0.517132","0.51706004","0.51705337","0.5169497","0.51622057","0.5158712","0.51585853","0.51584387","0.51542884","0.5151343"],"string":"[\n \"0.6244465\",\n \"0.6143601\",\n \"0.61348015\",\n \"0.60307336\",\n \"0.5914714\",\n \"0.586357\",\n \"0.5847307\",\n \"0.5737416\",\n \"0.57315356\",\n \"0.5697165\",\n \"0.5688825\",\n \"0.5688825\",\n \"0.5688825\",\n \"0.56794524\",\n \"0.56679034\",\n \"0.5638842\",\n \"0.5594738\",\n \"0.55896443\",\n \"0.5576749\",\n \"0.5571661\",\n \"0.5566135\",\n \"0.55470383\",\n \"0.55427605\",\n \"0.55363\",\n \"0.5533603\",\n \"0.5511647\",\n \"0.5506512\",\n \"0.5505972\",\n \"0.5497721\",\n \"0.5486407\",\n \"0.548037\",\n \"0.5476035\",\n \"0.54685867\",\n \"0.5468541\",\n \"0.5467939\",\n \"0.54578525\",\n \"0.5452075\",\n \"0.54466486\",\n \"0.5445254\",\n \"0.54385006\",\n \"0.542862\",\n \"0.54209685\",\n \"0.5416206\",\n \"0.54059947\",\n \"0.5404547\",\n \"0.539713\",\n \"0.53939366\",\n \"0.539324\",\n \"0.53845215\",\n \"0.5381983\",\n \"0.53802574\",\n \"0.5377551\",\n \"0.537401\",\n \"0.5359855\",\n \"0.53598505\",\n \"0.5346049\",\n \"0.5337342\",\n \"0.5337006\",\n \"0.53349125\",\n \"0.5331081\",\n \"0.53269154\",\n \"0.53198904\",\n \"0.5314291\",\n \"0.5304881\",\n \"0.5301916\",\n \"0.5288876\",\n \"0.52844673\",\n \"0.527676\",\n \"0.5275084\",\n \"0.5266523\",\n \"0.5246314\",\n \"0.52454597\",\n \"0.52436614\",\n \"0.52405983\",\n \"0.5240039\",\n \"0.52320546\",\n \"0.522516\",\n \"0.5224297\",\n \"0.52206016\",\n \"0.5217984\",\n \"0.5204504\",\n \"0.52011865\",\n \"0.5196571\",\n \"0.5195059\",\n \"0.5186499\",\n \"0.5186499\",\n \"0.51855266\",\n \"0.51777923\",\n \"0.5175602\",\n \"0.5172361\",\n \"0.517132\",\n \"0.51706004\",\n \"0.51705337\",\n \"0.5169497\",\n \"0.51622057\",\n \"0.5158712\",\n \"0.51585853\",\n \"0.51584387\",\n \"0.51542884\",\n \"0.5151343\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58103776"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":97,"cells":{"query":{"kind":"string","value":"The providerassigned unique ID for this managed resource."},"document":{"kind":"string","value":"def id(self) -> str:\n return pulumi.get(self, \"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 provider_id(self):\n return self.get('_id')","def provider_id(self):\n raise NotImplementedError","def id(self):\n return self.raw_resource.uuid","def healthcare_provider_id(self):\n return self._healthcare_provider_id","def unique_identifier(self) -> str:\n return pulumi.get(self, \"unique_identifier\")","def resource_id(self) -> str:\n return pulumi.get(self, \"resource_id\")","def resource_id(self) -> str:\n return pulumi.get(self, \"resource_id\")","def resource_id(self) -> str:\n return pulumi.get(self, \"resource_id\")","def unique_id(self) -> str:\n return pulumi.get(self, \"unique_id\")","def unique_id(self):\r\n return f\"{DOMAIN}_{self.charge_point_id}_{self.connector_id}\"","def unique_id(self) -> str:\n return self._unique_id","def unique_id(self) -> str:\n return self._unique_id","def unique_id(self) -> str:\n return self._unique_id","def unique_id(self) -> str:\n return self._unique_id","def unique_id(self) -> str:\n return self._unique_id","def unique_id(self) -> str:\n return self._unique_id","def unique_id(self) -> str:\n return self._unique_id","def unique_id(self) -> str:\n return self._unique_id","def unique_id(self):\n return self._uuid","def unique_id(self):\n return self._uuid","def unique_id(self) -> str:\n return self._uid","def unique_id(self):\n return f\"{self.device.id}-{self.key}\"","def unique_id(self):\n return self.properties.get(\"UniqueId\", None)","def internal_id(self) -> str:\n return pulumi.get(self, \"internal_id\")","def unique_id(self) -> str:\n return f\"{self._host}_{self._name}_{self._unique_id}\"","def custom_id(self) -> str:\n return self._underlying.custom_id","def unique_id(self):\n return self._id","def unique_id(self):\n return self._id","def unique_id(self):\n return (\n \"a80f3d5b-df3d-4e38-bbb7-1025276830cd\"\n )","def get_objectID(self):\n return self.resource.uuid","def unique_id(self):\n return self._uid","def unique_id(self):\n return self._uid","def unique_id(self):\n return self._uid","def unique_id(self):\n id = \"{}{}{}\".format(\n DOMAIN, self._account, self.sensorName.lower().replace(\" \", \"\")\n )\n return id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self):\n return self._unique_id","def unique_id(self) -> str:\n return self.get_unique_id(wallet=self.wallet_id, nonce=self.nonce)","def unique_id(self):\n return self.device_id","def get_id(self):\n \"\"\"Requires use of Python 3\"\"\"\n return str(self.id)","def resourceid(self):","def unique_id(self) -> str:\n return '{0}_{1}'.format(self._mac.replace(':', ''), self.entity_id)","def unique_id(self):\n return self._device_id","def getid(self):\n if self.Id is None:\n return self.internalid\n else:\n return self.Id","def getid(self):\n if self.Id is None:\n return self.internalid\n else:\n return self.Id","def getid(self):\n if self.Id is None:\n return self.internalid\n else:\n return self.Id","def getid(self):\n if self.Id is None:\n return self.internalid\n else:\n return self.Id","def getid(self):\n if self.Id is None:\n return self.internalid\n else:\n return self.Id","def getid(self):\n if self.Id is None:\n return self.internalid\n else:\n return self.Id","def get_id(self):\n return str(self._id)","def get_id(self):\n return str(self._id)","def identity(self) -> str:\n return self.requester.uuid","def get_id(self) -> str:\n return self._register_id","def get_unique_id(self):\n if not self.unique_id:\n self.unique_id = uuid.uuid4().hex\n return self.unique_id","def unique_id(self):\n return f\"{self.config_entry.entry_id}_{self.hub_name}_{self.sensor_name}\"","def getID(self):\n return str(self._storage_id)","def id(self):\n return self.raw_resource[\"id\"]","def get_id(self): # real signature unknown; restored from __doc__\n return \"\"","def id(self) -> str:\r\n return self._id","def get_id(self):\n pass","def get_id(self):\n pass","def get_id(self):\n pass","def get_id(self):\n pass","def identifier(self):\n return self.__id","def get_id(self):\n return self.uid","def resource_id(self) -> Optional[str]:\n return pulumi.get(self, \"resource_id\")","def unique_id(self):\n return self._device.serial","def id(self) -> str:\n return self._id","def id(self) -> str:\n return self._id","def id(self) -> str:\n return self._id","def id(self) -> str:\n return self._id","def id(self) -> str:\n return self._id","def id(self) -> str:\n return self._id","def id(self) -> str:\n return self._id","def id(self) -> str:\n return self._id","def id(self) -> str:\n return self._id","def id(self) -> str:\n return self._id","def id(self) -> str:\n return self._id","def id(self) -> str:\n return self._id"],"string":"[\n \"def provider_id(self):\\n return self.get('_id')\",\n \"def provider_id(self):\\n raise NotImplementedError\",\n \"def id(self):\\n return self.raw_resource.uuid\",\n \"def healthcare_provider_id(self):\\n return self._healthcare_provider_id\",\n \"def unique_identifier(self) -> str:\\n return pulumi.get(self, \\\"unique_identifier\\\")\",\n \"def resource_id(self) -> str:\\n return pulumi.get(self, \\\"resource_id\\\")\",\n \"def resource_id(self) -> str:\\n return pulumi.get(self, \\\"resource_id\\\")\",\n \"def resource_id(self) -> str:\\n return pulumi.get(self, \\\"resource_id\\\")\",\n \"def unique_id(self) -> str:\\n return pulumi.get(self, \\\"unique_id\\\")\",\n \"def unique_id(self):\\r\\n return f\\\"{DOMAIN}_{self.charge_point_id}_{self.connector_id}\\\"\",\n \"def unique_id(self) -> str:\\n return self._unique_id\",\n \"def unique_id(self) -> str:\\n return self._unique_id\",\n \"def unique_id(self) -> str:\\n return self._unique_id\",\n \"def unique_id(self) -> str:\\n return self._unique_id\",\n \"def unique_id(self) -> str:\\n return self._unique_id\",\n \"def unique_id(self) -> str:\\n return self._unique_id\",\n \"def unique_id(self) -> str:\\n return self._unique_id\",\n \"def unique_id(self) -> str:\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._uuid\",\n \"def unique_id(self):\\n return self._uuid\",\n \"def unique_id(self) -> str:\\n return self._uid\",\n \"def unique_id(self):\\n return f\\\"{self.device.id}-{self.key}\\\"\",\n \"def unique_id(self):\\n return self.properties.get(\\\"UniqueId\\\", None)\",\n \"def internal_id(self) -> str:\\n return pulumi.get(self, \\\"internal_id\\\")\",\n \"def unique_id(self) -> str:\\n return f\\\"{self._host}_{self._name}_{self._unique_id}\\\"\",\n \"def custom_id(self) -> str:\\n return self._underlying.custom_id\",\n \"def unique_id(self):\\n return self._id\",\n \"def unique_id(self):\\n return self._id\",\n \"def unique_id(self):\\n return (\\n \\\"a80f3d5b-df3d-4e38-bbb7-1025276830cd\\\"\\n )\",\n \"def get_objectID(self):\\n return self.resource.uuid\",\n \"def unique_id(self):\\n return self._uid\",\n \"def unique_id(self):\\n return self._uid\",\n \"def unique_id(self):\\n return self._uid\",\n \"def unique_id(self):\\n id = \\\"{}{}{}\\\".format(\\n DOMAIN, self._account, self.sensorName.lower().replace(\\\" \\\", \\\"\\\")\\n )\\n return id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self):\\n return self._unique_id\",\n \"def unique_id(self) -> str:\\n return self.get_unique_id(wallet=self.wallet_id, nonce=self.nonce)\",\n \"def unique_id(self):\\n return self.device_id\",\n \"def get_id(self):\\n \\\"\\\"\\\"Requires use of Python 3\\\"\\\"\\\"\\n return str(self.id)\",\n \"def resourceid(self):\",\n \"def unique_id(self) -> str:\\n return '{0}_{1}'.format(self._mac.replace(':', ''), self.entity_id)\",\n \"def unique_id(self):\\n return self._device_id\",\n \"def getid(self):\\n if self.Id is None:\\n return self.internalid\\n else:\\n return self.Id\",\n \"def getid(self):\\n if self.Id is None:\\n return self.internalid\\n else:\\n return self.Id\",\n \"def getid(self):\\n if self.Id is None:\\n return self.internalid\\n else:\\n return self.Id\",\n \"def getid(self):\\n if self.Id is None:\\n return self.internalid\\n else:\\n return self.Id\",\n \"def getid(self):\\n if self.Id is None:\\n return self.internalid\\n else:\\n return self.Id\",\n \"def getid(self):\\n if self.Id is None:\\n return self.internalid\\n else:\\n return self.Id\",\n \"def get_id(self):\\n return str(self._id)\",\n \"def get_id(self):\\n return str(self._id)\",\n \"def identity(self) -> str:\\n return self.requester.uuid\",\n \"def get_id(self) -> str:\\n return self._register_id\",\n \"def get_unique_id(self):\\n if not self.unique_id:\\n self.unique_id = uuid.uuid4().hex\\n return self.unique_id\",\n \"def unique_id(self):\\n return f\\\"{self.config_entry.entry_id}_{self.hub_name}_{self.sensor_name}\\\"\",\n \"def getID(self):\\n return str(self._storage_id)\",\n \"def id(self):\\n return self.raw_resource[\\\"id\\\"]\",\n \"def get_id(self): # real signature unknown; restored from __doc__\\n return \\\"\\\"\",\n \"def id(self) -> str:\\r\\n return self._id\",\n \"def get_id(self):\\n pass\",\n \"def get_id(self):\\n pass\",\n \"def get_id(self):\\n pass\",\n \"def get_id(self):\\n pass\",\n \"def identifier(self):\\n return self.__id\",\n \"def get_id(self):\\n return self.uid\",\n \"def resource_id(self) -> Optional[str]:\\n return pulumi.get(self, \\\"resource_id\\\")\",\n \"def unique_id(self):\\n return self._device.serial\",\n \"def id(self) -> str:\\n return self._id\",\n \"def id(self) -> str:\\n return self._id\",\n \"def id(self) -> str:\\n return self._id\",\n \"def id(self) -> str:\\n return self._id\",\n \"def id(self) -> str:\\n return self._id\",\n \"def id(self) -> str:\\n return self._id\",\n \"def id(self) -> str:\\n return self._id\",\n \"def id(self) -> str:\\n return self._id\",\n \"def id(self) -> str:\\n return self._id\",\n \"def id(self) -> str:\\n return self._id\",\n \"def id(self) -> str:\\n return self._id\",\n \"def id(self) -> str:\\n return self._id\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8193033","0.78504187","0.77109545","0.7604915","0.74777704","0.74738747","0.74738747","0.74738747","0.7426179","0.7379609","0.73721254","0.73721254","0.73721254","0.73721254","0.73721254","0.73721254","0.73721254","0.73721254","0.7357793","0.7357793","0.73480314","0.72914726","0.72816133","0.72517055","0.72515404","0.7217732","0.72115767","0.72115767","0.72016704","0.71804124","0.71662354","0.71662354","0.71662354","0.71388066","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7137693","0.7133868","0.71262634","0.71189636","0.71131366","0.70899886","0.70684016","0.7059034","0.7059034","0.7059034","0.7059034","0.7059034","0.7059034","0.7057848","0.7057848","0.70524055","0.70343935","0.70216423","0.7020117","0.70147526","0.7013113","0.7012862","0.7006446","0.6989674","0.6989674","0.6989674","0.6989674","0.698813","0.6972098","0.6954006","0.69364727","0.69364226","0.69364226","0.69364226","0.69364226","0.69364226","0.69364226","0.69364226","0.69364226","0.69364226","0.69364226","0.69364226","0.69364226"],"string":"[\n \"0.8193033\",\n \"0.78504187\",\n \"0.77109545\",\n \"0.7604915\",\n \"0.74777704\",\n \"0.74738747\",\n \"0.74738747\",\n \"0.74738747\",\n \"0.7426179\",\n \"0.7379609\",\n \"0.73721254\",\n \"0.73721254\",\n \"0.73721254\",\n \"0.73721254\",\n \"0.73721254\",\n \"0.73721254\",\n \"0.73721254\",\n \"0.73721254\",\n \"0.7357793\",\n \"0.7357793\",\n \"0.73480314\",\n \"0.72914726\",\n \"0.72816133\",\n \"0.72517055\",\n \"0.72515404\",\n \"0.7217732\",\n \"0.72115767\",\n \"0.72115767\",\n \"0.72016704\",\n \"0.71804124\",\n \"0.71662354\",\n \"0.71662354\",\n \"0.71662354\",\n \"0.71388066\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7137693\",\n \"0.7133868\",\n \"0.71262634\",\n \"0.71189636\",\n \"0.71131366\",\n \"0.70899886\",\n \"0.70684016\",\n \"0.7059034\",\n \"0.7059034\",\n \"0.7059034\",\n \"0.7059034\",\n \"0.7059034\",\n \"0.7059034\",\n \"0.7057848\",\n \"0.7057848\",\n \"0.70524055\",\n \"0.70343935\",\n \"0.70216423\",\n \"0.7020117\",\n \"0.70147526\",\n \"0.7013113\",\n \"0.7012862\",\n \"0.7006446\",\n \"0.6989674\",\n \"0.6989674\",\n \"0.6989674\",\n \"0.6989674\",\n \"0.698813\",\n \"0.6972098\",\n \"0.6954006\",\n \"0.69364727\",\n \"0.69364226\",\n \"0.69364226\",\n \"0.69364226\",\n \"0.69364226\",\n \"0.69364226\",\n \"0.69364226\",\n \"0.69364226\",\n \"0.69364226\",\n \"0.69364226\",\n \"0.69364226\",\n \"0.69364226\",\n \"0.69364226\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":98,"cells":{"query":{"kind":"string","value":"The managed object reference ID of the root resource pool for the cluster."},"document":{"kind":"string","value":"def resource_pool_id(self) -> str:\n return pulumi.get(self, \"resource_pool_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 pool_id ( self ):\n return self._pool_id","def managed_object_id(self):\n o = self._data[\"managed_object\"]\n if type(o) in (int, long):\n return o\n return o.id","def identity_pool_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"identity_pool_id\")","def elastic_pool_id(self) -> Optional[str]:\n return pulumi.get(self, \"elastic_pool_id\")","def parent_cluster_resource_id(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"parent_cluster_resource_id\")","def _pool_id(self, queue, project=None):\n return self._catalogue_ctrl.get(project, queue)['pool']","def root_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"root_id\")","def get_objectID(self):\n return self.resource.uuid","def reference_id(self) -> str:\n return pulumi.get(self, \"reference_id\")","def get_parentID(self):\n parent = Collection.find(self.resource.container)\n return parent.uuid","def getId(self):\n return _libsbml.CompartmentReference_getId(self)","def cluster_id(self) -> str:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> str:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> str:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> str:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> str:\n return pulumi.get(self, \"cluster_id\")","def parent_cluster_resource_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"parent_cluster_resource_id\")","def cluster_id(self):\n return self._cluster_id","def obj_id(self) -> int:\n return int(self.index.split(\"/\")[-1]) if self.index else None","def identity_pool_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"identity_pool_id\")","def get_objectID(self):\n return self.collection.uuid","def identity_pool_id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"identity_pool_id\")","def rootid(self):\n candidates = [nid for nid, attrs\n in self.graph.nodes.items()\n if attrs['type'] == 'root']\n \n if len(candidates) > 1:\n errmsg = self.name + ' has more than one root'\n raise ValueError(errmsg)\n\n if len(candidates) == 0:\n errmsg = self.name + ' has no root'\n raise ValueError(errmsg) \n \n return candidates[0]","def central_node_id(self):\n if self._central_node_id is None:\n return self.nodes[0]\n else:\n return self._central_node_id","def owner_id(self) -> int:\n return self.proto.owner","def get_parentID(self):\n parent_path = self.collection.container\n if self.collection.is_root:\n parent_path = \"/\"\n parent = Collection.find(parent_path)\n return parent.uuid","def resource_group_id(self) -> str:\n return pulumi.get(self, \"resource_group_id\")","def resource_group_id(self) -> str:\n return pulumi.get(self, \"resource_group_id\")","def resource_group_id(self) -> str:\n return pulumi.get(self, \"resource_group_id\")","def resource_group_id(self) -> str:\n return pulumi.get(self, \"resource_group_id\")","def resource_group_id(self) -> str:\n return pulumi.get(self, \"resource_group_id\")","def master_id(self):\r\n return self._arm.master_id","def object_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"object_id\")","def object_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"object_id\")","def get_resource_id(self, obj):\n return obj.id","def owner_id(self) -> str:\n return self.__owner_id","def object_id(self) -> Optional[str]:\n return pulumi.get(self, \"object_id\")","def object_id(self) -> Optional[str]:\n return pulumi.get(self, \"object_id\")","def object_id(self) -> Optional[str]:\n return pulumi.get(self, \"object_id\")","def owner_id(self) -> str:\n return pulumi.get(self, \"owner_id\")","def owner_id(self):\n return self._owner_id","def reference_id(self) -> Optional[str]:\n return pulumi.get(self, \"reference_id\")","def resource_id(self) -> str:\n return pulumi.get(self, \"resource_id\")","def resource_id(self) -> str:\n return pulumi.get(self, \"resource_id\")","def resource_id(self) -> str:\n return pulumi.get(self, \"resource_id\")","def customer_owned_ipv4_pool(self) -> str:\n return pulumi.get(self, \"customer_owned_ipv4_pool\")","def getId(self):\n return _libsbml.Compartment_getId(self)","def tree_id(self):\n if self.is_root:\n return 0\n elif self._link is not None:\n return self._link.tree_id\n else:\n return self._tree_id","def pool(self):\n return self._properties.get('pool')","def rootkey(self):\n return self._follow(self._tree_ref).key","def id(self):\n return self.raw_resource.uuid","def getObjectID(self):\n\n return self.objectID","def id(self): \n if self.cloudnet:\n return self.cloudnet.id\n else:\n return None","def resourceid(self):","def resource_group_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"resource_group_id\")","def resource_group_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"resource_group_id\")","def resource_group_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"resource_group_id\")","def get_id(self):\n if not self.nccl_id:\n logger.warning(\"The NCCL ID has not been \"\n \"set yet for store {}.\".format(self.name))\n return self.nccl_id","def node_id(self) -> int:\r\n return self._node_id","def label_id(self):\n return int(self.instance_id // 1000)","def orig_cluster_id(self):\n if self.old_cluster_name is None:\n raise RuntimeError('old_cluster_name is not set')\n return self.fuel_web.client.get_cluster_id(self.old_cluster_name)","def _get_msti_root_id(self):\n return self.__msti_root_id","def cont_to_id(self):\n return self.client.containers.get(self.container).id","def _get_id(self) -> int:\n if len(self._id_pool) == 0:\n raise ArchonError(\"No ids reamining in the pool!\")\n return self._id_pool.pop()","def get_managed_object(self):\n return self.key","def get_pool_id(pool_name, host=None):\n cmd = utils.XMS_CLI_HEADER + \"-f json pool list\"\n print cmd\n ret = utils.execute_cmd_in_host(cmd, host)\n if ret[2] != 0 or isinstance(ret[0], dict):\n print \"[Error] Failed to get pool info. Error message: [{err}]\".format(err=ret[1])\n return -1\n try:\n pool_info = json.loads(ret[0])\n pools = pool_info[\"pools\"]\n for p in pools:\n if pool_name == p[\"name\"]:\n return p[\"id\"]\n except Exception as e:\n print \"[Error] error message is: \" + e.message\n return -1","def data_center_id(self) -> str:\n return pulumi.get(self, \"data_center_id\")","def data_center_id(self) -> str:\n return pulumi.get(self, \"data_center_id\")","def compartment_id(self):\n return self._compartment_id","def compartment_id(self):\n return self._compartment_id","def getIdRef(self):\n return _libsbml.SBaseRef_getIdRef(self)","def get_cluster_id(options):\n cluster = options.cluster\n datacenter = get_datacenter(options)\n for item in datacenter.hostFolder.childEntity:\n if (item.name == cluster):\n return item._GetMoId()","def containerID(self):\n return self._container","def getOid(self):\n if self.__state & self.stClean:\n return self.__oid\n else:\n raise SmiError('%s object not fully initialized' % self.__class__.__name__)","def get_id(self):\n return self.__id","def get_id(self):\n return self.__id","def nodebalancer_id(self) -> pulumi.Output[int]:\n return pulumi.get(self, \"nodebalancer_id\")","def cluster_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"cluster_id\")","def global_replication_group_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"global_replication_group_id\")","def get_catalog_hierarchy_id(self):\n # Implemented from kitosid template for -\n # osid.resource.BinHierarchySession.get_bin_hierarchy_id\n return self._get_provider_session('catalog_hierarchy_session').get_catalog_hierarchy_id()","def persistent_id(self):\n return '{0}/{1}'.format(self.model_label(), self.id)","def get_id(self):\n\n\t\treturn self.__id","def resource_group_id(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"resource_group_id\")","def control_node_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"control_node_id\")","def getRootName(self):\n return self.__rootName","def context_parent_id(self) -> str | None:\n return bytes_to_ulid_or_none(self.context_parent_id_bin)","def get_custom_object_id():\n worker = ray.worker.global_worker\n object_id = ray._raylet.compute_put_id(worker.current_task_id,\n worker.task_context.put_index)\n worker.task_context.put_index += 1\n return object_id","def get_host_master_id(self):\r\n return self._handler.get_host_master_id()","def resource_group_id(self) -> Optional[str]:\n return pulumi.get(self, \"resource_group_id\")","def get_id(self):\n return self.name","def base_image_id(self):\n return self._base_image_id","def core_id(self):\n return self._dll.JLINKARM_GetId()","def _newClusterId(self):\n return self.guidGenerator.new_id()","def getid(self):\n return self.__id","def getLastObjectId(self):\n return self.objId","def internal_id(self) -> str:\n return pulumi.get(self, \"internal_id\")","def managed_rule_identifier(self) -> str:\n return pulumi.get(self, \"managed_rule_identifier\")"],"string":"[\n \"def pool_id ( self ):\\n return self._pool_id\",\n \"def managed_object_id(self):\\n o = self._data[\\\"managed_object\\\"]\\n if type(o) in (int, long):\\n return o\\n return o.id\",\n \"def identity_pool_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"identity_pool_id\\\")\",\n \"def elastic_pool_id(self) -> Optional[str]:\\n return pulumi.get(self, \\\"elastic_pool_id\\\")\",\n \"def parent_cluster_resource_id(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"parent_cluster_resource_id\\\")\",\n \"def _pool_id(self, queue, project=None):\\n return self._catalogue_ctrl.get(project, queue)['pool']\",\n \"def root_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"root_id\\\")\",\n \"def get_objectID(self):\\n return self.resource.uuid\",\n \"def reference_id(self) -> str:\\n return pulumi.get(self, \\\"reference_id\\\")\",\n \"def get_parentID(self):\\n parent = Collection.find(self.resource.container)\\n return parent.uuid\",\n \"def getId(self):\\n return _libsbml.CompartmentReference_getId(self)\",\n \"def cluster_id(self) -> str:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> str:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> str:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> str:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> str:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def parent_cluster_resource_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"parent_cluster_resource_id\\\")\",\n \"def cluster_id(self):\\n return self._cluster_id\",\n \"def obj_id(self) -> int:\\n return int(self.index.split(\\\"/\\\")[-1]) if self.index else None\",\n \"def identity_pool_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"identity_pool_id\\\")\",\n \"def get_objectID(self):\\n return self.collection.uuid\",\n \"def identity_pool_id(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"identity_pool_id\\\")\",\n \"def rootid(self):\\n candidates = [nid for nid, attrs\\n in self.graph.nodes.items()\\n if attrs['type'] == 'root']\\n \\n if len(candidates) > 1:\\n errmsg = self.name + ' has more than one root'\\n raise ValueError(errmsg)\\n\\n if len(candidates) == 0:\\n errmsg = self.name + ' has no root'\\n raise ValueError(errmsg) \\n \\n return candidates[0]\",\n \"def central_node_id(self):\\n if self._central_node_id is None:\\n return self.nodes[0]\\n else:\\n return self._central_node_id\",\n \"def owner_id(self) -> int:\\n return self.proto.owner\",\n \"def get_parentID(self):\\n parent_path = self.collection.container\\n if self.collection.is_root:\\n parent_path = \\\"/\\\"\\n parent = Collection.find(parent_path)\\n return parent.uuid\",\n \"def resource_group_id(self) -> str:\\n return pulumi.get(self, \\\"resource_group_id\\\")\",\n \"def resource_group_id(self) -> str:\\n return pulumi.get(self, \\\"resource_group_id\\\")\",\n \"def resource_group_id(self) -> str:\\n return pulumi.get(self, \\\"resource_group_id\\\")\",\n \"def resource_group_id(self) -> str:\\n return pulumi.get(self, \\\"resource_group_id\\\")\",\n \"def resource_group_id(self) -> str:\\n return pulumi.get(self, \\\"resource_group_id\\\")\",\n \"def master_id(self):\\r\\n return self._arm.master_id\",\n \"def object_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"object_id\\\")\",\n \"def object_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"object_id\\\")\",\n \"def get_resource_id(self, obj):\\n return obj.id\",\n \"def owner_id(self) -> str:\\n return self.__owner_id\",\n \"def object_id(self) -> Optional[str]:\\n return pulumi.get(self, \\\"object_id\\\")\",\n \"def object_id(self) -> Optional[str]:\\n return pulumi.get(self, \\\"object_id\\\")\",\n \"def object_id(self) -> Optional[str]:\\n return pulumi.get(self, \\\"object_id\\\")\",\n \"def owner_id(self) -> str:\\n return pulumi.get(self, \\\"owner_id\\\")\",\n \"def owner_id(self):\\n return self._owner_id\",\n \"def reference_id(self) -> Optional[str]:\\n return pulumi.get(self, \\\"reference_id\\\")\",\n \"def resource_id(self) -> str:\\n return pulumi.get(self, \\\"resource_id\\\")\",\n \"def resource_id(self) -> str:\\n return pulumi.get(self, \\\"resource_id\\\")\",\n \"def resource_id(self) -> str:\\n return pulumi.get(self, \\\"resource_id\\\")\",\n \"def customer_owned_ipv4_pool(self) -> str:\\n return pulumi.get(self, \\\"customer_owned_ipv4_pool\\\")\",\n \"def getId(self):\\n return _libsbml.Compartment_getId(self)\",\n \"def tree_id(self):\\n if self.is_root:\\n return 0\\n elif self._link is not None:\\n return self._link.tree_id\\n else:\\n return self._tree_id\",\n \"def pool(self):\\n return self._properties.get('pool')\",\n \"def rootkey(self):\\n return self._follow(self._tree_ref).key\",\n \"def id(self):\\n return self.raw_resource.uuid\",\n \"def getObjectID(self):\\n\\n return self.objectID\",\n \"def id(self): \\n if self.cloudnet:\\n return self.cloudnet.id\\n else:\\n return None\",\n \"def resourceid(self):\",\n \"def resource_group_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"resource_group_id\\\")\",\n \"def resource_group_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"resource_group_id\\\")\",\n \"def resource_group_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"resource_group_id\\\")\",\n \"def get_id(self):\\n if not self.nccl_id:\\n logger.warning(\\\"The NCCL ID has not been \\\"\\n \\\"set yet for store {}.\\\".format(self.name))\\n return self.nccl_id\",\n \"def node_id(self) -> int:\\r\\n return self._node_id\",\n \"def label_id(self):\\n return int(self.instance_id // 1000)\",\n \"def orig_cluster_id(self):\\n if self.old_cluster_name is None:\\n raise RuntimeError('old_cluster_name is not set')\\n return self.fuel_web.client.get_cluster_id(self.old_cluster_name)\",\n \"def _get_msti_root_id(self):\\n return self.__msti_root_id\",\n \"def cont_to_id(self):\\n return self.client.containers.get(self.container).id\",\n \"def _get_id(self) -> int:\\n if len(self._id_pool) == 0:\\n raise ArchonError(\\\"No ids reamining in the pool!\\\")\\n return self._id_pool.pop()\",\n \"def get_managed_object(self):\\n return self.key\",\n \"def get_pool_id(pool_name, host=None):\\n cmd = utils.XMS_CLI_HEADER + \\\"-f json pool list\\\"\\n print cmd\\n ret = utils.execute_cmd_in_host(cmd, host)\\n if ret[2] != 0 or isinstance(ret[0], dict):\\n print \\\"[Error] Failed to get pool info. Error message: [{err}]\\\".format(err=ret[1])\\n return -1\\n try:\\n pool_info = json.loads(ret[0])\\n pools = pool_info[\\\"pools\\\"]\\n for p in pools:\\n if pool_name == p[\\\"name\\\"]:\\n return p[\\\"id\\\"]\\n except Exception as e:\\n print \\\"[Error] error message is: \\\" + e.message\\n return -1\",\n \"def data_center_id(self) -> str:\\n return pulumi.get(self, \\\"data_center_id\\\")\",\n \"def data_center_id(self) -> str:\\n return pulumi.get(self, \\\"data_center_id\\\")\",\n \"def compartment_id(self):\\n return self._compartment_id\",\n \"def compartment_id(self):\\n return self._compartment_id\",\n \"def getIdRef(self):\\n return _libsbml.SBaseRef_getIdRef(self)\",\n \"def get_cluster_id(options):\\n cluster = options.cluster\\n datacenter = get_datacenter(options)\\n for item in datacenter.hostFolder.childEntity:\\n if (item.name == cluster):\\n return item._GetMoId()\",\n \"def containerID(self):\\n return self._container\",\n \"def getOid(self):\\n if self.__state & self.stClean:\\n return self.__oid\\n else:\\n raise SmiError('%s object not fully initialized' % self.__class__.__name__)\",\n \"def get_id(self):\\n return self.__id\",\n \"def get_id(self):\\n return self.__id\",\n \"def nodebalancer_id(self) -> pulumi.Output[int]:\\n return pulumi.get(self, \\\"nodebalancer_id\\\")\",\n \"def cluster_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def global_replication_group_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"global_replication_group_id\\\")\",\n \"def get_catalog_hierarchy_id(self):\\n # Implemented from kitosid template for -\\n # osid.resource.BinHierarchySession.get_bin_hierarchy_id\\n return self._get_provider_session('catalog_hierarchy_session').get_catalog_hierarchy_id()\",\n \"def persistent_id(self):\\n return '{0}/{1}'.format(self.model_label(), self.id)\",\n \"def get_id(self):\\n\\n\\t\\treturn self.__id\",\n \"def resource_group_id(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"resource_group_id\\\")\",\n \"def control_node_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"control_node_id\\\")\",\n \"def getRootName(self):\\n return self.__rootName\",\n \"def context_parent_id(self) -> str | None:\\n return bytes_to_ulid_or_none(self.context_parent_id_bin)\",\n \"def get_custom_object_id():\\n worker = ray.worker.global_worker\\n object_id = ray._raylet.compute_put_id(worker.current_task_id,\\n worker.task_context.put_index)\\n worker.task_context.put_index += 1\\n return object_id\",\n \"def get_host_master_id(self):\\r\\n return self._handler.get_host_master_id()\",\n \"def resource_group_id(self) -> Optional[str]:\\n return pulumi.get(self, \\\"resource_group_id\\\")\",\n \"def get_id(self):\\n return self.name\",\n \"def base_image_id(self):\\n return self._base_image_id\",\n \"def core_id(self):\\n return self._dll.JLINKARM_GetId()\",\n \"def _newClusterId(self):\\n return self.guidGenerator.new_id()\",\n \"def getid(self):\\n return self.__id\",\n \"def getLastObjectId(self):\\n return self.objId\",\n \"def internal_id(self) -> str:\\n return pulumi.get(self, \\\"internal_id\\\")\",\n \"def managed_rule_identifier(self) -> str:\\n return pulumi.get(self, \\\"managed_rule_identifier\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71896243","0.66001445","0.65141094","0.6471181","0.6368429","0.6354283","0.634698","0.6305942","0.62388986","0.62217504","0.6184611","0.61742735","0.61742735","0.61742735","0.61742735","0.61742735","0.61529875","0.6127469","0.6123672","0.61147434","0.6111746","0.6098793","0.6090876","0.60850084","0.6024355","0.60161644","0.59966296","0.59966296","0.59966296","0.59966296","0.59966296","0.599174","0.59531385","0.59531385","0.59526616","0.5931739","0.5921793","0.5921793","0.5921793","0.5910044","0.5891344","0.58674043","0.5865836","0.5865836","0.5865836","0.5846603","0.58360183","0.58343476","0.58328295","0.58216864","0.58187777","0.5809769","0.5797921","0.579548","0.57866424","0.57866424","0.57866424","0.57799953","0.5772858","0.57616293","0.5755846","0.57490695","0.57463205","0.5745851","0.5741512","0.5731438","0.5717889","0.5717889","0.57112294","0.57112294","0.57018363","0.5693533","0.5685139","0.5679186","0.5664299","0.5664299","0.566111","0.5660358","0.5660358","0.5660358","0.5660358","0.56501937","0.56490844","0.56462514","0.56418395","0.5636773","0.5626972","0.56261516","0.5621096","0.56149316","0.5613158","0.55974424","0.55966043","0.5591686","0.5586472","0.5585928","0.5584781","0.5584699","0.55723506","0.5566295"],"string":"[\n \"0.71896243\",\n \"0.66001445\",\n \"0.65141094\",\n \"0.6471181\",\n \"0.6368429\",\n \"0.6354283\",\n \"0.634698\",\n \"0.6305942\",\n \"0.62388986\",\n \"0.62217504\",\n \"0.6184611\",\n \"0.61742735\",\n \"0.61742735\",\n \"0.61742735\",\n \"0.61742735\",\n \"0.61742735\",\n \"0.61529875\",\n \"0.6127469\",\n \"0.6123672\",\n \"0.61147434\",\n \"0.6111746\",\n \"0.6098793\",\n \"0.6090876\",\n \"0.60850084\",\n \"0.6024355\",\n \"0.60161644\",\n \"0.59966296\",\n \"0.59966296\",\n \"0.59966296\",\n \"0.59966296\",\n \"0.59966296\",\n \"0.599174\",\n \"0.59531385\",\n \"0.59531385\",\n \"0.59526616\",\n \"0.5931739\",\n \"0.5921793\",\n \"0.5921793\",\n \"0.5921793\",\n \"0.5910044\",\n \"0.5891344\",\n \"0.58674043\",\n \"0.5865836\",\n \"0.5865836\",\n \"0.5865836\",\n \"0.5846603\",\n \"0.58360183\",\n \"0.58343476\",\n \"0.58328295\",\n \"0.58216864\",\n \"0.58187777\",\n \"0.5809769\",\n \"0.5797921\",\n \"0.579548\",\n \"0.57866424\",\n \"0.57866424\",\n \"0.57866424\",\n \"0.57799953\",\n \"0.5772858\",\n \"0.57616293\",\n \"0.5755846\",\n \"0.57490695\",\n \"0.57463205\",\n \"0.5745851\",\n \"0.5741512\",\n \"0.5731438\",\n \"0.5717889\",\n \"0.5717889\",\n \"0.57112294\",\n \"0.57112294\",\n \"0.57018363\",\n \"0.5693533\",\n \"0.5685139\",\n \"0.5679186\",\n \"0.5664299\",\n \"0.5664299\",\n \"0.566111\",\n \"0.5660358\",\n \"0.5660358\",\n \"0.5660358\",\n \"0.5660358\",\n \"0.56501937\",\n \"0.56490844\",\n \"0.56462514\",\n \"0.56418395\",\n \"0.5636773\",\n \"0.5626972\",\n \"0.56261516\",\n \"0.5621096\",\n \"0.56149316\",\n \"0.5613158\",\n \"0.55974424\",\n \"0.55966043\",\n \"0.5591686\",\n \"0.5586472\",\n \"0.5585928\",\n \"0.5584781\",\n \"0.5584699\",\n \"0.55723506\",\n \"0.5566295\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74713767"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":99,"cells":{"query":{"kind":"string","value":"The `ComputeCluster` data source can be used to discover the ID of a cluster in vSphere. This is useful to fetch the ID of a cluster that you want to use for virtual machine placement via the `VirtualMachine` resource, allowing to specify the cluster's root resource pool directly versus using the alias available through the `ResourcePool` data source. > You may also wish to see the `ComputeCluster` resource for more information about clusters and how to managed the resource in this provider. Example Usage ```python import pulumi import pulumi_vsphere as vsphere datacenter = vsphere.get_datacenter(name=\"dc01\") compute_cluster = vsphere.get_compute_cluster(name=\"cluster01\", datacenter_id=datacenter.id) ```"},"document":{"kind":"string","value":"def get_compute_cluster(datacenter_id: Optional[str] = None,\n name: Optional[str] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetComputeClusterResult:\n __args__ = dict()\n __args__['datacenterId'] = datacenter_id\n __args__['name'] = name\n opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)\n __ret__ = pulumi.runtime.invoke('vsphere:index/getComputeCluster:getComputeCluster', __args__, opts=opts, typ=GetComputeClusterResult).value\n\n return AwaitableGetComputeClusterResult(\n datacenter_id=pulumi.get(__ret__, 'datacenter_id'),\n id=pulumi.get(__ret__, 'id'),\n name=pulumi.get(__ret__, 'name'),\n resource_pool_id=pulumi.get(__ret__, 'resource_pool_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 get_cluster_id(options):\n cluster = options.cluster\n datacenter = get_datacenter(options)\n for item in datacenter.hostFolder.childEntity:\n if (item.name == cluster):\n return item._GetMoId()","def get_compute_cluster_output(datacenter_id: Optional[pulumi.Input[Optional[str]]] = None,\n name: Optional[pulumi.Input[str]] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetComputeClusterResult]:\n ...","def get_cluster(self,cluster_name,project_id=''):\n print( f'>>>>>>{self.project_id}')\n if project_id == '':\n project_id = self.project_id\n return self.get('{}/groups/{}/clusters/{}'.format(ApiVersion.A1.value,project_id,cluster_name))","def get_cluster_id(self):\n cmd = \"svcinfo lscluster -delim :\"\n\n output = self._svc_command(cmd)[0]\n\n if len(output) != 2:\n return None\n\n header = output[0].split(':')\n values = output[1].split(':')\n index = header.index(SVC_CLUSTER_ID)\n cluster_id = values[index]\n return cluster_id","def cluster_id(self) -> str:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> str:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> str:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> str:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> str:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"cluster_id\")","def find_cluster(self, id: str) -> dto.Cluster:\n raise errors.UnsupportedOperationError(\n \"Operation not supported for provider '{}'\".format(self.provider_name)\n )","def cluster_id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"cluster_id\")","def cluster_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"cluster_id\")","def clusters(self,project_id=os.environ.get(\"ATLAS_PROJECT\")):\n project_id = project_id if project_id != '' else self.__project_id\n return self.get('{}/groups/{}/clusters'.format(ApiVersion.A1.value,project_id))","def cluster_id(self):\n return self._cluster_id","def find_cluster(self, id):\n raise NotImplementedError","def cluster_identifier(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"cluster_identifier\")","def find_kubernetes_cluster(self, id: str) -> dto.KubernetesCluster:\n raise errors.UnsupportedOperationError(\n \"Operation not supported for provider '{}'\".format(self.provider_name)\n )","def show_cluster(name: str) -> Cluster:\n environment = EnvironmentProvider().environment\n return environment.clusters[name]","def get_coe_cluster(self, name_or_id, filters=None):\n return _utils._get_entity(self, 'coe_cluster', name_or_id, filters)","def lookup_cluster_by_name(cluster_name):\n cluster_root = get_cluster_root()\n if not cluster_root:\n print('Cannot get the root of the linked list of clusters')\n return\n cluster = None\n\n # lookup for the task associated with the id\n if cluster_root['cluster_']['name'].string() == cluster_name:\n cluster = cluster_root['cluster_'].address\n else:\n curr = cluster_root\n while True:\n curr = curr['next'].cast(uClusterDL_ptr_type)\n\n if curr['cluster_']['name'].string() == cluster_name:\n cluster = curr['cluster_'].address\n break\n\n if curr == cluster_root:\n break\n\n if not cluster:\n print(\n (\"Cannot find a cluster with the name: {}.\".format(cluster_name))\n )\n return cluster","def cluster_myid(self, target_node: \"TargetNodesT\") -> ResponseT:\n return self.execute_command(\"CLUSTER MYID\", target_nodes=target_node)","def show_vsan_cluster(self, cluster_id):\n url = \"clusters/%s\" % str(cluster_id)\n resp, body = self.get(url)\n body = json.loads(body)\n self.expected_success(200, resp.status)\n return service_client.ResponseBody(resp, body['cluster'])","def data_center_id(self) -> str:\n return pulumi.get(self, \"data_center_id\")","def data_center_id(self) -> str:\n return pulumi.get(self, \"data_center_id\")","def get_one_cluster_by_name(ctx, cluster_name, project_name):\n project = ctx.obj.groups.byName[project_name].get().data\n cluster = ctx.obj.groups[project.id].clusters[cluster_name].get()\n pprint(cluster.data)","def get_datacenter(conn):\n datacenter_id = get_datacenter_id()\n\n for item in conn.list_datacenters()[\"items\"]:\n if item[\"id\"] == datacenter_id:\n return item\n\n raise SaltCloudNotFound(\n \"The specified datacenter '{}' could not be found.\".format(datacenter_id)\n )","def get_cluster(cluster_id: Optional[str] = None,\n location: Optional[str] = None,\n project: Optional[str] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetClusterResult:\n __args__ = dict()\n __args__['clusterId'] = cluster_id\n __args__['location'] = location\n __args__['project'] = project\n if opts is None:\n opts = pulumi.InvokeOptions()\n if opts.version is None:\n opts.version = _utilities.get_version()\n __ret__ = pulumi.runtime.invoke('google-native:container/v1:getCluster', __args__, opts=opts, typ=GetClusterResult).value\n\n return AwaitableGetClusterResult(\n addons_config=__ret__.addons_config,\n authenticator_groups_config=__ret__.authenticator_groups_config,\n autopilot=__ret__.autopilot,\n autoscaling=__ret__.autoscaling,\n binary_authorization=__ret__.binary_authorization,\n cluster_ipv4_cidr=__ret__.cluster_ipv4_cidr,\n conditions=__ret__.conditions,\n confidential_nodes=__ret__.confidential_nodes,\n create_time=__ret__.create_time,\n current_master_version=__ret__.current_master_version,\n current_node_version=__ret__.current_node_version,\n database_encryption=__ret__.database_encryption,\n default_max_pods_constraint=__ret__.default_max_pods_constraint,\n description=__ret__.description,\n enable_kubernetes_alpha=__ret__.enable_kubernetes_alpha,\n enable_tpu=__ret__.enable_tpu,\n endpoint=__ret__.endpoint,\n expire_time=__ret__.expire_time,\n initial_cluster_version=__ret__.initial_cluster_version,\n ip_allocation_policy=__ret__.ip_allocation_policy,\n label_fingerprint=__ret__.label_fingerprint,\n legacy_abac=__ret__.legacy_abac,\n location=__ret__.location,\n locations=__ret__.locations,\n logging_config=__ret__.logging_config,\n logging_service=__ret__.logging_service,\n maintenance_policy=__ret__.maintenance_policy,\n master_auth=__ret__.master_auth,\n master_authorized_networks_config=__ret__.master_authorized_networks_config,\n mesh_certificates=__ret__.mesh_certificates,\n monitoring_config=__ret__.monitoring_config,\n monitoring_service=__ret__.monitoring_service,\n name=__ret__.name,\n network=__ret__.network,\n network_config=__ret__.network_config,\n network_policy=__ret__.network_policy,\n node_ipv4_cidr_size=__ret__.node_ipv4_cidr_size,\n node_pools=__ret__.node_pools,\n notification_config=__ret__.notification_config,\n private_cluster_config=__ret__.private_cluster_config,\n release_channel=__ret__.release_channel,\n resource_labels=__ret__.resource_labels,\n resource_usage_export_config=__ret__.resource_usage_export_config,\n self_link=__ret__.self_link,\n services_ipv4_cidr=__ret__.services_ipv4_cidr,\n shielded_nodes=__ret__.shielded_nodes,\n status=__ret__.status,\n subnetwork=__ret__.subnetwork,\n tpu_ipv4_cidr_block=__ret__.tpu_ipv4_cidr_block,\n vertical_pod_autoscaling=__ret__.vertical_pod_autoscaling,\n workload_identity_config=__ret__.workload_identity_config)","def cluster_name(self) -> str:\n return pulumi.get(self, \"cluster_name\")","def cluster_name(self) -> str:\n return pulumi.get(self, \"cluster_name\")","def cluster_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"cluster_name\")","def cluster_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"cluster_name\")","def resource_type(self):\n return 'cluster'","def pc_cluster(data, clusters):\n dist = MorningstarPCA.pc_distance(data, clusters)\n return MorningstarPCA.get_column_with_min_value(dist)","def cluster_name(self):\n return self._data['cluster_name']","def get_cluster(self, label):\n try:\n return self._clusters[label]\n except KeyError:\n return None","def find_kubernetes_cluster_template(self, id: str) -> dto.KubernetesClusterTemplate:\n raise errors.UnsupportedOperationError(\n \"Operation not supported for provider '{}'\".format(self.provider_name)\n )","def find_cluster_sample(self, sample):\n for cluster in self.cluster_lst:\n if sample in cluster.get_samples():\n return cluster.get_c_id()","def cluster_name(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"cluster_name\")","def get_coe_cluster_certificate(self, cluster_id):\n return (\n self.container_infrastructure_management.get_cluster_certificate(\n cluster_id\n )\n )","def cluster_query(cluster_id):\n request_debug(r, logger)\n # cluster_id = request_get(r, \"cluster_id\")\n\n result = cluster_handler.get_by_id(cluster_id)\n logger.info(result)\n if result:\n response_ok['data'] = result\n return jsonify(response_ok), CODE_OK\n else:\n logger.warning(\"cluster not found with id=\" + cluster_id)\n response_fail[\"data\"] = r.form\n response_fail[\"code\"] = CODE_NOT_FOUND\n return jsonify(response_fail), CODE_NOT_FOUND","def get_datacenter_id():\n datacenter_id = config.get_cloud_config_value(\n \"datacenter_id\", get_configured_provider(), __opts__, search_global=False\n )\n\n conn = get_conn()\n\n try:\n conn.get_datacenter(datacenter_id=datacenter_id)\n except PBNotFoundError:\n log.error(\"Failed to get datacenter: %s\", datacenter_id)\n raise\n\n return datacenter_id","def get_cluster_output(cluster_id: Optional[pulumi.Input[str]] = None,\n location: Optional[pulumi.Input[str]] = None,\n project: Optional[pulumi.Input[Optional[str]]] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetClusterResult]:\n ...","def get_cluster_name(cls):\n\n mid = Machineid()\n if mid.is_sps_cluster:\n return cls.SPS\n if mid.is_spts_cluster:\n return cls.SPTS\n if mid.is_mdfl_cluster:\n return cls.MDFL\n\n return cls.LOCAL","def get_cluster_idx(_cluster):\n\n return _cluster.cluster_idx","def cluster(self):\n return self._cluster","def cluster(self):\n return self._cluster","def cluster_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"cluster_name\")","def cluster_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"cluster_name\")","def cluster_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"cluster_name\")","def cluster_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"cluster_name\")","def cluster_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"cluster_name\")","def get_cluster(t2_url, t2_token, id):\n response = requests.get(f\"{t2_url}/api/clusters/{id}\", headers={ \"t2-token\": t2_token })\n if(response.status_code != 200):\n log(f\"API call to get cluster returned error code {response.status_code}\")\n return None\n return response.json()","def get_cluster_by_id(self, c_id: str) -> List[str]:\n return [k for k, v in self._clusters.items() if v == c_id]","def get(resource_name: str,\n id: pulumi.Input[str],\n opts: Optional[pulumi.ResourceOptions] = None,\n cluster_id: Optional[pulumi.Input[str]] = None,\n identity: Optional[pulumi.Input[pulumi.InputType['ClusterIdentityArgs']]] = None,\n location: Optional[pulumi.Input[str]] = None,\n name: Optional[pulumi.Input[str]] = None,\n resource_group_name: Optional[pulumi.Input[str]] = None,\n size_gb: Optional[pulumi.Input[int]] = None,\n tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None) -> 'Cluster':\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))\n\n __props__ = _ClusterState.__new__(_ClusterState)\n\n __props__.__dict__[\"cluster_id\"] = cluster_id\n __props__.__dict__[\"identity\"] = identity\n __props__.__dict__[\"location\"] = location\n __props__.__dict__[\"name\"] = name\n __props__.__dict__[\"resource_group_name\"] = resource_group_name\n __props__.__dict__[\"size_gb\"] = size_gb\n __props__.__dict__[\"tags\"] = tags\n return Cluster(resource_name, opts=opts, __props__=__props__)","def getClusterData(clusterName,data):\n clusters = rhevGet(\"/api/clusters\")\n doc = libxml2.parseDoc(clusters)\n ctxt = doc.xpathNewContext()\n res = ctxt.xpathEval(\"/clusters/cluster[name [position()=1]= '\"+ clusterName + \"']\")\n return res[0].prop(data)","def cluster_identity_get(self, desired_attributes=None):\n return self.request( \"cluster-identity-get\", {\n 'desired_attributes': [ desired_attributes, 'desired-attributes', [ ClusterIdentityInfo, 'None' ], False ],\n }, {\n 'attributes': [ ClusterIdentityInfo, False ],\n } )","def clustering(self) -> 'outputs.ClusteringResponse':\n return pulumi.get(self, \"clustering\")","def get(resource_name: str,\n id: pulumi.Input[str],\n opts: Optional[pulumi.ResourceOptions] = None,\n auto_renew: Optional[pulumi.Input[bool]] = None,\n auto_renew_period: Optional[pulumi.Input[int]] = None,\n cluster_name: Optional[pulumi.Input[str]] = None,\n data_center_name: Optional[pulumi.Input[str]] = None,\n disk_size: Optional[pulumi.Input[int]] = None,\n disk_type: Optional[pulumi.Input[str]] = None,\n enable_public: Optional[pulumi.Input[bool]] = None,\n instance_type: Optional[pulumi.Input[str]] = None,\n ip_white: Optional[pulumi.Input[str]] = None,\n maintain_end_time: Optional[pulumi.Input[str]] = None,\n maintain_start_time: Optional[pulumi.Input[str]] = None,\n major_version: Optional[pulumi.Input[str]] = None,\n node_count: Optional[pulumi.Input[int]] = None,\n password: Optional[pulumi.Input[str]] = None,\n pay_type: Optional[pulumi.Input[str]] = None,\n period: Optional[pulumi.Input[int]] = None,\n period_unit: Optional[pulumi.Input[str]] = None,\n public_points: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n status: Optional[pulumi.Input[str]] = None,\n tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,\n vswitch_id: Optional[pulumi.Input[str]] = None,\n zone_id: Optional[pulumi.Input[str]] = None) -> 'Cluster':\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))\n\n __props__ = _ClusterState.__new__(_ClusterState)\n\n __props__.__dict__[\"auto_renew\"] = auto_renew\n __props__.__dict__[\"auto_renew_period\"] = auto_renew_period\n __props__.__dict__[\"cluster_name\"] = cluster_name\n __props__.__dict__[\"data_center_name\"] = data_center_name\n __props__.__dict__[\"disk_size\"] = disk_size\n __props__.__dict__[\"disk_type\"] = disk_type\n __props__.__dict__[\"enable_public\"] = enable_public\n __props__.__dict__[\"instance_type\"] = instance_type\n __props__.__dict__[\"ip_white\"] = ip_white\n __props__.__dict__[\"maintain_end_time\"] = maintain_end_time\n __props__.__dict__[\"maintain_start_time\"] = maintain_start_time\n __props__.__dict__[\"major_version\"] = major_version\n __props__.__dict__[\"node_count\"] = node_count\n __props__.__dict__[\"password\"] = password\n __props__.__dict__[\"pay_type\"] = pay_type\n __props__.__dict__[\"period\"] = period\n __props__.__dict__[\"period_unit\"] = period_unit\n __props__.__dict__[\"public_points\"] = public_points\n __props__.__dict__[\"security_groups\"] = security_groups\n __props__.__dict__[\"status\"] = status\n __props__.__dict__[\"tags\"] = tags\n __props__.__dict__[\"vswitch_id\"] = vswitch_id\n __props__.__dict__[\"zone_id\"] = zone_id\n return Cluster(resource_name, opts=opts, __props__=__props__)","def get_clusters(self):\n fields = ['name', ]\n return self.get_data(\"clusters\", fields)","def cluster_name(self):\n return self.name","async def get(id):\n cluster = clusters.get_by_id(id)\n\n if cluster is None:\n raise HTTPException(status_code=404, detail=\"Cluster not found for ID: {0}\".format(id))\n\n return cluster.export()","def orig_cluster_id(self):\n if self.old_cluster_name is None:\n raise RuntimeError('old_cluster_name is not set')\n return self.fuel_web.client.get_cluster_id(self.old_cluster_name)","def get_cluster_config(cohesity_client):\n config = cohesity_client.cluster.get_cluster()\n return config","def _find_cluster(clusters, label):\n for clst in clusters:\n if clst.label == label: return clst\n return None","def get(resource_name: str,\n id: pulumi.Input[str],\n opts: Optional[pulumi.ResourceOptions] = None) -> 'Cluster':\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))\n\n __props__ = ClusterArgs.__new__(ClusterArgs)\n\n __props__.__dict__[\"allocation_state\"] = None\n __props__.__dict__[\"allocation_state_transition_time\"] = None\n __props__.__dict__[\"creation_time\"] = None\n __props__.__dict__[\"current_node_count\"] = None\n __props__.__dict__[\"errors\"] = None\n __props__.__dict__[\"name\"] = None\n __props__.__dict__[\"node_setup\"] = None\n __props__.__dict__[\"node_state_counts\"] = None\n __props__.__dict__[\"provisioning_state\"] = None\n __props__.__dict__[\"provisioning_state_transition_time\"] = None\n __props__.__dict__[\"scale_settings\"] = None\n __props__.__dict__[\"subnet\"] = None\n __props__.__dict__[\"type\"] = None\n __props__.__dict__[\"user_account_settings\"] = None\n __props__.__dict__[\"virtual_machine_configuration\"] = None\n __props__.__dict__[\"vm_priority\"] = None\n __props__.__dict__[\"vm_size\"] = None\n return Cluster(resource_name, opts=opts, __props__=__props__)","def _get_center(data, node_id, feature_columns):\n if node_id in data.id.values:\n return data[data.id == node_id][feature_columns].values\n else:\n return _get_center(data, node_id[:-1], feature_columns)","def cluster_type(self) -> str:\n return pulumi.get(self, \"cluster_type\")","def get_cluster(self, profile):\n if self._value.has_option(profile, 'cluster'):\n if self._value.has_option(profile, 'cluster'):\n cluster = self._value.get(profile, 'cluster')\n self.logger.info(\"Connecting to: %s cluster\" % cluster)\n else:\n self.logger.error(\n \"No cluster parameter found\"\n )\n exit(1)\n else:\n self.logger.error(\n \"No profile found. Please define a default profile, \\\n or specify a named profile using `--profile`\"\n )\n exit(1)\n return cluster","def get_cluster_entry(self):\n\n cert_data = self.cluster_description.get(\"certificateAuthority\", {}).get(\"data\", \"\")\n endpoint = self.cluster_description.get(\"endpoint\")\n arn = self.cluster_description.get(\"arn\")\n\n return OrderedDict([\n (\"cluster\", OrderedDict([\n (\"certificate-authority-data\", cert_data),\n (\"server\", endpoint)\n ])),\n (\"name\", arn)\n ])","def cluster_description(self):\n if self._cluster_description is None:\n if self._parsed_globals is None:\n client = self._session.create_client(\"eks\")\n else:\n client = self._session.create_client(\n \"eks\",\n region_name=self._parsed_globals.region,\n endpoint_url=self._parsed_globals.endpoint_url,\n verify=self._parsed_globals.verify_ssl\n )\n full_description = client.describe_cluster(name=self._cluster_name)\n self._cluster_description = full_description[\"cluster\"]\n\n if \"status\" not in self._cluster_description:\n raise EKSClusterError(\"Cluster not found\")\n if self._cluster_description[\"status\"] not in [\"ACTIVE\", \"UPDATING\"]:\n raise EKSClusterError(\"Cluster status is {0}\".format(\n self._cluster_description[\"status\"]\n ))\n\n return self._cluster_description","def gke_cluster(self) -> Optional['outputs.MembershipEndpointGkeCluster']:\n return pulumi.get(self, \"gke_cluster\")","def get_cluster_template(self, name_or_id, filters=None, detail=False):\n return _utils._get_entity(\n self,\n 'cluster_template',\n name_or_id,\n filters=filters,\n detail=detail,\n )","def launch_cluster(self):\n version = self.get_latest_spark_version()\n import os\n real_path = os.path.dirname(os.path.realpath(__file__))\n if self.is_aws():\n with open(real_path+'/../data/aws_cluster.json', 'r') as fp:\n cluster_json = json.loads(fp.read())\n else:\n with open(real_path+'/../data/azure_cluster.json', 'r') as fp:\n cluster_json = json.loads(fp.read())\n # set the latest spark release regardless of defined cluster json\n cluster_json['spark_version'] = version['key']\n c_info = self.post('/clusters/create', cluster_json)\n self.wait_for_cluster(c_info['cluster_id'])\n return c_info['cluster_id']","def ecs_getClusterArn(region, cluster):\n client = boto3.client('ecs', region_name=region)\n response = client.describe_clusters(clusters=[cluster])\n\n logging.debug(\"ECS Cluster Details: %s\", response)\n if len(response['clusters']) == 1:\n return (response['clusters'][0]['clusterArn'])\n else:\n return ''","def cluster_solution_id(dataset_name, cluster_solution_name):\n dataset_id = get_dataset(name=dataset_name).id\n cs_id = db.session.query(ClusterSolution)\\\n .filter(\n and_(\n ClusterSolution.dataset_id == dataset_id,\n ClusterSolution.name == cluster_solution_name\n )\n )[0].id\n return cs_id","def cluster_info(self, target_nodes: Optional[\"TargetNodesT\"] = None) -> ResponseT:\n return self.execute_command(\"CLUSTER INFO\", target_nodes=target_nodes)","def DescribeCluster(self, ResourceId):\n\n Client = boto3.client('emr')\n \n response = Client.describe_cluster (\n ClusterId = ResourceId\n\t)\n\n return response","def search_cluster_by_node(self, target):\n for i in range(len(self.result)):\n cluster = self.result[i]\n for node in cluster.get_nodes():\n if target == node:\n return i\n return None","def getClusterVmNextId(self):\n data = self.connect('get','cluster/nextid',None)\n return data","def create_coe_cluster(\n self,\n name,\n cluster_template_id,\n **kwargs,\n ):\n cluster = self.container_infrastructure_management.create_cluster(\n name=name,\n cluster_template_id=cluster_template_id,\n **kwargs,\n )\n\n self.list_coe_clusters.invalidate(self)\n return cluster","def get_datacenter_id(options):\n datacenter = get_datacenter(options)\n return datacenter._GetMoId()","def get_ceph_clusters_by_pcc(conn: dict, id: str) -> dict:\n return get(conn, f\"{S3PCCS}/{id}/storage/clusters\")","def get_cluster_info(self) -> Dict[str, Any]:\n pass","def get_cluster_pool(cluster_pool_name: Optional[str] = None,\n resource_group_name: Optional[str] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetClusterPoolResult:\n __args__ = dict()\n __args__['clusterPoolName'] = cluster_pool_name\n __args__['resourceGroupName'] = resource_group_name\n opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)\n __ret__ = pulumi.runtime.invoke('azure-native:hdinsight/v20230601preview:getClusterPool', __args__, opts=opts, typ=GetClusterPoolResult).value\n\n return AwaitableGetClusterPoolResult(\n aks_cluster_profile=pulumi.get(__ret__, 'aks_cluster_profile'),\n aks_managed_resource_group_name=pulumi.get(__ret__, 'aks_managed_resource_group_name'),\n cluster_pool_profile=pulumi.get(__ret__, 'cluster_pool_profile'),\n compute_profile=pulumi.get(__ret__, 'compute_profile'),\n deployment_id=pulumi.get(__ret__, 'deployment_id'),\n id=pulumi.get(__ret__, 'id'),\n location=pulumi.get(__ret__, 'location'),\n log_analytics_profile=pulumi.get(__ret__, 'log_analytics_profile'),\n managed_resource_group_name=pulumi.get(__ret__, 'managed_resource_group_name'),\n name=pulumi.get(__ret__, 'name'),\n network_profile=pulumi.get(__ret__, 'network_profile'),\n provisioning_state=pulumi.get(__ret__, 'provisioning_state'),\n status=pulumi.get(__ret__, 'status'),\n system_data=pulumi.get(__ret__, 'system_data'),\n tags=pulumi.get(__ret__, 'tags'),\n type=pulumi.get(__ret__, 'type'))","def data_center_name(self) -> str:\n return pulumi.get(self, \"data_center_name\")","def show_cluster(self):\n if self.controller.cluster:\n self.print_object(\n 'cluster', ('id', 'name', 'status'), self.controller.cluster\n )\n else:\n print(\"There is no cluster.\")","def get_cluster_properties(redshift_client):\n cluster_properties = redshift_client.describe_clusters(\n ClusterIdentifier=IDENTIFIER\n )['Clusters'][0]\n return cluster_properties","def list_cluster_response():\n return {\n \"clusters\": [\n EXAMPLE_NAME\n ]\n }","def get_cluster_def():\n if settings.NO_OP:\n return None\n\n ensure_in_custer()\n\n cluster = os.getenv('POLYAXON_CLUSTER', None)\n try:\n return json.loads(cluster) if cluster else None\n except (ValueError, TypeError):\n print('Could get cluster definition, '\n 'please make sure this is running inside a polyaxon job.')\n return None","def cluster_kmeans(self, data, n_clusters):\n km = cl.KMeans(n_clusters)\n kmf = km.fit(data)\n\n labels = kmf.labels_\n\n return labels, [np.nan]","def __str__(self):\n return \"Cluster\"","def get_datacenter(options):\n content = get_vc_content(options)\n rootFolder = content.rootFolder\n for item in rootFolder.childEntity:\n if (options.datacenter == item.name):\n return item\n return None","def list_clusters(self, **kwargs):\n return self._get_names('SCVMHostCluster')"],"string":"[\n \"def get_cluster_id(options):\\n cluster = options.cluster\\n datacenter = get_datacenter(options)\\n for item in datacenter.hostFolder.childEntity:\\n if (item.name == cluster):\\n return item._GetMoId()\",\n \"def get_compute_cluster_output(datacenter_id: Optional[pulumi.Input[Optional[str]]] = None,\\n name: Optional[pulumi.Input[str]] = None,\\n opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetComputeClusterResult]:\\n ...\",\n \"def get_cluster(self,cluster_name,project_id=''):\\n print( f'>>>>>>{self.project_id}')\\n if project_id == '':\\n project_id = self.project_id\\n return self.get('{}/groups/{}/clusters/{}'.format(ApiVersion.A1.value,project_id,cluster_name))\",\n \"def get_cluster_id(self):\\n cmd = \\\"svcinfo lscluster -delim :\\\"\\n\\n output = self._svc_command(cmd)[0]\\n\\n if len(output) != 2:\\n return None\\n\\n header = output[0].split(':')\\n values = output[1].split(':')\\n index = header.index(SVC_CLUSTER_ID)\\n cluster_id = values[index]\\n return cluster_id\",\n \"def cluster_id(self) -> str:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> str:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> str:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> str:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> str:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def find_cluster(self, id: str) -> dto.Cluster:\\n raise errors.UnsupportedOperationError(\\n \\\"Operation not supported for provider '{}'\\\".format(self.provider_name)\\n )\",\n \"def cluster_id(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def cluster_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"cluster_id\\\")\",\n \"def clusters(self,project_id=os.environ.get(\\\"ATLAS_PROJECT\\\")):\\n project_id = project_id if project_id != '' else self.__project_id\\n return self.get('{}/groups/{}/clusters'.format(ApiVersion.A1.value,project_id))\",\n \"def cluster_id(self):\\n return self._cluster_id\",\n \"def find_cluster(self, id):\\n raise NotImplementedError\",\n \"def cluster_identifier(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"cluster_identifier\\\")\",\n \"def find_kubernetes_cluster(self, id: str) -> dto.KubernetesCluster:\\n raise errors.UnsupportedOperationError(\\n \\\"Operation not supported for provider '{}'\\\".format(self.provider_name)\\n )\",\n \"def show_cluster(name: str) -> Cluster:\\n environment = EnvironmentProvider().environment\\n return environment.clusters[name]\",\n \"def get_coe_cluster(self, name_or_id, filters=None):\\n return _utils._get_entity(self, 'coe_cluster', name_or_id, filters)\",\n \"def lookup_cluster_by_name(cluster_name):\\n cluster_root = get_cluster_root()\\n if not cluster_root:\\n print('Cannot get the root of the linked list of clusters')\\n return\\n cluster = None\\n\\n # lookup for the task associated with the id\\n if cluster_root['cluster_']['name'].string() == cluster_name:\\n cluster = cluster_root['cluster_'].address\\n else:\\n curr = cluster_root\\n while True:\\n curr = curr['next'].cast(uClusterDL_ptr_type)\\n\\n if curr['cluster_']['name'].string() == cluster_name:\\n cluster = curr['cluster_'].address\\n break\\n\\n if curr == cluster_root:\\n break\\n\\n if not cluster:\\n print(\\n (\\\"Cannot find a cluster with the name: {}.\\\".format(cluster_name))\\n )\\n return cluster\",\n \"def cluster_myid(self, target_node: \\\"TargetNodesT\\\") -> ResponseT:\\n return self.execute_command(\\\"CLUSTER MYID\\\", target_nodes=target_node)\",\n \"def show_vsan_cluster(self, cluster_id):\\n url = \\\"clusters/%s\\\" % str(cluster_id)\\n resp, body = self.get(url)\\n body = json.loads(body)\\n self.expected_success(200, resp.status)\\n return service_client.ResponseBody(resp, body['cluster'])\",\n \"def data_center_id(self) -> str:\\n return pulumi.get(self, \\\"data_center_id\\\")\",\n \"def data_center_id(self) -> str:\\n return pulumi.get(self, \\\"data_center_id\\\")\",\n \"def get_one_cluster_by_name(ctx, cluster_name, project_name):\\n project = ctx.obj.groups.byName[project_name].get().data\\n cluster = ctx.obj.groups[project.id].clusters[cluster_name].get()\\n pprint(cluster.data)\",\n \"def get_datacenter(conn):\\n datacenter_id = get_datacenter_id()\\n\\n for item in conn.list_datacenters()[\\\"items\\\"]:\\n if item[\\\"id\\\"] == datacenter_id:\\n return item\\n\\n raise SaltCloudNotFound(\\n \\\"The specified datacenter '{}' could not be found.\\\".format(datacenter_id)\\n )\",\n \"def get_cluster(cluster_id: Optional[str] = None,\\n location: Optional[str] = None,\\n project: Optional[str] = None,\\n opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetClusterResult:\\n __args__ = dict()\\n __args__['clusterId'] = cluster_id\\n __args__['location'] = location\\n __args__['project'] = project\\n if opts is None:\\n opts = pulumi.InvokeOptions()\\n if opts.version is None:\\n opts.version = _utilities.get_version()\\n __ret__ = pulumi.runtime.invoke('google-native:container/v1:getCluster', __args__, opts=opts, typ=GetClusterResult).value\\n\\n return AwaitableGetClusterResult(\\n addons_config=__ret__.addons_config,\\n authenticator_groups_config=__ret__.authenticator_groups_config,\\n autopilot=__ret__.autopilot,\\n autoscaling=__ret__.autoscaling,\\n binary_authorization=__ret__.binary_authorization,\\n cluster_ipv4_cidr=__ret__.cluster_ipv4_cidr,\\n conditions=__ret__.conditions,\\n confidential_nodes=__ret__.confidential_nodes,\\n create_time=__ret__.create_time,\\n current_master_version=__ret__.current_master_version,\\n current_node_version=__ret__.current_node_version,\\n database_encryption=__ret__.database_encryption,\\n default_max_pods_constraint=__ret__.default_max_pods_constraint,\\n description=__ret__.description,\\n enable_kubernetes_alpha=__ret__.enable_kubernetes_alpha,\\n enable_tpu=__ret__.enable_tpu,\\n endpoint=__ret__.endpoint,\\n expire_time=__ret__.expire_time,\\n initial_cluster_version=__ret__.initial_cluster_version,\\n ip_allocation_policy=__ret__.ip_allocation_policy,\\n label_fingerprint=__ret__.label_fingerprint,\\n legacy_abac=__ret__.legacy_abac,\\n location=__ret__.location,\\n locations=__ret__.locations,\\n logging_config=__ret__.logging_config,\\n logging_service=__ret__.logging_service,\\n maintenance_policy=__ret__.maintenance_policy,\\n master_auth=__ret__.master_auth,\\n master_authorized_networks_config=__ret__.master_authorized_networks_config,\\n mesh_certificates=__ret__.mesh_certificates,\\n monitoring_config=__ret__.monitoring_config,\\n monitoring_service=__ret__.monitoring_service,\\n name=__ret__.name,\\n network=__ret__.network,\\n network_config=__ret__.network_config,\\n network_policy=__ret__.network_policy,\\n node_ipv4_cidr_size=__ret__.node_ipv4_cidr_size,\\n node_pools=__ret__.node_pools,\\n notification_config=__ret__.notification_config,\\n private_cluster_config=__ret__.private_cluster_config,\\n release_channel=__ret__.release_channel,\\n resource_labels=__ret__.resource_labels,\\n resource_usage_export_config=__ret__.resource_usage_export_config,\\n self_link=__ret__.self_link,\\n services_ipv4_cidr=__ret__.services_ipv4_cidr,\\n shielded_nodes=__ret__.shielded_nodes,\\n status=__ret__.status,\\n subnetwork=__ret__.subnetwork,\\n tpu_ipv4_cidr_block=__ret__.tpu_ipv4_cidr_block,\\n vertical_pod_autoscaling=__ret__.vertical_pod_autoscaling,\\n workload_identity_config=__ret__.workload_identity_config)\",\n \"def cluster_name(self) -> str:\\n return pulumi.get(self, \\\"cluster_name\\\")\",\n \"def cluster_name(self) -> str:\\n return pulumi.get(self, \\\"cluster_name\\\")\",\n \"def cluster_name(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"cluster_name\\\")\",\n \"def cluster_name(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"cluster_name\\\")\",\n \"def resource_type(self):\\n return 'cluster'\",\n \"def pc_cluster(data, clusters):\\n dist = MorningstarPCA.pc_distance(data, clusters)\\n return MorningstarPCA.get_column_with_min_value(dist)\",\n \"def cluster_name(self):\\n return self._data['cluster_name']\",\n \"def get_cluster(self, label):\\n try:\\n return self._clusters[label]\\n except KeyError:\\n return None\",\n \"def find_kubernetes_cluster_template(self, id: str) -> dto.KubernetesClusterTemplate:\\n raise errors.UnsupportedOperationError(\\n \\\"Operation not supported for provider '{}'\\\".format(self.provider_name)\\n )\",\n \"def find_cluster_sample(self, sample):\\n for cluster in self.cluster_lst:\\n if sample in cluster.get_samples():\\n return cluster.get_c_id()\",\n \"def cluster_name(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"cluster_name\\\")\",\n \"def get_coe_cluster_certificate(self, cluster_id):\\n return (\\n self.container_infrastructure_management.get_cluster_certificate(\\n cluster_id\\n )\\n )\",\n \"def cluster_query(cluster_id):\\n request_debug(r, logger)\\n # cluster_id = request_get(r, \\\"cluster_id\\\")\\n\\n result = cluster_handler.get_by_id(cluster_id)\\n logger.info(result)\\n if result:\\n response_ok['data'] = result\\n return jsonify(response_ok), CODE_OK\\n else:\\n logger.warning(\\\"cluster not found with id=\\\" + cluster_id)\\n response_fail[\\\"data\\\"] = r.form\\n response_fail[\\\"code\\\"] = CODE_NOT_FOUND\\n return jsonify(response_fail), CODE_NOT_FOUND\",\n \"def get_datacenter_id():\\n datacenter_id = config.get_cloud_config_value(\\n \\\"datacenter_id\\\", get_configured_provider(), __opts__, search_global=False\\n )\\n\\n conn = get_conn()\\n\\n try:\\n conn.get_datacenter(datacenter_id=datacenter_id)\\n except PBNotFoundError:\\n log.error(\\\"Failed to get datacenter: %s\\\", datacenter_id)\\n raise\\n\\n return datacenter_id\",\n \"def get_cluster_output(cluster_id: Optional[pulumi.Input[str]] = None,\\n location: Optional[pulumi.Input[str]] = None,\\n project: Optional[pulumi.Input[Optional[str]]] = None,\\n opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetClusterResult]:\\n ...\",\n \"def get_cluster_name(cls):\\n\\n mid = Machineid()\\n if mid.is_sps_cluster:\\n return cls.SPS\\n if mid.is_spts_cluster:\\n return cls.SPTS\\n if mid.is_mdfl_cluster:\\n return cls.MDFL\\n\\n return cls.LOCAL\",\n \"def get_cluster_idx(_cluster):\\n\\n return _cluster.cluster_idx\",\n \"def cluster(self):\\n return self._cluster\",\n \"def cluster(self):\\n return self._cluster\",\n \"def cluster_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"cluster_name\\\")\",\n \"def cluster_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"cluster_name\\\")\",\n \"def cluster_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"cluster_name\\\")\",\n \"def cluster_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"cluster_name\\\")\",\n \"def cluster_name(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"cluster_name\\\")\",\n \"def get_cluster(t2_url, t2_token, id):\\n response = requests.get(f\\\"{t2_url}/api/clusters/{id}\\\", headers={ \\\"t2-token\\\": t2_token })\\n if(response.status_code != 200):\\n log(f\\\"API call to get cluster returned error code {response.status_code}\\\")\\n return None\\n return response.json()\",\n \"def get_cluster_by_id(self, c_id: str) -> List[str]:\\n return [k for k, v in self._clusters.items() if v == c_id]\",\n \"def get(resource_name: str,\\n id: pulumi.Input[str],\\n opts: Optional[pulumi.ResourceOptions] = None,\\n cluster_id: Optional[pulumi.Input[str]] = None,\\n identity: Optional[pulumi.Input[pulumi.InputType['ClusterIdentityArgs']]] = None,\\n location: Optional[pulumi.Input[str]] = None,\\n name: Optional[pulumi.Input[str]] = None,\\n resource_group_name: Optional[pulumi.Input[str]] = None,\\n size_gb: Optional[pulumi.Input[int]] = None,\\n tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None) -> 'Cluster':\\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))\\n\\n __props__ = _ClusterState.__new__(_ClusterState)\\n\\n __props__.__dict__[\\\"cluster_id\\\"] = cluster_id\\n __props__.__dict__[\\\"identity\\\"] = identity\\n __props__.__dict__[\\\"location\\\"] = location\\n __props__.__dict__[\\\"name\\\"] = name\\n __props__.__dict__[\\\"resource_group_name\\\"] = resource_group_name\\n __props__.__dict__[\\\"size_gb\\\"] = size_gb\\n __props__.__dict__[\\\"tags\\\"] = tags\\n return Cluster(resource_name, opts=opts, __props__=__props__)\",\n \"def getClusterData(clusterName,data):\\n clusters = rhevGet(\\\"/api/clusters\\\")\\n doc = libxml2.parseDoc(clusters)\\n ctxt = doc.xpathNewContext()\\n res = ctxt.xpathEval(\\\"/clusters/cluster[name [position()=1]= '\\\"+ clusterName + \\\"']\\\")\\n return res[0].prop(data)\",\n \"def cluster_identity_get(self, desired_attributes=None):\\n return self.request( \\\"cluster-identity-get\\\", {\\n 'desired_attributes': [ desired_attributes, 'desired-attributes', [ ClusterIdentityInfo, 'None' ], False ],\\n }, {\\n 'attributes': [ ClusterIdentityInfo, False ],\\n } )\",\n \"def clustering(self) -> 'outputs.ClusteringResponse':\\n return pulumi.get(self, \\\"clustering\\\")\",\n \"def get(resource_name: str,\\n id: pulumi.Input[str],\\n opts: Optional[pulumi.ResourceOptions] = None,\\n auto_renew: Optional[pulumi.Input[bool]] = None,\\n auto_renew_period: Optional[pulumi.Input[int]] = None,\\n cluster_name: Optional[pulumi.Input[str]] = None,\\n data_center_name: Optional[pulumi.Input[str]] = None,\\n disk_size: Optional[pulumi.Input[int]] = None,\\n disk_type: Optional[pulumi.Input[str]] = None,\\n enable_public: Optional[pulumi.Input[bool]] = None,\\n instance_type: Optional[pulumi.Input[str]] = None,\\n ip_white: Optional[pulumi.Input[str]] = None,\\n maintain_end_time: Optional[pulumi.Input[str]] = None,\\n maintain_start_time: Optional[pulumi.Input[str]] = None,\\n major_version: Optional[pulumi.Input[str]] = None,\\n node_count: Optional[pulumi.Input[int]] = None,\\n password: Optional[pulumi.Input[str]] = None,\\n pay_type: Optional[pulumi.Input[str]] = None,\\n period: Optional[pulumi.Input[int]] = None,\\n period_unit: Optional[pulumi.Input[str]] = None,\\n public_points: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n status: Optional[pulumi.Input[str]] = None,\\n tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,\\n vswitch_id: Optional[pulumi.Input[str]] = None,\\n zone_id: Optional[pulumi.Input[str]] = None) -> 'Cluster':\\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))\\n\\n __props__ = _ClusterState.__new__(_ClusterState)\\n\\n __props__.__dict__[\\\"auto_renew\\\"] = auto_renew\\n __props__.__dict__[\\\"auto_renew_period\\\"] = auto_renew_period\\n __props__.__dict__[\\\"cluster_name\\\"] = cluster_name\\n __props__.__dict__[\\\"data_center_name\\\"] = data_center_name\\n __props__.__dict__[\\\"disk_size\\\"] = disk_size\\n __props__.__dict__[\\\"disk_type\\\"] = disk_type\\n __props__.__dict__[\\\"enable_public\\\"] = enable_public\\n __props__.__dict__[\\\"instance_type\\\"] = instance_type\\n __props__.__dict__[\\\"ip_white\\\"] = ip_white\\n __props__.__dict__[\\\"maintain_end_time\\\"] = maintain_end_time\\n __props__.__dict__[\\\"maintain_start_time\\\"] = maintain_start_time\\n __props__.__dict__[\\\"major_version\\\"] = major_version\\n __props__.__dict__[\\\"node_count\\\"] = node_count\\n __props__.__dict__[\\\"password\\\"] = password\\n __props__.__dict__[\\\"pay_type\\\"] = pay_type\\n __props__.__dict__[\\\"period\\\"] = period\\n __props__.__dict__[\\\"period_unit\\\"] = period_unit\\n __props__.__dict__[\\\"public_points\\\"] = public_points\\n __props__.__dict__[\\\"security_groups\\\"] = security_groups\\n __props__.__dict__[\\\"status\\\"] = status\\n __props__.__dict__[\\\"tags\\\"] = tags\\n __props__.__dict__[\\\"vswitch_id\\\"] = vswitch_id\\n __props__.__dict__[\\\"zone_id\\\"] = zone_id\\n return Cluster(resource_name, opts=opts, __props__=__props__)\",\n \"def get_clusters(self):\\n fields = ['name', ]\\n return self.get_data(\\\"clusters\\\", fields)\",\n \"def cluster_name(self):\\n return self.name\",\n \"async def get(id):\\n cluster = clusters.get_by_id(id)\\n\\n if cluster is None:\\n raise HTTPException(status_code=404, detail=\\\"Cluster not found for ID: {0}\\\".format(id))\\n\\n return cluster.export()\",\n \"def orig_cluster_id(self):\\n if self.old_cluster_name is None:\\n raise RuntimeError('old_cluster_name is not set')\\n return self.fuel_web.client.get_cluster_id(self.old_cluster_name)\",\n \"def get_cluster_config(cohesity_client):\\n config = cohesity_client.cluster.get_cluster()\\n return config\",\n \"def _find_cluster(clusters, label):\\n for clst in clusters:\\n if clst.label == label: return clst\\n return None\",\n \"def get(resource_name: str,\\n id: pulumi.Input[str],\\n opts: Optional[pulumi.ResourceOptions] = None) -> 'Cluster':\\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))\\n\\n __props__ = ClusterArgs.__new__(ClusterArgs)\\n\\n __props__.__dict__[\\\"allocation_state\\\"] = None\\n __props__.__dict__[\\\"allocation_state_transition_time\\\"] = None\\n __props__.__dict__[\\\"creation_time\\\"] = None\\n __props__.__dict__[\\\"current_node_count\\\"] = None\\n __props__.__dict__[\\\"errors\\\"] = None\\n __props__.__dict__[\\\"name\\\"] = None\\n __props__.__dict__[\\\"node_setup\\\"] = None\\n __props__.__dict__[\\\"node_state_counts\\\"] = None\\n __props__.__dict__[\\\"provisioning_state\\\"] = None\\n __props__.__dict__[\\\"provisioning_state_transition_time\\\"] = None\\n __props__.__dict__[\\\"scale_settings\\\"] = None\\n __props__.__dict__[\\\"subnet\\\"] = None\\n __props__.__dict__[\\\"type\\\"] = None\\n __props__.__dict__[\\\"user_account_settings\\\"] = None\\n __props__.__dict__[\\\"virtual_machine_configuration\\\"] = None\\n __props__.__dict__[\\\"vm_priority\\\"] = None\\n __props__.__dict__[\\\"vm_size\\\"] = None\\n return Cluster(resource_name, opts=opts, __props__=__props__)\",\n \"def _get_center(data, node_id, feature_columns):\\n if node_id in data.id.values:\\n return data[data.id == node_id][feature_columns].values\\n else:\\n return _get_center(data, node_id[:-1], feature_columns)\",\n \"def cluster_type(self) -> str:\\n return pulumi.get(self, \\\"cluster_type\\\")\",\n \"def get_cluster(self, profile):\\n if self._value.has_option(profile, 'cluster'):\\n if self._value.has_option(profile, 'cluster'):\\n cluster = self._value.get(profile, 'cluster')\\n self.logger.info(\\\"Connecting to: %s cluster\\\" % cluster)\\n else:\\n self.logger.error(\\n \\\"No cluster parameter found\\\"\\n )\\n exit(1)\\n else:\\n self.logger.error(\\n \\\"No profile found. Please define a default profile, \\\\\\n or specify a named profile using `--profile`\\\"\\n )\\n exit(1)\\n return cluster\",\n \"def get_cluster_entry(self):\\n\\n cert_data = self.cluster_description.get(\\\"certificateAuthority\\\", {}).get(\\\"data\\\", \\\"\\\")\\n endpoint = self.cluster_description.get(\\\"endpoint\\\")\\n arn = self.cluster_description.get(\\\"arn\\\")\\n\\n return OrderedDict([\\n (\\\"cluster\\\", OrderedDict([\\n (\\\"certificate-authority-data\\\", cert_data),\\n (\\\"server\\\", endpoint)\\n ])),\\n (\\\"name\\\", arn)\\n ])\",\n \"def cluster_description(self):\\n if self._cluster_description is None:\\n if self._parsed_globals is None:\\n client = self._session.create_client(\\\"eks\\\")\\n else:\\n client = self._session.create_client(\\n \\\"eks\\\",\\n region_name=self._parsed_globals.region,\\n endpoint_url=self._parsed_globals.endpoint_url,\\n verify=self._parsed_globals.verify_ssl\\n )\\n full_description = client.describe_cluster(name=self._cluster_name)\\n self._cluster_description = full_description[\\\"cluster\\\"]\\n\\n if \\\"status\\\" not in self._cluster_description:\\n raise EKSClusterError(\\\"Cluster not found\\\")\\n if self._cluster_description[\\\"status\\\"] not in [\\\"ACTIVE\\\", \\\"UPDATING\\\"]:\\n raise EKSClusterError(\\\"Cluster status is {0}\\\".format(\\n self._cluster_description[\\\"status\\\"]\\n ))\\n\\n return self._cluster_description\",\n \"def gke_cluster(self) -> Optional['outputs.MembershipEndpointGkeCluster']:\\n return pulumi.get(self, \\\"gke_cluster\\\")\",\n \"def get_cluster_template(self, name_or_id, filters=None, detail=False):\\n return _utils._get_entity(\\n self,\\n 'cluster_template',\\n name_or_id,\\n filters=filters,\\n detail=detail,\\n )\",\n \"def launch_cluster(self):\\n version = self.get_latest_spark_version()\\n import os\\n real_path = os.path.dirname(os.path.realpath(__file__))\\n if self.is_aws():\\n with open(real_path+'/../data/aws_cluster.json', 'r') as fp:\\n cluster_json = json.loads(fp.read())\\n else:\\n with open(real_path+'/../data/azure_cluster.json', 'r') as fp:\\n cluster_json = json.loads(fp.read())\\n # set the latest spark release regardless of defined cluster json\\n cluster_json['spark_version'] = version['key']\\n c_info = self.post('/clusters/create', cluster_json)\\n self.wait_for_cluster(c_info['cluster_id'])\\n return c_info['cluster_id']\",\n \"def ecs_getClusterArn(region, cluster):\\n client = boto3.client('ecs', region_name=region)\\n response = client.describe_clusters(clusters=[cluster])\\n\\n logging.debug(\\\"ECS Cluster Details: %s\\\", response)\\n if len(response['clusters']) == 1:\\n return (response['clusters'][0]['clusterArn'])\\n else:\\n return ''\",\n \"def cluster_solution_id(dataset_name, cluster_solution_name):\\n dataset_id = get_dataset(name=dataset_name).id\\n cs_id = db.session.query(ClusterSolution)\\\\\\n .filter(\\n and_(\\n ClusterSolution.dataset_id == dataset_id,\\n ClusterSolution.name == cluster_solution_name\\n )\\n )[0].id\\n return cs_id\",\n \"def cluster_info(self, target_nodes: Optional[\\\"TargetNodesT\\\"] = None) -> ResponseT:\\n return self.execute_command(\\\"CLUSTER INFO\\\", target_nodes=target_nodes)\",\n \"def DescribeCluster(self, ResourceId):\\n\\n Client = boto3.client('emr')\\n \\n response = Client.describe_cluster (\\n ClusterId = ResourceId\\n\\t)\\n\\n return response\",\n \"def search_cluster_by_node(self, target):\\n for i in range(len(self.result)):\\n cluster = self.result[i]\\n for node in cluster.get_nodes():\\n if target == node:\\n return i\\n return None\",\n \"def getClusterVmNextId(self):\\n data = self.connect('get','cluster/nextid',None)\\n return data\",\n \"def create_coe_cluster(\\n self,\\n name,\\n cluster_template_id,\\n **kwargs,\\n ):\\n cluster = self.container_infrastructure_management.create_cluster(\\n name=name,\\n cluster_template_id=cluster_template_id,\\n **kwargs,\\n )\\n\\n self.list_coe_clusters.invalidate(self)\\n return cluster\",\n \"def get_datacenter_id(options):\\n datacenter = get_datacenter(options)\\n return datacenter._GetMoId()\",\n \"def get_ceph_clusters_by_pcc(conn: dict, id: str) -> dict:\\n return get(conn, f\\\"{S3PCCS}/{id}/storage/clusters\\\")\",\n \"def get_cluster_info(self) -> Dict[str, Any]:\\n pass\",\n \"def get_cluster_pool(cluster_pool_name: Optional[str] = None,\\n resource_group_name: Optional[str] = None,\\n opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetClusterPoolResult:\\n __args__ = dict()\\n __args__['clusterPoolName'] = cluster_pool_name\\n __args__['resourceGroupName'] = resource_group_name\\n opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)\\n __ret__ = pulumi.runtime.invoke('azure-native:hdinsight/v20230601preview:getClusterPool', __args__, opts=opts, typ=GetClusterPoolResult).value\\n\\n return AwaitableGetClusterPoolResult(\\n aks_cluster_profile=pulumi.get(__ret__, 'aks_cluster_profile'),\\n aks_managed_resource_group_name=pulumi.get(__ret__, 'aks_managed_resource_group_name'),\\n cluster_pool_profile=pulumi.get(__ret__, 'cluster_pool_profile'),\\n compute_profile=pulumi.get(__ret__, 'compute_profile'),\\n deployment_id=pulumi.get(__ret__, 'deployment_id'),\\n id=pulumi.get(__ret__, 'id'),\\n location=pulumi.get(__ret__, 'location'),\\n log_analytics_profile=pulumi.get(__ret__, 'log_analytics_profile'),\\n managed_resource_group_name=pulumi.get(__ret__, 'managed_resource_group_name'),\\n name=pulumi.get(__ret__, 'name'),\\n network_profile=pulumi.get(__ret__, 'network_profile'),\\n provisioning_state=pulumi.get(__ret__, 'provisioning_state'),\\n status=pulumi.get(__ret__, 'status'),\\n system_data=pulumi.get(__ret__, 'system_data'),\\n tags=pulumi.get(__ret__, 'tags'),\\n type=pulumi.get(__ret__, 'type'))\",\n \"def data_center_name(self) -> str:\\n return pulumi.get(self, \\\"data_center_name\\\")\",\n \"def show_cluster(self):\\n if self.controller.cluster:\\n self.print_object(\\n 'cluster', ('id', 'name', 'status'), self.controller.cluster\\n )\\n else:\\n print(\\\"There is no cluster.\\\")\",\n \"def get_cluster_properties(redshift_client):\\n cluster_properties = redshift_client.describe_clusters(\\n ClusterIdentifier=IDENTIFIER\\n )['Clusters'][0]\\n return cluster_properties\",\n \"def list_cluster_response():\\n return {\\n \\\"clusters\\\": [\\n EXAMPLE_NAME\\n ]\\n }\",\n \"def get_cluster_def():\\n if settings.NO_OP:\\n return None\\n\\n ensure_in_custer()\\n\\n cluster = os.getenv('POLYAXON_CLUSTER', None)\\n try:\\n return json.loads(cluster) if cluster else None\\n except (ValueError, TypeError):\\n print('Could get cluster definition, '\\n 'please make sure this is running inside a polyaxon job.')\\n return None\",\n \"def cluster_kmeans(self, data, n_clusters):\\n km = cl.KMeans(n_clusters)\\n kmf = km.fit(data)\\n\\n labels = kmf.labels_\\n\\n return labels, [np.nan]\",\n \"def __str__(self):\\n return \\\"Cluster\\\"\",\n \"def get_datacenter(options):\\n content = get_vc_content(options)\\n rootFolder = content.rootFolder\\n for item in rootFolder.childEntity:\\n if (options.datacenter == item.name):\\n return item\\n return None\",\n \"def list_clusters(self, **kwargs):\\n return self._get_names('SCVMHostCluster')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70518404","0.70052683","0.67735595","0.6768537","0.6736824","0.6736824","0.6736824","0.6736824","0.6736824","0.66624004","0.66624004","0.66624004","0.66624004","0.6613303","0.660601","0.660601","0.6474703","0.6474703","0.6474703","0.63924193","0.63861185","0.63270766","0.6276351","0.6269334","0.62308496","0.6221327","0.62061673","0.61876196","0.6160735","0.61367285","0.61367285","0.6121547","0.6103939","0.606107","0.6054131","0.6054131","0.6031278","0.6031278","0.60063285","0.5993482","0.5970224","0.5945154","0.5939524","0.593516","0.5921245","0.58835465","0.5882657","0.5878035","0.58768255","0.5869813","0.5865723","0.5855551","0.5855551","0.58481365","0.58481365","0.58481365","0.58481365","0.58481365","0.5829678","0.58203787","0.5819459","0.57718134","0.5758876","0.57381326","0.5734544","0.57087946","0.56975925","0.56702477","0.5658413","0.56578165","0.56324726","0.5627083","0.56178856","0.5616781","0.56036544","0.5601759","0.5601101","0.5597886","0.5590274","0.55648077","0.5554557","0.5547291","0.5545548","0.55238587","0.5521631","0.55111134","0.5500737","0.5494587","0.54801834","0.5477136","0.54766876","0.546071","0.5446311","0.5440939","0.5437183","0.54263484","0.54172444","0.54061675","0.5401415","0.5395855"],"string":"[\n \"0.70518404\",\n \"0.70052683\",\n \"0.67735595\",\n \"0.6768537\",\n \"0.6736824\",\n \"0.6736824\",\n \"0.6736824\",\n \"0.6736824\",\n \"0.6736824\",\n \"0.66624004\",\n \"0.66624004\",\n \"0.66624004\",\n \"0.66624004\",\n \"0.6613303\",\n \"0.660601\",\n \"0.660601\",\n \"0.6474703\",\n \"0.6474703\",\n \"0.6474703\",\n \"0.63924193\",\n \"0.63861185\",\n \"0.63270766\",\n \"0.6276351\",\n \"0.6269334\",\n \"0.62308496\",\n \"0.6221327\",\n \"0.62061673\",\n \"0.61876196\",\n \"0.6160735\",\n \"0.61367285\",\n \"0.61367285\",\n \"0.6121547\",\n \"0.6103939\",\n \"0.606107\",\n \"0.6054131\",\n \"0.6054131\",\n \"0.6031278\",\n \"0.6031278\",\n \"0.60063285\",\n \"0.5993482\",\n \"0.5970224\",\n \"0.5945154\",\n \"0.5939524\",\n \"0.593516\",\n \"0.5921245\",\n \"0.58835465\",\n \"0.5882657\",\n \"0.5878035\",\n \"0.58768255\",\n \"0.5869813\",\n \"0.5865723\",\n \"0.5855551\",\n \"0.5855551\",\n \"0.58481365\",\n \"0.58481365\",\n \"0.58481365\",\n \"0.58481365\",\n \"0.58481365\",\n \"0.5829678\",\n \"0.58203787\",\n \"0.5819459\",\n \"0.57718134\",\n \"0.5758876\",\n \"0.57381326\",\n \"0.5734544\",\n \"0.57087946\",\n \"0.56975925\",\n \"0.56702477\",\n \"0.5658413\",\n \"0.56578165\",\n \"0.56324726\",\n \"0.5627083\",\n \"0.56178856\",\n \"0.5616781\",\n \"0.56036544\",\n \"0.5601759\",\n \"0.5601101\",\n \"0.5597886\",\n \"0.5590274\",\n \"0.55648077\",\n \"0.5554557\",\n \"0.5547291\",\n \"0.5545548\",\n \"0.55238587\",\n \"0.5521631\",\n \"0.55111134\",\n \"0.5500737\",\n \"0.5494587\",\n \"0.54801834\",\n \"0.5477136\",\n \"0.54766876\",\n \"0.546071\",\n \"0.5446311\",\n \"0.5440939\",\n \"0.5437183\",\n \"0.54263484\",\n \"0.54172444\",\n \"0.54061675\",\n \"0.5401415\",\n \"0.5395855\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72311264"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":0,"numItemsPerPage":100,"numTotalItems":95772,"offset":0,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3Mjg1MzA4MCwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzI4NTY2ODAsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.yLFCNqQv8KcQcxTWa-ueW_OCNPELuOnm9-cXNbUp6rod_f6MagCyvhnz-7hsYrFIqqEIzJyiUB0ik1UD1j9DCA","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 |
|---|---|---|---|---|---|---|
Read stop words from input file (filename) and insert each word as a key into the stop words hash table. | def load_stop_table(self, filename):
self.stop_table = HashTable(191)
try:
a = open(filename, "r")
lines = a.readlines()
a.close()
except:
raise FileNotFoundError()
for n in range(len(lines)):
self.stop_table.insert(lines[n][:-1], n) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_stop_table(self, filename):\n self.stop_table = HashTable(191)\n with open(filename, 'r') as f:\n for word in f.readlines():\n self.stop_table.insert(word.replace('\\n',''),None)",
"def load_stop_words(stop_word_file):\n stop_words = []\n for line in open(st... | [
"0.7675772",
"0.6984068",
"0.67051345",
"0.65770996",
"0.6555971",
"0.65203714",
"0.6489752",
"0.6475122",
"0.6467671",
"0.6451879",
"0.6377066",
"0.63083595",
"0.63079983",
"0.6283576",
"0.6268957",
"0.6258872",
"0.6253571",
"0.6214078",
"0.61646724",
"0.6143819",
"0.608474"... | 0.69579995 | 2 |
Read words from input text file (filename) and insert them into the concordance hash table, after processing for punctuation, numbers and filtering out words that are in the stop words hash table. Do not include duplicate line numbers (word appearing on same line more than once, just one entry for that line) | def load_concordance_table(self, filename):
self.concordance_table = HashTable(191)
try:
a = open(filename, "r")
lines = a.readlines()
a.close()
except:
raise FileNotFoundError()
for n in range(len(lines)):
lone = clean(lines[n])
line = lone.split(" ")
for i in line:
if (i != None) and (self.stop_table.in_table(i) == False) and (i != ""):
self.concordance_table.insert(i, n+1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_text_file(self, filepath: str):\n with open(filepath) as fh:\n for line in fh:\n for word in re.split('\\W+', line):\n word = word.lower()\n if len(word):\n l = self.hash_map.lookup(word)\n ... | [
"0.70385915",
"0.6925145",
"0.6899971",
"0.6768178",
"0.6651934",
"0.6420912",
"0.6312901",
"0.6296871",
"0.6231026",
"0.6214866",
"0.62069726",
"0.6178269",
"0.616501",
"0.615068",
"0.61372495",
"0.6134684",
"0.612722",
"0.61159056",
"0.6110232",
"0.6060298",
"0.6052872",
... | 0.65844196 | 5 |
Write the concordance entries to the output file(filename) See sample output files for format. | def write_concordance(self, filename):
all_keys = self.concordance_table.get_all_keys()
lines = []
for i in all_keys:
a = ""
a += i + ":"
f = self.concordance_table.get_value(i)
if f != None:
for s in f:
a += " " + str(s)
a += "\n"
lines.append(a)
a = open(filename, "w+")
for i in lines:
a.write(i)
a.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_concordance(self, filename):\n out = ''\n values = [x for x in self.concordance_table.hash_table if x is not None]\n values.sort(key=lambda x: x[0])\n for v in values:\n out += f'{v[0]}: {\" \".join(str(x) for x in sorted(set(v[1])))}\\n' \n with open(filenam... | [
"0.7794726",
"0.66742295",
"0.64932483",
"0.64526165",
"0.6379942",
"0.63655496",
"0.63634735",
"0.62910575",
"0.6240714",
"0.6233921",
"0.6233921",
"0.6233921",
"0.61785156",
"0.61412483",
"0.61257005",
"0.610843",
"0.6082861",
"0.60720426",
"0.6064205",
"0.60603034",
"0.598... | 0.7876976 | 0 |
Builds a kfactor circulant matrix (A matrix with the structure of circulant matrices, but with the entries above the diagonal multiplied by the same factor.) The matrix is store in memory. | def factor_circulant_matrix(x, k):
n=len(x)
return circulant(x) * (tri(n,n, 0) + k*np.transpose(tri(n,n, -1))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_k_matrix(self):\r\n K = self.uv_vol + self.Epsilon * self.guv_vol + \\\r\n (self.Epsilon / self.Beta) * self.uv_bound\r\n return K",
"def _K(m):\n M = m*(m - 1)/2\n K = np.zeros((M, m**2), dtype=np.int64)\n row = 0\n for j in range(1, m):\n col = (j - 1)*m + j... | [
"0.6495986",
"0.6089255",
"0.6045119",
"0.59890914",
"0.5949488",
"0.59035623",
"0.5859298",
"0.58462423",
"0.57634705",
"0.574443",
"0.5730508",
"0.5717386",
"0.56819576",
"0.566873",
"0.5568253",
"0.55545205",
"0.5523086",
"0.55172205",
"0.5492196",
"0.5491694",
"0.5478032"... | 0.78092545 | 0 |
Compute the matrixvector product y = Cu where C is a kfactor circulant matrix All matrices are real | def factor_circulant_multiplication(u, x, k=1):
n = len(u)
D_k = (k**(1/n))**np.arange(0,n)
Lambda = fft(D_k*x)
return (1/D_k)*real(ifft(Lambda*fft(D_k*u))) # y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def updateC(A, U, B):\n \n m_dim = A.shape[1] \n q_dim = B.shape[0]\n \n C_tensor = np.zeros((m_dim, m_dim, q_dim), dtype=np.complex)\n \n for k in range(q_dim):\n A_k = A[:, :, k]\n b_k = B[k]\n \n x_hat = U @ b_k\n y_hat = A_k.conj().T @ x_hat\n \... | [
"0.6325033",
"0.6273725",
"0.6251581",
"0.62479377",
"0.6177961",
"0.6087597",
"0.6022537",
"0.60215706",
"0.6020421",
"0.60090333",
"0.6000697",
"0.5998053",
"0.59429264",
"0.59204763",
"0.58713275",
"0.5850264",
"0.5813686",
"0.57964927",
"0.57901424",
"0.57262236",
"0.5726... | 0.693636 | 0 |
Compute the matrixvector product y = Cu where C is a circulant matrix All matrices are real | def circulant_multiplication(u, a):
return real(ifft(fft(a)*fft(u))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def covar(fx,cx):\n \n fx = np.array(fx)\n cx = np.array(cx)\n \n shape_fx = fx.shape\n shape_cx = cx.shape\n \n \n if shape_fx[1] != shape_cx[0]:\n print('-----------------------------------------')\n print(\"Shapes of fx and cx cannot be multiplied:\")\n print(shap... | [
"0.650418",
"0.650212",
"0.6441079",
"0.6313763",
"0.6310517",
"0.62949276",
"0.62782884",
"0.62631303",
"0.61975265",
"0.6096459",
"0.608041",
"0.606508",
"0.6038961",
"0.6011421",
"0.60068315",
"0.59920776",
"0.59303707",
"0.58836865",
"0.5879482",
"0.58772385",
"0.58575416... | 0.6389226 | 3 |
Compute the matrixvector product y = Tu where T is a Toeplitz matrix All matrices are real | def toeplitz_multiplication(u, c, r=None):
n = len(u)
if r is None:
r = c
u1 = zeros((2*n))
u1[0:n] = u
c = np.concatenate((c, [0], r[-1:0:-1]))
y1 = circulant_multiplication(u1, c)
return y1[0:n] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def matrix_vector_prod(m,u):\n each_product = []\n for v in m:\n each_product.append(dot_prod(v, u))\n return each_product",
"def matmul(x, y):\n if len(list(y.size())) == 2:\n # if one of them is a vector (i.e. wanting to do MV mult)\n z = torch.zeros(2, x.size()[1], dtype=torch... | [
"0.7003199",
"0.6513981",
"0.64759356",
"0.6454179",
"0.6377554",
"0.6326698",
"0.6245358",
"0.620894",
"0.6208685",
"0.61977005",
"0.6195611",
"0.61694974",
"0.6168602",
"0.6134469",
"0.6106113",
"0.60868716",
"0.6082444",
"0.60823506",
"0.6070701",
"0.60688484",
"0.6063607"... | 0.63380134 | 5 |
Solves Tx=b using the Levinson algorithm where T is apositivedefinite symmetric Toeplitz matrix b is a real vector | def levinson(r, b):
n = len(b)
y = zeros((n,))
x = zeros((n,))
# normalize the system so that the T matrix has diagonal of ones
r_0 = r/r[0]
b_0 = b/r[0]
if n == 1:
return b_0
y[0] = -r_0[1]
x[0] = b_0[0]
beta = 1
alpha = -r_0[1]
for k in range(0,n-1):
beta = (1 - alpha*alpha)*beta
mu = (b_0[k+1] - dot(r_0[1:k+2], x[k::-1])) /beta
x[0:k+1] = x[0:k+1] + mu*y[k::-1]
x[k+1] = mu
if k < n-2:
alpha = -(r_0[k+2] + dot(r_0[1:k+2], y[k::-1]))/beta
y[0:k+1] = y[0:k+1] + alpha * y[k::-1]
y[k+1] = alpha
return x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _tridisolve(d, e, b, overwrite_b=True):\n\t\tN = len(b)\n\t\t# work vectors\n\t\tdw = d.copy()\n\t\tew = e.copy()\n\t\tif overwrite_b:\n\t\t\tx = b\n\t\telse:\n\t\t\tx = b.copy()\n\t\tfor k in range(1, N):\n\t\t\t# e^(k-1) = e(k-1) / d(k-1)\n\t\t\t# d(k) = d(k) - e^(k-1)e(k-1) / d(k-1)\n\t\t\tt = ew[ k - 1 ]\n... | [
"0.63466734",
"0.61827254",
"0.61033237",
"0.6093494",
"0.60769826",
"0.5885008",
"0.58844715",
"0.5877297",
"0.58737326",
"0.58588946",
"0.5838278",
"0.5794063",
"0.57753825",
"0.5773156",
"0.5763559",
"0.57562786",
"0.574674",
"0.57452273",
"0.57390094",
"0.57179475",
"0.56... | 0.7257071 | 0 |
Compute the log determinant of a positivedefinite symmetric toeplitz matrix. The determinant is computed recursively. The intermediate solutions of the Levinson recursion are expolited. | def toeplitz_slogdet(r):
n = len(r)
r_0 = r[0]
r = np.concatenate((r, np.array([r_0])))
r /= r_0 # normalize the system so that the T matrix has diagonal of ones
logdet = n*np.log(np.abs(r_0))
sign = np.sign(r_0)**n
if n == 1:
return (sign, logdet)
# now on is a modification of Levinson algorithm
y = zeros((n,))
x = zeros((n,))
b = -r[1:n+1]
r = r[:n]
y[0] = -r[1]
x[0] = b[0]
beta = 1
alpha = -r[1]
d = 1 + dot(-b[0], x[0])
sign *= np.sign(d)
logdet += np.log(np.abs(d))
for k in range(0,n-2):
beta = (1 - alpha*alpha)*beta
mu = (b[k+1] - dot(r[1:k+2], x[k::-1])) /beta
x[0:k+1] = x[0:k+1] + mu*y[k::-1]
x[k+1] = mu
d = 1 + dot(-b[0:k+2], x[0:k+2])
sign *= np.sign(d)
logdet += np.log(np.abs(d))
if k < n-2:
alpha = -(r[k+2] + dot(r[1:k+2], y[k::-1]))/beta
y[0:k+1] = y[0:k+1] + alpha * y[k::-1]
y[k+1] = alpha
return(sign, logdet) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fast_logdet(matrix):\n sign, ld = np.linalg.slogdet(matrix)\n if not sign > 0:\n return -np.inf\n return ld",
"def pddet(A):\r\n L = jitchol(A)\r\n logdetA = 2*sum(np.log(np.diag(L)))\r\n return logdetA",
"def log_abs_det_jacobian(self, z):\n pre_u = self.u_ + self.u\n ... | [
"0.7205463",
"0.69225436",
"0.6803772",
"0.6577487",
"0.65662503",
"0.6258033",
"0.6235449",
"0.6192166",
"0.61640286",
"0.60718197",
"0.602648",
"0.5906651",
"0.5904567",
"0.58784807",
"0.58522433",
"0.5850299",
"0.58452636",
"0.5838441",
"0.5796368",
"0.57808894",
"0.577887... | 0.6977162 | 1 |
Preprocessing needed for toeplitz_inverse_multiplication() | def toeplitz_inverse_multiplication_prep(T_column):
phi=1
psi=2
assert phi != 0
assert psi != 0
assert phi != psi
n = len(T_column)
x = levinson(T_column, np.concatenate( (np.array([1]), np.zeros((n-1,))) ) )
y = levinson(T_column, np.concatenate( (np.zeros((n-1,)), np.array([1])) ) )
x_0 = x[0]
D_phi = (phi**(1/n))**np.arange(0,n)
D_psi = (psi**(1/n))**np.arange(0,n)
Lambda_1 = fft(D_psi*x)
Lambda_2 = fft(D_phi*np.concatenate(([phi*y[-1]], y[0:-1])))
Lambda_3 = fft(D_psi*np.concatenate(([psi*y[-1]], y[0:-1])))
Lambda_4 = fft(D_phi*x)
return (x_0, phi, psi, D_phi, D_psi, Lambda_1, Lambda_2, Lambda_3, Lambda_4) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bd_toeplitz_inverse_multiplication_prep(*arrs):\n \n t = []\n for c in arrs: # loop over each block\n t.append(toeplitz_inverse_multiplication_prep(c))\n return tuple(t)",
"def toeplitz_inverse_multiplication(u, x_0, phi, psi, D_phi, D_psi, Lambda_1, Lambda_2, Lambda_3, Lambda_4):\n\n y... | [
"0.65743506",
"0.63173485",
"0.60780877",
"0.60345995",
"0.5920918",
"0.5710167",
"0.5684219",
"0.56176597",
"0.56087387",
"0.5590726",
"0.5568226",
"0.556281",
"0.5558012",
"0.5548983",
"0.5540906",
"0.5426001",
"0.5426001",
"0.5406237",
"0.53970987",
"0.5395093",
"0.5389461... | 0.65871215 | 0 |
Compute y = inv(T) u Where T is a symmetrix Toeplitz matrix. Requires preprocessing with toeplitz_inverse_multiplication_prep() See Gohberg, I. and V. Olshevsky (1994) | def toeplitz_inverse_multiplication(u, x_0, phi, psi, D_phi, D_psi, Lambda_1, Lambda_2, Lambda_3, Lambda_4):
y = fft(D_phi*u)
a = Lambda_1*fft(D_psi*(1/D_phi)*ifft(Lambda_2*y))
b = Lambda_3*fft(D_psi*(1/D_phi)*ifft(Lambda_4*y))
y = (1/D_psi)*real(ifft(a-b))/(x_0*(phi-psi))
return y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toeplitz_inverse_multiplication_prep(T_column):\n \n phi=1\n psi=2\n assert phi != 0\n assert psi != 0\n assert phi != psi\n \n n = len(T_column)\n \n x = levinson(T_column, np.concatenate( (np.array([1]), np.zeros((n-1,))) ) )\n y = levinson(T_column, np.concatenate( (np.zeros... | [
"0.7413214",
"0.7380314",
"0.7238792",
"0.711224",
"0.7110274",
"0.70157236",
"0.6988002",
"0.69570976",
"0.69044274",
"0.68427217",
"0.6829249",
"0.68215156",
"0.6778755",
"0.6680136",
"0.6677371",
"0.66401356",
"0.66035974",
"0.6586728",
"0.65792894",
"0.6540509",
"0.651056... | 0.7070988 | 5 |
Determinant of a blockdiagonal matrix having Toeplitz blocks | def bd_toeplitz_slogdet(*arrs):
sign = 1
logdet = 0
for c in arrs: # loop over each block
(t_sign, t_logdet) = toeplitz_slogdet(c)
sign *= t_sign
logdet += t_logdet
return (sign, logdet) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _block_diagonal(factor_matrices):\n shapes_dict = {}\n for i, matrix_i in enumerate(factor_matrices):\n for j, matrix_j in enumerate(factor_matrices):\n shapes_dict[(i, j)] = matrix_i.shape[:-1] + matrix_j.shape[-1:]\n rows = []\n # concacatenate along axis = -2\n for i, matrix... | [
"0.6306205",
"0.62420654",
"0.6225076",
"0.62029904",
"0.61590856",
"0.6147025",
"0.61394644",
"0.60699403",
"0.6061244",
"0.60523754",
"0.6031275",
"0.6016392",
"0.6009104",
"0.60022414",
"0.59936255",
"0.59645134",
"0.5953049",
"0.59515077",
"0.5947138",
"0.59100145",
"0.58... | 0.0 | -1 |
Preprocessing for block diagonal matrices analogous to toeplitz_inverse_multiplication_prep() | def bd_toeplitz_inverse_multiplication_prep(*arrs):
t = []
for c in arrs: # loop over each block
t.append(toeplitz_inverse_multiplication_prep(c))
return tuple(t) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _block_diagonal(factor_matrices):\n shapes_dict = {}\n for i, matrix_i in enumerate(factor_matrices):\n for j, matrix_j in enumerate(factor_matrices):\n shapes_dict[(i, j)] = matrix_i.shape[:-1] + matrix_j.shape[-1:]\n rows = []\n # concacatenate along axis = -2\n for i, matrix... | [
"0.6073989",
"0.5890842",
"0.57211554",
"0.5672026",
"0.5595262",
"0.5567827",
"0.5543956",
"0.5539411",
"0.5534139",
"0.5419887",
"0.537693",
"0.5354077",
"0.5354077",
"0.53476894",
"0.53476274",
"0.52978414",
"0.52978414",
"0.5297459",
"0.5286128",
"0.52755713",
"0.5268031"... | 0.55643 | 6 |
matrix multiplication with the inverse of a blockdiagonal matrix having Toeplitz blocks. y = T u Analogous to toeplitz_inverse_multiplication() | def bd_toeplitz_inverse_multiplication(u, *arrs):
y = zeros(shape(u))
n_start = 0
n_end = 0
for t in arrs:
n_start = n_end
n_end += len(t[3]) # len(t[3]) is the length of the block
y[n_start:n_end] = toeplitz_inverse_multiplication(u[n_start:n_end], *t)
assert len(y) == n_end
return y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toeplitz_inverse_multiplication_prep(T_column):\n \n phi=1\n psi=2\n assert phi != 0\n assert psi != 0\n assert phi != psi\n \n n = len(T_column)\n \n x = levinson(T_column, np.concatenate( (np.array([1]), np.zeros((n-1,))) ) )\n y = levinson(T_column, np.concatenate( (np.zeros... | [
"0.65371925",
"0.6473114",
"0.639856",
"0.6361315",
"0.6302969",
"0.6292023",
"0.6192051",
"0.61344135",
"0.61059606",
"0.60929507",
"0.6069136",
"0.6021487",
"0.60205114",
"0.6011188",
"0.5997013",
"0.5966648",
"0.5926399",
"0.5926365",
"0.5916658",
"0.5888663",
"0.5883227",... | 0.7164876 | 0 |
Parse a single line of csvtoarrow output. Raise RuntimeError if a line cannot be parsed. (We can't recover from that because we don't know what's happening.) | def _parse_csv_to_arrow_warning(line: str) -> I18nMessage:
for pattern, builder in _ERROR_PATTERNS:
match = pattern.match(line)
if match:
return builder(**match.groupdict())
raise RuntimeError("Could not parse csv-to-arrow output line: %r" % line) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_line(self, line):\n raise NotImplementedError",
"def test_parseLine2(mocker):\n \n # given: setup test framework\n worker = Worker()\n testString = \"11/11/19,Brighter Futures,12000\"\n \n # when:\n result = worker.parseLineCSV(testString)\n \n # then: (Using PyTruth a... | [
"0.6595832",
"0.6529445",
"0.62704617",
"0.61401874",
"0.61335003",
"0.61316746",
"0.61252147",
"0.61061907",
"0.5982218",
"0.5961737",
"0.5809438",
"0.5809438",
"0.5809438",
"0.5809438",
"0.5806658",
"0.5806658",
"0.5729117",
"0.5704075",
"0.5667828",
"0.56519485",
"0.562726... | 0.7278119 | 0 |
Return `table`, with final column names but still String values. | def _postprocess_name_columns(
table: pyarrow.Table, has_header: bool, settings: Settings
) -> Tuple[pyarrow.Table, List[I18nMessage]]:
if has_header and table.num_rows > 0:
names, warnings = gen_unique_clean_colnames_and_warn(
list((c[0].as_py() if c[0].is_valid else "") for c in table.columns),
settings=settings,
)
# Remove header (zero-copy: builds new pa.Table with same backing data)
table = table.slice(1)
else:
names = [f"Column {i + 1}" for i in range(len(table.columns))]
warnings = []
return (
pyarrow.table(dict(zip(names, table.columns))),
warnings,
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n\n table_list = [self.headers]\n\n for row in self.data:\n table_list.append([row[col] or \"\" for col in self.headers])\n\n return create_table_string(table_list)",
"def _fix_query_table(table):\n for i in table.columns:\n tdtype = table[i].dtype.cha... | [
"0.6711792",
"0.64184517",
"0.64011616",
"0.62590617",
"0.6193587",
"0.6136157",
"0.6058402",
"0.6052583",
"0.60350543",
"0.5984028",
"0.5966508",
"0.59490246",
"0.5942764",
"0.5938039",
"0.59240717",
"0.5916883",
"0.5916883",
"0.5908916",
"0.59033936",
"0.5902068",
"0.589069... | 0.602494 | 9 |
Return a pa.Array that replaces "" with null. Assume `arr` is of type `utf8` or a dictionary of `utf8`. | def _nix_utf8_chunk_empty_strings(chunk: pyarrow.Array) -> pyarrow.Array:
# pyarrow's cast() can't handle empty string. Create a new Array with
# "" changed to null.
_, offsets_buf, data_buf = chunk.buffers()
# Build a new validity buffer, based on offsets. Empty string = null.
# Assume `data` has no padding bytes in the already-null values. That way
# we can ignore the _original_ validity buffer and assume all original
# values are not-null. (Null values are stored as "" plus "invalid".)
#
# Validity-bitmap spec:
# https://arrow.apache.org/docs/format/Columnar.html#validity-bitmaps
# first offset must be 0. Next offsets are used to calculate lengths
offsets = array.array("i")
assert offsets.itemsize == 4
offsets.frombytes(offsets_buf)
if sys.byteorder != "little":
offsets.byteswap() # pyarrow is little-endian
validity = bytearray()
null_count = 0
last_offset = offsets[0]
assert last_offset == 0
pos = 1
while True:
# Travel offsets in strides of 8: one per char in the validity bitmap.
# Pad with an extra 1 bit -- [2020-02-20, adamhooper] I think I read
# this is needed somewhere.
valid_byte = 0x00
block = offsets[pos : pos + 8]
try:
if block[0] > last_offset:
valid_byte |= 0x1
else:
null_count += 1
if block[1] > block[0]:
valid_byte |= 0x2
else:
null_count += 1
if block[2] > block[1]:
valid_byte |= 0x4
else:
null_count += 1
if block[3] > block[2]:
valid_byte |= 0x8
else:
null_count += 1
if block[4] > block[3]:
valid_byte |= 0x10
else:
null_count += 1
if block[5] > block[4]:
valid_byte |= 0x20
else:
null_count += 1
if block[6] > block[5]:
valid_byte |= 0x40
else:
null_count += 1
if block[7] > block[6]:
valid_byte |= 0x80
else:
null_count += 1
validity.append(valid_byte)
last_offset = block[7]
pos += 8
except IndexError:
validity.append(valid_byte)
break # end of offsets
validity_buf = pyarrow.py_buffer(validity)
# We may have over-counted in null_count: anything before `chunk.offset`
# should not count.
#
# It's less work to "undo" the counting we did before -- otherwise we'd
# riddle the above loop with if-statements.
for i in range(chunk.offset):
if offsets[i + 1] == offsets[i]:
null_count -= 1
return pyarrow.StringArray.from_buffers(
length=len(chunk),
value_offsets=offsets_buf,
data=data_buf,
null_bitmap=validity_buf,
null_count=null_count,
offset=chunk.offset,
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _unicode(arr):\n try:\n return unicode(arr)\n except UnicodeEncodeError:\n dt = arr.dtype.newbyteorder('S')\n return unicode(arr.view(dt))",
"def strip_array(arr):\n\n return [word.strip(' ') for word in arr]",
"def _strip_all(dic):\n for k, v in dic.items():\n\n if ... | [
"0.6056737",
"0.60276425",
"0.5736321",
"0.56652236",
"0.5625485",
"0.55626565",
"0.5436401",
"0.5387418",
"0.53866494",
"0.53788817",
"0.53714484",
"0.5352443",
"0.53399795",
"0.53159595",
"0.52804863",
"0.5268372",
"0.52583706",
"0.52422833",
"0.5236339",
"0.5233802",
"0.52... | 0.5096824 | 28 |
Return true if we should fastskip converting a pa.Array. The _true_ reason for this function is to test whether an Array contains "Inf" or "NaN". A numberconversion library will parse those. But _this_ library is for Workbench, and Workbench doesn't support NaN/Inf. So this function helps us decide _not_ to autoconvert a column when the intent isn't perfectly clear. Assume `arr` is of type `utf8` or a dictionary of `utf8`. Assume there are no gaps hidden in null values in the buffer. (It's up to the caller to prove this.) | def _utf8_chunk_may_contain_inf_or_nan(chunk: pyarrow.Array) -> bool:
_, offsets_buf, data_buf = chunk.buffers()
offsets = array.array("i")
assert offsets.itemsize == 4
offsets.frombytes(offsets_buf)
if sys.byteorder != "little":
offsets.byteswap() # pyarrow is little-endian
offset0 = offsets[chunk.offset]
offsetN = offsets[chunk.offset + len(chunk)] # len(offsets) == 1 + len(chunk)
b = data_buf[offset0:offsetN].to_pybytes()
return SCARY_BYTE_REGEX.search(b) is not None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def asarray_chkfinite(a):\n a = asarray(a)\n if (a.dtype.char in typecodes['AllFloat']) \\\n and (_nx.isnan(a).any() or _nx.isinf(a).any()):\n raise ValueError, \"array must not contain infs or NaNs\"\n return a",
"def is_array(self, arr):\n return isinstance(arr, np.ndarray)",
... | [
"0.63142204",
"0.59511065",
"0.59251046",
"0.5863669",
"0.5700599",
"0.5661153",
"0.5581066",
"0.54970616",
"0.54685277",
"0.54147017",
"0.53897524",
"0.5384138",
"0.53668594",
"0.5293467",
"0.52856606",
"0.527953",
"0.5257239",
"0.5248469",
"0.5248469",
"0.5215622",
"0.52145... | 0.60420185 | 1 |
Convert `data` to float64 or int(64|32|16|8); as fallback, return `data`. Assume `data` is of type `utf8` or a dictionary of utf8. | def _autocast_column(data: pyarrow.ChunkedArray) -> pyarrow.ChunkedArray:
# All-empty (and all-null) columns stay text
for chunk in data.iterchunks():
# https://arrow.apache.org/docs/format/Columnar.html#variable-size-binary-layout
_, offsets_buf, _ = chunk.buffers()
# If data has an offset, ignore what comes before
#
# We don't need to grab the _int_ offset: we can just look at the
# byte-representation of it.
offset_0_buf = offsets_buf[chunk.offset * 4 : (chunk.offset + 1) * 4]
# last offset isn't always the last 4 bytes: there can be padding
offset_n_buf = offsets_buf[
(chunk.offset + len(chunk)) * 4 : (chunk.offset + len(chunk) + 1) * 4
]
if offset_0_buf.to_pybytes() != offset_n_buf.to_pybytes():
# there's at least 1 byte of text. (Assumes the CSV reader doesn't
# pad the buffer with gibberish.)
break
else:
# there are 0 bytes of text
return data
# Convert "" => null, so pyarrow cast() won't balk at it.
sane = pyarrow.chunked_array(
[_nix_utf8_chunk_empty_strings(chunk) for chunk in data.iterchunks()]
)
for chunk in sane.iterchunks():
# pyarrow cast() uses double-conversion, so it parses "NaN" and "Inf"
# as doubles. Workbench doesn't support NaN or Inf, so don't convert to
# them.
if _utf8_chunk_may_contain_inf_or_nan(chunk):
return data
try:
numbers = sane.cast(pyarrow.float64())
except pyarrow.ArrowInvalid:
# Some string somewhere wasn't a number
return data
# Test that there's no infinity. We'll use numpy. .to_numpy() with
# zero_copy_only=False will convert nulls to NaN. That's fine, since we
# know `numbers` has no NaN values (because `cast()` would have raised
# rather than return a NaN.)
for chunk in numbers.iterchunks():
npchunk = chunk.to_numpy(zero_copy_only=False)
if np.inf in npchunk or -np.inf in npchunk:
# Numbers too large
return data
# Downcast integers, when possible.
#
# We even downcast float to int. Workbench semantics say a Number is a
# Number; so we might as well store it efficiently.
try:
# Shrink as far as we can, until pyarrow complains.
#
# pyarrow will error "Floating point value truncated" if a conversion
# from float to int would be lossy.
#
# We'll return the last _successful_ `numbers` result.
numbers = numbers.cast(pyarrow.int32())
numbers = numbers.cast(pyarrow.int16())
numbers = numbers.cast(pyarrow.int8())
except pyarrow.ArrowInvalid:
pass
return numbers | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def try_float(data):\n try:\n return float(data)\n except (ValueError, TypeError ):\n return data",
"def float_from_string(data):\n return float(maybe_number(data))",
"def _float(data):\n try:\n return float(data)\n except ValueError as err:\n if data in ('None', 'NA'... | [
"0.748317",
"0.69878703",
"0.6950177",
"0.6709056",
"0.6397729",
"0.6396958",
"0.63965064",
"0.6293659",
"0.6279694",
"0.6161165",
"0.61318475",
"0.61182475",
"0.5992608",
"0.596135",
"0.5870688",
"0.5860507",
"0.58470494",
"0.58467394",
"0.5794232",
"0.5766028",
"0.5722432",... | 0.0 | -1 |
Parse CSV, TSV or other delimiterseparated text file. Raise LookupError for an `encoding` Python cannot handle. Raise UnicodeError when the file simply cannot be read as text. (e.g., a UTF16 file that does not start with a byteorder marker.) | def _parse_csv(
path: Path,
*,
settings: Settings = DEFAULT_SETTINGS,
encoding: Optional[str],
delimiter: Optional[str],
has_header: bool,
autoconvert_text_to_numbers: bool,
) -> ParseCsvResult:
warnings = []
with contextlib.ExitStack() as ctx:
n_bytes = path.stat().st_size
if n_bytes > settings.MAX_CSV_BYTES:
# We can't simply os.truncate() the input file, because sandboxed code
# can't modify input files.
truncated_path = ctx.enter_context(tempfile_context(prefix="truncated-"))
with path.open("rb") as src, truncated_path.open("wb") as dest:
os.sendfile(dest.fileno(), src.fileno(), 0, settings.MAX_CSV_BYTES)
path = truncated_path
warnings.append(
_trans_cjwparse(
"csv.truncated_file",
"{n_bytes_truncated, one{Truncated # byte} other{Truncated # bytes}} from file (maximum is {max_n_bytes} bytes)",
dict(
n_bytes_truncated=(n_bytes - settings.MAX_CSV_BYTES),
max_n_bytes=settings.MAX_CSV_BYTES,
),
)
)
utf8_path = ctx.enter_context(tempfile_context(prefix="utf8-", suffix=".txt"))
# raises LookupError, UnicodeError
warnings.extend(
transcode_to_utf8_and_warn(path, utf8_path, encoding, settings=settings)
)
# Sniff delimiter
if not delimiter:
delimiter = detect_delimiter(utf8_path, settings)
with tempfile_context(suffix=".arrow") as arrow_path:
# raise subprocess.CalledProcessError on error ... but there is no
# error csv-to-arrow will throw that we can recover from.
child = subprocess.run(
[
"/usr/bin/csv-to-arrow",
"--delimiter",
delimiter,
"--max-rows",
str(settings.MAX_ROWS_PER_TABLE),
"--max-columns",
str(settings.MAX_COLUMNS_PER_TABLE),
"--max-bytes-per-value",
str(settings.MAX_BYTES_PER_VALUE),
utf8_path.as_posix(),
arrow_path.as_posix(),
],
capture_output=True,
check=True,
)
warnings.extend(_parse_csv_to_arrow_warnings(child.stdout.decode("utf-8")))
reader = pyarrow.ipc.open_file(arrow_path.as_posix())
raw_table = reader.read_all() # efficient -- RAM is mmapped
table, more_warnings = _postprocess_table(
raw_table, has_header, autoconvert_text_to_numbers, settings
)
return ParseCsvResult(table, warnings + more_warnings) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read(filename, encodings=['ascii', 'utf-8', 'utf-16', 'latin-1']):\n text = None\n\n for encoding in encodings:\n try:\n f = open(filename, encoding=encoding)\n text = f.read()\n f.close()\n except UnicodeDecodeError:\n f.close()\n except ... | [
"0.6560378",
"0.62868285",
"0.61147213",
"0.6035779",
"0.6029811",
"0.5926391",
"0.5827321",
"0.5804859",
"0.58034223",
"0.5774665",
"0.5699063",
"0.56861764",
"0.56857336",
"0.56818",
"0.56673634",
"0.5613292",
"0.56082886",
"0.55889183",
"0.5518909",
"0.5518909",
"0.5518909... | 0.60616267 | 3 |
Initialize your data structure here. | def __init__(self):
self.intervals = []
### O(len(intervals))
def addNum(self, val: int) -> None:
if(len(self.intervals) == 0):
self.intervals.append([val, val])
return
flag, left = 1, -math.inf
for i, interval in enumerate(self.intervals):
for point in interval:
right = point
if(left == val or right == val):
return
elif(left < val and right > val):
if(flag):
### merge case
if(val == left+1 and val == right -1):
self.intervals[i-1][1] = self.intervals[i][1]
self.intervals.pop(i)
elif(val == left+1):
self.intervals[i-1][1] = val
elif(val == right-1):
self.intervals[i][0] = val
else:
self.intervals.insert(i, [val, val])
### val in one of the existing intervals
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_empty(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__... | [
"0.77675813",
"0.7644977",
"0.7644977",
"0.7644977",
"0.7644977",
"0.7644977",
"0.7644977",
"0.75942147",
"0.7585732",
"0.75570554",
"0.75295925",
"0.75295925",
"0.75295925",
"0.75295925",
"0.75295925",
"0.7495997",
"0.7495997",
"0.7476943",
"0.7476324",
"0.7476324",
"0.74763... | 0.0 | -1 |
Clean up any files leftover from past runs with different hyperparameters. | def clean_up(model_path):
cmds = ["rm */grad*.pickle",
"rm -r checkpoints",
"rm */train_len",
"rm log_human_read.csv",
"rm */log_human_read.csv",
"rm -r best_model",
"rm */*epoch*"]
for cmd in cmds:
os.system("cd {} && {}".format(model_path, cmd)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _clean_files(self):\n if self.delfiles & 1:\n ProcUtils.remove(self.okm)\n if self.delfiles & 2:\n ProcUtils.remove(self.hkm)\n if self.delfiles & 4:\n ProcUtils.remove(self.qkm)\n if self.delfiles & 8:\n ProcUtils.remove(self.obc)\n\n ... | [
"0.74296117",
"0.7379356",
"0.721091",
"0.7174838",
"0.7121328",
"0.7096112",
"0.7081824",
"0.7073559",
"0.7040567",
"0.69962186",
"0.69456387",
"0.69263583",
"0.689189",
"0.68870115",
"0.6879709",
"0.68567586",
"0.6842316",
"0.6828324",
"0.6814952",
"0.6776448",
"0.6773137",... | 0.0 | -1 |
Train a model with the current hyperparameters. | def run(job_path, model_path, metric):
cmd = (f"cd $NFFDIR/scripts/cp3d/train "
f"&& python train_parallel.py {job_path}")
os.system(cmd)
best_score, best_epoch = parse_score(model_path, metric)
return best_score | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_model(self, *args, **kwargs):\n self.model.train(self.training, *args, **kwargs)",
"def train(self, current_hyper_params):\n train_loss = 0\n train_n_iter = 0\n # Set model to train mode\n self.model.train()\n # Iterate over train data\n print(\"Iteratin... | [
"0.7977213",
"0.7823189",
"0.77489245",
"0.77486706",
"0.744381",
"0.74099916",
"0.74027795",
"0.73351485",
"0.7293548",
"0.72867054",
"0.7273446",
"0.72411215",
"0.7087587",
"0.708289",
"0.708289",
"0.708289",
"0.708289",
"0.708289",
"0.70720506",
"0.7064753",
"0.70588857",
... | 0.0 | -1 |
Update the config information with new dropout values. | def update_dropout(info,
dropout,
dropout_type,
prop_name):
if dropout_type == "schnet_dropout":
info["model_params"]["schnet_dropout"] = dropout
elif dropout_type == "chemprop_dropout":
info["model_params"]["cp_dropout"] = dropout
elif dropout_type == "readout_dropout":
# if it's in the readout layers, find the dropout
# layers in the readout dictionary and update them
readout = info["model_params"]["readoutdict"]
layer_dics = readout[prop_name]
for layer_dic in layer_dics:
if layer_dic["name"] == "Dropout":
layer_dic["param"]["p"] = dropout
info["model_params"]["readoutdict"] = {prop_name: layer_dics}
elif dropout_type == "attention_dropout":
info["model_params"]["boltzmann_dict"]["dropout_rate"] = dropout
else:
info["model_params"][dropout_type] = dropout | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conf_update(self):\n pass",
"def update(self):\n self.save_config_file()",
"def updateConfig(self):\n # Make sure to keep the default values in place.\n if self.newConfig['sensor'] == 0:\n self.newConfig['sensor'] = self.config['sensor']\n if self.newConfig['ca... | [
"0.6544299",
"0.63342535",
"0.60116196",
"0.59151256",
"0.5909534",
"0.57759255",
"0.57704425",
"0.5765275",
"0.5730661",
"0.56408286",
"0.5635697",
"0.558882",
"0.55770063",
"0.5571904",
"0.5553866",
"0.5534613",
"0.5478377",
"0.546527",
"0.5463798",
"0.5436312",
"0.5427711"... | 0.63966775 | 1 |
Update the config information with the number of attention heads. | def update_heads(info,
heads):
info["model_params"]["boltzmann_dict"]["num_heads"] = heads
# Concatenate the fingerprints produced by the different heads
info["model_params"]["boltzmann_dict"]["head_pool"] = "concatenate"
readoutdict = info["model_params"]["readoutdict"]
feat_dim = info["model_params"]["mol_basis"]
for key, lst in readoutdict.items():
for i, dic in enumerate(lst):
if "param" in dic and "in_features" in dic.get("param", {}):
# make sure that the input dimension to the readout is equal to
# `heads * feat_dim`, where `feat_dim` is the feature dimension
# produced by each head
readoutdict[key][i]["param"]["in_features"] = feat_dim * heads
break
info["model_params"]["readoutdict"] = readoutdict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_config(self):\n self.channel_count = self.config_global['channel_count']\n self.pixel_count = self.config_global['pixel_count']\n self.pixel_index_max = self.pixel_count - 1\n self.repeat_count = self.config_global['repeat_count']\n self.repeat_snake = self.config_glob... | [
"0.5661511",
"0.5599164",
"0.54210174",
"0.53882116",
"0.5338775",
"0.5247799",
"0.5247248",
"0.5225227",
"0.51431704",
"0.5058479",
"0.49841285",
"0.49445143",
"0.49379683",
"0.48532596",
"0.4848556",
"0.48481622",
"0.4835506",
"0.48258802",
"0.48030823",
"0.48024145",
"0.47... | 0.5935313 | 0 |
Update a general parameter that's in the main info dictionary. | def update_general(info, key, val):
info["model_params"][key] = val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_general_param(self, param, val):\n assert param in self.params, '%s is not recognized as a valid parameter' % param\n self.params[param].change_value(val)",
"def _paramUpdate(self):\n\n # Update the database attributes accordingly.\n dt.utilities.DB_attrs_save(self.Database... | [
"0.7279819",
"0.71316004",
"0.70896465",
"0.68731415",
"0.6845889",
"0.68180555",
"0.6810109",
"0.67108864",
"0.6680052",
"0.6631445",
"0.6597182",
"0.6568276",
"0.65336627",
"0.65146816",
"0.64628476",
"0.64187586",
"0.64153326",
"0.63640064",
"0.63570213",
"0.63570213",
"0.... | 0.7829526 | 0 |
Update the config information and save it. | def update_info(job_path,
vals,
param_names,
prop_name):
with open(job_path, "r") as f:
info = json.load(f)
real_names = []
real_vals = []
for param_name, val in zip(param_names, vals):
if param_name.startswith("log_"):
# if anything starts with "log_" (e.g. "log_schnet_dropout"),
# exponentiate its value to get the actual number
real_names.append(param_name.replace("log_", ""))
real_vals.append(np.exp(val))
else:
real_names.append(param_name)
real_vals.append(val)
# update values
for param_type, val in zip(real_names, real_vals):
if 'dropout' in param_type:
update_dropout(info=info,
dropout=val,
dropout_type=param_type,
prop_name=prop_name)
elif param_type == "num_heads":
update_heads(info=info,
heads=val)
elif param_type == "attention_type":
info["model_params"]["boltzmann_dict"]["type"] = val
else:
if param_type not in info["model_params"]:
msg = (f"Warning: assuming that {param_type} "
"is just a key in `model_params`, but "
"it is not currently in `model_params` in "
"the config file. If it should be in a "
"different location then you will need "
"to write a custom function for updating "
"it.")
fprint(msg)
update_general(info, key=param_type, val=val)
# save
with open(job_path, "w") as f:
json.dump(info, f, indent=4, sort_keys=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self):\n self.save_config_file()",
"def save(self):\n self.__config.sync()\n self.__saved = True\n Logger().debug(\"Configuration saved\")",
"def update_config(self, data):\n self.config.data = dict_merge(self.config.data, data)\n self.config.save()",
"def... | [
"0.9107356",
"0.79640085",
"0.77216876",
"0.7674935",
"0.767021",
"0.7651261",
"0.7618307",
"0.7609429",
"0.7594311",
"0.75444627",
"0.74497473",
"0.73920816",
"0.7372493",
"0.73333156",
"0.73213214",
"0.72997504",
"0.7294209",
"0.7274685",
"0.72723716",
"0.7229026",
"0.72210... | 0.0 | -1 |
Create a space for `hyperopt`. | def get_space(options, param_types, names):
space = {}
for i, lst in enumerate(options):
param_type = param_types[i]
name = names[i]
# if categorical, sample one of the options randomly
if param_type == "categorical":
sample = hp.choice(name, lst)
# otherwise sample between the minimum and maximum values
elif param_type in ["int", "float"]:
min_val = lst[0]
max_val = lst[1]
if "dropout" in name:
if min_val == 0:
min_val = 1e-4
low = np.log(min_val)
high = np.log(max_val)
sample = hp.loguniform(name,
low=low,
high=high)
elif param_type == "float":
sample = hp.uniform(name, low=min_val, high=max_val)
elif param_type == "int":
sample = hp.quniform(name, low=min_val, high=max_val, q=1)
space[name] = sample
return space | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _build_space(self, param_grid):\n if self.verbose>9:\n 'Building param space...'\n \n _warnings.filterwarnings('ignore')\n \n param_grid = param_grid.copy()\n space = {}\n for key in param_grid.keys():\n params = param_grid[key]\n ... | [
"0.62174714",
"0.5995565",
"0.59907234",
"0.5958852",
"0.58709556",
"0.5789153",
"0.5679872",
"0.54301524",
"0.5426742",
"0.5412645",
"0.5411937",
"0.535265",
"0.53177315",
"0.5313377",
"0.5309271",
"0.52801293",
"0.52665275",
"0.524695",
"0.524695",
"0.52416915",
"0.5237613"... | 0.53067887 | 15 |
Save score from a hyperparameter iteration. | def save_score(dic_path,
hyperparams,
metric,
best_score):
if os.path.isfile(dic_path):
with open(dic_path, "r") as f:
score_list = json.load(f)
else:
score_list = []
score_list.append(hyperparams)
score_list[-1].update({metric: best_score})
with open(dic_path, "w") as f:
json.dump(score_list, f, indent=4, sort_keys=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, score, model):\n if self.best_score is None:\n # assign the best score and save the model at the end of the first epoch\n self.best_score = score\n self.save_checkpoint(model)\n elif score < self.best_score + self.delta:\n # if the score ... | [
"0.62541574",
"0.61163104",
"0.6092135",
"0.59902626",
"0.5891033",
"0.57781833",
"0.5758972",
"0.5758972",
"0.5757687",
"0.57543606",
"0.5740902",
"0.57180816",
"0.5717469",
"0.5684043",
"0.5682911",
"0.5615517",
"0.5614505",
"0.55993366",
"0.5589203",
"0.55578935",
"0.55561... | 0.5386014 | 76 |
Make objective function that gets called by `hyperopt`. | def make_objective(model_path,
param_names,
param_types,
job_path,
prop_name,
metric,
dic_path):
param_type_dic = {name: typ for name, typ in zip(param_names,
param_types)}
def objective(hyperparams):
# clean up model folder from previous interation
clean_up(model_path=model_path)
# Convert hyperparams from float to int when necessary
for key, typ in param_type_dic.items():
if typ == "int":
hyperparams[key] = int(hyperparams[key])
# print hyperparameters being used
val_str = " " + "\n ".join([f"{key}: {val}" for key, val
in hyperparams.items()])
fprint(f"Hyperpameters used this round:\n{val_str}")
# update config file, run, get the score, and save
vals = [hyperparams[key] for key in param_names]
update_info(job_path=job_path,
vals=vals,
param_names=param_names,
prop_name=prop_name)
# train the model and get the score
best_score = run(job_path=job_path,
model_path=model_path,
metric=metric)
# get the hyperparameter score, given that the aim is
# to minimize whatever comes out
metric_obj = METRIC_DIC[convert_metric(metric)]
hyper_score = -best_score if (metric_obj ==
"maximize") else best_score
# save the score
save_score(dic_path=dic_path,
hyperparams=hyperparams,
metric=metric,
best_score=best_score)
return hyper_score
return objective | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def objective_function(x):\n return x * 1 # change this to our actual function",
"def objective(hyperparams): \n global iteration #necessary with a global variable because of implementation from hyperopt. \n iteration += 1\n\n result = run_model(hyperparams, iteration)\n loss = -result #transfo... | [
"0.7482436",
"0.73444074",
"0.7161457",
"0.7161457",
"0.6737644",
"0.67088556",
"0.6661867",
"0.66453636",
"0.6605384",
"0.6507975",
"0.6357",
"0.6254179",
"0.62437993",
"0.62437993",
"0.62322885",
"0.6193143",
"0.61185783",
"0.6108092",
"0.6072014",
"0.6065767",
"0.60194516"... | 0.65957934 | 9 |
Save the best parameters from the optimization. | def save_best(dic_path,
metric,
model_path):
# load the scores
with open(dic_path, "r") as f:
score_list = json.load(f)
# get the best parameters
objective = METRIC_DIC[convert_metric(metric)]
pref = 1 if (objective == "minimize") else (-1)
hyper_scores = [pref * score_dic[metric] for score_dic in score_list]
best_params = score_list[np.argmin(hyper_scores)]
# print the best parameters
save_path = os.path.join(model_path, "best_params.json")
best_str = "\n ".join([f"{key}: {val}" for key, val
in best_params.items()])
fprint(f"Best parameters are {best_str}")
fprint(f"Saving to {save_path}")
# save them
with open(save_path, "w") as f:
json.dump(best_params, f, indent=4, sort_keys=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_optimal_parameters(self):\n # Getting the best trial based on the test errors\n idx = self.trial_losses.index(min(self.trial_losses))\n self.best_trial = self.trial_list[idx]\n self.objective.parse_trial(self.best_trial)",
"def optimize_parameters(self):\n pass",
"def... | [
"0.6838676",
"0.6757881",
"0.6757881",
"0.6757881",
"0.6701749",
"0.6567907",
"0.6534331",
"0.6523155",
"0.6520775",
"0.6517323",
"0.65010434",
"0.64957666",
"0.6460189",
"0.6451601",
"0.639737",
"0.6354237",
"0.63056695",
"0.6299728",
"0.62912434",
"0.62902164",
"0.62139994"... | 0.6462199 | 12 |
Sample hyperparmeters and save scores for each combination. | def main(job_path,
model_path,
options,
num_samples,
metric,
score_file,
param_names,
prop_name,
param_types,
seed,
**kwargs):
dic_path = os.path.join(model_path, score_file)
space = get_space(options=options,
param_types=param_types,
names=param_names)
objective = make_objective(model_path=model_path,
param_names=param_names,
param_types=param_types,
job_path=job_path,
prop_name=prop_name,
metric=metric,
dic_path=dic_path)
# sample hyperparameters with the aim to minimize the
# result of `objective`
fmin(objective,
space,
algo=tpe.suggest,
max_evals=num_samples,
rstate=np.random.RandomState(seed))
# save best results
save_best(dic_path, metric, model_path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _sample_hyperparameters(self):\n\t\tconfig = {}\n\t\tfor attr, option in self._config_options.items():\n\t\t\tprint('Sampling', attr)\n\t\t\tconfig[attr] = option.sample()\n\t\treturn config",
"def __init__(self):\n self.param_names = []\n self.param_values = []\n self.param_settings = [... | [
"0.62443453",
"0.58079064",
"0.57170784",
"0.57169795",
"0.5709108",
"0.5601513",
"0.55566067",
"0.5552902",
"0.5533448",
"0.5526824",
"0.54794496",
"0.54682755",
"0.544979",
"0.5448814",
"0.5426104",
"0.5412882",
"0.541072",
"0.5403978",
"0.53949046",
"0.53916514",
"0.538766... | 0.0 | -1 |
Construct generalized extreme value distribution. The parameters `loc`, `scale`, and `concentration` must be shaped in a way that supports broadcasting (e.g. `loc + scale` + `concentration` is valid). | def __init__(self,
loc,
scale,
concentration,
validate_args=False,
allow_nan_stats=True,
name='GeneralizedExtremeValue'):
parameters = dict(locals())
with tf.name_scope(name) as name:
dtype = dtype_util.common_dtype([loc, scale, concentration],
dtype_hint=tf.float32)
loc = tensor_util.convert_nonref_to_tensor(
loc, name='loc', dtype=dtype)
scale = tensor_util.convert_nonref_to_tensor(
scale, name='scale', dtype=dtype)
concentration = tensor_util.convert_nonref_to_tensor(
concentration, name='concentration', dtype=dtype)
dtype_util.assert_same_float_dtype([loc, scale, concentration])
# Positive scale is asserted by the incorporated GEV bijector.
self._gev_bijector = gev_cdf_bijector.GeneralizedExtremeValueCDF(
loc=loc, scale=scale, concentration=concentration,
validate_args=validate_args)
# Because the uniform sampler generates samples in `[0, 1)` this would
# cause samples to lie in `(inf, -inf]` instead of `(inf, -inf)`. To fix
# this, we use `np.finfo(dtype_util.as_numpy_dtype(self.dtype).tiny`
# because it is the smallest, positive, 'normal' number.
super(GeneralizedExtremeValue, self).__init__(
distribution=uniform.Uniform(
low=np.finfo(dtype_util.as_numpy_dtype(dtype)).tiny,
high=tf.ones([], dtype=dtype),
allow_nan_stats=allow_nan_stats),
# The GEV bijector encodes the CDF function as the forward,
# and hence needs to be inverted.
bijector=invert_bijector.Invert(
self._gev_bijector, validate_args=validate_args),
parameters=parameters,
name=name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, loc=0, scale=1, size=None, **kwargs):\n return super().__call__(loc, scale, size=size, **kwargs)",
"def __call__(self, loc=0.0, scale=1.0, size=None, **kwargs):\n return super().__call__(loc, scale, size=size, **kwargs)",
"def __call__(self, loc=0.0, scale=1.0, size=None, **kwa... | [
"0.5140067",
"0.51391375",
"0.51391375",
"0.51391375",
"0.51391375",
"0.51391375",
"0.51385653",
"0.512212",
"0.51002985",
"0.5092538",
"0.5085862",
"0.5006036",
"0.49219593",
"0.49213806",
"0.4891641",
"0.48677793",
"0.48438725",
"0.4842382",
"0.48329198",
"0.48204932",
"0.4... | 0.6448586 | 0 |
Distribution parameter for the location. | def loc(self):
return self._gev_bijector.loc | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def distribution(self) -> str:\n return pulumi.get(self, \"distribution\")",
"def loc(self):\n return self.distribution.loc",
"def get_distribution_parameters(self):\r\n return \"UNDEFINED\"",
"def distribution(self, env):\n pass",
"def _handleInput(self, paramInput):\n super()._... | [
"0.65867454",
"0.62829775",
"0.62012964",
"0.59412557",
"0.57245076",
"0.56689125",
"0.5637412",
"0.5567886",
"0.5564207",
"0.55510134",
"0.5550806",
"0.55264115",
"0.5516382",
"0.550923",
"0.5505646",
"0.5505646",
"0.5499564",
"0.5482442",
"0.5477142",
"0.54546994",
"0.54109... | 0.0 | -1 |
Distribution parameter for scale. | def scale(self):
return self._gev_bijector.scale | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scale(self):\n return self.distribution.scale",
"def scale_parameter(self):\n return self._scale_parameter",
"def get_scale_parameter(self):\n\n shape_in_gamma_func = float(1 + (1 / self._shape_parameter))\n gamma_func = special.gamma(shape_in_gamma_func)\n self._scale_parame... | [
"0.83170885",
"0.75846076",
"0.7424819",
"0.7398855",
"0.7397794",
"0.704038",
"0.7032206",
"0.7026145",
"0.7016287",
"0.69452536",
"0.6886023",
"0.6884829",
"0.68717456",
"0.6735917",
"0.6735917",
"0.67252976",
"0.6618296",
"0.65950215",
"0.65737295",
"0.65534216",
"0.653268... | 0.7008766 | 9 |
Distribution parameter for shape. | def concentration(self):
return self._gev_bijector.concentration | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, shape):\n return np.random.uniform(low=self.minval, high=self.maxval, size=shape)",
"def weight(self, shape, name=\"\"):\n return tf.Variable(tf.truncated_normal(shape, stddev=0.1), name=name)",
"def __call__(self, shape):\n return np.random.normal(loc=self.mean, scale=s... | [
"0.66089565",
"0.61828715",
"0.6138457",
"0.61047345",
"0.60195476",
"0.6013357",
"0.59687215",
"0.5935368",
"0.5908499",
"0.589005",
"0.5882569",
"0.5881735",
"0.58765745",
"0.5872159",
"0.5871932",
"0.58504355",
"0.58504355",
"0.58361685",
"0.58349097",
"0.5757327",
"0.5756... | 0.0 | -1 |
Processor File Import statements | def get_imports(self) -> str:
imports = [
"_ = require('lodash');",
"stream = require('stream');",
f"const hookRegister = require('./{settings.ARTILLERY_HOOK_FILE}').hookRegister;",
f"hook = require('./{settings.ARTILLERY_LIB_FOLDER}/hooks').hook;",
f"utils = require('./{settings.ARTILLERY_LIB_FOLDER}/providers');",
f"settings = require('./{settings.ARTILLERY_LIB_FOLDER}/settings');",
f"StatsCollector = require('./{settings.ARTILLERY_LIB_FOLDER}/statsCollector').StatsCollector;",
f"profiles = require('./{settings.ARTILLERY_LIB_FOLDER}/profiles').profiles;",
f"influx = require('./{settings.ARTILLERY_LIB_FOLDER}/influx').client;",
]
return "\n".join(imports) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def importer():\n pass",
"def file_import(self):\r\n\r\n try:\r\n self.process_file_import()\r\n except InputError as ex:\r\n print(ex)\r\n self.file_import()",
"def test_import_process(self):\r\n good_file = self._get_file()\r\n imp = Importer(go... | [
"0.72246414",
"0.72070956",
"0.6955379",
"0.6755924",
"0.6729011",
"0.66933364",
"0.6478454",
"0.646348",
"0.6388376",
"0.6222997",
"0.61884964",
"0.6172685",
"0.5980641",
"0.59624255",
"0.5938535",
"0.59262383",
"0.59066707",
"0.5905204",
"0.5884838",
"0.58748347",
"0.584964... | 0.0 | -1 |
Processor File Global statements | def get_global_vars(self) -> str:
return templates.GLOBAL_STATEMENTS | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess_main():",
"def process_file(file_name):\n pass # delete this line and replace with your code here",
"def pre_processor(self):",
"def main():\n processor.custom_config = parse_arguments()\n processor.process()\n logger.info(processor.statistics)\n logger.info(processor.custom_co... | [
"0.6421695",
"0.62486196",
"0.61764765",
"0.5911357",
"0.58984786",
"0.57821095",
"0.5671686",
"0.56631225",
"0.5623473",
"0.56146",
"0.5594075",
"0.5566961",
"0.5538859",
"0.5524859",
"0.5524859",
"0.5524859",
"0.5524859",
"0.5524859",
"0.55061376",
"0.5503649",
"0.5500372",... | 0.0 | -1 |
Construct Artillery YAML configuration | def set_yaml_config(self) -> None:
# LT-248: We can pick Artillery Phase configuration from conf file
self.yaml_config = {
"config": {
"target": self.get_swagger_url(),
"processor": f"./{self.OUT_FILE}",
"phases": [
{
"duration": settings.DURATION or 1,
"arrivalRate": settings.SPAWN_RATE or 1
}
]
},
"scenarios": self.task_set.yaml_flow
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def yamlConfigForParsingPlugins():\n parameters = \"\"\"\njoinPaths: !joinPaths\n - a\n - b\n - \"c\"\nrunPageTemplates: !findRunPageTemplates\n - \"templates\"\nbcrypt: !bcrypt\n bcryptLogRounds: 12\n user: \"pass\"\nbcryptNoUser: !bcrypt\n bcryptLogRounds: 12\n null: null\nsecretKey: !... | [
"0.6141873",
"0.6054223",
"0.6019494",
"0.5994903",
"0.59923637",
"0.5968164",
"0.59273314",
"0.57849234",
"0.5761136",
"0.57510424",
"0.57198846",
"0.5717234",
"0.57150394",
"0.5667676",
"0.5636936",
"0.56257606",
"0.55977577",
"0.55945677",
"0.55880404",
"0.55880404",
"0.55... | 0.69550043 | 0 |
Write to YAML and JS files the final constructed configurations | def write_to_file(self, file_name=None, sub_path=None) -> None:
super().write_to_file(file_name, settings.ARTILLERY_FOLDER)
self.set_yaml_config()
self.write_file_to_output(
settings.ARTILLERY_YAML, self.yaml_config, append_mode=False, project_sub_folder=settings.ARTILLERY_FOLDER
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self):\n for p, c in self.configs_:\n c.write(p)",
"def _save_configuration_to_yml(self):\n data = self.get_configuration_data()\n timestamp = self.model.timestamp\n with open(os.path.join(CHECKPOINTS_DIR, timestamp, 'config_{}.yml'.format(timestamp)), 'w') as outf... | [
"0.68511325",
"0.66506356",
"0.6543113",
"0.64862216",
"0.6447968",
"0.6264091",
"0.61741364",
"0.6169828",
"0.61404073",
"0.61322165",
"0.6058652",
"0.604859",
"0.60388285",
"0.6029666",
"0.60256445",
"0.60251164",
"0.6015038",
"0.60138613",
"0.6009589",
"0.59702086",
"0.595... | 0.5634283 | 71 |
Tell if a person if allergic to the given allergen. | def is_allergic_to(self, allergen):
return allergen in self.list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_allergen(self, is_allergen):\n\n self._is_allergen = is_allergen",
"def in_garden(obj):\n print(\"Searching the garden's random objects\")\n return obj in _random_objects",
"def allergies(self, allergies):\n\n self.logger.debug(\"In 'allergies' setter.\")\n\n self._allergies =... | [
"0.6099033",
"0.5558612",
"0.5521234",
"0.5301362",
"0.5294011",
"0.5216652",
"0.5088434",
"0.507583",
"0.5070816",
"0.50542706",
"0.5041537",
"0.50312674",
"0.49993923",
"0.49899283",
"0.49749395",
"0.49660623",
"0.49616873",
"0.49227342",
"0.49170405",
"0.49064264",
"0.4897... | 0.77161974 | 0 |
Initialise an allergy storage with the given allergy score. | def __init__(self, score):
self.score = score
self.list = [candidate[0] for candidate in self._allergens
if candidate[1] & self.score] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _krls_init(self, iALDth=1e-4, iMaxDict=1e3):\n \n dAldKRLS = {} # Initialize dictionary with data for aldkrls algorithm\n \n # Store all the parameters in the dictionary\n dAldKRLS['iALDth'] = iALDth; # ALD threshold\n dAldKRLS['iMaxDt'] = iMaxDict; # M... | [
"0.5347252",
"0.5322024",
"0.5263044",
"0.5225015",
"0.5212653",
"0.51022935",
"0.5069073",
"0.50057083",
"0.50024194",
"0.49871403",
"0.49801096",
"0.49767306",
"0.49670827",
"0.49553522",
"0.4951048",
"0.49419042",
"0.4933451",
"0.48849487",
"0.48819917",
"0.48739007",
"0.4... | 0.5045687 | 7 |
Gets the header of the explog.yml file. the returned text is as below. | def getExplogHeader(FolderID, NumberofExps):
HeaderLines = []
HeaderLines.append("ExpFolderID: {ExpDirID}".format(ExpDirID=FolderID))
HeaderLines.append("NumberofEntries: {NumExps}".format(NumExps=NumberofExps))
HeaderLines.append("ExpEntries: ")
return "\n".join(HeaderLines) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_header():\n try:\n yml_iter = cfg.yml_config[\"header\"]\n except:\n # Probably no \"comments\" section in the yml-file.\n return \"\"\n\n return (\"\\n\".join(yml_iter) + \"\\n\\n\") if yml_iter is not None else \"\\n\"",
"def _get_compose_header(ctx):\n return get_artif... | [
"0.76283085",
"0.68693167",
"0.6808511",
"0.65722984",
"0.6551671",
"0.654237",
"0.639567",
"0.6334269",
"0.62707156",
"0.6265091",
"0.62361425",
"0.62100714",
"0.618234",
"0.617842",
"0.61768436",
"0.61641693",
"0.6152005",
"0.61499393",
"0.61389565",
"0.6129883",
"0.6125649... | 0.62574416 | 10 |
This returns a single entry corresponding to the Directory Entity referred to by FolderEntityData. The returned string is given below (between Start and End) Start | def getFolderEntry(FolderEntityData):
if FolderEntityData.Type not in ['IntermediateDir', 'ExperimentDir']:
errprint('\nThe given EntityData does not represent the data of a directory')
raise ValueError
OutputLines = []
OutputLines.append("FolderID : {UID}".format(UID=FolderEntityData.ID))
OutputLines.append("ParentFolderID : {UID}".format(UID=FolderEntityData.ParentID))
OutputLines.append("FolderType : {Type}".format(Type=FolderEntityData.Type))
OutputLines.append("FolderTitle : {Title}".format(Title=FolderEntityData.Title))
OutputLines.append("FolderDescription: |-2")
OutputLines += [" "+Line for Line in FolderEntityData.Description.splitlines()]
OutputLines.append("")
return "\n".join(OutputLines) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getFolderItemName(self) -> unicode:\n ...",
"def getFolderPath(self) -> unicode:\n ...",
"def directory_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"directory_id\")",
"def get(self):\n return self.directory_name",
"def metadataDirectory(self):\n guid_ha... | [
"0.5994919",
"0.56029546",
"0.5287925",
"0.52766377",
"0.5237696",
"0.52345103",
"0.5213454",
"0.5185664",
"0.517336",
"0.51614946",
"0.51094973",
"0.51090777",
"0.50988936",
"0.50865364",
"0.50664777",
"0.5054286",
"0.50433457",
"0.5036197",
"0.50105923",
"0.4974974",
"0.497... | 0.7627963 | 0 |
This returns a single entry corresponding to the Experiment Entity referred to by ExpEntityData. The returned string is given below (between Start and End) Start | def getExperimentEntry(ExpEntityData):
# Validate that ExpEntityData actually corresponds to an Experiment Entity
if ExpEntityData.Type != 'Experiment':
errprint("\nThe Entity Data does not represent the data of an experiment")
raise ValueError
OutputLines = []
OutputLines.append("")
OutputLines.append("- ID : {ID}".format(ID=ExpEntityData.ID))
OutputLines.append(" Title : {Title}".format(Title=ExpEntityData.Title))
OutputLines.append(" Description: |-2")
OutputLines += [" "+Line for Line in ExpEntityData.Description.splitlines()]
OutputLines.append("")
OutputLines.append(
"{0:#<100}".format("## End of Experiment {UID} ".format(UID=ExpEntityData.ID)))
return "\n".join(OutputLines) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_full_entity(entity: spacy.tokens.Token) -> str:\n entity_string = SpacyEventExtractor._get_chunk(entity)\n\n word = entity\n while True:\n prep, word = SpacyEventExtractor._get_prep_with_word(word)\n if word is None:\n break\n entity_str... | [
"0.6376407",
"0.5688458",
"0.56678385",
"0.5637462",
"0.5474638",
"0.5404834",
"0.5358794",
"0.53286546",
"0.5274664",
"0.5274664",
"0.52555805",
"0.5246036",
"0.51556396",
"0.51428646",
"0.51405764",
"0.51387566",
"0.51039517",
"0.5103533",
"0.5092884",
"0.5080785",
"0.50753... | 0.81062454 | 0 |
a constructor for an EmployeeAccess object | def __init__(self):
self.dbconnect = dbConnection.connection | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, employee_id, name, supervisor_id, lft, rgt):\n self.employee_id = employee_id\n self.name = name\n self.supervisor_id = supervisor_id\n self.lft = lft\n self.rgt = rgt",
"def __init__(self,name,empid,designation,experience):\n self.name = name\n ... | [
"0.6591341",
"0.65801567",
"0.616899",
"0.61554563",
"0.6011643",
"0.5887966",
"0.58608353",
"0.58440644",
"0.5821259",
"0.581591",
"0.5810037",
"0.5808263",
"0.57878995",
"0.57751787",
"0.57714325",
"0.57638586",
"0.57473",
"0.5722684",
"0.5716975",
"0.57147384",
"0.5699858"... | 0.0 | -1 |
get all the employees out of the database | def get_employees(self):
from Employee import Employee
cursor = self.dbconnect.get_cursor()
cursor.execute('select * from employee')
employees = list()
for row in cursor:
employee = Employee(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8])
employees.append(employee)
return employees | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self):\n resultado = EmployeeModel.query.all()\n return resultado",
"def get_employees(self, active_only):\n cursor = self.dbconnect.get_cursor()\n\n if active_only:\n cursor.execute(\n 'SELECT id, name, email, office, extra_info, picture_location, re... | [
"0.7986589",
"0.78798616",
"0.7810305",
"0.7761145",
"0.771737",
"0.7529015",
"0.7422921",
"0.722801",
"0.7137951",
"0.71137774",
"0.7091648",
"0.7014968",
"0.6984071",
"0.6906787",
"0.6850874",
"0.67577934",
"0.6755647",
"0.67153805",
"0.66789347",
"0.6564769",
"0.65336215",... | 0.8586788 | 0 |
this function gets all the admins from the database | def get_admins(self):
from Employee import Employee
admins = list()
cursorRoles = self.dbconnect.get_cursor()
cursorRoles.execute('select * from employeeRoles where role=\'admin\'')
for row in cursorRoles:
admins.append(self.get_employee(row[0]))
return admins | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_admins():\n users = get_users()\n admins = []\n for user in users:\n if user[\"approval_level\"] == \"admin\":\n admins.append(user)\n\n return admins",
"def get_admins(name):\n obj = DataService.objects(name=name).first()\n if obj is None:\n return []\n retu... | [
"0.77166426",
"0.76271695",
"0.76095897",
"0.7580871",
"0.75705355",
"0.7568923",
"0.74572515",
"0.7428086",
"0.7204757",
"0.7203195",
"0.7175435",
"0.70761865",
"0.70348865",
"0.70129657",
"0.69840354",
"0.6977274",
"0.69340014",
"0.6931243",
"0.6885563",
"0.6853746",
"0.684... | 0.81468296 | 0 |
gets a single employee out the database on an id | def get_employee(self, id):
from Employee import Employee
cursor = self.dbconnect.get_cursor()
cursor.execute('SELECT * FROM employee WHERE employeeID=%s ', (id,))
row = cursor.fetchone()
return Employee(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, id):\n resultado = EmployeeModel.query.filter_by(employee_id=id).first()\n if resultado:\n return resultado\n api.abort(404)",
"def get(id_: int):\n logger.debug('Retrieving employee by id %i.', id_)\n try:\n query = db.session.query(Employee)\n e... | [
"0.8462909",
"0.8436909",
"0.8286135",
"0.8277989",
"0.795276",
"0.7786417",
"0.75786275",
"0.7489491",
"0.7484681",
"0.73151207",
"0.7233033",
"0.6973724",
"0.6964095",
"0.6891466",
"0.68717116",
"0.6806852",
"0.66826135",
"0.6661457",
"0.6648924",
"0.6645056",
"0.66137886",... | 0.8603124 | 0 |
gets a single employee out the database on a name | def get_employeeOnName(self, name):
from Employee import Employee
cursor = self.dbconnect.get_cursor()
cursor.execute('SELECT * FROM employee WHERE name=%s ', (name,))
if (cursor.rowcount != 0):
row = cursor.fetchone()
return Employee(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8])
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_employee_by_name(self, name):\n cursor = self.dbconnect.get_cursor()\n cursor.execute('SELECT id, name, email, office, extra_info, picture_location, research_group, title, is_external,'\n ' is_admin, is_active FROM employee WHERE name=%s', (name,))\n row = cursor.... | [
"0.75500387",
"0.7348031",
"0.7300037",
"0.72360134",
"0.7058836",
"0.7009213",
"0.6654517",
"0.66495013",
"0.66377455",
"0.65564954",
"0.6541405",
"0.6435797",
"0.6376785",
"0.6338932",
"0.61743134",
"0.61031044",
"0.60764945",
"0.60599095",
"0.59950364",
"0.5983809",
"0.597... | 0.8025803 | 0 |
adds an employee to the database | def add_employee(self, empl):
cursor = self.dbconnect.get_cursor()
try:
cursor.execute('INSERT INTO employee values(default,%s,%s,%s,%s,%s,%s,%s,%s)',
(empl.name, empl.email, empl.office, empl.research_group, empl.title, empl.internOrExtern,
empl.active, empl.promotor))
cursor.execute('SELECT LASTVAL()')
eid = cursor.fetchone()[0]
empl.id = eid
# get id and return updated object
self.dbconnect.commit()
except(Exception, self.dbconnect.get_error()) as error:
self.dbconnect.rollback()
raise Exception('\nUnable to save Employee!\n(%s)' % (error)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_employee(self, obj):\n cursor = self.dbconnect.get_cursor()\n try:\n cursor.execute('INSERT INTO employee(id, name, email, office, extra_info, picture_location, research_group, '\n 'title, is_external, is_admin, is_active) VALUES(%s,%s,%s,%s,%s,%s,%s,%s,%s... | [
"0.8205563",
"0.7556254",
"0.74963003",
"0.74677837",
"0.74195415",
"0.71267223",
"0.7027136",
"0.68783706",
"0.6761403",
"0.6604914",
"0.6410982",
"0.63886535",
"0.6380282",
"0.6344615",
"0.6239359",
"0.6239359",
"0.6229492",
"0.6211725",
"0.618129",
"0.61335653",
"0.6131431... | 0.7959675 | 1 |
removes an emplouee out the database | def remove_employee(self, id):
cursor = self.dbconnect.get_cursor()
try:
cursor.execute('DELETE FROM employee WHERE employeeID=%s', (id,))
self.dbconnect.commit()
except(Exception, self.dbconnect.get_error()) as error:
self.dbconnect.rollback()
raise Exception('\nUnable to remove Employee!\n(%s)' % (error)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete():",
"def remove():\n\n db_remove()",
"def remove(name):\n del person_database[name]",
"def remove_data(self):\n db.session.delete(self)\n db.session.commit( )",
"def remove():",
"def remove(self):",
"def delete(self, name):\n if name in self._dict:\n se... | [
"0.67720187",
"0.67416126",
"0.66954815",
"0.6653715",
"0.6581915",
"0.65473205",
"0.65393317",
"0.6538599",
"0.6497466",
"0.6485631",
"0.6443768",
"0.6437587",
"0.6437587",
"0.6437587",
"0.6437587",
"0.64256126",
"0.6419886",
"0.64053607",
"0.6392454",
"0.6385016",
"0.636547... | 0.6492649 | 9 |
does a filter on all the employees in the database | def filter_employees(self, searchQuery="", researchGroup="", promotor=0, ):
from Employee import Employee
try:
cursor = self.dbconnect.get_cursor()
sql = 'select * from employee e INNER JOIN researchGroup r ON r.groupID=e.researchGroup WHERE ' \
'e.name LIKE %(searchQueryQ)s'
if researchGroup != "":
sql += "AND r.name = %(researchGroupQ)s"
if promotor == 1:
sql += 'AND e.promotor = TRUE'
if promotor == 2:
sql += 'AND e.promotor = FALSE'
cursor.execute(sql, dict(searchQueryQ="%" + searchQuery + "%", researchGroupQ=researchGroup))
employees = list()
for row in cursor:
employee = Employee(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8])
employees.append(employee)
return employees
except:
self.dbconnect.rollback()
raise Exception('unable to filter employees') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_all_employees(self):\n try:\n employees = self.admin_repository.show_all_employees()\n if employees:\n for employee in employees:\n print(\"Employee Id : {}\".format(employee[0]))\n print(\"Name : {}\".format(employee[1]))\n... | [
"0.6927609",
"0.6896321",
"0.6624646",
"0.6393193",
"0.63894564",
"0.6377485",
"0.63540703",
"0.6346314",
"0.62784153",
"0.6278148",
"0.6203518",
"0.6151426",
"0.61103714",
"0.6102392",
"0.60782236",
"0.60275084",
"0.5902977",
"0.58386964",
"0.5763383",
"0.5734938",
"0.573440... | 0.6596226 | 3 |
adds a role to an employee | def add_employeeRole(self, id, role):
cursor = self.dbconnect.get_cursor()
try:
cursor.execute('INSERT INTO employeeRoles values(%s,%s)',
(id, role))
# get id and return updated object
self.dbconnect.commit()
except(Exception, self.dbconnect.get_error()) as error:
self.dbconnect.rollback()
raise Exception('\nUnable to save EmployeeRole!\n(%s)' % (error)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_role():\n role = roles.find_or_create_role(request.values.get('role_name', ''))\n user = users.get_or_404(int(request.values.get('user_id', '')))\n if not users.add_role_to_user(user, role):\n return {}, 500\n return {}",
"def test_add_role(self):\n pass",
"def add_role(role):... | [
"0.7416667",
"0.73289865",
"0.72949153",
"0.72568375",
"0.7244213",
"0.71598387",
"0.7032163",
"0.699969",
"0.6978381",
"0.69690233",
"0.6907972",
"0.68849903",
"0.687573",
"0.6826044",
"0.6823985",
"0.6823678",
"0.67929417",
"0.67829245",
"0.6731767",
"0.6684479",
"0.6680996... | 0.80732065 | 0 |
gets al the roles of an employee | def get_employeeRoles(self, id):
cursor = self.dbconnect.get_cursor()
cursor.execute('select * from employeeRoles where employee=%s', (id,))
roles = list()
for row in cursor:
roles.append(row[1])
return roles | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_roles(role):",
"def getRoles(self):",
"def getRoles(self):\n return [self.getRole(), {\"roleName\":\"policajti\", \"roleTitle\":\"Svestky\"}]",
"def roles(self):\n params = {\n \"f\" : \"json\"\n }\n uURL = self._url + \"/roles\"\n return self._con.get(path=u... | [
"0.7949602",
"0.77490324",
"0.7219508",
"0.7100693",
"0.70895886",
"0.70715743",
"0.6987245",
"0.6968574",
"0.6919542",
"0.6890405",
"0.6882044",
"0.6865154",
"0.6842712",
"0.67842984",
"0.67706275",
"0.67660475",
"0.6756659",
"0.673916",
"0.6718372",
"0.6637145",
"0.66315967... | 0.81541693 | 0 |
changes the data of an employee | def change_employee(self, employee):
cursor = self.dbconnect.get_cursor()
try:
if employee.id == None:
raise Exception('no id given')
cursor.execute('select * from employee where employeeID=%s', (str(employee.id),))
if cursor.rowcount == 0:
raise Exception('no employee found with that id')
cursor.execute(
'update employee set name= %s,email= %s,office= %s,title= %s,INTernORextern= %s,active= %s,promotor= %s where employeeID=%s',
(employee.name, employee.email, employee.office, employee.title,
employee.internOrExtern, employee.active, employee.promotor, employee.id))
self.dbconnect.commit()
except:
self.dbconnect.rollback()
raise Exception('unable to change employee') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_employee(self, obj):\n cursor = self.dbconnect.get_cursor()\n try:\n cursor.execute('UPDATE employee '\n 'SET name = %s, email = %s, office = %s, extra_info = %s, picture_location = %s, '\n 'research_group = %s, title = %s, is_... | [
"0.7302678",
"0.718177",
"0.7112663",
"0.7027216",
"0.7005247",
"0.68823713",
"0.6850561",
"0.67905223",
"0.6775437",
"0.6432232",
"0.6327525",
"0.6219686",
"0.61889017",
"0.6159903",
"0.61581737",
"0.6071851",
"0.60707927",
"0.597288",
"0.5945182",
"0.58981615",
"0.5867029",... | 0.7703579 | 0 |
get all the projects of an employee IMPORTANT not all fields will be completed only the fields in the project table and that of the activeYears | def get_employeeProjects(self, id):
from Project import Project
cursor = self.dbconnect.get_cursor()
cursor.execute('select project from projectpromotor where employee=%s', (id,))
projectsId = list()
for row in cursor:
projectsId.append(row[0])
projects = list()
for projId in projectsId:
cursor.execute('select * from project where projectID=%s',
(projId,)) # returns exactly one row from the table
row = cursor.fetchone()
project = Project(row[0], row[1], row[2], row[3])
cursor.execute('select year from projectYearConnection where projectID=%s', (projId,))
years = list()
for row in cursor:
years.append(row[0])
project.activeYear = years
projects.append(project)
return projects | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_projects():\n if current_user.get_id() is None:\n return\n with database.engine.begin() as connection:\n result = connection.execute(select(\n [models.projects.c.project_id, models.projects.c.name, models.projects.c.path, models.projects.c.creation_date, models.projects.c.use... | [
"0.6504841",
"0.6427155",
"0.6327203",
"0.6314313",
"0.6288553",
"0.62257266",
"0.62068164",
"0.6192607",
"0.6165686",
"0.6157085",
"0.6130755",
"0.61147606",
"0.61008775",
"0.60764706",
"0.60260594",
"0.60055494",
"0.5962676",
"0.5942284",
"0.5927183",
"0.58933854",
"0.58909... | 0.72116566 | 0 |
Relative Strength Index Is a momentum indicator, measuring the magnitude of recent price changes. 70 is overbought 30 is oversold | def RelativeStrengthIndex(self, timeperiod=14):
return ta.RSI(self.data.close,timeperiod) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculateRelativeStrengthIndex(self, series, interval=14):\n\n if not isinstance(series, pd.Series):\n raise TypeError('Pandas Series required.')\n\n if not isinstance(interval, int):\n raise TypeError('Interval integer required.')\n\n if(len(series) < interval):\n ... | [
"0.6922888",
"0.6838217",
"0.6272428",
"0.61821586",
"0.5993364",
"0.5774363",
"0.5760759",
"0.5744267",
"0.57409",
"0.5716144",
"0.5701222",
"0.57010186",
"0.56948054",
"0.5676221",
"0.56436366",
"0.5643337",
"0.5643337",
"0.5614214",
"0.55853677",
"0.55841684",
"0.5581936",... | 0.655698 | 2 |
MACD Moving Average Convergence/Divergence | def MovingAverageConvergenceDivergence(self, fastperiod=12, slowperiod=26,signalperiod=9):
df = pd.DataFrame()
df['macd'], df['signal'], df['history'] = ta.MACDFIX(self.data.close, 9)
return df[-30:] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def computeMACD(x, slow=26, fast=12):\n emaslow = ExpMovingAverage(x, slow)\n emafast = ExpMovingAverage(x, fast)\n return emaslow, emafast, emafast - emaslow",
"def computeMACD(x, slow=26, fast=12):\n emaslow = ExpMovingAverage(x, slow)\n emafast = ExpMovingAverage(x, fast)\n return (emaslow, ... | [
"0.6501676",
"0.64562273",
"0.6412754",
"0.61223274",
"0.6114551",
"0.6047385",
"0.5973728",
"0.5865776",
"0.5864788",
"0.5819191",
"0.575621",
"0.5704251",
"0.5700242",
"0.5680569",
"0.56672055",
"0.56551254",
"0.56424147",
"0.56197876",
"0.5551434",
"0.5538618",
"0.553018",... | 0.56003624 | 18 |
The Simple Moving Average (SMA) is calculated by adding the price of an instrument over a number of time periods and then dividing the sum by the number of time periods. The SMA is basically the average price of the given time period, with equal weighting given to the price of each period. Simple Moving Average SMA = ( Sum ( Price, n ) ) / n | def SimpleMovingAverage(self, timeperiod = 14):
return ta.SMA(self.data.close,timeperiod) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SMA(serie, n):\r\n\r\n return serie.rolling(window=n).mean()",
"def get_SMA(values, window=20):\n\treturn values.rolling(window, center=False).mean()",
"def sma(matrix, interval):\n\n # declare empty SMA numpy array\n s = np.zeros((matrix.shape[0] - interval))\n\n # calculate the value of each ... | [
"0.7370013",
"0.73070514",
"0.72123134",
"0.72123134",
"0.71889323",
"0.71044785",
"0.69947493",
"0.6878451",
"0.6826726",
"0.67439926",
"0.6694565",
"0.6685296",
"0.6657218",
"0.6633062",
"0.6631047",
"0.6587248",
"0.6556056",
"0.6541206",
"0.6492296",
"0.64602447",
"0.64139... | 0.8110601 | 0 |
Average True Range Is a lagging indicator, used to provide insights into volatility. | def AverageTrueRange(self, timeperiod = 14):
return ta.ATR(self.data.high, self.data.low, self.data.close, timeperiod) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def average_true_range(self, period=14):\n tr = self._true_range_computation(period=period * 2)\n return pd.Series(tr.rolling(center=False, window=period,\n min_periods=period - 1).mean(),\n name='{} day ATR Ticker: {}'.format(period,\n ... | [
"0.6600089",
"0.6148675",
"0.6051582",
"0.59976155",
"0.57290894",
"0.5724756",
"0.5678576",
"0.56369007",
"0.55565417",
"0.5463608",
"0.5455246",
"0.5452944",
"0.54398197",
"0.5430366",
"0.5412434",
"0.53751826",
"0.5327749",
"0.5327182",
"0.5326094",
"0.52998155",
"0.527575... | 0.6382062 | 1 |
Average True Range Is a lagging indicator, used to provide insights into volatility. | def AverageTrueRangeStopLoss(self, timeperiod = 14, multiplier = 2):
stopLoss = ta.ATR(self.data.high, self.data.low, self.data.close, timeperiod)
plus_dm = ta.PLUS_DM(self.data.high,self.data.low, timeperiod)
minus_dm = ta.MINUS_DM(self.data.high,self.data.low, timeperiod)
if plus_dm > minus_dm:
stopLoss = self.data.close - multiplier * stopLoss
else:
stopLoss = self.data.close + multiplier * stopLoss
stopLoss.dropna(inplace=True)
return stopLoss | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def average_true_range(self, period=14):\n tr = self._true_range_computation(period=period * 2)\n return pd.Series(tr.rolling(center=False, window=period,\n min_periods=period - 1).mean(),\n name='{} day ATR Ticker: {}'.format(period,\n ... | [
"0.6598846",
"0.6380403",
"0.61479884",
"0.6053863",
"0.59975517",
"0.57305396",
"0.56783205",
"0.56357294",
"0.5556505",
"0.54646796",
"0.54572976",
"0.54534125",
"0.5439065",
"0.54316556",
"0.5413024",
"0.53748345",
"0.5328688",
"0.53281933",
"0.532751",
"0.5298861",
"0.527... | 0.5725855 | 6 |
100 LOG10( SUM(ATR(1), n) / ( MaxHi(n) MinLo(n) ) ) / LOG10(n) n = User defined period length. LOG10(n) = base10 LOG of n ATR(1) = Average True Range (Period of 1) SUM(ATR(1), n) = Sum of the Average True Range over past n bars MaxHi(n) = The highest high over past n bars | def ChoppinessIndex(self, timeperiod = 14):
return ta.C | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ATR(df, n):\n HML = abs(df['High'] - df['Low'])\n HMPC= abs(df['High'] - df['Close'].shift(1))\n LMPC= abs(df['Low'] - df['Close'].shift(1))\n TR = pd.concat([HML, HMPC, LMPC], axis=1).max(axis=1, skipna=False)\n return TR.rolling(n).mean()",
"def ATR(stockData , ticker, n):\n start = dt.... | [
"0.63604623",
"0.629991",
"0.6296152",
"0.61950475",
"0.605709",
"0.5966973",
"0.5952976",
"0.59012014",
"0.5847547",
"0.5821448",
"0.5785486",
"0.575912",
"0.5732089",
"0.5712802",
"0.5695987",
"0.5627515",
"0.5604428",
"0.5594196",
"0.55866754",
"0.55238754",
"0.5521845",
... | 0.0 | -1 |
Schaff Trend Cycle (STC) STC indicator is a forwardlooking leading indicator combining moving averages (MACD) with oscillator (stochastic). | def Schaff(self, shortPeriod=23, longPeriod=50):
shortEMAClose = ta.EMA(self.data.close, timeperiod=shortPeriod)
longEMAClose = ta.EMA(self.data.close, timeperiod=longPeriod)
macdClose = shortEMAClose - longEMAClose
shortEMALow = ta.EMA(self.data.low, timeperiod=shortPeriod)
longEMALow = ta.EMA(self.data.low, timeperiod=longPeriod)
macdLow = shortEMALow - longEMALow
shortEMAHigh = ta.EMA(self.data.high, timeperiod=shortPeriod)
longEMAHigh = ta.EMA(self.data.high, timeperiod=longPeriod)
macdHigh = shortEMAHigh - longEMAHigh
fastk, fastd = ta.STOCHF(macdHigh, macdLow, macdClose, fastk_period=10, fastd_period=10, fastd_matype=0)
return 100 * ((macdClose - fastk) / (fastd - fastk)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def one_transition_spectrum_cd(self,tr):\n \n\n ta = tr[\"ta\"] # TimeAxis\n rr = tr[\"rr\"] # transition dipole strength\n om = tr[\"om\"] # frequency - rwa\n gg = tr[\"gg\"] # natural broadening (constant or time dependent)\n fwhm = tr[\"fwhm\"] # Additional gaussian bro... | [
"0.55765706",
"0.5497741",
"0.5477658",
"0.5466189",
"0.54562336",
"0.54297197",
"0.53879595",
"0.5304885",
"0.5280067",
"0.52764845",
"0.5274857",
"0.52428555",
"0.5241364",
"0.51811355",
"0.5174693",
"0.51709056",
"0.5167392",
"0.5165704",
"0.5157772",
"0.51531",
"0.5118141... | 0.4891067 | 52 |
Calculates the variational expectations used by an SVGP model. | def variational_expectations(self, Fmu, Fvar, Y):
# Y must be in (-1, +1), not (0, 1)
assert_01 = tf.Assert(tf.reduce_all((Y == 0.0) | (Y == 1.0)), [Y])
with tf.control_dependencies([assert_01]):
Y = Y * 2.0 - 1.0
c2 = Fmu ** 2 + Fvar
c = tf.sqrt(c2)
theta = tf.tanh(c / 2) / (2 * c)
varexp = 0.5 * (Y * Fmu - theta * c2)
return varexp - PolyaGammaBernoulli.kl_term(c) - np.log(2.0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_var_exp(self):\n with self.test_context() as session:\n test_setups, F, feed = self.prepare()\n for test_setup in test_setups:\n l = test_setup.likelihood\n y = test_setup.Y\n l.compile()\n r1 = session.run(l.logp(F, ... | [
"0.72795737",
"0.66067874",
"0.62614894",
"0.6069039",
"0.60592204",
"0.6042628",
"0.6035716",
"0.60188943",
"0.5992968",
"0.5962066",
"0.591116",
"0.58926576",
"0.58375585",
"0.58221173",
"0.58154273",
"0.57872385",
"0.5785738",
"0.5771455",
"0.57044655",
"0.56976736",
"0.56... | 0.6047066 | 5 |
Creates a logger of given level and saves logs to a file | def create_logger(
project_name: str,
level: str = "INFO",
log_dir: str = "/tmp/logs",
file_name: Optional[str] = None,
do_print: bool = True,
simple_logging: bool = False,
log_to_file: bool = False,
rich_logging: bool = False,
time_zone: Optional[str] = None,
):
import __main__
if file_name is None:
try:
file_name = ntpath.basename(__main__.__file__).split(".")[0]
except:
file_name = "logs"
logger = logging.getLogger(file_name)
logger.handlers.clear()
logger.setLevel(getattr(logging, level))
if time_zone:
from pytz import timezone, utc
def time_formatter(*args):
# TODO: Doesnt work with rich formatter
utc_dt = utc.localize(datetime.datetime.utcnow())
my_tz = timezone(time_zone)
converted = utc_dt.astimezone(my_tz)
return converted.timetuple()
logging.Formatter.converter = time_formatter
if rich_logging:
from rich.logging import RichHandler
stream_format = f"{project_name}:%(module)s:%(funcName)s: %(message)s"
stream_handler = RichHandler(omit_repeated_times=False)
else:
stream_format = f"%(asctime)s:%(levelname)s:{project_name}:%(module)s:%(funcName)s: %(message)s"
stream_handler = logging.StreamHandler()
file_formatter = stream_formatter = logging.Formatter(
stream_format, "%Y-%m-%d %H:%M:%S"
)
if simple_logging:
file_formatter = logging.Formatter("%(message)s")
stream_formatter = logging.Formatter("%(message)s")
if log_to_file:
date = datetime.date.today()
date = "%s-%s-%s" % (date.day, date.month, date.year)
log_file_path = os.path.join(log_dir, "%s-%s.log" % (file_name, date))
create_folder(log_dir)
file_handler = logging.FileHandler(log_file_path)
file_handler.setFormatter(file_formatter)
logger.addHandler(file_handler)
if do_print:
stream_handler.setFormatter(stream_formatter)
logger.addHandler(stream_handler)
logger.propagate = False
return logger | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logger(level, log_info):\n log_path = getconfig(\"log\", \"LOG_PATH\")\n log_level = getconfig(\"log\", \"LOG_LEVEL\")\n log_enable = getconfig(\"log\", \"LOG_ENABLE\")\n log_fname = getconfig(\"log\", \"LOG_FNAME\")\n if not os.path.exists(log_path):\n os.makedirs(log_path)\n log_file... | [
"0.8126159",
"0.76459956",
"0.684709",
"0.68146396",
"0.6813477",
"0.6811436",
"0.6630617",
"0.6629015",
"0.6616148",
"0.65982366",
"0.65957934",
"0.65776724",
"0.6575906",
"0.657348",
"0.6556677",
"0.6537464",
"0.6526564",
"0.65043306",
"0.64900917",
"0.6485572",
"0.64745295... | 0.63525015 | 42 |
Initialize the cell to only point to itself. header is the column header for the cell | def __init__(self, header, name):
self.up = self
self.down = self
self.left = self
self.right = self
self.header = header
self.name = name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n\n self.reset_row()",
"def __init__(cell, value):\n\t\tcell.value = value\n\t\tcell.parent = None\n\t\tcell.visited = False",
"def __init__(self, numcols):\n # Start by making a root cell\n # This isn't part of the matrix, but it gives an entry point to the matrix\n ... | [
"0.6575508",
"0.6537204",
"0.6273338",
"0.62425",
"0.6164589",
"0.61148554",
"0.6096474",
"0.59903026",
"0.59864986",
"0.5979671",
"0.597449",
"0.58925885",
"0.58822554",
"0.5868053",
"0.58567417",
"0.58472",
"0.5832728",
"0.5818981",
"0.58085716",
"0.5777822",
"0.57610726",
... | 0.5778897 | 19 |
Initialize the sum to zero | def __init__(self, name):
super(Column, self).__init__(self, name)
self.sum = 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset_sum(self):\n self.sum_e = 0",
"def initial(self):\n return zero",
"def zero(self):\n raise NotImplementedError(\"Not implemented yet.\")",
"def reset_sum(self):\n self._error_sum = 0",
"def zero_sum(list):\n if not list:\n return 0\n else:\n return ... | [
"0.7703882",
"0.71630156",
"0.69994444",
"0.6945991",
"0.6897512",
"0.67463124",
"0.6605019",
"0.65537924",
"0.653141",
"0.65299124",
"0.6520557",
"0.65204495",
"0.6479404",
"0.6479189",
"0.6431233",
"0.64236397",
"0.6403008",
"0.63670397",
"0.63195443",
"0.62968844",
"0.6264... | 0.0 | -1 |
Initialize the dancling links matrix with a given number of columns | def __init__(self, numcols):
# Start by making a root cell
# This isn't part of the matrix, but it gives an entry point to the matrix
# root.right is the first column header, root.left is the last
# root.up and root.down just wrap around to itself
root = Column("root")
self.root = root
self.numcols = numcols
self.numrows = 0
# Now make all of the column headers
for col in range(numcols):
c = Column("header-" + str(col))
# Insert this column to the right side of the matrix
root.left.right = c
c.left = root.left
c.right = root
root.left = c | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, n):\n self.row = [0]*n\n self.col =[0]*n\n self.diagonal = 0\n self.antidiag = 0\n self.n = n",
"def setup(self, length):\n self.matrix = [None] * length\n for x in range(0,length):\n self.matrix[x] = [None] * length\n self.i =... | [
"0.6169552",
"0.61102796",
"0.6080898",
"0.5925205",
"0.5843429",
"0.5816062",
"0.5752628",
"0.5748185",
"0.57156444",
"0.57052106",
"0.56688374",
"0.5662722",
"0.5662606",
"0.5644519",
"0.564434",
"0.5636628",
"0.56212884",
"0.5586612",
"0.5582982",
"0.5580839",
"0.554456",
... | 0.5835481 | 5 |
Add a row to the matrix. cols is a sorted list of the column numbers that have a 1, indexed from 0. | def add_row(self, cols, name=None):
def get_header(col_current, col_shift):
"""
Starting at the current column header, shift to the right col_shift times
"""
header = col_current
for i in range(col_shift):
header = header.right
return header
# Update the number of rows
self.numrows += 1
if name is None:
name = self.numrows
# Get the first column header
head = self.root.right
head = get_header(head, cols[0])
# Place the first cell
cell = Cell(head, name)
cell.up = head.up
cell.down = head
head.up.down = cell
head.up = cell
head.sum += 1
oldcell = cell
oldcol = cols[0]
# Loop over all of the other entries
for col in cols[1:]:
# Shift to get the header
head = get_header(head, col - oldcol)
# Add in the cell
cell = Cell(head, name)
cell.up = head.up
cell.down = head
head.up.down = cell
head.up = cell
# Now add the left/right links
cell.left = oldcell
cell.right = oldcell.right
cell.right.left = cell
cell.left.right = cell
# Add to the header sum
head.sum += 1
# Keep the old cell for reference
oldcell = cell
oldcol = col | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_row(matrix):\n\tl = len(matrix[0])\n\ttemp = matrix[:]\n\ttemp += [[0]*l]\n\treturn temp",
"def add_row(matrix):\n import numpy as np\n shape = np.shape(matrix)\n if matrix is np.zeros(shape):\n return matrix.append(np.zeros(shape[0]))",
"def addRow(self, row):\n nc = len(row)\n ... | [
"0.7198061",
"0.716274",
"0.6843265",
"0.6479029",
"0.6377876",
"0.6279669",
"0.62465566",
"0.6215555",
"0.62106025",
"0.62064993",
"0.6145421",
"0.6095104",
"0.60865563",
"0.6051224",
"0.6049674",
"0.6012048",
"0.59923834",
"0.5945139",
"0.5912783",
"0.58509195",
"0.58039695... | 0.6547947 | 3 |
Starting at the current column header, shift to the right col_shift times | def get_header(col_current, col_shift):
header = col_current
for i in range(col_shift):
header = header.right
return header | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shift_column(self, coords, direction):\n self.shift_cells(self.get_column(coords, direction), direction)",
"def rollback(self) -> None:\n for k in self._moved_cols:\n self._cols[k].move_back()",
"def shift_right(self):\n self.pointer = (self.pointer + 1) % len(self.data)",
... | [
"0.6121716",
"0.59776706",
"0.5851196",
"0.5847812",
"0.57968843",
"0.5760453",
"0.566838",
"0.5658573",
"0.558538",
"0.5567467",
"0.5556038",
"0.5546835",
"0.55436087",
"0.5541556",
"0.5532854",
"0.5511011",
"0.5500459",
"0.5493521",
"0.5485904",
"0.54635084",
"0.5462295",
... | 0.69813544 | 0 |
Remove the specified column header from the header chain All rows that appear in this column are also removed | def remove_col(self, col_header):
# Remove the column header from the header chain
col_header.right.left = col_header.left
col_header.left.right = col_header.right
# Loop down through the column and remove the rows
cell = col_header.down
while cell != col_header:
row_cell = cell.right
# Move through all cells in this row and update their up/down links
while row_cell != cell:
row_cell.down.up = row_cell.up
row_cell.up.down = row_cell.down
row_cell.header.sum -= 1
# Move on to the next cell in the row
row_cell = row_cell.right
# Move on to the next row
cell = cell.down | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unremove_col(self, col_header):\n # Add the column head back into the chain\n col_header.right.left = col_header\n col_header.left.right = col_header\n # Loop up through the column and add the rows back in\n # Doing this in exactly the reverse order of the removing ensures th... | [
"0.7807759",
"0.7441563",
"0.71072763",
"0.67735565",
"0.6634205",
"0.6594297",
"0.6533182",
"0.6480123",
"0.6172724",
"0.6143548",
"0.6119587",
"0.6100099",
"0.60919523",
"0.6055784",
"0.60248214",
"0.60123044",
"0.60102904",
"0.5948839",
"0.5927248",
"0.5872746",
"0.5860796... | 0.80928975 | 0 |
Adds the specified column header back into the header chain Also adds all rows that this column removed back in | def unremove_col(self, col_header):
# Add the column head back into the chain
col_header.right.left = col_header
col_header.left.right = col_header
# Loop up through the column and add the rows back in
# Doing this in exactly the reverse order of the removing ensures that we return
# to the state we were in before the removal
cell = col_header.up
while cell != col_header:
row_cell = cell.left
# Move through all cells in this row and update their up/down links
while row_cell != cell:
row_cell.down.up = row_cell
row_cell.up.down = row_cell
row_cell.header.sum += 1
# Move on to the next cell in the row
row_cell = row_cell.left
# Move on to the next row
cell = cell.up | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_col(self, col_header):\n # Remove the column header from the header chain\n col_header.right.left = col_header.left\n col_header.left.right = col_header.right\n # Loop down through the column and remove the rows\n cell = col_header.down\n while cell != col_heade... | [
"0.71142775",
"0.6889686",
"0.65644413",
"0.6336859",
"0.608312",
"0.60671866",
"0.6046899",
"0.6015363",
"0.5942229",
"0.58050436",
"0.5728618",
"0.57080615",
"0.5686853",
"0.5644749",
"0.55979675",
"0.5594624",
"0.5594624",
"0.5585846",
"0.5558042",
"0.5540971",
"0.55384934... | 0.73550874 | 0 |
Find the column that has the minimum number of cells in it to minimize branching Returning a column with 0 cells in it is ok this gets dealt with in the solving loop | def get_minimum_column(self):
min_col = self.root.right
current_col = min_col.right
while current_col != self.root:
if current_col.sum < min_col.sum:
min_col = current_col
# Move on to the next column
current_col = current_col.right
return min_col | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def min_reduce_nb(col, a, *args):\n return np.nanmin(a)",
"def find_smallest(self):\n # add max value to covered rows and columns to ignore the covered cells\n maxval = self.C.max()\n C = self.C + self.row_cover[:, np.newaxis]*maxval\n C += self.col_cover*maxval\n # return t... | [
"0.6645709",
"0.6558186",
"0.64990723",
"0.6368767",
"0.63344336",
"0.6301566",
"0.6237791",
"0.6110719",
"0.60172206",
"0.60031587",
"0.59943664",
"0.59906703",
"0.5983194",
"0.59770536",
"0.5949309",
"0.5948226",
"0.59324056",
"0.592747",
"0.5884803",
"0.58845806",
"0.58685... | 0.69948006 | 0 |
Solve the exact cover problem recursively | def solve(self, solution_rows):
# Are we out of columns?
# Can only occur if each column has been removed through row selection
if self.root.right == self.root:
# Construct a tuple of the rows in this solution
soln = []
for row in solution_rows:
soln.append(row.name)
# Add it to the list of solutions
self.solutions.append(tuple(sorted(soln)))
return
# Choose the column with the minimum sum
col = self.get_minimum_column()
# Remove the column
self.remove_col(col)
# print("Chosen to remove column " + str(col.name))
# Try adding each row in this column to the solution, one at a time
row = col.down
while row != col:
# If there are no rows in this column, there is nothing to loop over here
# Add to the solution
solution_rows.append(row)
# print("Trying row " + str(row.name))
# Every column on this row needs to be removed
cell = row.right
while cell != row:
self.remove_col(cell.header)
cell = cell.right
# Now try to solve
self.solve(solution_rows)
# Now add that row back in
cell = row.left
while cell != row:
self.unremove_col(cell.header)
cell = cell.left
# Remove this row from the solution
solution_rows.pop()
# print("Removing row " + str(row.name))
# Move on to the next row
row = row.down
# Add the column back in
self.unremove_col(col) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_cover():\n # D corresponds to the items and the transactions in which they appear, it is the standard code table\n D = {\n \"B\": Bitmap([0, 1, 2]),\n \"A\": Bitmap([0, 1]),\n \"C\": Bitmap([0, 2]),\n \"D\": Bitmap([2])\n }\n # ct corresponds to the itemsets on whic... | [
"0.6313552",
"0.6258296",
"0.6128886",
"0.57589465",
"0.5733039",
"0.57001925",
"0.5643672",
"0.55785424",
"0.5561169",
"0.5516535",
"0.5466868",
"0.5454839",
"0.5434189",
"0.5430339",
"0.5400842",
"0.5336104",
"0.5285302",
"0.5259781",
"0.52392155",
"0.5232197",
"0.5226537",... | 0.0 | -1 |
Find the minimum volume ellipsoid which holds all the points Based on work by Nima Moshtagh | def getMinVolEllipse(P, tolerance=0.01):
(N, d) = np.shape(P)
d = float(d)
# Q will be our working array
Q = np.vstack([np.copy(P.T), np.ones(N)])
QT = Q.T
# initializations
err = 1.0 + tolerance
u = (1.0 / N) * np.ones(N)
# Khachiyan Algorithm
while err > tolerance:
V = np.dot(Q, np.dot(np.diag(u), QT))
M = np.diag(np.dot(QT , np.dot(linalg.inv(V), Q))) # M the diagonal vector of an NxN matrix
j = np.argmax(M)
maximum = M[j]
step_size = (maximum - d - 1.0) / ((d + 1.0) * (maximum - 1.0))
new_u = (1.0 - step_size) * u
new_u[j] += step_size
err = np.linalg.norm(new_u - u)
u = new_u
# center of the ellipse
center = np.dot(P.T, u)
# the A matrix for the ellipse
A = linalg.inv(
np.dot(P.T, np.dot(np.diag(u), P)) -
np.array([[a * b for b in center] for a in center])
) / d
# Get the values we'd like to return
U, s, rotation = linalg.svd(A)
radii = 1.0/np.sqrt(s)
rot_err = linalg.norm(np.identity(3)-abs(rotation))
if(rot_err > 0.05):
radii = np.array([radii[1],radii[0],radii[2]])
return radii | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_sphere_full():\n \n num_voxels = 31\n c = (15.0, 15.0, 15.0)\n\n data_x = []\n data_y = []\n data_z = []\n data_intensity = []\n\n volume = numpy.zeros((num_voxels, num_voxels, num_voxels))\n\n for x in range(num_voxels):\n for y in range(num_voxels):\n for... | [
"0.62986",
"0.62653875",
"0.5862462",
"0.5844809",
"0.5837435",
"0.58371854",
"0.5790067",
"0.5785195",
"0.5721557",
"0.5710913",
"0.56959003",
"0.5689655",
"0.5679842",
"0.56546134",
"0.56341815",
"0.56135213",
"0.5597461",
"0.55802417",
"0.5576471",
"0.55697113",
"0.5559904... | 0.6222927 | 2 |
Method called to collect data and send to Prometheus | def get_commit_time(self, metric):
session = requests.Session()
session.verify = False
logging.debug("metric.repo_project %s" % (metric.repo_project))
logging.debug("metric.git_api %s" % (self._git_api))
git_server = self._git_api
if (
"github" in git_server
or "bitbucket" in git_server
or "gitlab" in git_server
or "gitea" in git_server
):
logging.warn("Skipping non Azure DevOps server, found %s" % (git_server))
return None
# Private or personal token
# Fill in with your personal access token and org URL
personal_access_token = self._token
organization_url = self._git_api
# Create a connection to the org
credentials = BasicAuthentication("", personal_access_token)
connection = Connection(base_url=organization_url, creds=credentials)
# Get a client (the "git" client provides access to commits)
git_client = connection.clients.get_git_client()
commit = git_client.get_commit(
commit_id=metric.commit_hash,
repository_id=metric.repo_project,
project=metric.repo_project,
)
logging.debug("Commit %s" % ((commit.committer.date).isoformat("T", "auto")))
if hasattr(commit, "innerExepction"):
# This will occur when trying to make an API call to non-Github
logging.warning(
"Unable to retrieve commit time for build: %s, hash: %s, url: %s. Got http code: %s"
% (
metric.build_name,
metric.commit_hash,
metric.repo_url,
str(commit.message),
)
)
else:
try:
metric.commit_time = commit.committer.date.isoformat("T", "auto")
logging.info("metric.commit_time %s" % (str(metric.commit_time)[:19]))
logging.info("self._timedate_format %s" % (self._timedate_format))
metric.commit_timestamp = pelorus.convert_date_time_to_timestamp(
(str(metric.commit_time)[:19]), self._timedate_format
)
except Exception:
logging.error(
"Failed processing commit time for build %s" % metric.build_name,
exc_info=True,
)
logging.debug(commit)
raise
return metric | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\r\n self.collect_data()",
"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 fetch(self):\n\n\n # Update Prom... | [
"0.74755186",
"0.72660923",
"0.69965476",
"0.68536365",
"0.67639965",
"0.66526055",
"0.6617369",
"0.63650906",
"0.62632084",
"0.6253866",
"0.62457424",
"0.62276083",
"0.6208388",
"0.61819595",
"0.61701816",
"0.61203456",
"0.611145",
"0.6091151",
"0.60695875",
"0.60637254",
"0... | 0.0 | -1 |
requires class model name | def __init__(self, model, idx=0, seed=None):
self.__logger.info("Synthesizer init")
self.__logger.debug("DEBUG Message")
self.fake = Faker(seed) # First initialization of Faker
self.__reccntr = idx # ?? Unknown variable
self.add_providers() # Add providers to the faker
self.schema = []
self.is_dependent = []
for field in model.info.schema.info.fields:
self.schema.append(field.name)
if field.info.aux.dependent == "":
self.is_dependent.append(False)
else:
self.is_dependent.append(True)
# Cache the generator functions once
self.generator_fcns = {}
self.set_generators_from_proto(model)
# Following extension for generating duplicate records
self.__dupcntr = 0
self.__maxdup = 0
self.__dupdist = [] # List of duplicate counts
self._original = []
self.duplicate = False
self._expect_duplicate = False
self.nduplicate_weights = None
self.wrg = None
self.mod = None
# Generator counters/stats
self.stats = {"Total": 0, "Original": 0, "Duplicate": 0}
# self.h_dupdist = Histogram1D(range(10))
if model.info.aux.HasField("duplicate"):
self.duplicate = True
self.duplicate_cfg = dict()
self.duplicate_cfg["Prob_duplicate"] = model.info.aux.duplicate.probability
self.duplicate_cfg["Dist_duplicate"] = model.info.aux.duplicate.distribution
self.duplicate_cfg["Max_duplicate"] = model.info.aux.duplicate.maximum
self.nduplicate_weights = self.generate_duplicate_pdf()
if model.info.aux.HasField("record_modifier"):
self.mod = Modifier(
self.fake,
self.generator_fcns,
self.schema,
model.info.aux.record_modifier,
)
self.__logger.info("")
self.__logger.info("Synthesizer configured")
self.__logger.info("Model: %s" % model)
self.__logger.info("Schema:")
self.__logger.info(pformat(self.schema))
self.__logger.info("Dataset record index: %d" % idx)
if seed:
self.__logger.info("Seed set: %d" % seed)
self.__logger.info("Generate duplicate records:")
self.__logger.info(pformat(self.duplicate))
if self.duplicate:
self.__logger.info("Duplicate record probabilities")
self.__logger.info(pformat(self.duplicate_cfg))
self.__logger.info("Duplicate PDF")
self.__logger.info(pformat(self.nduplicate_weights))
self.__logger.info("Record modifier configuration")
self.__logger.info(model.info.aux.record_modifier) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def modelClass(self):\n raise NotImplementedError",
"def get_model(params):\r\n module_name, class_name = params.model.name.rsplit('.', 1)\r\n i = importlib.import_module(module_name)\r\n return getattr(i, class_name)",
"def model(self) -> str:\n ...",
"def test_valid_model(self):\n ... | [
"0.7560292",
"0.6874529",
"0.684144",
"0.6818532",
"0.68008655",
"0.6774673",
"0.67614686",
"0.67368454",
"0.6727387",
"0.6721594",
"0.6721594",
"0.6721594",
"0.6721594",
"0.6721594",
"0.6679806",
"0.66507953",
"0.66507953",
"0.66507953",
"0.66507953",
"0.6616141",
"0.6581579... | 0.0 | -1 |
This method swaps out the numpy instance in the module, should it have one, to the one in the fake instance we have here. | def _swap_numpy(self, module):
# Check to make sure this is not one of the string options from the YAML
if not isinstance(module, str):
if hasattr(module, 'numpy'): # Check if it has a self.numpy object
# TODO: Replace this with the correct variable
module.numpy = self.fake.numpy # Swap out with the class's instance of numpy
return module # Return out the mutated module | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_reference_to_array(self):\n arr = numpy.arange(0.0, 10.0, 0.1)\n arr = numpy.reshape(arr, (25, 4))\n vtk_arr = array_handler.array2vtk(arr)\n arr1 = array_handler.vtk2array(vtk_arr)\n # Now make sure these are using the same memory.\n arr[0][0] = 100.0\n s... | [
"0.60902596",
"0.58744705",
"0.5683738",
"0.5663783",
"0.5609355",
"0.5535437",
"0.5494269",
"0.54620075",
"0.54172635",
"0.5362005",
"0.5362005",
"0.5336442",
"0.5305379",
"0.530221",
"0.5182793",
"0.51734614",
"0.5172819",
"0.51510024",
"0.51288235",
"0.5113124",
"0.5095370... | 0.765654 | 0 |
This method injects in the providers to the faker instance. | def add_providers(self):
str_providers = PROVIDERS[0] # Providers, called by name
live_providers = PROVIDERS[1] # Providers, provided as a live module
for providers in PROVIDERS: # Iterate over the types of providers
for provider in providers: # Iterate over all the methods
# Inject those into faker, and swap the numpy instance
self.fake.add_faker(self._swap_numpy(provider[0]), provider[1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, config: Config) -> None:\n self.config = config\n\n faker_config = self.config.faker\n self.faker = Faker(locale=faker_config.locale)\n\n self.fakes = {}",
"def setup_provider(self):\n pass",
"def add_providers_deped(self):\n # This gives direct acce... | [
"0.63692963",
"0.6351762",
"0.61550707",
"0.6035626",
"0.5997692",
"0.5795709",
"0.57771325",
"0.57227266",
"0.55226743",
"0.54858613",
"0.5434935",
"0.54322845",
"0.53593737",
"0.5339375",
"0.5336239",
"0.53179175",
"0.529026",
"0.5267008",
"0.52436227",
"0.52424914",
"0.520... | 0.77991426 | 0 |
Add custom providers, Now depricated to to allow for the injection of the new methods. | def add_providers_deped(self):
# This gives direct access to the module's main class called Provider.
klasses = [
provider.Provider for provider in PROVIDERS] # Accessing the PROVIDERS. Check this method out, see how it operates.
for k in klasses:
self.fake.add_provider(k) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_providers(self):\n str_providers = PROVIDERS[0] # Providers, called by name\n live_providers = PROVIDERS[1] # Providers, provided as a live module\n for providers in PROVIDERS: # Iterate over the types of providers\n for provider in providers: # Iterate over all the meth... | [
"0.763159",
"0.6670083",
"0.66017246",
"0.6336766",
"0.62416",
"0.60363275",
"0.5885727",
"0.5830474",
"0.57857096",
"0.5718912",
"0.56462735",
"0.56242216",
"0.5617124",
"0.5603441",
"0.56022394",
"0.5557451",
"0.55536884",
"0.5521999",
"0.55216455",
"0.55036163",
"0.5493164... | 0.64158905 | 3 |
Convert field parameters to/from a message to python type parameters which do not contain Fields are converted to python type | def get_field_parameters(self, in_parms):
if len(in_parms) == 0: # Check if there are params
return None # If that's the case, return None
values = [] # Empty values
is_msg = False # Check if the param is a message
for parm in in_parms: # Loop over params
if parm.type == "Field": # If it is a message
is_msg = True # Set is_message to true
continue # Go to top of loop
_type = eval(parm.type) # create a type object
value = _type(parm.value) # Create the value, and cast it to the type
values.append(value) # Add that into the parameters
if is_msg is True: # check if is a message
return in_parms # Return input params
elif len(values) == 1: # If there is only one element
return values[-1] # Return just that element
else: # Otherwise
return values # Return the params | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_type(self, value, schema_type, **kwargs):",
"def _ConvertFieldValuePair(self, js, message, path):\n names = []\n message_descriptor = message.DESCRIPTOR\n fields_by_json_name = dict((f.json_name, f)\n for f in message_descriptor.fields)\n for name in js:\n ... | [
"0.5889569",
"0.58535415",
"0.5846825",
"0.5840448",
"0.58211553",
"0.5739531",
"0.5697468",
"0.5670201",
"0.5669158",
"0.558879",
"0.5576237",
"0.5560981",
"0.5541033",
"0.5484416",
"0.5465832",
"0.54647964",
"0.54605037",
"0.5457013",
"0.54551595",
"0.54478323",
"0.5439084"... | 0.5692826 | 7 |
This method sets the generators from a protocol buffer. This does... not sure yet | def set_generators_from_proto(self, table):
self.__logger.info("Setting Generator functions from Msg") # Let us know
for field in table.info.schema.info.fields: # Iterate over the fields in the proto
# Let us know what field is being accessed
self.__logger.info("Gathering fakers %s", field.name)
if field.info.aux.dependent != "": # If the aux.dependent field is empty
continue # Goto the top of the loop if the above is the case
self.__logger.info("Independent field %s", field) # Getting the field
# Get the parameters out of the generator
parms = self.get_field_parameters(
field.info.aux.generator.parameters) # Grab our params
# Load this data into the system, associate field with params and generator
self.generator_fcns[field.name] = (field.info.aux.generator.name, parms)
self.__logger.debug(parms) # Tell us
self.__logger.debug(field.info.aux.generator.name) # Tell us
self.__logger.debug(self.generator_fcns[field.name]) # Tell us | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_generator(self, gen):\n self.generator = gen",
"def setGenerators(self):\n shape = (self.input_shape[0],self.input_shape[1])\n self.trainGen,self.validateGen = getBatchGenerators(self.batch_size,\n self.dataPath,\n ... | [
"0.6843186",
"0.6817292",
"0.623496",
"0.61516976",
"0.5911144",
"0.5882668",
"0.5799233",
"0.56797016",
"0.5637793",
"0.561574",
"0.560835",
"0.5581869",
"0.55451405",
"0.5529971",
"0.552042",
"0.5490284",
"0.54892546",
"0.5484604",
"0.54761255",
"0.54730356",
"0.5460637",
... | 0.6150093 | 4 |
Create a map of duplicates and probabilities according to a pdf, i.e. uniform and store for reuse on each original event current version taken directly from FEBRL needs review b/c number of duplicates stored starts at 2? | def generate_duplicate_pdf(self):
num_dup = 1
prob_sum = 0.0
prob_list = [(num_dup, prob_sum)]
max_dups = self.duplicate_cfg["Max_duplicate"]
uniform_val = 1.0 / float(max_dups)
for i in range(max_dups - 1):
num_dup += 1
prob_list.append((num_dup, uniform_val + prob_list[-1][1]))
return prob_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def multinomial_pmf(sample, probabilities):\r\n # TODO\r\n a=[]\r\n b=[]\r\n i=0\r\n key_list=[]\r\n value_list=[]\r\n for key,value in sample.items():\r\n key_list.append(key)\r\n value_list.append(value)\r\n b=list(sample)\r\n while i< len(b):\r\n a.append(probabil... | [
"0.6266391",
"0.6231039",
"0.6222904",
"0.6209188",
"0.62075746",
"0.60514987",
"0.60154533",
"0.59842813",
"0.59767723",
"0.5969421",
"0.5939433",
"0.58987904",
"0.58945656",
"0.58854735",
"0.58664787",
"0.5817961",
"0.57828134",
"0.5771365",
"0.5759954",
"0.5755793",
"0.573... | 0.74976236 | 0 |
Setter method for original | def reset_original(self):
self._original = [] # Empty out self._originals | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setOriginal(self,neworiginal):\n\t\tself.original = neworiginal;",
"def original(self, original):\n self._original = original",
"def original(self) -> Any:\n raise NotImplementedError",
"def __init__(self, orig):\n self.orig = orig",
"def update_original_data(self):\n pass",... | [
"0.8130244",
"0.8047649",
"0.7397236",
"0.730968",
"0.6972755",
"0.68666035",
"0.6818994",
"0.67645526",
"0.67645526",
"0.6702549",
"0.6689829",
"0.6665114",
"0.6546259",
"0.6500433",
"0.64820886",
"0.64437467",
"0.6417436",
"0.6361053",
"0.63502926",
"0.6325794",
"0.6284538"... | 0.5829867 | 57 |
Create an orriginal record. | def generate_original(self):
fakers = self.schema # Get the schema; Not sure what this is
self.reset_original() # Set the self._original value to be empty
self.__logger.debug("generate_original()") # Let us know
self.__logger.debug("Event ID %d" % self.record_count) # Let us know
darr = [] # Data array
for i, fake in enumerate(fakers): # Enumerate the fakers
if self.is_dependent[i] is True: # Skip over if there is a dependent
continue # Skipper
if self.generator_fcns[fake][1] is None: # Check if there are params
value = self.fake.fake(
self.generator_fcns[fake][0], params=None) # Create fake datum
darr.append(value) # Append the data to the list
else: # If there are
self.__logger.info(self.generator_fcns[fake][1])
value = self.fake.fake(
self.generator_fcns[fake][0], self.generator_fcns[fake][1]) # Create fake datum
if isinstance(value, list): # If it is a list
darr.extend(value) # Extend
else: # Otherwise
if value not in darr:
darr.append(value) # Just append the value
self.record_counter() # Count the number of records
self.cache_original(darr) # Cache the results
return darr # Return the data array | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createRecord(self):\n self.dto.getRecord().append(self.controller.createNewObj())\n print(\"Record added.\")",
"def _inmate_record_get_or_create(self):\n raise NotImplementedError('_inmate_record_get_or_create needs to be implemented with the new format')",
"def create_record(self, zon... | [
"0.66684353",
"0.6392694",
"0.61336666",
"0.6101538",
"0.6050459",
"0.6033388",
"0.5997482",
"0.5970368",
"0.5938527",
"0.59184444",
"0.5904673",
"0.5903052",
"0.58274496",
"0.5815766",
"0.5784867",
"0.57735556",
"0.57151145",
"0.5684695",
"0.5666976",
"0.5666811",
"0.5662072... | 0.0 | -1 |
Determines whether original record will be duplicated Gets the maximum number of duplicated records to generate | def expect_duplicate(self):
# Reset everything for this record
self._expect_duplicate = False
self.__dupcntr = 0
self.__maxdup = 0
# Get the probability to generate duplicate for next record
if self.fake.random.random() < self.duplicate_cfg["Prob_duplicate"]:
self._expect_duplicate = True
self.__maxdup = self.random_select_ndups()
else:
self._expect_duplicate = False
self.__maxdup = 0
self.__logger.debug("expect_duplicate ndups: %d", self.__maxdup) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_duplicate(self):\n return bool(self.duplicated)",
"def isRepeated(self):\n return self._field.label == FieldDescriptor.LABEL_REPEATED",
"def is_duplicate(self, **kwargs):\n return len(list(self.c.select(**kwargs))) > 0",
"def process_duplicate_rows(self):\n pass",
"def is... | [
"0.675923",
"0.63455653",
"0.6291391",
"0.5996474",
"0.59781253",
"0.5973371",
"0.59171003",
"0.5903125",
"0.5873092",
"0.58724254",
"0.5841418",
"0.58190286",
"0.5798888",
"0.5789265",
"0.5784065",
"0.57638514",
"0.5761442",
"0.57307065",
"0.5723805",
"0.5719764",
"0.5711496... | 0.7407912 | 0 |
Load data if data have been created. Create data otherwise. | def load_data():
if 'data' not in os.listdir('.'):
os.mkdir('data')
if 'id_to_word.pkl' not in os.listdir('data'):
print('Loading data...')
(x_train, y_train), (x_val, y_val) = imdb.load_data(num_words=max_features, skip_top=20, index_from=3)
word_to_id = imdb.get_word_index()
word_to_id ={k:(v+3) for k,v in word_to_id.items()}
word_to_id["<PAD>"] = 0
word_to_id["<START>"] = 1
word_to_id["<UNK>"] = 2
id_to_word = {value:key for key,value in word_to_id.items()}
print(len(x_train), 'train sequences')
print(len(x_val), 'test sequences')
print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_val = sequence.pad_sequences(x_val, maxlen=maxlen)
y_train = np.eye(2)[y_train]
y_val = np.eye(2)[y_val]
np.save('./data/x_train.npy', x_train)
np.save('./data/y_train.npy', y_train)
np.save('./data/x_val.npy', x_val)
np.save('./data/y_val.npy', y_val)
with open('data/id_to_word.pkl','wb') as f:
pickle.dump(id_to_word, f)
else:
x_train, y_train, x_val, y_val = np.load('data/x_train.npy'),np.load('data/y_train.npy'),np.load('data/x_val.npy'),np.load('data/y_val.npy')
with open('data/id_to_word.pkl','rb') as f:
id_to_word = pickle.load(f)
return x_train, y_train, x_val, y_val, id_to_word | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data(self) -> None:",
"def load_data(self):",
"def load_data(self):\n raise NotImplementedError()",
"def _load(self):\n if self.file_path.exists():\n with open(self.file_path) as fid:\n self.data = json.load(fid)",
"def _load_data(self):\n if self._ap... | [
"0.6876719",
"0.65628785",
"0.6523932",
"0.64879066",
"0.644452",
"0.6407347",
"0.62683874",
"0.6245403",
"0.6236588",
"0.6224349",
"0.62203705",
"0.61988556",
"0.61792195",
"0.6178383",
"0.61401325",
"0.6105626",
"0.608856",
"0.608699",
"0.6083278",
"0.60767114",
"0.6059067"... | 0.0 | -1 |
Build the original model to be explained. | def create_original_model():
model = Sequential()
model.add(Embedding(max_features,
embedding_dims,
input_length=maxlen))
model.add(Dropout(0.2))
model.add(Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(GlobalMaxPooling1D())
model.add(Dense(hidden_dims))
model.add(Dropout(0.2))
model.add(Activation('relu'))
model.add(Dense(2))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_model():",
"def build_model(self):\n pass",
"def build_model(self):\n pass",
"def build_model(self):\n raise NotImplementedError",
"def _build_model(self):\n raise NotImplementedError()",
"def build_model(self) -> nn.Module:\n pass",
"def _build_model(self, ... | [
"0.76988584",
"0.7433274",
"0.7433274",
"0.7323292",
"0.71259195",
"0.69584244",
"0.6808802",
"0.6758032",
"0.66716534",
"0.65664864",
"0.64607084",
"0.6417122",
"0.63994056",
"0.6390134",
"0.6358464",
"0.6354998",
"0.62842834",
"0.62842834",
"0.6279981",
"0.6247293",
"0.6068... | 0.0 | -1 |
Generate the predictions of the original model on training and validation datasets. The original model is also trained if train = True. | def generate_original_preds(train = True):
x_train, y_train, x_val, y_val, id_to_word = load_data()
model = create_original_model()
if train:
filepath="models/original.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='val_acc',
verbose=1, save_best_only=True, mode='max')
callbacks_list = [checkpoint]
model.fit(x_train, y_train, validation_data=(x_val, y_val),callbacks = callbacks_list, epochs=epochs, batch_size=batch_size)
model.load_weights('./models/original.hdf5',
by_name=True)
pred_train = model.predict(x_train,verbose = 1, batch_size = 1000)
pred_val = model.predict(x_val,verbose = 1, batch_size = 1000)
if not train:
print('The val accuracy is {}'.format(calculate_acc(pred_val,y_val)))
print('The train accuracy is {}'.format(calculate_acc(pred_train,y_train)))
np.save('data/pred_train.npy', pred_train)
np.save('data/pred_val.npy', pred_val) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_predict(self):\n self.classifier = self.model\n self.classifier.fit(self.X_sample, self.y_sample)\n self.y_pred = self.classifier.predict(self.X_test)",
"def get_predictions(fitted_model_filename):\n click.echo(\"Mode: predicting probabilities.\\n\")\n defaults = get_defaults()... | [
"0.6959041",
"0.6904541",
"0.6858206",
"0.674883",
"0.6679141",
"0.65974444",
"0.654767",
"0.65204763",
"0.64544606",
"0.6438485",
"0.6437152",
"0.64298964",
"0.6410104",
"0.640449",
"0.640449",
"0.6369408",
"0.63413376",
"0.63313776",
"0.62701774",
"0.6262735",
"0.6240748",
... | 0.7165115 | 0 |
Build the L2X model for selecting words. | def construct_gumbel_selector(X_ph, num_words, embedding_dims, maxlen):
emb_layer = Embedding(num_words, embedding_dims, input_length = maxlen, name = 'emb_gumbel')
emb = emb_layer(X_ph) #(400, 50)
net = Dropout(0.2, name = 'dropout_gumbel')(emb)
net = emb
first_layer = Conv1D(100, kernel_size, padding='same', activation='relu', strides=1, name = 'conv1_gumbel')(net) # bs, 400, 100
# global info
net_new = GlobalMaxPooling1D(name = 'new_global_max_pooling1d_1')(first_layer) # bs, 100
global_info = Dense(100, name = 'new_dense_1', activation='relu')(net_new) # bs, 100
# local info
net = Conv1D(100, 3, padding='same', activation='relu', strides=1, name = 'conv2_gumbel')(first_layer) # bs, 400, 100
local_info = Conv1D(100, 3, padding='same', activation='relu', strides=1, name = 'conv3_gumbel')(net) # bs, 400, 100
combined = Concatenate()([global_info,local_info])
net = Dropout(0.2, name = 'new_dropout_2')(combined)
net = Conv1D(100, 1, padding='same', activation='relu', strides=1, name = 'conv_last_gumbel')(net)
logits_T = Conv1D(1, 1, padding='same', activation=None, strides=1, name = 'conv4_gumbel')(net) # bs, 400, 1
# wanna make it bs, maxlen*num_groups
squeeze_layer = Lambda(lambda x:tf.squeeze(x), output_shape=lambda x:x[:-1])
logits_T_grp = Dense(maxlen*num_groups)(squeeze_layer(logits_T))
#print(logits_T_grp.shape)
return logits_T_grp # bs, 400* num_groups | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_model_from_inputs(self):\n if self.term_list is None:\n # no supplied token list -- use vocabulary of the training dataset\n # self.term_list = self.vocabulary\n # info(\"Setting bag dimension to {} from input vocabulary.\".format(len(self.term_list)))\n ... | [
"0.64706546",
"0.628739",
"0.61955893",
"0.6154911",
"0.6109166",
"0.60060537",
"0.5975403",
"0.59434366",
"0.5934024",
"0.588384",
"0.58455455",
"0.58168155",
"0.58109325",
"0.57811666",
"0.5767697",
"0.56962854",
"0.56701654",
"0.56225514",
"0.56121624",
"0.5598342",
"0.559... | 0.0 | -1 |
Generate scores on features on validation by L2X. Train the L2X model with variational approaches if train = True. | def L2X(train = True):
print('Loading dataset...')
x_train, y_train, x_val, y_val, id_to_word = load_data()
#pred_train = np.load('data/pred_train.npy')
#pred_val = np.load('data/pred_val.npy')
print('Creating model...')
# P(S|X)
with tf.variable_scope('selection_model'):
X_ph = Input(shape=(maxlen,), dtype='int32')
logits_T_grp = construct_gumbel_selector(X_ph, max_features, embedding_dims, maxlen) # bs, max_len * num_groups
tau = 0.5
T = Sample_Concrete(tau, k, num_feature=maxlen, num_groups=num_groups)(logits_T_grp)
T = Reshape((maxlen, num_groups))(T)
T = Permute((2, 1))(T) # bs, num_groups, max_len
# q(X_S)
with tf.variable_scope('prediction_model'):
emb2 = Embedding(max_features, embedding_dims,
input_length=maxlen)(X_ph)
# emb2 bs, max_len, 50
# apply the matrix trick as before
# here the output size of matmul layer is different from before
net = matmul_layer([T, emb2]) # bs, num_groups, 50
#print(net.shape)
net = Conv1D(1, 1, padding='same', activation=None, strides=1, name = 'merge_channel')(net) # bs, num_groups, 1
# net = Mean(net) # bs, 50
input_group = Flatten()(net) # bs, num_groups
# num_groups = K.int_shape(input_group)[1]
# here we add instance wise f-s again!!!!
net = Dense(100, activation='relu', name = 's/dense1',
kernel_regularizer=regularizers.l2(1e-3))(input_group)
net = Dense(100, activation='relu', name = 's/dense2',
kernel_regularizer=regularizers.l2(1e-3))(net)
logits = Dense(num_groups)(net)
# A tensor of shape, [batch_size, max_sents, 100]
samples = Sample_Concrete_Original(tau, num_vital_group, name='group_importance')(logits)
new_input_group = Multiply()([input_group, samples])
net = Dense(hidden_dims, activation='relu')(new_input_group)
preds = Dense(2, activation='softmax',
name = 'new_dense')(net)
model = Model(inputs=X_ph,
outputs=preds)
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',#optimizer,
metrics=['acc'])
#train_acc = np.mean(np.argmax(pred_train, axis = 1)==np.argmax(y_train, axis = 1))
#val_acc = np.mean(np.argmax(pred_val, axis = 1)==np.argmax(y_val, axis = 1))
#print('The train and validation accuracy of the original model is {} and {}'.format(train_acc, val_acc))
if train:
filepath="models/l2x.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='val_acc',
verbose=1, save_best_only=True, mode='max')
callbacks_list = [checkpoint]
st = time.time()
model.fit(x_train, y_train,
validation_data=(x_val, y_val),
callbacks = callbacks_list,
epochs=epochs, batch_size=batch_size)
duration = time.time() - st
print('Training time is {}'.format(duration))
model.load_weights('models/l2x.hdf5', by_name=True)
pred_model = Model(X_ph, [T, samples])
pred_model.summary()
pred_model.compile(loss='categorical_crossentropy',
optimizer='adam', metrics=['acc'])
st = time.time()
#scores = pred_model.predict(x_val,
# verbose = 1, batch_size = batch_size)[:,:,0]
#scores = np.reshape(scores, [scores.shape[0], maxlen])
scores_t, group_importances_t = pred_model.predict(x_train, verbose = 1, batch_size = batch_size)
scores_v, group_importances_v = pred_model.predict(x_val, verbose = 1, batch_size = batch_size)
return scores_t, group_importances_t, scores_v, group_importances_v, x_val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self,features,y):\r\n \r\n if self.learn_type == \"nn\":\r\n #generate supervised dataset\r\n return(self.learner.train_on_batch(features,y))\r\n elif self.learn_type == \"linear\":\r\n grad = 0\r\n n = len(features)\r\n for i in... | [
"0.654589",
"0.64421695",
"0.63593584",
"0.63469756",
"0.62618685",
"0.62167436",
"0.6188725",
"0.6184751",
"0.6142719",
"0.6141688",
"0.60937035",
"0.60724396",
"0.6038608",
"0.6014961",
"0.5990709",
"0.59876823",
"0.59866655",
"0.59690255",
"0.5963425",
"0.5955654",
"0.5946... | 0.0 | -1 |
Generate the predictions of the original model on training and validation datasets. The original model is also trained if train = True. | def generate_post_preds(train = True):
x_train, y_train, x_val, y_val = np.load('data/x_train_new.npy'),np.load('data/y_train.npy'),np.load('data/x_val_new.npy'),np.load('data/y_val.npy')
with open('data/id_to_word.pkl','rb') as f:
id_to_word = pickle.load(f)
model = create_original_model()
if train:
filepath="./models/post.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='val_acc',
verbose=1, save_best_only=True, mode='max')
callbacks_list = [checkpoint]
model.fit(x_train, y_train, validation_data=(x_val, y_val),callbacks = callbacks_list, epochs=epochs, batch_size=batch_size)
model.load_weights('./models/post.hdf5',
by_name=True)
pred_train = model.predict(x_train,verbose = 1, batch_size = 1000)
pred_val = model.predict(x_val,verbose = 1, batch_size = 1000)
if not train:
print('The val accuracy is {}'.format(calculate_acc(pred_val,y_val)))
print('The train accuracy is {}'.format(calculate_acc(pred_train,y_train))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_original_preds(train = True):\n x_train, y_train, x_val, y_val, id_to_word = load_data() \n model = create_original_model()\n\n if train:\n filepath=\"models/original.hdf5\"\n checkpoint = ModelCheckpoint(filepath, monitor='val_acc', \n verbose=1, save_best_only=True,... | [
"0.7163424",
"0.69594693",
"0.6906497",
"0.6859476",
"0.67500716",
"0.6679552",
"0.6597463",
"0.654829",
"0.65226644",
"0.6456303",
"0.643875",
"0.6437849",
"0.6430144",
"0.6410656",
"0.6405512",
"0.6405512",
"0.6370887",
"0.6341422",
"0.63307375",
"0.6271287",
"0.6262299",
... | 0.6127523 | 40 |
Compose the largest number out of a set of integers. | def largest_number(digits):
res = ""
while digits:
max_digit = None
for digit in digits:
if max_digit is None or \
is_greater_or_equal_than(digit, max_digit):
max_digit = digit
res += max_digit
digits.remove(max_digit)
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def largest_int(numbers):\n\n if numbers == []:\n return \n max_int = numbers[0]\n for number in numbers:\n if number > max_int:\n max_int = number\n \n return max_int",
"def max_(lst: Iterable[int]) -> int:\n return reduce(lambda x, y: x if x > y else y, lst)",
"def ... | [
"0.7238424",
"0.68917364",
"0.6735405",
"0.66264164",
"0.66255736",
"0.6614427",
"0.66113424",
"0.65993583",
"0.6570257",
"0.6552687",
"0.65461093",
"0.65238184",
"0.64182717",
"0.63805205",
"0.63039565",
"0.6295779",
"0.62524813",
"0.6228118",
"0.6196727",
"0.61448497",
"0.6... | 0.6804858 | 2 |
A function to build the neural network of the required size using the weights and biases provided. Instead of doing this, can we use a simple constructor method and initalize them post the construction? That would be sensible and faster. | def neural_net(self, layers):
model = nn.Sequential()
for l in range(0, len(layers) - 1):
model.add_module("layer_"+str(l), nn.Linear(layers[l],layers[l+1], bias=True))
if l != len(layers) - 2:
model.add_module("tanh_"+str(l), nn.Tanh())
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, sizes):\r\n self.num_layers = len(sizes)\r\n self.sizes = sizes\r\n self.biases = [np.random.randn(y, 1) for y in sizes[1:]]\r\n self.weights = [np.random.randn(y, x)\r\n for x, y in zip(sizes[:-1], sizes[1:])]",
"def __init__(self, sizes):\n ... | [
"0.7550142",
"0.7535491",
"0.75056463",
"0.74940723",
"0.7493714",
"0.7344416",
"0.7279779",
"0.7265629",
"0.7218069",
"0.72046214",
"0.71778685",
"0.71470296",
"0.7120793",
"0.70849985",
"0.7019694",
"0.70176697",
"0.69794846",
"0.69722265",
"0.6920543",
"0.6879415",
"0.6876... | 0.0 | -1 |
Initialize the neural network with the required layers, the weights and the biases. The input "layers" in an array that contains the number of nodes (neurons) in each layer. | def initialize_NN(self, m):
if type(m) == nn.Linear:
nn.init.xavier_uniform_(m.weight)
# print(m.weight) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, layerNeurons, initialWeights = None, layerTypes=None, **kwargs):\r\n \r\n # Ensure that there is at-least one input and one output layer in the network\r\n assert len(layerNeurons)>1, \"At least one input layer and one output layer is needed\"\r\n \r\n # Get th... | [
"0.7665592",
"0.75891453",
"0.7549877",
"0.7288455",
"0.7238649",
"0.72074854",
"0.7202781",
"0.71520114",
"0.7109726",
"0.70575273",
"0.6969205",
"0.69633704",
"0.68633807",
"0.6848898",
"0.6821339",
"0.68000925",
"0.677125",
"0.67679054",
"0.6746093",
"0.6742651",
"0.672905... | 0.0 | -1 |
Forward pass through the network to obtain the U field. | def net_u(self, x, t):
u = self.model(torch.cat((x,t),1))
return u | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def U(self):\n return self._U",
"def forward(self, u):\n self.pop(u)\n return self.read(1.)",
"def get_U(self):\n if self.U is not None:\n return self.U\n return self.calc_Uiso()",
"def forward(self, inputs):\n\n down0 = self.layer_0(inputs=inputs)\n ... | [
"0.6244465",
"0.6143601",
"0.61348015",
"0.60307336",
"0.5914714",
"0.586357",
"0.5847307",
"0.5737416",
"0.57315356",
"0.5697165",
"0.5688825",
"0.5688825",
"0.5688825",
"0.56794524",
"0.56679034",
"0.5638842",
"0.5594738",
"0.55896443",
"0.5576749",
"0.5571661",
"0.5566135"... | 0.58103776 | 7 |
The providerassigned unique ID for this managed resource. | def id(self) -> str:
return pulumi.get(self, "id") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def provider_id(self):\n return self.get('_id')",
"def provider_id(self):\n raise NotImplementedError",
"def id(self):\n return self.raw_resource.uuid",
"def healthcare_provider_id(self):\n return self._healthcare_provider_id",
"def unique_identifier(self) -> str:\n retur... | [
"0.8193033",
"0.78504187",
"0.77109545",
"0.7604915",
"0.74777704",
"0.74738747",
"0.74738747",
"0.74738747",
"0.7426179",
"0.7379609",
"0.73721254",
"0.73721254",
"0.73721254",
"0.73721254",
"0.73721254",
"0.73721254",
"0.73721254",
"0.73721254",
"0.7357793",
"0.7357793",
"0... | 0.0 | -1 |
The managed object reference ID of the root resource pool for the cluster. | def resource_pool_id(self) -> str:
return pulumi.get(self, "resource_pool_id") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pool_id ( self ):\n return self._pool_id",
"def managed_object_id(self):\n o = self._data[\"managed_object\"]\n if type(o) in (int, long):\n return o\n return o.id",
"def identity_pool_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"identity_pool_id\"... | [
"0.71896243",
"0.66001445",
"0.65141094",
"0.6471181",
"0.6368429",
"0.6354283",
"0.634698",
"0.6305942",
"0.62388986",
"0.62217504",
"0.6184611",
"0.61742735",
"0.61742735",
"0.61742735",
"0.61742735",
"0.61742735",
"0.61529875",
"0.6127469",
"0.6123672",
"0.61147434",
"0.61... | 0.74713767 | 0 |
The `ComputeCluster` data source can be used to discover the ID of a cluster in vSphere. This is useful to fetch the ID of a cluster that you want to use for virtual machine placement via the `VirtualMachine` resource, allowing to specify the cluster's root resource pool directly versus using the alias available through the `ResourcePool` data source. > You may also wish to see the `ComputeCluster` resource for more information about clusters and how to managed the resource in this provider. Example Usage ```python import pulumi import pulumi_vsphere as vsphere datacenter = vsphere.get_datacenter(name="dc01") compute_cluster = vsphere.get_compute_cluster(name="cluster01", datacenter_id=datacenter.id) ``` | def get_compute_cluster(datacenter_id: Optional[str] = None,
name: Optional[str] = None,
opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetComputeClusterResult:
__args__ = dict()
__args__['datacenterId'] = datacenter_id
__args__['name'] = name
opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
__ret__ = pulumi.runtime.invoke('vsphere:index/getComputeCluster:getComputeCluster', __args__, opts=opts, typ=GetComputeClusterResult).value
return AwaitableGetComputeClusterResult(
datacenter_id=pulumi.get(__ret__, 'datacenter_id'),
id=pulumi.get(__ret__, 'id'),
name=pulumi.get(__ret__, 'name'),
resource_pool_id=pulumi.get(__ret__, 'resource_pool_id')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cluster_id(options):\n cluster = options.cluster\n datacenter = get_datacenter(options)\n for item in datacenter.hostFolder.childEntity:\n if (item.name == cluster):\n return item._GetMoId()",
"def get_compute_cluster_output(datacenter_id: Optional[pulumi.Input[Optional[str]]] = N... | [
"0.70518404",
"0.70052683",
"0.67735595",
"0.6768537",
"0.6736824",
"0.6736824",
"0.6736824",
"0.6736824",
"0.6736824",
"0.66624004",
"0.66624004",
"0.66624004",
"0.66624004",
"0.6613303",
"0.660601",
"0.660601",
"0.6474703",
"0.6474703",
"0.6474703",
"0.63924193",
"0.6386118... | 0.72311264 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.