None:\\n trend_transform = TrendTransform(in_column=\\\"target\\\", detrend_model=LinearRegression(), model=\\\"rbf\\\")\\n example_tsds.fit_transform([trend_transform])\\n original = example_tsds.df.copy()\\n example_tsds.inverse_transform()\\n assert (example_tsds.df == original).all().all()\",\n \"def switch_to_test_data(self) -> None:\\n if self._test_name not in self._datasets:\\n raise ValueError(\\\"Test data not provided.\\\")\\n self.switch_to_dataset(self._test_name)\",\n \"def evaluate(\\n self,\\n test_dataset: Union[Dataset, InstanceDataset],\\n batch_size: int = 16,\\n lazy: bool = False,\\n output_dir: Optional[Union[str, Path]] = None,\\n verbose: bool = True,\\n ) -> Dict[str, Any]:\\n trainer = Trainer(self, lazy=lazy)\\n\\n return trainer.test(\\n test_dataset, batch_size=batch_size, output_dir=output_dir, verbose=verbose\\n )\",\n \"def prepare_data(train, test):\\n # change the name of the target column\\n train.rename(columns={\\\"revenue\\\": \\\"target\\\"}, inplace=True)\\n # map bool values to yes and no\\n train[\\\"Weekend\\\"] = train[\\\"Weekend\\\"].map({True: \\\"Yes\\\", False: \\\"No\\\"})\\n test[\\\"Weekend\\\"] = test[\\\"Weekend\\\"].map({True: \\\"Yes\\\", False: \\\"No\\\"})\\n # set the id col as index\\n train.set_index(\\\"id\\\", inplace=True)\\n test.set_index(\\\"id\\\", inplace=True)\\n\\n # seperate the fetures and the target\\n X_train = train.drop(\\\"target\\\", axis=1).copy()\\n y_train = train[\\\"target\\\"].copy()\\n X_test = test.copy()\\n\\n # select numerical and categorical columns\\n num_cols = X_train.select_dtypes(exclude=\\\"object\\\").columns.tolist()\\n cat_cols = X_train.select_dtypes(include=\\\"object\\\").columns.tolist()\\n\\n # numerical pipeline\\n num_pipe = make_pipeline(SimpleImputer(strategy=\\\"mean\\\"))\\n\\n # categorical pipeline\\n cat_pipe = make_pipeline(\\n SimpleImputer(strategy=\\\"constant\\\", fill_value=\\\"NA\\\"),\\n OneHotEncoder(handle_unknown=\\\"ignore\\\", sparse=False),\\n )\\n\\n # full pipeline for data preprocessing\\n full_pipe = ColumnTransformer(\\n [(\\\"num\\\", num_pipe, num_cols), (\\\"cat\\\", cat_pipe, cat_cols)]\\n )\\n return X_train, y_train, X_test, full_pipe\",\n \"def testing_input_fn():\\n dataset = tf.data.Dataset.range(len(cube_features))\\n dataset = dataset.batch(16)\\n dataset = dataset.map(mapping_function)\\n return dataset\",\n \"def test(self, training_set, original_test_set, imitation_test_set ):\\n\\n plt.figure()\\n\\n training_axis = np.arange(len(training_set))\\n original_test_axis = np.arange(len(original_test_set))+len(training_axis)\\n imitation_test_axis = np.arange(len(imitation_test_set))+len(training_axis)+len(original_test_set)\\n\\n training_scores = []\\n original_test_scores = []\\n imitation_test_scores = []\\n\\n for signature in training_set:\\n vectorized_signature = signature.tolist()\\n score = -1*self.model.score(vectorized_signature)\\n training_scores.append(score)\\n\\n for signature in original_test_set:\\n vectorized_signature = signature.tolist()\\n score = -1*self.model.score(vectorized_signature)\\n original_test_scores.append(score)\\n\\n for signature in imitation_test_set:\\n vectorized_signature = signature.tolist()\\n score = -1*self.model.score(vectorized_signature)\\n imitation_test_scores.append(score)\\n\\n accuracy, threshold = self.evaluate(training_scores, original_test_scores, imitation_test_scores)\\n\\n xaxis = np.arange(len(imitation_test_set)+len(training_axis)+len(original_test_set))\\n plt.plot( xaxis, threshold*np.ones(len(xaxis)), \\\"--\\\", label=\\\"Threshold\\\" )\\n plt.scatter(training_axis,training_scores, label=\\\"Training data\\\")\\n plt.scatter(original_test_axis, original_test_scores, c=\\\"g\\\", label=\\\"Original Test data\\\")\\n plt.scatter(imitation_test_axis, imitation_test_scores, c=\\\"r\\\", label=\\\"Imitated Test data\\\")\\n plt.legend(loc=\\\"best\\\")\\n plt.title(f\\\"{self.user} data. Accuracy={accuracy} \\\")\\n plt.ylabel(\\\"Score\\\")\\n plt.xlabel(\\\"File\\\")\\n plt.savefig(f\\\"{self.n_components}_{self.user}.png\\\")\\n\\n Model.accuracies.append(accuracy)\",\n \"def test_predictor():\",\n \"def _testData(self, functor, tests, check_type=True):\\n for test_output, test_input in tests.iteritems():\\n result = functor(test_input)\\n self._assertEqual(functor.__name__, test_input, test_output, result)\\n\\n if check_type:\\n # Also make sure the result is a string, otherwise the %r\\n # output will include a \\\"u\\\" prefix and that is not good for\\n # logging.\\n self.assertEqual(type(test_output), str)\",\n \"def test_pipeline_basic(self):\\n raw_data = pd.read_csv(\\n join(get_test_data_file(), INPUT_DATA_FILENAME), encoding=\\\"iso-8859-1\\\"\\n )\\n\\n # preprocessing\\n processed_df = preprocess_pipeline(raw_data)\\n\\n # assumptions about the data\\n # check number of rows\\n assert processed_df.shape[0] > 0\\n\\n vectorizer, term_document_matrix, word_list = create_tfidf_term_document_matrix(\\n processed_df\\n )\\n\\n assert vectorizer is not None\\n assert term_document_matrix is not None\\n assert word_list is not None\",\n \"def transform(self, dataset: NumpyOrPandas) -> NumpyDataset:\\n # checks here\\n super().transform(dataset)\\n # convert to accepted dtype and get attributes\\n dataset = dataset.to_pandas()\\n df = dataset.data\\n\\n # transform\\n roles = NumericRole()\\n outputs = []\\n\\n for n, conlumn_name in enumerate(df.columns):\\n if self.cache_dir is not None:\\n full_hash = get_textarr_hash(df[conlumn_name]) + get_textarr_hash(self.dicts[conlumn_name][\\\"feats\\\"])\\n fname = os.path.join(self.cache_dir, full_hash + \\\".pkl\\\")\\n\\n if os.path.exists(fname):\\n logger.info3(f\\\"Load saved dataset for {conlumn_name}\\\")\\n\\n with open(fname, \\\"rb\\\") as f:\\n new_arr = pickle.load(f)\\n\\n else:\\n new_arr = self.dicts[conlumn_name][\\\"transformer\\\"].transform(df[conlumn_name])\\n with open(fname, \\\"wb\\\") as f:\\n pickle.dump(new_arr, f)\\n else:\\n new_arr = self.dicts[conlumn_name][\\\"transformer\\\"].transform(df[conlumn_name])\\n\\n output = dataset.empty().to_numpy()\\n output.set_data(new_arr, self.dicts[conlumn_name][\\\"feats\\\"], roles)\\n outputs.append(output)\\n logger.info3(f\\\"Feature {conlumn_name} transformed\\\")\\n # create resulted\\n return dataset.empty().to_numpy().concat(outputs)\",\n \"def get_dataset_transform(dataset_name):\\n if dataset_name == \\\"MNIST\\\":\\n train_transform = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Normalize((0.1307,), (0.3081,))\\n ])\\n test_transform = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Normalize((0.1307,), (0.3081,))\\n ])\\n elif dataset_name == \\\"CIFAR10\\\":\\n train_transform = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))\\n ])\\n test_transform = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))\\n ])\\n elif dataset_name == \\\"CIFAR100\\\":\\n train_transform = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))\\n ])\\n test_transform = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))\\n ])\\n elif dataset_name == \\\"EMNIST\\\":\\n train_transform = transforms.Compose([\\n Transpose(),\\n transforms.ToTensor(),\\n transforms.Normalize((0.1307,), (0.3081,))\\n ])\\n test_transform = transforms.Compose([\\n Transpose(),\\n transforms.ToTensor(),\\n transforms.Normalize((0.1307,), (0.3081,))\\n ])\\n else:\\n print(\\\"current dataset name:{} is not right\\\".format(dataset_name))\\n sys.exit(1)\\n return train_transform, test_transform\",\n \"def run(dataset = 1):\\n train_list, test_list = load_list(dataset, False)\\n train_imgs = process_list(train_list)\\n test_imgs = process_list(test_list)\\n with open(os.path.join(WORKING_DIR, 'data', 'train' + str(dataset) + '.txt'), 'w') as f:\\n for img in train_imgs:\\n f.write(img)\\n f.write(' ')\\n if img[-14] == 'F':\\n f.write('1')\\n else:\\n f.write('0')\\n f.write('\\\\n')\\n with open(os.path.join(WORKING_DIR, 'data', 'test' + str(dataset) + '.txt'), 'w') as f:\\n for img in test_imgs:\\n f.write(img)\\n f.write(' ')\\n if img[-14] == 'F':\\n f.write('1')\\n else:\\n f.write('0')\\n f.write('\\\\n')\",\n \"def test_000_basic_functionality() -> None:\\n df = generate_test_data()\\n skim(df)\",\n \"def test_transform(self):\\n t = OneHotEncode(3)\\n assert numpy.all(t.transform(0) == numpy.array((1.0, 0.0, 0.0)))\\n assert numpy.all(t.transform(1) == numpy.array((0.0, 1.0, 0.0)))\\n assert numpy.all(t.transform(2) == numpy.array((0.0, 0.0, 1.0)))\\n with pytest.raises(AssertionError):\\n t.transform(4)\\n with pytest.raises(AssertionError):\\n t.transform(-1)\\n with pytest.raises(AssertionError):\\n t.transform(2.2)\\n assert numpy.all(\\n t.transform([[2, 1], [0, 2]])\\n == numpy.array(\\n [[(0.0, 0.0, 1.0), (0.0, 1.0, 0.0)], [(1.0, 0.0, 0.0), (0.0, 0.0, 1.0)]]\\n )\\n )\\n\\n t = OneHotEncode(2)\\n assert t.transform(0) == 0.0\\n assert t.transform(1) == 1.0\\n with pytest.raises(TypeError):\\n t.transform(\\\"ipsi\\\")\\n assert numpy.all(\\n t.transform([[1, 1], [0, 1]]) == numpy.array([[1.0, 1.0], [0.0, 1.0]])\\n )\\n\\n # for the crazy enough\\n t = OneHotEncode(1)\\n assert t.transform(0) == 0.0\\n with pytest.raises(TypeError):\\n t.transform(\\\"ipsi\\\")\\n assert numpy.all(t.transform([[0, 0], [0, 0]]) == [[0.0, 0.0], [0.0, 0.0]])\",\n \"def test__transform_continuous(self):\",\n \"def test(self, test):\\r\\n self.ml_data.set_target(test[0])\\r\\n self.ml_data.set_features(test[1])\\r\\n if self.ml_data.target_type.all() == np.float64 or self.ml_data.target_type.all() == np.int64:\\r\\n self.model_qua.open()\\r\\n else:\\r\\n self.model_quali.open()\",\n \"def test_transform(self):\\n X,Y,Z = self.generate_data()\\n\\n p={'k':-1,'r':0}\\n\\n task = mmSCHPOLY('sc2=0.5')\\n res= task.fit_transform(X,Y,Z)\\n # check if Instance\\n self.assertIsInstance(res,Container)\\n # check if expected response\\n print res.colnames(**p)\\n self.assertEqual(res.colnames(**p)==['0','Pol1stTerm_1','Pol2ndTerm_1'],True)\\n self.assertEqual(np.all(res(**p)[:,0]-X()[:,0]==0),True)\\n self.assertEqual(np.all(res(**p)[:,1]-X()[:,1]==0),True)\\n self.assertEqual(np.all(res(**p)[:,2]-0.5*X()[:,1]**2==0),True)\\n\\n task = mmSCH2W('sc=0.1')\\n res= task.fit_transform(X,Y,Z)\\n # check if Instance\\n self.assertIsInstance(res,Container)\\n # check if expected response\\n print res.colnames(**p)\\n self.assertEqual(res.colnames(**p)==['Product_1_2'],True)\\n self.assertEqual(np.all(res(**p)[:,0]-0.1*X()[:,1]*X()[:,2]==0),True)\",\n \"def test_transform(self):\\n t = Quantize()\\n assert t.transform(8.6) == 9\\n assert t.transform(8.4) == 8\\n assert t.transform(5.3) == 5\\n assert numpy.all(t.transform([8.6, 5.3]) == numpy.array([9, 5], dtype=int))\",\n \"def _test(self,model, dataset):\\n avg_loss = tfe.metrics.Mean('loss')\\n accuracy = tfe.metrics.Accuracy('accuracy')\\n\\n for (images, labels) in tfe.Iterator(dataset):\\n logits = model(images, training=False)\\n avg_loss(self._loss(logits, labels))\\n accuracy(\\n tf.argmax(logits, axis=1, output_type=tf.int64),\\n tf.cast(labels, tf.int64))\\n print('Test set: Average loss: %.4f, Accuracy: %4f%%\\\\n' %\\n (avg_loss.result(), 100 * accuracy.result()))\\n with tf.contrib.summary.always_record_summaries():\\n tf.contrib.summary.scalar('loss', avg_loss.result())\\n tf.contrib.summary.scalar('accuracy', accuracy.result())\",\n \"def run():\\r\\n \\r\\n LABEL = data.LabelField(use_vocab=True)\\r\\n TEXT = data.Field(sequential=True, tokenize=lambda x:x.split(), lower=True, fix_length=config.MAX_LENGTH)\\r\\n\\r\\n### 1/5\\r\\n dataset = data.TabularDataset(path=config.TRAIN_DATASET_FNAME, \\r\\n format='csv', \\r\\n fields=[('text', TEXT),('label', LABEL)], \\r\\n skip_header=True)\\r\\n # split the dataset, 8:2\\r\\n train_dataset, valid_dataset = dataset.split(split_ratio=[0.8,0.2], random_state=random.getstate())\\r\\n \\r\\n test_data = data.TabularDataset(path=config.TEST_DATASET_FNAME,\\r\\n format='csv', \\r\\n fields=[('text', TEXT),('label', LABEL)], \\r\\n skip_header=True)\\r\\n \\r\\n### 2\\r\\n# train_dataset = data.TabularDataset(path=config.TRAIN_DATASET_FNAME, \\r\\n# format='csv', \\r\\n# fields=[('text', TEXT),('label', LABEL)], \\r\\n# skip_header=True) \\r\\n# valid_dataset = data.TabularDataset(path=config.VAL_DATASET_FNAME, \\r\\n# format='csv', \\r\\n# fields=[('text', TEXT),('label', LABEL)], \\r\\n# skip_header=True) \\r\\n \\r\\n# test_data = data.TabularDataset(path=config.TEST_DATASET_FNAME,\\r\\n# format='csv', \\r\\n# fields=[('text', TEXT),('label', LABEL)], \\r\\n# skip_header=True)\\r\\n \\r\\n### 3/4\\r\\n# train_dataset = data.TabularDataset(path=config.TRAIN_DATASET_FNAME, \\r\\n# format='csv', \\r\\n# fields=[('text', TEXT),('label', LABEL)], \\r\\n# skip_header=True) \\r\\n \\r\\n# dataset = data.TabularDataset(path=config.TEST_DATASET_FNAME, \\r\\n# format='csv', \\r\\n# fields=[('text', TEXT),('label', LABEL)], \\r\\n# skip_header=True)\\r\\n# # split the dataset, 5:5\\r\\n# valid_dataset, test_data = dataset.split(split_ratio=[0.5,0.5], random_state=random.getstate())\\r\\n\\r\\n### 5\\r\\n\\r\\n\\r\\n\\r\\n # load embeddings\\r\\n vectors_data = load_vectors(config.EMBEDDING_FNAME)\\r\\n\\r\\n TEXT.build_vocab(train_dataset, vectors=vectors_data)\\r\\n LABEL.build_vocab(train_dataset)\\r\\n print ('vector size:',TEXT.vocab.vectors.size())\\r\\n embedding_pretrained_matrix = TEXT.vocab.vectors\\r\\n \\r\\n # create torch device\\r\\n print(\\\"To device...\\\")\\r\\n USE_CUDA = torch.cuda.is_available()\\r\\n device = torch.device(\\\"cuda\\\" if USE_CUDA else \\\"cpu\\\")\\r\\n\\r\\n train_it, valid_it = data.BucketIterator.splits((train_dataset, valid_dataset),\\r\\n batch_sizes=(config.TRAIN_BATCH_SIZE,config.VAL_BATCH_SIZE), \\r\\n device=device, \\r\\n sort_key=lambda x: len(x.text),\\r\\n sort_within_batch=False,\\r\\n shuffle=True,\\r\\n repeat=False)\\r\\n test_it = data.BucketIterator(test_data, \\r\\n batch_size=config.TEST_BATCH_SIZE, \\r\\n sort_key=lambda x: len(x.text), \\r\\n shuffle=False,\\r\\n device=device)\\r\\n \\r\\n \\r\\n # fetch model\\r\\n vocab_size = len(TEXT.vocab) # TEXT.vocab.vectors.size()\\r\\n# pretrained_vec = TEXT.vocab.vectors\\r\\n \\r\\n # selecte network \\r\\n x = import_module('networks.'+config.NETWORK)\\r\\n model = x.Model(vocab_size,embedding_pretrained=embedding_pretrained_matrix)\\r\\n \\r\\n # send model to device\\r\\n model.to(device)\\r\\n\\r\\n # initialize Adam optimizer\\r\\n optimizer = torch.optim.Adam(model.parameters(), lr=config.LEARNING_RATE)\\r\\n\\r\\n # if you have multiple GPUs, model model to DataParallel to use multiple GPUs\\r\\n if torch.cuda.device_count() > 1:\\r\\n model = nn.DataParallel(model)\\r\\n \\r\\n params_list = []\\r\\n # train and validate for all epochs\\r\\n for epoch in range(config.EPOCHS):\\r\\n epoch_start_time = time.time()\\r\\n\\r\\n ###----Train--------\\r\\n train_outputs, train_labels, train_loss = engine.train_fn(train_it, model, optimizer, device)\\r\\n train_outputs = torch.Tensor(train_outputs)\\r\\n _, train_predicted = torch.max(train_outputs, dim=1)\\r\\n train_parameters_dict = metrics_func.performance_evaluation_func(train_predicted,train_labels,epoch=str(epoch))\\r\\n # save train paremeters\\r\\n params_list.append(train_parameters_dict)\\r\\n train_f1 = train_parameters_dict['f1_score_macro']\\r\\n train_prec = train_parameters_dict['precision_macro']\\r\\n train_recall = train_parameters_dict['precision_macro']\\r\\n print('\\\\n')\\r\\n print(f\\\" Train Epoch: {epoch}, F1 = {train_f1},precision = {train_prec},recall = {train_recall}\\\")\\r\\n ###------------\\r\\n \\r\\n # validate\\r\\n val_outputs, val_labels, valid_loss = engine.evaluate_fn(valid_it, model, device)\\r\\n val_outputs = torch.Tensor(val_outputs)\\r\\n _, val_predicted = torch.max(val_outputs, dim=1) \\r\\n # calculate evaluation paremeters\\r\\n val_parameters_dict = metrics_func.performance_evaluation_func(val_predicted, val_labels, epoch=str(epoch),flag='val')\\r\\n # save evaluation paremeters\\r\\n params_list.append(val_parameters_dict)\\r\\n \\r\\n val_f1 = val_parameters_dict['f1_score_macro']\\r\\n val_prec = val_parameters_dict['precision_macro']\\r\\n val_recall = val_parameters_dict['recall_macro']\\r\\n print(f\\\"Val Epoch: {epoch},F1 = {val_f1},precision = {val_prec}, recall = {val_recall}\\\")\\r\\n \\r\\n ###-------Test-----------------------\\r\\n test_outputs, test_labels, test_loss = engine.evaluate_fn(test_it, model, device)\\r\\n test_outputs = torch.Tensor(test_outputs)\\r\\n _, test_predicted = torch.max(test_outputs, dim=1) \\r\\n # calculate evaluation paremeters\\r\\n test_parameters_dict = metrics_func.performance_evaluation_func(test_predicted, test_labels, epoch=str(epoch),flag='test')\\r\\n # save evaluation paremeters\\r\\n params_list.append(test_parameters_dict)\\r\\n \\r\\n test_f1 = test_parameters_dict['f1_score_macro']\\r\\n test_prec = test_parameters_dict['precision_macro']\\r\\n test_recall = test_parameters_dict['recall_macro']\\r\\n print(f\\\"test Epoch: {epoch},F1 = {test_f1},precision = {test_prec}, recall = {test_recall}\\\")\\r\\n \\r\\n lr_scheduler = LRScheduler(optimizer)\\r\\n lr_scheduler(valid_loss)\\r\\n \\r\\n \\r\\n # simple early stopping\\r\\n# val_f1 = float(val_f1)\\r\\n #f1 = (float(train_f1) + float(val_f1)) / 2\\r\\n val_loss = float(valid_loss)\\r\\n early_stopping(val_loss, model)\\r\\n if early_stopping.early_stop:\\r\\n print(\\\"Early stopping\\\")\\r\\n break\\r\\n # 获得 early stopping 时的模型参数\\r\\n# model.load_state_dict(torch.load('checkpoint.pt'))\\r\\n\\r\\n# save_model_func(model, epoch, path='outputs')\\r\\n \\r\\n metrics_func.save_parameters_txt(params_list)\",\n \"def transform_data_set(data_set, grid_transformer):\\n return [transform_example(example, grid_transformer) for example in data_set]\",\n \"def create_train_test(option, transform, params, split=0.2):\\r\\n clip_im_dir = option.clip_im_dir\\r\\n matting_dir = option.matting_dir\\r\\n csv_path = option.csv_path\\r\\n \\r\\n print(\\\"create datasets\\\")\\r\\n \\r\\n \\r\\n data_df = pd.read_csv(csv_path)\\r\\n # data_df = MergeDataframe(clip_im_dir, matting_dir)\\r\\n \\r\\n #separate data in training and test data (20/80)\\r\\n train_df, test_df = train_test_split(data_df, test_size=split)\\r\\n \\r\\n #search right Dataset class\\r\\n package_dir = Path(src.dataset.__file__).resolve().parent\\r\\n\\r\\n for (_, module_name, _) in iter_modules([package_dir]):\\r\\n # print(module_name, self.ComType)\\r\\n if option.dataset.lower() == module_name.lower() :\\r\\n modelModule = importlib.import_module(\\\".\\\"+module_name)\\r\\n break\\r\\n \\r\\n # train data\\r\\n training_set = modelModule(train_df, clip_im_dir, matting_dir, transform, transform)\\r\\n train_loader = DataLoader(training_set, **params)\\r\\n \\r\\n \\r\\n #test data\\r\\n testing_set = modelModule(test_df, clip_im_dir, matting_dir, transform, transform)\\r\\n test_loader = DataLoader(testing_set, **params)\\r\\n \\r\\n return train_loader, test_loader\",\n \"def run_test(self):\\n self.output_analytics = self.run_inference()\\n self.output_df = pd.DataFrame(self.output_analytics)\",\n \"def test_transform(self):\\n result = transform((1, 2) ,2, 2)\\n self.assertEqual(result, (4 * PIXEL, 3 * PIXEL))\",\n \"def test(self, data):\\n num = len(data['y'])\\n self.reshape_mat(data)\\n\\n acc = 0\\n order = np.random.permutation(num)\\n for i in range(0, num):\\n x, y = data['x'][order[i]], data['y'][order[i]]\\n yhat = self.predict(self.w, x)\\n if y == yhat:\\n acc += 1\\n accuracy = acc / float(num)\\n print 'Test: acc = %f' % (accuracy * 100)\",\n \"def run_feature_extraction_tests():\\n test_feature_extraction()\\n test_distributed_feature_extraction()\\n test_multimodel_feature_extraction()\\n test_distributed_multimodel_feature_extraction()\",\n \"def test_iter(setup_teardown_file):\\n f = setup_teardown_file[3]\\n grp = f.create_group(\\\"test\\\")\\n\\n data = np.arange(30, dtype='f').reshape((10, 3))\\n dset = grp.create_dataset('foo', data=data)\\n for x, y in zip(dset, data):\\n assert len(x) == 3\\n assert np.array_equal(x, y)\",\n \"def test_load_one_transform(self):\\n self.add_transform(cond_artist=True, pattern_artist='Foo',\\n change_artist=True, to_artist='Bar')\\n self.app.load_data()\\n self.assertEqual(len(self.app.transforms), 1)\",\n \"def transform(self, dataset: NumpyOrPandas) -> NumpyDataset:\\n # checks here\\n super().transform(dataset)\\n # convert to accepted dtype and get attributes\\n dataset = dataset.to_pandas()\\n df = dataset.data\\n\\n # transform\\n roles = NumericRole()\\n outputs = []\\n for n, i in enumerate(df.columns):\\n new_arr = self.dicts[i][\\\"fg\\\"].transform(df[i].values)\\n output = dataset.empty().to_numpy()\\n output.set_data(new_arr, self.dicts[i][\\\"feats\\\"], roles)\\n outputs.append(output)\\n # create resulted\\n return dataset.empty().to_numpy().concat(outputs)\",\n \"def test(self) -> tf.contrib.data.Dataset:\\n return self.__test_dataset\",\n \"def test_load_ten_transforms(self):\\n for num in range(10):\\n self.add_transform(cond_artist=True, pattern_artist='Foo',\\n change_artist=True, to_artist='Bar',\\n commit=False)\\n self.app.db.commit()\\n self.app.load_data()\\n self.assertEqual(len(self.app.transforms), 10)\",\n \"def test(self, dataset):\\n model_path = os.path.join(self.check_point, 'model.pt')\\n if not os.path.exists(model_path):\\n raise Exception('Cannot find %s.' %model_path)\\n \\n self.model = torch.load(model_path)\\n _, _, stats, outputs = self._check_PSNR(dataset, is_test=True)\\n return stats, outputs\",\n \"def preprocess_dataset(dataset, transform, num_workers=8):\\n worker_fn = partial(_worker_fn, transform=transform)\\n start = time.time()\\n\\n pool = mp.Pool(num_workers)\\n dataset_transform = []\\n dataset_len = []\\n\\n for data in pool.map(worker_fn, dataset):\\n if data:\\n for _data in data:\\n dataset_transform.append(_data[:-1])\\n dataset_len.append(_data[-1])\\n\\n dataset = SimpleDataset(dataset_transform).transform(\\n lambda x: (x[0], x[1], x[2], x[3], x[4], x[5])\\n )\\n\\n end = time.time()\\n pool.close()\\n\\n print(\\\"Done! Transform dataset costs %.2f seconds.\\\" % (end - start))\\n return dataset, dataset_len\",\n \"def use(self,dataset):\\n features = []\\n outputs = np.zeros((len(dataset),1))\\n for xy in dataset:\\n x,y = xy\\n features += [x]\\n\\n for test,out in zip(features,outputs):\\n out[0] = self.tree.apply(test)\\n \\n return outputs\",\n \"def test_random_transform():\\n # given\\n train = pd.read_csv('source/train.csv')\\n train['labels'] = train['labels'].map(ast.literal_eval)\\n image_path = os.path.join('source', train.iloc[0].path)\\n all_labels = train.iloc[0]['labels']\\n for label in all_labels:\\n if label['class'] == 'whiteboard':\\n break\\n xn = [int(float(x)) for x in label['xn'].split(';')][:4]\\n yn = [int(float(y)) for y in label['yn'].split(';')][:4]\\n labels = np.zeros((4, 2))\\n for i in range(4):\\n labels[i, 0] = xn[i]\\n labels[i, 1] = yn[i]\\n img = cv2.imread(image_path)\\n kw = dict(rotation_range=15,\\n height_shift_range=0.2,\\n width_shift_range=0.2,\\n shear_range=0.3,\\n channel_shift_range=0.2,\\n horizontal_flip=True,\\n vertical_flip=True,\\n dim_ordering='tf',\\n seed=1313)\\n # when\\n rimg, rlabels = image_generator.random_transform(img, labels, **kw)\\n\\n # then just assert transformation isn't changed much\\n assert MultiPoint([[224.91875347, 58.05657097],\\n [673.57648317, 189.27244333],\\n [544.23308452, 381.12743459],\\n [70.73339963, 312.7359806]]\\n ).equals_exact(rlabels, 5)\",\n \"def test_inverse_transform_train(transform, outliers_solid_tsds):\\n original_df = outliers_solid_tsds.df.copy()\\n outliers_solid_tsds.fit_transform([transform])\\n outliers_solid_tsds.inverse_transform()\\n\\n assert (original_df == outliers_solid_tsds.df).all().all()\",\n \"def test_super_transform_called(self, mocker):\\n\\n df = d.create_df_2()\\n\\n x = ScalingTransformer(columns=[\\\"a\\\"], scaler=\\\"standard\\\")\\n\\n x.fit(df)\\n\\n expected_call_args = {0: {\\\"args\\\": (d.create_df_2(),), \\\"kwargs\\\": {}}}\\n\\n with h.assert_function_call(\\n mocker,\\n tubular.base.BaseTransformer,\\n \\\"transform\\\",\\n expected_call_args,\\n return_value=d.create_df_2(),\\n ):\\n\\n x.transform(df)\",\n \"def make_tests(test_descr=TRANSFORMS_TESTINFO):\\n tests = []\\n for _transform, tr_input, tr_output, _normalize, _subobjects in test_descr:\\n # load transform if necessary\\n if type(_transform) is type(''):\\n try:\\n _transform = load(_transform).register()\\n except MissingBinary:\\n # we are not interessted in tests with missing binaries\\n continue\\n except:\\n import traceback\\n traceback.print_exc()\\n continue\\n\\n if TR_NAMES is not None and not _transform.name() in TR_NAMES:\\n print 'skip test for', _transform.name()\\n continue\\n\\n class TransformTestSubclass(TransformTest):\\n input = input_file_path(tr_input)\\n output = output_file_path(tr_output)\\n transform = _transform\\n normalize = lambda x, y: _normalize(y)\\n subobjects = _subobjects\\n\\n tests.append(TransformTestSubclass)\\n\\n return tests\",\n \"def test_dataset(self):\\n self.assertIsInstance(self.dataset, LazyDataset)\\n\\n # Not loaded\\n self.assertIsNone(self.dataset._training)\\n self.assertIsNone(self.dataset._testing)\\n self.assertIsNone(self.dataset._validation)\\n self.assertFalse(self.dataset._loaded)\\n self.assertFalse(self.dataset._loaded_validation)\\n\\n # Load\\n try:\\n self.dataset._load()\\n except (EOFError, IOError):\\n self.skipTest('Problem with connection. Try this test again later.')\\n\\n self.assertIsInstance(self.dataset.training, TriplesFactory)\\n self.assertIsInstance(self.dataset.testing, TriplesFactory)\\n self.assertTrue(self.dataset._loaded)\\n\\n if self.autoloaded_validation:\\n self.assertTrue(self.dataset._loaded_validation)\\n else:\\n self.assertFalse(self.dataset._loaded_validation)\\n self.dataset._load_validation()\\n\\n self.assertIsInstance(self.dataset.validation, TriplesFactory)\\n\\n self.assertIsNotNone(self.dataset._training)\\n self.assertIsNotNone(self.dataset._testing)\\n self.assertIsNotNone(self.dataset._validation)\\n self.assertTrue(self.dataset._loaded)\\n self.assertTrue(self.dataset._loaded_validation)\\n\\n self.assertEqual(self.dataset.num_entities, self.exp_num_entities)\\n self.assertEqual(self.dataset.num_relations, self.exp_num_relations)\\n\\n num_triples = sum(\\n triples_factory.num_triples for\\n triples_factory in (self.dataset._training, self.dataset._testing, self.dataset._validation)\\n )\\n if self.exp_num_triples_tolerance is None:\\n self.assertEqual(self.exp_num_triples, num_triples)\\n else:\\n self.assertAlmostEqual(self.exp_num_triples, num_triples, delta=self.exp_num_triples_tolerance)\\n\\n # Test caching\\n start = timeit.default_timer()\\n _ = self.dataset.training\\n end = timeit.default_timer()\\n # assert (end - start) < 1.0e-02\\n self.assertAlmostEqual(start, end, delta=1.0e-02, msg='Caching should have made this operation fast')\",\n \"def run_suite():\\n print(\\\"*Input*\\\")\\n input_str = get_input()\\n stripped = strip(input_str)\\n\\n print(\\\"*Transform*\\\")\\n operation, transformed = transform(stripped)\\n\\n print(\\\"*Output*\\\")\\n output(operation, transformed)\",\n \"def test(self, net: nn.Module, clean_data: CSVTextDataset, triggered_data: CSVTextDataset,\\n clean_test_triggered_labels_data: CSVTextDataset,\\n torch_dataloader_kwargs: dict = None) -> dict:\\n test_data_statistics = {}\\n test_data_statistics['clean_metrics'] = None\\n test_data_statistics['triggered_metrics'] = None\\n test_data_statistics['clean_test_metrics'] = None\\n net.eval()\\n\\n triggered_counts = None\\n clean_test_counts = None\\n test_counts = None\\n pin_memory = False\\n if self.device.type != 'cpu':\\n pin_memory = True\\n\\n # drop_last=True is from: https://stackoverflow.com/questions/56576716\\n data_loader_kwargs_in = dict(batch_size=1, pin_memory=pin_memory, drop_last=True, shuffle=False)\\n if torch_dataloader_kwargs:\\n data_loader_kwargs_in.update(torch_dataloader_kwargs)\\n logger.info('DataLoader[Test] kwargs=' + str(torch_dataloader_kwargs))\\n data_loader = self.convert_dataset_to_dataiterator(clean_data, batch_size=1)\\n\\n # Test the classification accuracy on clean data only, for all labels.\\n test_acc, test_n_total, test_n_correct, _, clean_counts = self._eval_acc(data_loader, net)\\n\\n acc_per_label = \\\"{\\\"\\n for k in test_n_total.keys():\\n acc_per_label += \\\"{}: {}, \\\".format(k, 0 if test_n_total[k] == 0 else float(test_n_correct[k]) / float(\\n test_n_total[k]))\\n acc_per_label += \\\"}\\\"\\n\\n test_data_statistics['clean_accuracy'] = test_acc\\n test_data_statistics['clean_n_total'] = test_n_total\\n test_data_statistics['clean_per_label_accuracy'] = acc_per_label\\n logger.info(\\\"Accuracy on clean test data: %0.02f\\\" % (test_data_statistics['clean_accuracy'],))\\n logger.info('Per label test accuracy: {}'.format(acc_per_label))\\n logger.info('Total per label correct: {}'.format(test_n_correct))\\n logger.info('Total per label: {}'.format(test_n_total))\\n\\n if triggered_data is not None:\\n # Test the classification accuracy on triggered data only, for all labels.\\n # we set batch_size=1 b/c\\n data_loader = self.convert_dataset_to_dataiterator(triggered_data, batch_size=1)\\n test_acc, test_n_total, test_n_correct, _, triggered_counts = self._eval_acc(data_loader, net)\\n acc_per_label = \\\"{\\\"\\n for k in test_n_total.keys():\\n acc_per_label += \\\"{}: {}, \\\".format(k, 0 if test_n_total[k] == 0 else float(test_n_correct[k]) / float(\\n test_n_total[k]))\\n acc_per_label += \\\"}\\\"\\n\\n test_data_statistics['triggered_accuracy'] = test_acc\\n test_data_statistics['triggered_n_total'] = test_n_total\\n test_data_statistics['triggered_per_label_accuracy'] = acc_per_label\\n\\n logger.info(\\\"Accuracy on triggered test data: %0.02f for n=%s\\\" %\\n (test_data_statistics['triggered_accuracy'], str(test_n_total)))\\n\\n self.ner_metrics.add_best(self.best_epoch, clean_counts, triggered_counts)\\n\\n # Write the report for ner_metrics\\n self.ner_metrics.write_per_epoch(self.ner_per_epoch_report_filepath)\\n self.ner_metrics.write_best_epoch(self.ner_report_filepath)\\n\\n return test_data_statistics\",\n \"def test_dataset_from_file(train_dataset):\\n dummy = \\\"justo. Praesent luctus. Curabitur egestas nunc sed libero. Proin sed\\\"\\n assert train_dataset[0][0] == dummy\\n assert train_dataset[0][1] == '6'\",\n \"def test_11_dataset(self, example):\\n example.zonenumbers_i = np.array([100, 200, 300])\\n example.groupnames_g = np.array(['Female', 'Male'], dtype='O')\\n example.create_ds()\\n assert isinstance(example.ds, xr.Dataset)\\n for attr, dtype in example.dtypes.items():\\n data_array = example.ds[attr]\\n # test if the shapes are correct\\n if dtype.shape:\\n np.testing.assert_array_equal(dtype.get_shape(example),\\n data_array.shape,\\n 'shape not correct')\\n else:\\n # not initialized array\\n assert not np.any(data_array.shape), 'shape not initialized'\\n #test if the datatypes are correct\\n assert np.dtype(dtype.dtype) == data_array.dtype, 'dtype not correct'\\n print(example.ds)\",\n \"def test(self, dataset): \\n predictions = np.zeros(len(dataset), int)\\n \\n accuracy = self.random_forest.score(dataset[:,:-1], dataset[:,-1]) # Predict and compute accuracy.\\n predictions = self.predict(dataset[:,:-1]) # Predict and return list of predictions.\\n \\n return predictions, accuracy\",\n \"def test_transform_prep():\\n args = get_layer('transform', 'manual', 'temporal', False, True, window=2, step_size=3)\\n run_layer(*args)\",\n \"def test_dataset_autogen(autogen_dataset):\\n train_dummy = \\\"eget, venenatis a, magna. Lorem ipsum dolor sit amet, consectetuer\\\"\\n val_dummy = \\\"leo. Vivamus nibh dolor, nonummy ac, feugiat non, lobortis quis,\\\"\\n test_dummy = \\\"turpis egestas. Aliquam fringilla cursus purus. Nullam scelerisque neque sed\\\"\\n\\n assert autogen_dataset.train[0][0] == train_dummy\\n assert autogen_dataset.train[0][1] == '8'\\n assert len(autogen_dataset.train) == 64\\n\\n assert autogen_dataset.val[0][0] == val_dummy\\n assert autogen_dataset.val[0][1] == '1'\\n assert len(autogen_dataset.val) == 16\\n\\n assert autogen_dataset.test[0][0] == test_dummy\\n assert autogen_dataset.test[0][1] == '6'\\n assert len(autogen_dataset.test) == 20\",\n \"def setUp(self):\\n self.dataset = get_test_dataset()\",\n \"def test_data_manipulation(self):\\n target_name = self.project['target']['name']\\n self.api_mock.return_value.get_metadata.return_value = [\\n {'_id': '0',\\n 'pid': '1',\\n 'created': datetime.datetime.now(),\\n 'name':'universe',\\n 'originalName': 'credit-sample-200.csv',\\n 'varTypeString': 'NN',\\n 'shape': [2, 100],\\n 'controls':{},\\n 'columns': [[1,target_name,0],[3,\\\"age\\\",0]],\\n 'files': ['projects/' + str(self.pid) + '/raw/' + self.testdatafile],\\n 'typeConvert': {}},\\n {'_id': '1',\\n 'pid': '1',\\n 'name':'test',\\n 'originalName': 'credit-sample-200.csv',\\n 'created': datetime.datetime.now(),\\n 'varTypeString': 'NN',\\n 'shape': [2, 100],\\n 'controls':{},\\n 'columns': [[1,target_name,0],[3,\\\"age\\\",0]],\\n 'files': ['projects/' + str(self.pid) + '/raw/' + self.testdatafile],\\n 'typeConvert': {}},\\n {'_id': '2',\\n 'pid': '1',\\n 'name':'new',\\n 'created': datetime.datetime.now(),\\n 'originalName': 'credit-sample-200.csv',\\n 'newdata':True,\\n 'controls':{},\\n 'shape': [2, 100],\\n 'varTypeString': 'NN',\\n 'columns': [[1,target_name,0],[3,\\\"age\\\",0]],\\n 'files': ['projects/' + str(self.pid) + '/raw/' + self.testdatafile],\\n 'typeConvert': {}}]\\n request = WorkerRequest({'pid': '1', 'uid': '1', 'dataset_id': '1',\\n 'command': 'fit', 'max_reps': 0,\\n 'samplepct': 100})\\n\\n #target\\n #this will map the target values to (0,1) because target type is Binary\\n target_vector = self.dataprocessor.target_vector()\\n target_series = target_vector['main']\\n self.assertItemsEqual(np.unique(target_series), [0,1])\\n\\n #this will be none because 'holdout_pct' isn't set in the project data\\n self.assertIsNone(target_vector['holdout'])\\n\\n #prediction dataset\\n predictors = self.dataprocessor.predictors()\\n pred_dataframe = predictors['1']['main']\\n self.assertItemsEqual(list(pred_dataframe.columns), [\\\"age\\\"])\\n self.assertEqual(self.dataprocessor.get_vartypestring_without_target('1'), \\\"N\\\")\\n\\n request = WorkerRequest({'pid': '1', 'uid': '1', 'dataset_id': '1', 'scoring_dataset_id': '2', 'command': 'predict', 'max_reps': 0, 'samplepct':100})\\n dp2 = DataProcessor(request)\\n data = dp2.request_datasets()\\n self.assertEqual(data.keys(), ['1'])\\n self.assertEqual(data['1'].keys(), ['scoring', 'vartypes'])\\n scoring_data = data['1']['scoring']\\n vartypes = data['1']['vartypes']\\n self.assertEqual(list(scoring_data.columns), [\\\"age\\\"])\\n self.assertEqual(vartypes, \\\"N\\\")\",\n \"def fit_andor_transform(X_train, X_test):\\n fit_transformed_df = mapper.fit_transform(X_train)\\n\\n X_np = np.asarray(fit_transformed_df)\\n X_np_test = np.asarray(mapper.transform(X_test))\\n\\n return X_np, X_np_test\",\n \"def test_transform_interface_repr(example_tsds: TSDataset) -> None:\\n trend_transform = TrendTransform(in_column=\\\"target\\\", detrend_model=LinearRegression(), model=\\\"rbf\\\")\\n out_column = f\\\"regressor_{trend_transform.__repr__()}\\\"\\n result = trend_transform.fit_transform(example_tsds.df)\\n for seg in result.columns.get_level_values(0).unique():\\n assert out_column in result[seg].columns\",\n \"def test_data_augmentation_transforms():\\n\\n transforms_list = get_data_augmentation_transforms(inp_size=(100, 50), pixel_mean=[0.5], pixel_std=[0.3]).transforms\\n\\n assert len(transforms_list) > 3\\n\\n # last 3 should be fundamental\\n augmentation_transforms = Compose(transforms_list[:-3])\\n\\n try:\\n inp_img = Image.fromarray(np.loadtxt(\\\"proj6_code/proj6_unit_tests/test_data/transform_inp.txt\\\", dtype=\\\"uint8\\\"))\\n\\n except:\\n inp_img = Image.fromarray(\\n np.loadtxt(\\\"../proj6_code/proj6_unit_tests/test_data/transform_inp.txt\\\", dtype=\\\"uint8\\\")\\n )\\n augmented_img = augmentation_transforms(inp_img)\\n assert isinstance(augmented_img, type(inp_img))\\n assert not np.array_equal(augmented_img, inp_img)\",\n \"def test_transform(self):\\n t = Identity()\\n assert t.transform(\\\"yo\\\") == \\\"yo\\\"\",\n \"def test_X_returned(self, df, expected):\\n\\n x = BaseTransformer(columns=\\\"a\\\", copy=True)\\n\\n df_transformed = x.transform(X=df)\\n\\n h.assert_equal_dispatch(\\n expected=expected,\\n actual=df_transformed,\\n msg=\\\"Check X returned from transform\\\",\\n )\",\n \"def test(model, args, test_loader):\\n with torch.no_grad():\\n model.eval()\\n test_loss = 0\\n correct = 0\\n # Data and target are a single pair of images and labels.\\n for data, target in tqdm(test_loader, desc='Batching Test Data'):\\n if args.cuda:\\n data, target = data.cuda(), target.cuda()\\n pred, tloss = make_prediction(data, target)\\n test_loss += tloss\\n correct += pred.eq(target.data.view_as(pred)).cpu().sum()\\n\\n test_loss /= len(test_loader.dataset)\\n uf.box_print('Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)'.format(\\n test_loss, correct, len(test_loader.dataset),\\n 100. * correct / len(test_loader.dataset)))\",\n \"def test_machine_learning():\",\n \"def test_single_image_dataset_train(mocker, simple_img):\\n\\n # This is in X, Y cooridnates\\n fake_random_data = torch.Tensor(\\n np.array(\\n [\\n [0, 0], # top left\\n [0, 1], # bottom left\\n [1, 0], # top right\\n ]\\n )\\n )\\n\\n mock_random = mocker.patch(\\\"dataset.torch.rand\\\")\\n mock_random.return_value = fake_random_data\\n\\n dataset = SingleImageDataset(simple_img, 3, normalize=False)\\n assert len(dataset) == 9\\n\\n dataloader = DataLoader(dataset, batch_size=None, batch_sampler=None)\\n\\n n_iter = 0\\n for x, y in dataloader:\\n n_iter += 1\\n x = x.numpy()\\n y = y.numpy()\\n expected_x = np.array(\\n [\\n [-1, -1], # Top left\\n [-1, 1], # Bottom left\\n [1, -1], # Top right\\n ]\\n )\\n assert (expected_x == x).all()\\n\\n expected_y = np.array(\\n [\\n [1.0, 2.0, 3.0],\\n [4.0, 5.0, 6.0],\\n [7.0, 8.0, 9.0],\\n ]\\n )\\n assert (expected_y == y).all()\\n\\n assert n_iter == 9\",\n \"def run_tests():\\n source1 = TextModel('hilary_speaches')\\n source1.add_file('hilary_source_text.txt')\\n\\n source2 = TextModel('bernie_speaches')\\n source2.add_file('bernie_source_text.txt')\\n\\n new1 = TextModel('trump_speach')\\n new1.add_file('trump_text.txt')\\n new1.classify(source1, source2)\\n\\n new2 = TextModel('hilary_test')\\n new2.add_file('hilary_test.txt')\\n new2.classify(source1, source2)\\n\\n new3 = TextModel('bernie_test')\\n new3.add_file('bernie_test.txt')\\n new3.classify(source1, source2)\\n\\n new4 = TextModel('bill_clinton_test')\\n new4.add_file('bill_clinton_source.txt')\\n new4.classify(source1, source2)\",\n \"def test_regression(test_data, model, criterion, batch_size, device, collate_fn=None): \\n \\n # Set model to evaluation mode\\n model.eval()\\n test_loss = 0\\n\\n # Create data loader\\n data = DataLoader(test_data, batch_size=batch_size, collate_fn=collate_fn)\\n \\n # Iterate through data by batch of observations\\n for feature, target_class in data:\\n \\n # Load data to specified device\\n feature, target_class = feature.to(device), target_class.to(device)\\n \\n # Set no update to gradients\\n with torch.no_grad():\\n \\n # Make predictions\\n output = model(feature)\\n \\n # Calculate loss for given batch\\n loss = criterion(output, target_class)\\n \\n # Calculate global loss\\n test_loss += loss.item()\\n \\n return test_loss / len(test_data), np.sqrt(test_loss / len(test_data))\",\n \"def test_process_data(self):\\n pass\",\n \"def refresh_test_dataset(self):\\n inputs_id, inputs_starts, inputs_paths, inputs_ends, inputs_label = self.build_data(self.reader, self.test_items, self.option.max_path_length)\\n self.test_dataset = CodeDataset(inputs_id, inputs_starts, inputs_paths, inputs_ends, inputs_label)\",\n \"def fit_test(self):\",\n \"def test_dataset():\\n # File paths\\n intervals_file = \\\"example_files/intervals.bed\\\"\\n target_file = \\\"example_files/targets.tsv\\\"\\n gtf_file = \\\"example_files/gencode.v24.annotation_chr22.gtf\\\"\\n fasta_file = \\\"example_files/hg38_chr22.fa\\\"\\n ds = SeqDistDataset(intervals_file, fasta_file, gtf_file, target_file)\\n\\n ds[0]\\n ds[10]\\n it = ds.batch_iter(32)\\n next(it)\",\n \"def test_fit_transform_many_segments(example_tsds: TSDataset) -> None:\\n out_column = \\\"regressor_result\\\"\\n example_tsds_original = deepcopy(example_tsds)\\n trend_transform = _TrendTransform(\\n in_column=\\\"target\\\",\\n change_point_model=Binseg(),\\n detrend_model=LinearRegression(),\\n n_bkps=5,\\n out_column=out_column,\\n )\\n example_tsds.fit_transform([trend_transform])\\n for segment in example_tsds.segments:\\n segment_slice = example_tsds[:, segment, :][segment]\\n segment_slice_original = example_tsds_original[:, segment, :][segment]\\n assert sorted(segment_slice.columns) == sorted([\\\"target\\\", out_column])\\n assert (segment_slice[\\\"target\\\"] == segment_slice_original[\\\"target\\\"]).all()\\n residue = segment_slice_original[\\\"target\\\"] - segment_slice[out_column]\\n assert residue.mean() < 1\",\n \"def get_dataset(\\n dataset_name: str = \\\"CIFAR100\\\",\\n transform_train: str = \\\"simple_augment_train_cifar100\\\",\\n transform_test: str = \\\"simple_augment_test_cifar100\\\",\\n transform_train_params: Dict[str, int] = None,\\n transform_test_params: Dict[str, int] = None,\\n) -> Tuple[VisionDataset, VisionDataset]:\\n if not transform_train_params:\\n transform_train_params = dict()\\n\\n # preprocessing policies\\n transform_train = getattr(\\n __import__(\\\"src.augmentation.policies\\\", fromlist=[\\\"\\\"]),\\n transform_train,\\n )(**transform_train_params)\\n transform_test = getattr(\\n __import__(\\\"src.augmentation.policies\\\", fromlist=[\\\"\\\"]),\\n transform_test,\\n )(**transform_test_params)\\n\\n # pytorch dataset\\n \\n # Dataset = getattr(__import__(\\\"torchvision.datasets\\\", fromlist=[\\\"\\\"]), dataset_name)\\n # trainset = Dataset(\\n # root=\\\"save/data\\\", train=True, download=True, transform=transform_train\\n # )\\n # testset = Dataset(\\n # root=\\\"save/data\\\", train=False, download=False, transform=transform_test\\n # )\\n\\n # return trainset, testset\\n \\n # Densedepth dataset\\n from src.densedepth_data import getTrainingTestingData\\n train_loader, test_loader = getTrainingTestingData(10,40)\\n\\n return train_loader, test_loader\",\n \"def test_data():\\n global _MEAN # pylint: disable=global-statement\\n _np.random.seed(1)\\n view = _skdc10.view.OfficialImageClassificationTask()\\n permutation = _np.random.permutation(range(10000))\\n if _MEAN is None:\\n _MEAN = view.train.x.reshape((50000 * 32 * 32, 3)).mean(axis=0)\\n return ((view.test.x[:10000, :][permutation, :] - _MEAN).\\n transpose((0, 3, 1, 2)).astype('float32'),\\n view.test.y[:10000][permutation].reshape((10000, 1)).astype('float32'))\",\n \"def test_integration():\\n\\n p = pipeline.Pipeline(\\n FX_TRAIN,\\n FX_TEST,\\n FX_LOOKUP,\\n RESULTS_DIR\\n )\\n\\n p.run()\\n\\n assert os.path.isfile(p.path(pipeline.PRED_FILE))\",\n \"def run_data (arguments):\\n if arguments.define_labels:\\n data.define_labels()\\n elif arguments.preprocess:\\n # Preprocess from data_raw --> data_preprocessed\\n data.preprocess()\\n elif arguments.annotate:\\n # Annotate from data_preprocessed --> data_annotated\\n reverse = False # DEBUG\\n annotator.annotate(reverse)\\n elif arguments.split:\\n # Split from data_annotated --> train.txt/valid.txt\\n restrict = 100 # Default: Keep 100% of all files\\n splitter.train_valid(restrict_to=restrict)\",\n \"def _proc_dataset(d):\\n # merge 2dseq complex frame group if present\\n if d.is_complex and d.type == '2dseq':\\n d = FrameGroupMerger().merge(d, 'FG_COMPLEX')\\n\\n # prepare the data array\\n if d.is_svs:\\n data = _prep_data_svs(d)\\n elif d.is_mrsi:\\n data = _prep_data_mrsi(d)\\n else:\\n data = d.data\\n\\n # get properties\\n properties = d.to_dict()\\n\\n # some Bruker datasets do not have affine property\\n if d.type == 'fid': if not 'affine' in properties: properties.update({'affine':np.identity(4)})\\n \\n yield data, properties\",\n \"def test(taskID, solve, data):\\n print(taskID)\\n train_input, train_output, test_input, test_output = data\\n print(\\\"Training grids\\\")\\n for x, y in zip(train_input, train_output):\\n yhat = solve(x)\\n show_result(x, y, yhat)\\n print(\\\"Test grids\\\")\\n for x, y in zip(test_input, test_output):\\n yhat = solve(x)\\n show_result(x, y, yhat)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7348205","0.7184683","0.71561563","0.7091412","0.7063284","0.7034932","0.68949515","0.68701756","0.6851518","0.6554057","0.6454966","0.63948965","0.63236576","0.62374663","0.6223602","0.61879635","0.6180748","0.6177663","0.6177561","0.6172904","0.6155157","0.61071193","0.6095829","0.6083418","0.605242","0.6045366","0.6030996","0.6015704","0.60139453","0.6004977","0.5996904","0.5993506","0.59779507","0.5973977","0.59660995","0.5963188","0.59602636","0.595659","0.5953072","0.59508145","0.59471905","0.5930645","0.59279764","0.59159124","0.58913","0.58808506","0.58796924","0.58712494","0.58623815","0.5862008","0.5861971","0.585357","0.58424234","0.5813001","0.580447","0.5792636","0.579123","0.57856166","0.5782792","0.5779871","0.57771045","0.57758856","0.57716","0.57700264","0.57695687","0.576389","0.57620317","0.5760082","0.57600063","0.5756252","0.57477295","0.5741378","0.5737649","0.57305735","0.57233244","0.57190615","0.57095426","0.5706195","0.57034755","0.5700066","0.5697509","0.56946176","0.56932646","0.5690143","0.5689217","0.5677452","0.56744033","0.5670678","0.56696147","0.56694585","0.5662882","0.5660194","0.56589055","0.56576127","0.56512123","0.5648505","0.5643806","0.563454","0.563177","0.56309307"],"string":"[\n \"0.7348205\",\n \"0.7184683\",\n \"0.71561563\",\n \"0.7091412\",\n \"0.7063284\",\n \"0.7034932\",\n \"0.68949515\",\n \"0.68701756\",\n \"0.6851518\",\n \"0.6554057\",\n \"0.6454966\",\n \"0.63948965\",\n \"0.63236576\",\n \"0.62374663\",\n \"0.6223602\",\n \"0.61879635\",\n \"0.6180748\",\n \"0.6177663\",\n \"0.6177561\",\n \"0.6172904\",\n \"0.6155157\",\n \"0.61071193\",\n \"0.6095829\",\n \"0.6083418\",\n \"0.605242\",\n \"0.6045366\",\n \"0.6030996\",\n \"0.6015704\",\n \"0.60139453\",\n \"0.6004977\",\n \"0.5996904\",\n \"0.5993506\",\n \"0.59779507\",\n \"0.5973977\",\n \"0.59660995\",\n \"0.5963188\",\n \"0.59602636\",\n \"0.595659\",\n \"0.5953072\",\n \"0.59508145\",\n \"0.59471905\",\n \"0.5930645\",\n \"0.59279764\",\n \"0.59159124\",\n \"0.58913\",\n \"0.58808506\",\n \"0.58796924\",\n \"0.58712494\",\n \"0.58623815\",\n \"0.5862008\",\n \"0.5861971\",\n \"0.585357\",\n \"0.58424234\",\n \"0.5813001\",\n \"0.580447\",\n \"0.5792636\",\n \"0.579123\",\n \"0.57856166\",\n \"0.5782792\",\n \"0.5779871\",\n \"0.57771045\",\n \"0.57758856\",\n \"0.57716\",\n \"0.57700264\",\n \"0.57695687\",\n \"0.576389\",\n \"0.57620317\",\n \"0.5760082\",\n \"0.57600063\",\n \"0.5756252\",\n \"0.57477295\",\n \"0.5741378\",\n \"0.5737649\",\n \"0.57305735\",\n \"0.57233244\",\n \"0.57190615\",\n \"0.57095426\",\n \"0.5706195\",\n \"0.57034755\",\n \"0.5700066\",\n \"0.5697509\",\n \"0.56946176\",\n \"0.56932646\",\n \"0.5690143\",\n \"0.5689217\",\n \"0.5677452\",\n \"0.56744033\",\n \"0.5670678\",\n \"0.56696147\",\n \"0.56694585\",\n \"0.5662882\",\n \"0.5660194\",\n \"0.56589055\",\n \"0.56576127\",\n \"0.56512123\",\n \"0.5648505\",\n \"0.5643806\",\n \"0.563454\",\n \"0.563177\",\n \"0.56309307\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6279633"},"document_rank":{"kind":"string","value":"13"}}},{"rowIdx":74699,"cells":{"query":{"kind":"string","value":"Creates a dataloader from dataset"},"document":{"kind":"string","value":"def data_loader(data, train=True):\n\n loader_config = {\n 'batch_size':64,\n 'shuffle':train\n }\n \n return torch.utils.data.DataLoader(data, **loader_config)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def create_dataloader(data):\r\n input_ids = torch.LongTensor([sent['input_ids'] for sent in data])\r\n input_mask = torch.LongTensor([sent['input_mask'] for sent in data])\r\n segment_ids = torch.LongTensor([sent['segment_ids'] for sent in data])\r\n label_ids = torch.LongTensor([sent['label_ids'] for sent in data])\r\n\r\n dataset = TensorDataset(input_ids, input_mask, segment_ids, label_ids)\r\n\r\n train_sampler = RandomSampler(dataset)\r\n dataloader = DataLoader(dataset, sampler=train_sampler, batch_size=BATCH_SIZE)\r\n\r\n return dataloader","def create_dataset(opt):\n data_loader = CustomDatasetDataLoader(opt)\n dataset = data_loader.load_data()\n return dataset","def create_dataset(opt):\n\tdata_loader = CustomDatasetDataLoader(opt)\n\tdataset = data_loader.load_data()\n\treturn dataset","def train_dataloader(self) -> torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_train, **self.dl_kwargs)","def dataloader(self):\n\n # load / split data\n train_data = self.data.get_train_data()\n if self.args.use_dev:\n train_data, dev_data = self.data.split_data(train_data)\n test_data = self.data.get_test_data()\n\n #print(train_data[0])\n #print(dev_data[0])\n #print(test_data[0])\n\n # build dataset\n train_dataset = self.loader.build_dataset(\n train_data, \n self.args.train_max_seq_len)\n train_loader = self.loader.build_dataloader(\n train_dataset, 'train')\n\n test_dataset = self.loader.build_dataset(\n test_data,\n self.args.eval_max_seq_len)\n test_loader = self.loader.build_dataloader(\n test_dataset, 'test')\n\n if self.args.use_dev:\n dev_dataset = self.loader.build_dataset(\n dev_data,\n self.args.eval_max_seq_len)\n dev_loader = self.loader.build_dataloader(\n dev_dataset, 'dev')\n return train_loader, dev_loader, test_loader\n else:\n return train_loader, test_loader","def torch_dataset_loader(dataset, batch_size, shuffle, kwargs):\n loader = DataLoader(TorchData(dataset),\n batch_size=batch_size,\n shuffle=shuffle,\n **kwargs)\n return loader","def train_dataloader(self) -> DataLoader:\n return DataLoader(\n self.train_dataset,\n batch_size=self.hparams.batch_size,\n shuffle=True,\n num_workers=multiprocessing.cpu_count(),\n )","def dataloader(self):\n return DataLoader","def to_DataLoader(self, **kwargs):\r\n return DataLoader(self, **kwargs)","def get_dataloader(self):\n shuffle = True if self.mode == \"train\" else False\n return DataLoader(self.get_dataset(), batch_size=self.batch_size, shuffle = shuffle, \n collate_fn=create_mini_batch)","def _get_dataloader(samples, batch_size):\n print(\"Cogiendo dataloader\")\n return DataLoader(samples, shuffle=True, batch_size=batch_size)","def test_dataloader(self) -> torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_test, **self.dl_kwargs)","def create_dataloader(datafile, dataset_type, batch_size, mechanism, shuffle=False):\n dataset = MazeDataset(datafile, dataset_type)\n assert dataset.num_actions == mechanism.num_actions\n return torch.utils.data.DataLoader(\n dataset, batch_size=batch_size, shuffle=shuffle, num_workers=0)","def build_dataloader(bs, shfle):\n # change get_labels to correct version (classification vs regression)\n dataset = TensorDataset(rand_data(), get_labels())\n dataset = TensorDataset(rand_data(), get_regression_labels())\n\n return DataLoader(dataset, batch_size=bs, shuffle=shfle, num_workers=0)","def get_dataloader(dataset, batchsize):\n\n train_set_size = int(0.8 * dataset.__len__())\n train_indices = np.random.choice(np.arange(dataset.__len__()),\n train_set_size, replace=False)\n train_sampler = SubsetRandomSampler(train_indices)\n\n val_indices = np.setdiff1d(np.arange(dataset.__len__()),\n train_indices, assume_unique=True)\n val_sampler = SubsetRandomSampler(val_indices)\n\n trainloader = DataLoader(dataset, batch_size=batchsize,\n sampler=train_sampler, num_workers=2)\n valloader = DataLoader(dataset, batch_size=batchsize,\n sampler=val_sampler, num_workers=2)\n\n return trainloader, valloader","def create_train_dataloader(configs):\n train_lidar_aug = OneOf([\n Random_Rotation(limit_angle=np.pi / 4, p=1.0),\n Random_Scaling(scaling_range=(0.95, 1.05), p=1.0),\n ], p=0.66)\n train_dataset = KittiDataset(configs, mode='train', lidar_aug=train_lidar_aug, hflip_prob=configs.hflip_prob,\n num_samples=configs.num_samples)\n train_sampler = None\n if configs.distributed:\n train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)\n train_dataloader = DataLoader(train_dataset, batch_size=configs.batch_size, shuffle=(train_sampler is None),\n pin_memory=configs.pin_memory, num_workers=configs.num_workers, sampler=train_sampler)\n\n return train_dataloader, train_sampler","def train_dataloader(self) -> DataLoader:\n return self._custom_data_loader()","def from_torch(\n dataset: \"torch.utils.data.Dataset\",\n) -> Dataset:\n return from_items(list(dataset))","def test_dataloader(self) -> DataLoader:\n return DataLoader(\n self.test_dataset,\n batch_size=self.hparams.batch_size,\n shuffle=False,\n num_workers=multiprocessing.cpu_count(),\n )","def get_dataloader(params, format_name='hdf5', **kwargs):\n \n Provider = get_proper_provider(format_name)(params.modality)\n \n return DataLoader(Provider(params.dataset_path,\n seq_length=params.seq_length),\n batch_size=params.batch_size,\n shuffle=params.is_training,\n num_workers=params.num_workers,\n pin_memory=params.cuda,\n collate_fn=pad_collate)","def create_loader(dataset: Dataset, cfg: trainer_configs.BaseDatasetConfig, batch_size: int, *,\r\n collate_fn: Optional[Callable[[List[Any]], Any]] = None) -> DataLoader:\r\n # return DataLoader(\r\n # dataset, batch_size=batch_size, num_workers=cfg.num_workers,\r\n # drop_last=cfg.drop_last, collate_fn=collate_fn) # type: ignore\r\n return DataLoader(\r\n dataset, batch_size=batch_size, shuffle=cfg.shuffle, num_workers=cfg.num_workers,\r\n drop_last=cfg.drop_last, collate_fn=collate_fn) # type: ignore\r","def _create_dataset(self, *data):\n # Make sure data is a tuple of dense tensors\n data = [self._to_torch(x, dtype=torch.FloatTensor) for x in data]\n return TensorDataset(*data)","def get_dataloader(self, cid, batch_size=None, type=\"train\"):\n dataset = self.get_dataset(cid, type)\n batch_size = len(dataset) if batch_size is None else batch_size\n data_loader = DataLoader(dataset, batch_size=batch_size)\n return data_loader","def get_loader(data, json, batch_size, shuffle, num_workers):\n dataset = FinNumDataset(data, json)\n\n data_loader = torch.utils.data.DataLoader(dataset=dataset,\n batch_size=batch_size,\n shuffle=shuffle,\n num_workers=num_workers,\n collate_fn=collate_fn)\n return data_loader","def Dataloader(dataset, batch_size, shuffle=False, drop_last=False, shuffle_buffer_size=10000):\n\n if shuffle:\n dataset = Shuffle(dataset, buffer_size=shuffle_buffer_size)\n\n dataset = Batch(dataset, batch_size=batch_size, drop_last=drop_last)\n dataset = dataset.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)\n\n return dataset","def _custom_data_loader(self) -> DataLoader:\n dataloaders = DataLoader(self.dataset, batch_size=1)\n return dataloaders","def test_dataloader(self) -> data.DataLoader:\n return data.DataLoader(dataset=self.datasets['test'], batch_size=self.batch_size,\n num_workers=self.num_workers, shuffle=False, pin_memory=False)","def create_dataset(dataset_type, soruce, opts): \n\n p = PreProcessor(dataset_type, opts)\n\n # If we are NOT running \"implementation.py\", we read the data from file\n if dataset_type == \"train\" or dataset_type == \"dev\" or dataset_type == \"test\":\n path_to_data = soruce\n p.read_labelled_data(path_to_data) \n # Otherwise, we read the sentence that \"implementation.py\" gave us\n elif dataset_type == \"submit\":\n submission_sentence = soruce\n p.read_test_data(submission_sentence)\n\n # Encode all the data to a list of torchTensors\n encoded_tokens, encoded_pred, encoded_tokens_pos, encoded_labels = p.encode_all_data()\n # Create SRL dataset\n dataset = SRLDataset(x=encoded_tokens, pr=encoded_pred, p=encoded_tokens_pos, y=encoded_labels)\n print(\"{} dataset size is {}\".format(dataset_type, len(dataset)))\n\n if dataset_type == \"train\" or dataset_type == \"dev\" or dataset_type == \"test\":\n return dataset\n elif dataset_type == \"submit\":\n return dataset, p.list_l_original_predicates","def data_loader(\n self, batch_size: int = 1, iter_steps: int = 0, batch_as_list: bool = True\n ) -> DataLoader:\n data = self.data\n datasets = []\n\n for _, dat in data.items():\n datasets.append(dat.dataset())\n\n if len(datasets) < 1:\n raise FileNotFoundError(\n \"no datasets available for this model to create a loader from\"\n )\n\n return DataLoader(\n *datasets,\n batch_size=batch_size,\n iter_steps=iter_steps,\n batch_as_list=batch_as_list,\n )","def get_dataloader(self, hdf_path, data_description=None):\r\n if data_description is None:\r\n data_description = \"data\"\r\n print(f\"* Loading preprocessed {data_description}.\", flush=True)\r\n\r\n dataset = HDFDataset(hdf_path)\r\n dataloader = BlockDataLoader(dataset=dataset,\r\n batch_size=self.C.batch_size,\r\n block_size=self.C.block_size,\r\n shuffle=True,\r\n n_workers=self.C.n_workers,\r\n pin_memory=True)\r\n self.print_time_elapsed()\r\n\r\n return dataloader","def data_loader(root, batch_size=64):\n input_transform = get_transform()\n dataset = CustomDataset(root, input_transform)\n return data.DataLoader(dataset=dataset,\n batch_size=batch_size,\n shuffle=False)","def _init_dataset(self, data_config, split='train'):\n assert split in {'train', 'valid'}\n\n # load datasets\n print(f'Load {split} dataset')\n if data_config['type'] == 'npy':\n dataset = MSDMelDataset(\n data_config['mel_root'], data_config[f'{split}_tids_fn'],\n data_config['label_fn'], on_mem=data_config['on_mem'],\n ignore_intersection=data_config['ignore_label_intersection'],\n transform=ToVariable())\n\n elif data_config['type'] == 'hdf':\n dataset = MSDMelHDFDataset(\n data_config['hdf_fn'], data_config[f'{split}_tids_fn'],\n data_config['label_fn'],\n ignore_intersection=data_config['ignore_label_intersection'],\n transform=ToVariable())\n\n elif data_config['type'] == 'audio':\n dataset = MSDAudioDataset(\n data_config['audio_root'], data_config[f'{split}_tids_fn'],\n data_config['tid2path_fn'], data_config['label_fn'],\n ignore_intersection=data_config['ignore_label_intersection'],\n device='cpu',\n transform=ToVariable())\n\n return dataset","def test_dataloader(self) -> DataLoader:\n return self._custom_data_loader()","def create_test_dataloader(configs):\n\n test_dataset = KittiDataset(configs, mode='test', lidar_aug=None, hflip_prob=0., num_samples=configs.num_samples)\n test_sampler = None\n if configs.distributed:\n test_sampler = torch.utils.data.distributed.DistributedSampler(test_dataset)\n test_dataloader = DataLoader(test_dataset, batch_size=configs.batch_size, shuffle=False,\n pin_memory=configs.pin_memory, num_workers=configs.num_workers, sampler=test_sampler)\n\n return test_dataloader","def build_dataloader(cfg, augmentor=None, mode='train', dataset=None, rank=None,\n dataset_class=VolumeDataset, dataset_options={}, cf=collate_fn_train):\n assert mode in ['train', 'val', 'test']\n print('Mode: ', mode)\n\n if mode == 'train':\n batch_size = cfg.SOLVER.SAMPLES_PER_BATCH\n elif mode == 'val':\n batch_size = cfg.SOLVER.SAMPLES_PER_BATCH * 4\n else:\n cf = collate_fn_test # update the collate function\n batch_size = cfg.INFERENCE.SAMPLES_PER_BATCH * cfg.SYSTEM.NUM_GPUS\n\n if dataset is None: # no pre-defined dataset instance\n if cfg.MODEL.TARGET_OPT_MULTISEG_SPLIT is not None:\n dataset_class = VolumeDatasetMultiSeg\n dataset = get_dataset(cfg, augmentor, mode, rank, dataset_class, dataset_options)\n\n sampler = None\n num_workers = cfg.SYSTEM.NUM_CPUS\n if cfg.SYSTEM.DISTRIBUTED:\n num_workers = cfg.SYSTEM.NUM_CPUS // cfg.SYSTEM.NUM_GPUS\n if cfg.DATASET.DISTRIBUTED == False:\n sampler = torch.utils.data.distributed.DistributedSampler(dataset)\n\n # In PyTorch, each worker will create a copy of the Dataset, so if the data\n # is preload the data, the memory usage should increase a lot.\n # https://discuss.pytorch.org/t/define-iterator-on-dataloader-is-very-slow/52238/2\n img_loader = torch.utils.data.DataLoader(\n dataset, batch_size=batch_size, shuffle=False, collate_fn=cf,\n sampler=sampler, num_workers=num_workers, pin_memory=True)\n\n return img_loader","def data_creator(config):\n train_dataset, val_dataset = LinearDataset(2, 5), LinearDataset(2, 5)\n train_loader = DataLoader(train_dataset, batch_size=config[\"batch_size\"])\n val_loader = DataLoader(val_dataset, batch_size=config[\"batch_size\"])\n return train_loader, val_loader","def get_loader(\n data_source: Iterable[dict],\n open_fn: Callable,\n dict_transform: Callable = None,\n sampler=None,\n collate_fn: Callable = default_collate_fn,\n batch_size: int = 32,\n num_workers: int = 4,\n shuffle: bool = False,\n drop_last: bool = False,\n):\n from catalyst.data.dataset import ListDataset\n\n dataset = ListDataset(\n list_data=data_source, open_fn=open_fn, dict_transform=dict_transform,\n )\n loader = torch.utils.data.DataLoader(\n dataset=dataset,\n sampler=sampler,\n collate_fn=collate_fn,\n batch_size=batch_size,\n num_workers=num_workers,\n shuffle=shuffle,\n pin_memory=torch.cuda.is_available(),\n drop_last=drop_last,\n )\n return loader","def prepare_dataloader(opt, dataobj):\n\n def load_data(name):\n with open(name, 'rb') as f:\n data = pickle.load(f)\n num_types = 1 # There is no event type prediction, hence using a dummy value, this will basically be a constant value field\n return data, num_types\n\n print('[Info] Loading train data...')\n train_data, num_types = load_data(opt.data + 'train_ny.pkl')\n print('[Info] Loading dev data...')\n val_data, _ = load_data(opt.data + 'val_ny.pkl')\n print('[Info] Loading test data...')\n test_data, _ = load_data(opt.data + 'test_ny.pkl')\n\n trainloader = get_dataloader(train_data, opt.batch_size, shuffle=True)\n validationloader = get_dataloader(val_data, opt.batch_size, shuffle=True)\n testloader = get_dataloader(test_data, opt.batch_size, shuffle=False)\n return trainloader, validationloader, testloader, num_types","def build_dataloader(dataset,\n samples_per_gpu,\n workers_per_gpu,\n num_gpus=1,\n dist=True,\n shuffle=True,\n seed=None,\n drop_last=False,\n pin_memory=True,\n dataloader_type='PoolDataLoader',\n **kwargs):\n rank, world_size = get_dist_info()\n if dist:\n sampler = DistributedSampler(\n dataset, world_size, rank, shuffle=shuffle)\n shuffle = False\n batch_size = samples_per_gpu\n num_workers = workers_per_gpu\n else:\n sampler = None\n batch_size = num_gpus * samples_per_gpu\n num_workers = num_gpus * workers_per_gpu\n\n init_fn = partial(\n worker_init_fn, num_workers=num_workers, rank=rank,\n seed=seed) if seed is not None else None\n\n assert dataloader_type in (\n 'DataLoader',\n 'PoolDataLoader'), f'unsupported dataloader {dataloader_type}'\n\n if dataloader_type == 'PoolDataLoader':\n dataloader = PoolDataLoader\n elif dataloader_type == 'DataLoader':\n dataloader = DataLoader\n\n data_loader = dataloader(\n dataset,\n batch_size=batch_size,\n sampler=sampler,\n num_workers=num_workers,\n collate_fn=partial(collate_fn, samples_per_gpu=samples_per_gpu),\n pin_memory=pin_memory,\n shuffle=shuffle,\n worker_init_fn=init_fn,\n drop_last=drop_last,\n **kwargs)\n\n return data_loader","def get_dataloader(dataset, datadir, train_bs, test_bs, dataidxs=None, noise_level=0, net_id=None, total=0):\n if dataset in ('mnist', 'femnist', 'fmnist', 'cifar10','cifar100', 'svhn', 'generated', 'covtype', 'a9a', 'rcv1', 'SUSY','tinyimagenet'):\n if dataset == 'mnist':\n dl_obj = MNIST_truncated\n\n transform_train = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n\n elif dataset == 'femnist':\n dl_obj = FEMNIST\n transform_train = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n\n elif dataset == 'fmnist':\n dl_obj = FashionMNIST_truncated\n transform_train = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n\n elif dataset == 'svhn':\n dl_obj = SVHN_custom\n transform_train = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n\n\n elif dataset == 'cifar10':\n dl_obj = CIFAR10_truncated\n\n transform_train = transforms.Compose([\n transforms.ToTensor(),\n transforms.Lambda(lambda x: F.pad(\n Variable(x.unsqueeze(0), requires_grad=False),\n (4, 4, 4, 4), mode='reflect').data.squeeze()),\n transforms.ToPILImage(),\n transforms.RandomCrop(32),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)\n ])\n # data prep for test set\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n AddGaussianNoise(0., noise_level, net_id, total)])\n \n elif dataset == 'cifar100':\n dl_obj = CIFAR100_truncated\n\n normalize = transforms.Normalize(mean=[0.5070751592371323, 0.48654887331495095, 0.4409178433670343],\n std=[0.2673342858792401, 0.2564384629170883, 0.27615047132568404])\n # transform_train = transforms.Compose([\n # transforms.RandomCrop(32),\n # transforms.RandomHorizontalFlip(),\n # transforms.ToTensor(),\n # normalize\n # ])\n transform_train = transforms.Compose([\n # transforms.ToPILImage(),\n transforms.RandomCrop(32, padding=4),\n transforms.RandomHorizontalFlip(),\n transforms.RandomRotation(15),\n transforms.ToTensor(),\n normalize\n ])\n # data prep for test set\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n normalize])\n\n elif dataset == 'tinyimagenet': \n # random_ids = np.random.randint(1000, size=datasize)\n # train_indices = random_ids\n\n imagenet_mean = [0.485, 0.456, 0.406]\n imagenet_std = [0.229, 0.224, 0.225]\n\n train_dl = torch.utils.data.DataLoader(\n torchvision.datasets.ImageFolder(datadir +\"/train\",\n transform=transforms.Compose([\n transforms.Resize(32), \n transforms.ToTensor(),\n # Phuong 09/26 change (mean, std) -> same as pretrained imagenet\n transforms.Normalize(mean=imagenet_mean, std=imagenet_std)])),\n #Phuong 09/26 drop_last=False -> True\n batch_size=train_bs, drop_last=True)\n \n test_dl = torch.utils.data.DataLoader(\n torchvision.datasets.ImageFolder(datadir +\"/test\",\n transform=transforms.Compose([\n transforms.Resize(32), \n transforms.ToTensor(),\n # Phuong 09/26 change (mean, std) -> same as pretrained imagenet\n transforms.Normalize(mean=imagenet_mean, std=imagenet_std)])),\n #Phuong 09/26 drop_last=False -> True\n batch_size=test_bs, drop_last=True)\n\n return train_dl, test_dl, None, None\n\n\n else:\n dl_obj = Generated\n transform_train = None\n transform_test = None\n\n\n train_ds = dl_obj(datadir, dataidxs=dataidxs, train=True, transform=transform_train, download=True)\n test_ds = dl_obj(datadir, train=False, transform=transform_test, download=True)\n\n train_dl = data.DataLoader(dataset=train_ds, batch_size=train_bs, shuffle=True, drop_last= dataset in ['cifar100'])\n test_dl = data.DataLoader(dataset=test_ds, batch_size=test_bs, shuffle=False, drop_last=False)\n\n return train_dl, test_dl, train_ds, test_ds","def _create_data_loader(self, data, **kwargs):\n if data is None:\n return None\n\n # Set DataLoader config\n # NOTE: Not applicable if data is already a DataLoader\n config = {\n **self.config[\"train_config\"][\"data_loader_config\"],\n **kwargs,\n \"pin_memory\": self.config[\"device\"] != \"cpu\",\n }\n # Return data as DataLoader\n if isinstance(data, DataLoader):\n return data\n elif isinstance(data, Dataset):\n return DataLoader(data, **config)\n elif isinstance(data, (tuple, list)):\n return DataLoader(self._create_dataset(*data), **config)\n else:\n raise ValueError(\"Input data type not recognized.\")","def get_data_loader(batch_size=10, num_workers=2):\n \n data_loader = torch.utils.data.DataLoader(dataset=TempuckeyDataSet(),\n batch_size=batch_size,\n shuffle=True,\n pin_memory=True,\n num_workers=num_workers,\n collate_fn=collate)\n return data_loader","def val_dataloader(self) -> torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_valid, **self.dl_kwargs)","def train_dataloader(self):\r\n\r\n # transformation\r\n train_transform = Compose(\r\n [\r\n ApplyTransformToKey(\r\n key='video',\r\n transform=Compose(\r\n [\r\n UniformTemporalSubsample(8),\r\n Lambda(lambda x: x / 255.0),\r\n Normalize((0.45, 0.45, 0.45), (0.225, 0.225, 0.225)),\r\n RandomShortSideScale(min_size=256, max_size=320),\r\n RandomCrop(244),\r\n RandomHorizontalFlip(p=0.5),\r\n ]\r\n )\r\n )\r\n ]\r\n )\r\n\r\n train_dataset = pv.data.Kinetics(\r\n data_path=os.path.join(self._DATA_PATH, \"train\"),\r\n clip_sampler=pv.data.make_clip_sampler(\"random\", self._CLIP_DURATION),\r\n decode_audio=False,\r\n transform=train_transform\r\n )\r\n return torch.utils.data.DataLoader(\r\n train_dataset,\r\n batch_size=self._BATCH_SIZE,\r\n num_workers=self._NUM_WORKERS,\r\n )","def create_dataset_downloader(source_uri, **kwargs):\n downloader_class = _find_downloader(source_uri=source_uri)\n return downloader_class(**kwargs)","def get_dataloader(path, chars_include, transform):\n return WSDataLoader(path, chars_include=chars_include, batch_size=64, transform=transform, return_path=True)","def make_standard_loader(self, dataset):\n return torch.utils.data.DataLoader(\n dataset,\n batch_size=self.batch_size,\n shuffle=False,\n drop_last=False,\n pin_memory=not (cfg.DEBUG > 0),\n num_workers=self.num_workers,\n )","def train_dataloader(self, batch_size: Optional[int] = None) -> DataLoader:\n dataset = TabularDataset(\n task=self.config.task,\n data=self.train,\n categorical_cols=self.config.categorical_cols,\n continuous_cols=self.config.continuous_cols,\n embed_categorical=(not self.do_leave_one_out_encoder()),\n target=self.target,\n )\n return DataLoader(\n dataset,\n batch_size if batch_size is not None else self.batch_size,\n shuffle=True if self.train_sampler is None else False,\n num_workers=self.config.num_workers,\n sampler=self.train_sampler,\n pin_memory=self.config.pin_memory,\n )","def __init__(self, dataset: Dataset):\n self.dataset = dataset","def batch_loader(data_set: Union[IterableDataset, Dataset],\n batch_size: bool,\n shuffle=False) -> DataLoader:\n return DataLoader(\n data_set,\n batch_size=batch_size,\n collate_fn=lambda x: x,\n shuffle=shuffle\n )","def load_dataset(dest = \"./Datasets/IsophonicsDataset.ds\") -> 'IsophonicsDataset':\n with lzma.open(dest, \"rb\") as dataset_file:\n loaded_dataset = pickle.load(dataset_file)\n\n data, chords, keys, sample_rate, nfft = loaded_dataset\n\n dataset = IsophonicsDataset()\n\n dataset.DATA = data\n dataset.CHORDS = chords\n dataset.KEYS = keys\n dataset.SAMPLE_RATE = sample_rate\n dataset.NFFT = nfft\n\n print(\"[INFO] The Isophonics Dataset was loaded successfully.\")\n return dataset","def __init__(self, dataloader):\n self._dataloader = dataloader\n\n self._iterator = iter(self._dataloader)","def get_test_dataset_DataLoader(self):\n test_info = self.get_test_DataLoader_info()\n name = test_info[\"name\"]\n task = test_info[\"task\"]\n data_dir = test_info[\"data_dir\"]\n hdf5_file = test_info[\"hdf5_file\"]\n\n data_loader = DataLoader(name, task, data_dir, hdf5_file)\n\n return data_loader, self.dataset, self.data_fields","def get_data_loader (imgs_path, labels, extra_info=None, transform=None, params=None):\n\n\n dt = BuildDataset(imgs_path, labels, extra_info, transform)\n\n # Checking the params values. If it's not defined in params of if params is None, the default values are described\n # below:\n batch_size = 30\n shuf = True\n num_workers = 4\n pin_memory = True\n\n # However, if the params is defined, we used the values described on it:\n if (params is not None):\n if ('batch_size' in params.keys()):\n batch_size = params['batch_size']\n if ('shuf' in params.keys()):\n shuf = params['shuf']\n if ('num_workers' in params.keys()):\n num_workers = params['num_workers']\n if ('pin_memory' in params.keys()):\n pin_memory = params['pin_memory']\n\n # Calling the dataloader\n dl = data.DataLoader (dataset=dt, batch_size=batch_size, shuffle=shuf, num_workers=num_workers,\n pin_memory=pin_memory)\n\n return dl","def __init__(self, **kwargs):\n DataLoader.__init__(self, **kwargs)","def get_dataloader(hp: HParams) \\\n -> Tuple[torch.utils.data.DataLoader, torch.utils.data.DataLoader, int]:\n if hp.data.dataset == \"podcast\":\n dataset = podcast.PODCAST(root=hp.data.path,\n audio_folder=hp.data.audio_folder,\n text_file=hp.data.text_file)\n length = len(dataset)\n train_length = int(0.9 * length)\n train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_length,\n length - train_length])\n\n # https://towardsdatascience.com/7-tips-for-squeezing-maximum-performance-from-pytorch-ca4a40951259\n train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,\n batch_size=hp.training.batch_size,\n shuffle=False,\n num_workers=hp.training.num_workers,\n collate_fn=collatedata.AudioCollatePodcast(),\n pin_memory=True)\n test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,\n batch_size=hp.training.batch_size,\n shuffle=False,\n num_workers=hp.training.num_workers,\n collate_fn=collatedata.AudioCollatePodcast(),\n pin_memory=True)\n return train_dataloader, test_dataloader, int(0.9 * length)\n\n elif hp.data.dataset == \"librispeech\":\n Path(hp.data.path).mkdir(parents=True, exist_ok=True)\n dataset = librispeech.download_data(root=hp.data.path, url=hp.data.url)\n length = len(dataset)\n train_length = int(0.9 * length)\n train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_length,\n length - train_length])\n train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,\n batch_size=hp.training.batch_size,\n shuffle=False,\n num_workers=hp.training.num_workers,\n collate_fn=collatedata.AudioCollatePodcast(),\n pin_memory=True)\n test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,\n batch_size=hp.training.batch_size,\n shuffle=False,\n num_workers=hp.training.num_workers,\n collate_fn=collatedata.AudioCollatePodcast(),\n pin_memory=True)\n return train_dataloader, test_dataloader, int(0.9 * length)\n\n elif hp.data.dataset == \"ljspeech\":\n Path(hp.data.path).mkdir(parents=True, exist_ok=True)\n dataset = ljspeech.download_data(root=hp.data.path)\n length = len(dataset)\n train_length = int(0.9 * length)\n train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_length,\n length - train_length])\n train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,\n batch_size=hp.training.batch_size,\n shuffle=False,\n num_workers=hp.training.num_workers,\n collate_fn=collatedata.AudioCollatePodcast(),\n pin_memory=True)\n test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,\n batch_size=hp.training.batch_size,\n shuffle=False,\n num_workers=hp.training.num_workers,\n collate_fn=collatedata.AudioCollatePodcast(),\n pin_memory=True)\n\n return train_dataloader, test_dataloader, int(0.9 * length)\n\n else:\n raise Exception(f\"Dataset {hp.data.dataset} does not exist\")","def creates_data_loader():\n dataset_faces = FaceDataset(\n IMG_DIR, transform=transform_train, face=True)\n\n dataset_no_faces = FaceDataset(\n IMG_DIR, transform=transform_train, face=False)\n\n datasets_faces_split = train_val_test(dataset_faces, 0.2, 0.0)\n datasets_no_faces_split = train_val_test(dataset_no_faces, 0.2, 0.0)\n\n datasets = {}\n datasets[\"train\"] = datasets_faces_split[\"train\"] + \\\n datasets_no_faces_split[\"train\"]\n datasets[\"test\"] = datasets_no_faces_split[\"test\"]\n datasets[\"val\"] = datasets_faces_split[\"val\"] + \\\n datasets_no_faces_split[\"val\"]\n\n train_loader = DataLoader(dataset=datasets[\"train\"], batch_size=BATCH_SIZE,\n num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=False)\n\n val_loader = DataLoader(dataset=datasets[\"val\"], batch_size=BATCH_SIZE,\n num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=False)\n return train_loader, val_loader","def load_dataset(self, f_handle):\n # The file handle might be None in which case an exception is raised\n if f_handle is None:\n raise ValueError('unknown file')\n # Expects a file in a supported tabular data format.\n if not f_handle.is_tabular:\n raise ValueError('cannot create dataset from file \\'' + f_handle.name + '\\'')\n # Open the file as a csv file. Expects that the first row contains the\n # column names. Read dataset schema and dataset rows into two separate\n # lists.\n columns = []\n rows = []\n with f_handle.open() as csvfile:\n reader = csv.reader(csvfile, delimiter=f_handle.delimiter)\n for col_name in next(reader):\n columns.append(\n DatasetColumn(\n identifier=len(columns),\n name=col_name.strip()\n )\n )\n for row in reader:\n values = [cast(v.strip()) for v in row]\n rows.append(DatasetRow(identifier=len(rows), values=values))\n # Get unique identifier and create subfolder for the new dataset\n identifier = get_unique_identifier()\n dataset_dir = self.get_dataset_dir(identifier)\n os.makedirs(dataset_dir)\n # Write rows to data file\n data_file = os.path.join(dataset_dir, DATA_FILE)\n DefaultJsonDatasetReader(data_file).write(rows)\n # Create dataset an write descriptor to file\n dataset = FileSystemDatasetHandle(\n identifier=identifier,\n columns=columns,\n data_file=data_file,\n row_count=len(rows),\n max_row_id=len(rows) - 1\n )\n dataset.to_file(\n descriptor_file=os.path.join(dataset_dir, DESCRIPTOR_FILE)\n )\n return dataset","def get_dataloader(self, mode, label_mode, batch_size):\n cached_features_file = self._feature_file(mode, label_mode)\n logger.info('Loading features from cached file %s', cached_features_file)\n features = torch.load(cached_features_file)\n\n all_input_ids = torch.tensor([f.input_ids for f in features], dtype=torch.long)\n all_input_mask = torch.tensor([f.input_mask for f in features], dtype=torch.long)\n all_segment_ids = torch.tensor([f.segment_ids for f in features], dtype=torch.long)\n all_label_ids = torch.tensor([f.label_ids for f in features], dtype=torch.long)\n all_emph_probs = torch.tensor([f.emph_probs for f in features], dtype=torch.float)\n\n dataset = TensorDataset(all_input_ids, all_input_mask, all_segment_ids, all_label_ids, all_emph_probs)\n\n if mode == 'train':\n sampler = RandomSampler(dataset)\n else:\n sampler = SequentialSampler(dataset)\n\n dataloader = DataLoader(dataset=dataset, batch_size=batch_size, sampler=sampler)\n return dataloader","def _init_al_dataset(self):\n\n self._init_dataset()\n\n train_dataset = self.datasets['train']\n\n dataset_size = len(train_dataset)\n self.budget = math.ceil(self.budget_frac*dataset_size)\n Sampler.__init__(self, config, self.budget) # TODO: Weird place to initialise this\n\n all_indices = set(np.arange(dataset_size))\n k_initial = math.ceil(len(all_indices)*self.initial_budget_frac)\n initial_indices = random.sample(list(all_indices), k=k_initial)\n\n sampler_init = data.sampler.SubsetRandomSampler(initial_indices) # need to sample from training dataset\n\n self.labelled_dataloader = data.DataLoader(train_dataset, sampler=sampler_init, batch_size=self.batch_size, drop_last=True)\n self.val_dataloader = data.DataLoader(self.datasets['valid'], batch_size=self.batch_size, drop_last=False)\n self.test_dataloader = data.DataLoader(self.datasets['test'], batch_size=self.batch_size, drop_last=False)\n\n return all_indices, initial_indices","def create_dataset_sampler_loader(file_path, cuda, batch_size, hvd):\n # When supported, use 'forkserver' to spawn dataloader workers\n # instead of 'fork' to prevent issues with Infiniband implementations\n # that are not fork-safe.\n kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {}\n if (kwargs.get('num_workers', 0) > 0 and hasattr(mp, '_supports_context')\n and 'forkserver' in mp.get_all_start_methods()):\n kwargs['multiprocessing_context'] = 'forkserver'\n\n # create dataset\n dataset = MNISTDataset(file_path)\n # Horovod: use DistributedSampler to partition the training data\n sampler = Data.distributed.DistributedSampler(\n dataset, num_replicas=hvd.size(), rank=hvd.rank())\n loader = torch.utils.data.DataLoader(\n dataset, batch_size=batch_size, sampler=sampler, **kwargs)\n return dataset, sampler, loader","def build_data_loader(dataset, micro_batch_size, num_workers, drop_last,\n task_collate_fn=None):\n\n # Sampler.\n world_size = mpu.get_data_parallel_world_size()\n rank = mpu.get_data_parallel_rank()\n sampler = torch.utils.data.distributed.DistributedSampler(\n dataset, num_replicas=world_size, rank=rank)\n\n # Data loader. Note that batch size is the per GPU batch size.\n data_loader = torch.utils.data.DataLoader(dataset,\n batch_size=micro_batch_size,\n sampler=sampler,\n shuffle=False,\n num_workers=num_workers,\n drop_last=drop_last,\n pin_memory=True,\n collate_fn=task_collate_fn)\n\n return data_loader","def train_dataloader(self) -> data.DataLoader:\n # Random weighted sampler to approach the imbalanced dataset\n self.weights = [1.0 / i for i in self.weights]\n\n _sample_weights = [0] * len(self.datasets['train'])\n\n for idx, (_, label) in enumerate(self.datasets['train']):\n _weight = self.weights[label]\n _sample_weights[idx] = _weight\n\n random_sampler = data.WeightedRandomSampler(_sample_weights,\n len(self.datasets['train']), replacement=False)\n\n return data.DataLoader(dataset=self.datasets['train'], batch_size=self.batch_size,\n num_workers=self.num_workers, pin_memory=False,\n sampler=random_sampler)","def __init__(self, dataset):\n self._dataset = dataset","def from_disk(cls, path: Path, loader_func: Callable = read_jsonl):\n return Dataset(\n loader_func(path / 'train.jsonl'),\n loader_func(path / 'dev.jsonl'),\n test=loader_func(path / 'test.jsonl')\n )","def make_dataloaders(params):\r\n transform_train = transforms.Compose([transforms.RandomCrop(32, padding=4),\r\n transforms.RandomHorizontalFlip(),\r\n transforms.ToTensor(),\r\n transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010])])\r\n\r\n transform_validation = transforms.Compose([transforms.ToTensor(),\r\n transforms.Normalize([0.4914, 0.4822, 0.4465],\r\n [0.2023, 0.1994, 0.2010])])\r\n\r\n transform_validation = transforms.Compose([transforms.ToTensor()])\r\n\r\n trainset = torchvision.datasets.CIFAR10(root=params['path'], train=True, transform=transform_train)\r\n testset = torchvision.datasets.CIFAR10(root=params['path'], train=False, transform=transform_validation)\r\n\r\n trainloader = torch.utils.data.DataLoader(trainset, batch_size=params['batch_size'], shuffle=True, num_workers=4)\r\n testloader = torch.utils.data.DataLoader(testset, batch_size=params['batch_size'], shuffle=False, num_workers=4)\r\n return trainloader, testloader","def get_lsun_dataloader(path_to_data='../lsun', dataset='bedroom_train',\n batch_size=64):\n # Compose transforms\n transform = transforms.Compose([\n transforms.Resize(128),\n transforms.CenterCrop(128),\n transforms.ToTensor()\n ])\n\n # Get dataset\n lsun_dset = datasets.LSUN(db_path=path_to_data, classes=[dataset],\n transform=transform)\n\n # Create dataloader\n return DataLoader(lsun_dset, batch_size=batch_size, shuffle=True)","def get_loader(file_path, src_word2id, trg_word2id, intent_type=None, intent2index=None, batch_size=1):\n dials = json.load(open(file_path))\n dataset_list = []\n for name in dials.keys():\n val_file = dials[name]\n # build a custom dataset\n dataset = MultiwozSingleDataset(val_file, name, src_word2id, trg_word2id, intent_type, intent2index)\n dataset_list.append(dataset)\n datasets = ConcatDataset(dataset_list)\n # data loader for custome dataset\n data_loader = DataLoader(dataset=datasets,\n batch_size=batch_size,\n shuffle=True,\n num_workers=0,\n collate_fn=collate_fn)\n return data_loader","def importDataset():\n module_path = os.path.join(path, \"dataset\")\n module_path = os.path.join(module_path, \"dataset.py\")\n dataset_class = importClass(\"Dataset\", \"dataset\", module_path)\n return dataset_class","def prepare_demo_dataset(path, reso, batch_size=1):\r\n transform = transforms.Compose([\r\n transforms.Resize(size=(reso, reso), interpolation=3),\r\n transforms.ToTensor()\r\n ])\r\n\r\n img_datasets = DemoDataset(path, transform)\r\n dataloader = torch.utils.data.DataLoader(img_datasets, batch_size=batch_size, num_workers=8)\r\n\r\n return img_datasets, dataloader","def create_dataset(fd, dobj, verbose=False, nodata=False):\n msg = \"creating dataset {}, shape: {}, type: {}\".format(dobj.name, dobj.shape, dobj.dtype)\n logging.info(msg)\n if verbose:\n print(msg) \n \n fillvalue = None\n try: \n # can trigger a runtime error if fillvalue is undefined\n fillvalue = dobj.fillvalue\n except RuntimeError:\n pass # ignore\n chunks=None\n if dobj.chunks:\n chunks = tuple(dobj.chunks)\n try:\n dset = fd.create_dataset( dobj.name, shape=dobj.shape, dtype=dobj.dtype, chunks=chunks, \\\n compression=dobj.compression, shuffle=dobj.shuffle, \\\n fletcher32=dobj.fletcher32, maxshape=dobj.maxshape, \\\n compression_opts=dobj.compression_opts, fillvalue=fillvalue, \\\n scaleoffset=dobj.scaleoffset)\n msg = \"dataset created, uuid: {}, chunk_size: {}\".format(dset.id.id, str(dset.chunks)) \n logging.info(msg)\n if verbose:\n print(msg)\n except (IOError, TypeError, KeyError) as e:\n msg = \"ERROR: failed to create dataset: {}\".format(str(e))\n logging.error(msg)\n print(msg)\n return\n # create attributes\n for da in dobj.attrs:\n copy_attribute(dset, da, dobj)\n\n if nodata:\n msg = \"skipping data load\"\n logging.info(msg)\n if verbose:\n print(msg)\n return\n\n if dset.shape is None:\n # null space dataset\n msg = \"no data for null space dataset: {}\".format(dobj.name)\n logging.info(msg)\n if verbose:\n print(msg)\n return # no data \n\n if len(dset.shape) == 0:\n # scalar dataset\n x = dobj[()]\n msg = \"writing: {} for scalar dataset: {}\".format(x, dobj.name)\n logging.info(msg)\n if verbose:\n print(msg)\n dset[()] = x\n return\n\n msg = \"iterating over chunks for {}\".format(dobj.name)\n logging.info(msg)\n if verbose:\n print(msg)\n try:\n it = ChunkIterator(dset)\n\n logging.debug(\"src dtype: {}\".format(dobj.dtype))\n logging.debug(\"des dtype: {}\".format(dset.dtype))\n \n for s in it:\n msg = \"writing dataset data for slice: {}\".format(s)\n logging.info(msg)\n if verbose:\n print(msg)\n arr = dobj[s]\n dset[s] = arr\n except (IOError, TypeError) as e:\n msg = \"ERROR : failed to copy dataset data : {}\".format(str(e))\n logging.error(msg)\n print(msg)\n msg = \"done with dataload for {}\".format(dobj.name)\n logging.info(msg)\n if verbose:\n print(msg)","def CreateDataset(all_arrays):\n dataset = Dataset()\n\n dataset._addData(all_arrays[0])\n dataset._addData(all_arrays[1])\n dataset._addData(all_arrays[3])\n dataset._addData(all_arrays[5])\n dataset._addData(all_arrays[6])\n dataset._addData(all_arrays[9])\n dataset._addData(all_arrays[8])\n dataset._addData(all_arrays[4])\n\n return dataset","def create_dataset():\n ds_train_raw, ds_test_raw = load_raw_datasets()\n vectorize_layer = create_vectorizer(ds_train_raw)\n ds_train = ds_train_raw.map(\n lambda text, label: (vectorize_layer(text), label)\n ).prefetch(tf.data.experimental.AUTOTUNE)\n ds_test = ds_test_raw.map(\n lambda text, label: (vectorize_layer(text), label)\n ).prefetch(tf.data.experimental.AUTOTUNE)\n return ds_train, ds_test, vectorize_layer","def create_dataloaders(data_dir):\n\n trng_dataset = datasets.ImageFolder(data_dir / TRNG_FOLDER,\n transform=flowernet.trng_transform)\n trng_dataloader = torch.utils.data.DataLoader(trng_dataset,\n batch_size=64,\n shuffle=True)\n\n valn_dataset = datasets.ImageFolder(data_dir / VALN_FOLDER,\n transform=flowernet.pred_transform)\n valn_dataloader = torch.utils.data.DataLoader(valn_dataset,\n batch_size=64,\n shuffle=True)\n\n return trng_dataloader, valn_dataloader","def initialise_dataset_loader(\n self, data_param=None, task_param=None, data_partitioner=None):\n raise NotImplementedError","def create_dataset(base_path, batch_size, is_train):\n columns_list = [\"feature\", \"label\"]\n num_consumer = 4\n\n if is_train:\n path = os.path.join(base_path, 'aclImdb_train.mindrecord0')\n else:\n path = os.path.join(base_path, 'aclImdb_test.mindrecord0')\n\n data_set = ds.MindDataset(path, columns_list, num_consumer)\n ds.config.set_seed(0)\n data_set = data_set.shuffle(buffer_size=data_set.get_dataset_size())\n data_set = data_set.batch(batch_size, drop_remainder=True)\n return data_set","def make_dataset(self, df, **kwargs):\n\t\treturn df","def get_dataloaders(args):\n if args.dataset == 'heat':\n dataset_class = heat.HeatDiffusionDataset\n else:\n raise ValueError(f'Unknown dataset {args.dataset}')\n train_dataset = dataset_class(\n dataset_class.get_train_path(args.data_path), args, train=True)\n if args.dist:\n train_sampler = torch.utils.data.distributed.DistributedSampler(\n train_dataset)\n else:\n train_sampler = torch.utils.data.RandomSampler(train_dataset)\n train_loader = torch.utils.data.DataLoader(\n train_dataset, batch_size=args.batch_size, num_workers=args.workers,\n sampler=train_sampler, pin_memory=True, drop_last=args.drop_last)\n if not args.no_eval:\n validation_dataset = dataset_class(\n dataset_class.get_validation_path(args.data_path), args, train=False)\n if args.dist:\n validation_sampler = torch.utils.data.distributed.DistributedSampler(\n validation_dataset, shuffle=False)\n else:\n validation_sampler = torch.utils.data.SequentialSampler(\n validation_dataset)\n validation_loader = torch.utils.data.DataLoader(\n validation_dataset, batch_size=args.batch_size,\n num_workers=args.workers, sampler=validation_sampler,\n pin_memory=True, drop_last=args.drop_last)\n\n test_dataset = dataset_class(\n dataset_class.get_test_path(args.data_path), args, train=False)\n if args.dist:\n test_sampler = torch.utils.data.distributed.DistributedSampler(\n test_dataset, shuffle=False)\n else:\n test_sampler = torch.utils.data.SequentialSampler(\n test_dataset)\n test_loader = torch.utils.data.DataLoader(\n test_dataset, batch_size=args.batch_size,\n num_workers=args.workers, sampler=test_sampler,\n pin_memory=True, drop_last=args.drop_last)\n else:\n validation_loader = None\n test_loader = None\n\n # Update the data shape if needed.\n if args.data_shape is None:\n args.data_shape = train_dataset.get_shape()\n if args.data_target_shape is None:\n args.data_target_shape = train_dataset.get_target_shape()\n\n return train_loader, validation_loader, test_loader","def create_dataset(cfg, xlmr, label2id):\n assert exists(cfg.data_dir), \\\n '{} does not exist.'.format(cfg.data_dir)\n\n metadata_path = join(\n cfg.data_dir, 'metadata.json')\n\n if not exists(metadata_path):\n # if dataset does not exist then create it\n # by tokenizing the raw files\n\n splits = [\n join(cfg.data_dir, 'train.jsonl'),\n join(cfg.data_dir, 'valid.jsonl')\n ]\n\n splits = tqdm(\n splits, \n desc='Converting to tfrecord',\n leave=False\n )\n\n train, valid = [\n transform_split(\n cfg=cfg,\n file_name=file_name,\n xlmr=xlmr,\n label2id=label2id)\n for file_name in splits]\n\n train_tfrecords, train_size = train\n valid_tfrecords, valid_size = valid\n\n print('Saving metadata to {}'.format(\n metadata_path))\n\n # save the location of the files in a metadata\n # json object and delete the file in case of\n # interrupt so it wont be left in corrupted state\n with open(metadata_path, 'w') as fh:\n try:\n json.dump({\n 'train': train,\n 'valid': valid\n }, fh)\n except KeyboardInterrupt:\n shutil.rmtree(metadata_path)\n\n print('Loading metadata from {}'.format(\n metadata_path))\n\n with open(metadata_path, 'r') as fh:\n metadata = json.load(fh)\n\n train_tfrecords, train_size = metadata['train']\n valid_tfrecords, valid_size = metadata['valid']\n\n pad_id = xlmr.task.dictionary.pad()\n\n train_dataset = create_tfrecord_loader(\n cfg=cfg,\n tfrecord_paths=train_tfrecords,\n size=train_size,\n pad_id=pad_id,\n shuffle=True)\n\n valid_dataset = create_tfrecord_loader(\n cfg=cfg,\n tfrecord_paths=valid_tfrecords,\n size=valid_size,\n pad_id=pad_id)\n\n return train_dataset, valid_dataset","def get_dataloader(data_folder, model_name, data_name, size=\"default\"):\n training_set = None\n validation_set = None\n\n if model_name == \"Howe_Patterson\":\n if data_name == \"combined\":\n partition = []\n for data_fold in data_folder:\n partition.append(load_obj(os.path.join(data_fold, 'data_partition.pkl')))\n\n elif size == \"small\":\n partition = load_obj(os.path.join(data_folder, 'data_partition_small.pkl'))\n elif size == \"tiny\":\n partition = load_obj(os.path.join(data_folder, 'data_partition_tiny.pkl'))\n else:\n partition = load_obj(os.path.join(data_folder, 'data_partition.pkl'))\n\n\n if data_name == \"SHHS\":\n training_set = Dataset_full_SHHS(partition['train'], data_folder)\n validation_set = Dataset_full_SHHS(partition['validation'], data_folder)\n elif data_name == \"snooze\":\n training_set = Dataset_full(partition['train'], data_folder)\n validation_set = Dataset_full(partition['validation'], data_folder)\n elif data_name == \"philips\":\n training_set = Dataset_Philips_full(partition['train'], data_folder)\n validation_set = Dataset_Philips_full(partition['validation'], data_folder)\n elif data_name == \"HMC\":\n print(\"{} not implemented data\".format(data_name))\n exit()\n elif data_name == \"combined\":\n training_set = ConcatDataset(\n Dataset_full(partition[0]['train'], data_folder[0], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False),\n Dataset_full_SHHS(partition[1]['train'], data_folder[1], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False))\n validation_set = ConcatDataset(\n Dataset_full(partition[0]['validation'], data_folder[0], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False),\n Dataset_full_SHHS(partition[1]['validation'], data_folder[1], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False))\n else:\n print(\"{} wrong data for dataloader\".format(data_name))\n exit()\n elif model_name == \"Deep_Sleep\":\n if data_name == \"combined\":\n partition = []\n for data_fold in data_folder:\n partition.append(load_obj(os.path.join(data_fold, 'data_partition.pkl')))\n\n elif size == \"small\":\n partition = load_obj(os.path.join(data_folder, 'data_partition_small.pkl'))\n elif size == \"tiny\":\n partition = load_obj(os.path.join(data_folder, 'data_partition_tiny.pkl'))\n else:\n partition = load_obj(os.path.join(data_folder, 'data_partition.pkl'))\n\n if data_name == \"SHHS\":\n training_set = Dataset_full_SHHS(partition['train'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n validation_set = Dataset_full_SHHS(partition['validation'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n elif data_name == \"snooze\":\n training_set = Dataset_full(partition['train'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n validation_set = Dataset_full(partition['validation'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n elif data_name == \"philips\":\n training_set = Dataset_Philips_full(partition['train'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n validation_set = Dataset_Philips_full(partition['validation'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n elif data_name == \"HMC\":\n print(\"{} not implemented data\".format(data_name))\n exit()\n elif data_name == \"combined\":\n # TODO combined dataset https://discuss.pytorch.org/t/train-simultaneously-on-two-datasets/649/17\n training_set = ConcatDataset(\n Dataset_full(partition[0]['train'], data_folder[0], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False),\n Dataset_full_SHHS(partition[1]['train'], data_folder[1], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False))\n validation_set = ConcatDataset(\n Dataset_full(partition[0]['validation'], data_folder[0], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False),\n Dataset_full_SHHS(partition[1]['validation'], data_folder[1], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False))\n else:\n print(\"{} wrong data for dataloader\".format(data_name))\n exit()\n elif model_name == \"ConvNet_IID\":\n if data_name == \"combined\":\n partition = []\n for data_fold in data_folder:\n partition.append(load_obj(os.path.join(data_fold, 'data_partition_IID_windows.pkl')))\n else:\n partition = load_obj(os.path.join(data_folder, 'data_partition_IID_windows.pkl'))\n if data_name == \"SHHS\":\n training_set = Dataset_IID_window_SHHS(partition['train'], data_folder)\n validation_set = Dataset_IID_window_SHHS(partition['validation'], data_folder)\n elif data_name == \"snooze\":\n training_set = Dataset_IID_window(partition['train'], data_folder)\n validation_set = Dataset_IID_window(partition['validation'], data_folder)\n elif data_name == \"philips\":\n print(\"{} not implemented data\".format(data_name))\n exit()\n elif data_name == \"HMC\":\n print(\"{} not implemented data\".format(data_name))\n exit()\n elif data_name == \"combined\":\n training_set = ConcatDataset(\n Dataset_IID_window(partition[0]['train'], data_folder[0]),\n Dataset_IID_window_SHHS(partition[1]['train'], data_folder[1]))\n validation_set = ConcatDataset(\n Dataset_IID_window(partition[0]['validation'], data_folder[0]),\n Dataset_IID_window_SHHS(partition[1]['validation'], data_folder[1]))\n else:\n print(\"{} wrong data for dataloader\".format(data_name))\n exit()\n\n else:\n print(\"{} wrong model for dataloader\".format(model_name))\n exit()\n\n return training_set, validation_set","def get_train_dataloader(self):\n if self.train_dataloader is not None:\n return self.train_dataloader\n\n assert self.schema is not None, \"schema is required to generate Train Dataloader\"\n return T4RecDataLoader.parse(self.args.data_loader_engine).from_schema(\n self.schema,\n self.train_dataset_or_path,\n self.args.per_device_train_batch_size,\n max_sequence_length=self.args.max_sequence_length,\n drop_last=self.args.dataloader_drop_last,\n shuffle=True,\n shuffle_buffer_size=self.args.shuffle_buffer_size,\n )","def get_loader(split):\n assert split in ['train', 'val', 'trainval', 'test']\n image_feature_path = config.rcnn_trainval_path if split != 'test' else config.rcnn_test_path\n dataset = VQAFeatureDataset(\n split,\n image_feature_path,\n )\n loader = torch.utils.data.DataLoader(\n dataset,\n batch_size=512,\n shuffle=True if split not in ['val', 'test'] else False, # only shuffle the data in training\n pin_memory=True,\n num_workers=config.workers,\n )\n return loader","def _get_dataset(\n self,\n dataset_path: str,\n data_folder: str = \"data/\",\n ):\n if not os.path.isdir(dataset_path):\n click.secho(f\"{dataset_path} not found!\", fg=\"red\")\n\n dataset_hash = (\n int(hashlib.sha256(dataset_path.encode(\"utf-8\")).hexdigest(), 16) % 10 ** 8\n )\n\n # To avoid using cache for different models\n # split(/) for google/electra-base-discriminator\n pretrained_model = (\n self.hparams.pretrained_model.split(\"/\")[1]\n if \"/\" in self.hparams.pretrained_model\n else self.hparams.pretrained_model\n )\n dataset_cache = data_folder + \".dataset_\" + str(dataset_hash) + pretrained_model\n\n if os.path.isfile(dataset_cache):\n click.secho(f\"Loading tokenized dataset from cache: {dataset_cache}.\")\n return torch.load(dataset_cache)\n\n dataset_path += \"\" if dataset_path.endswith(\"/\") else \"/\"\n dataset = {\n \"train\": pd.read_csv(dataset_path + \"train.tsv\", sep=\"\\t\").to_dict(\n \"records\"\n ),\n \"valid\": pd.read_csv(dataset_path + \"valid.tsv\", sep=\"\\t\").to_dict(\n \"records\"\n ),\n \"test\": pd.read_csv(dataset_path + \"test.tsv\", sep=\"\\t\").to_dict(\"records\"),\n }\n # Read Labels\n with open(dataset_path + \"labels.txt\", \"r\") as fp:\n labels = [line.strip() for line in fp.readlines()]\n label_encoder = {labels[i]: i for i in range(len(labels))}\n\n dataset[\"label_encoder\"] = label_encoder\n # Tokenize\n dataset[\"train\"] = self._tokenize(dataset[\"train\"])\n dataset[\"valid\"] = self._tokenize(dataset[\"valid\"])\n dataset[\"test\"] = self._tokenize(dataset[\"test\"])\n torch.save(dataset, dataset_cache)\n return dataset","def get_dataset(self, source='', importer='', parameters=None):\n if not source:\n raise aspecd.exceptions.MissingSourceError(\n 'A source is required to return a dataset')\n if not self.importer_factory:\n raise aspecd.exceptions.MissingImporterFactoryError(\n 'An ImporterFactory is required to return a dataset')\n dataset_ = self._create_dataset(source=source)\n importer = self.importer_factory.get_importer(source=source,\n importer=importer,\n parameters=parameters)\n dataset_.import_from(importer)\n return dataset_","def create_val_dataloader(configs, mode):\n val_sampler = None\n val_dataset = KittiDataset(configs, mode=mode, lidar_aug=None, hflip_prob=0., num_samples=configs.num_samples)\n if configs.distributed:\n val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset, shuffle=False)\n val_dataloader = DataLoader(val_dataset, batch_size=configs.batch_size, shuffle=False,\n pin_memory=configs.pin_memory, num_workers=configs.num_workers, sampler=val_sampler)\n\n return val_dataloader","def get_data_loader_from_data(cls, batch_size, X, Y, **kwargs):\n X_torch = torch.from_numpy(X).float()\n\n if (\n \"classification_problem\" in kwargs\n and kwargs[\"classification_problem\"] == False\n ):\n Y_torch = torch.from_numpy(Y).float()\n else:\n Y_torch = torch.from_numpy(Y).long()\n dataset = TensorDataset(X_torch, Y_torch)\n kwargs.pop(\"classification_problem\", None)\n return DataLoader(dataset, batch_size=batch_size, **kwargs)","def prepare_dataset(\n db, dataset: str, batch_size, chunk_size, shuffle=True,\n prefetch=True, dataset_slice=None,\n):\n dataset = db.get_dataset(dataset)\n\n if dataset_slice is not None:\n dataset = dataset[dataset_slice]\n\n segmenter = Segmenter(\n chunk_size, include_keys=('y', 's'), axis=-1,\n anchor='random' if shuffle else 'left',\n )\n\n def _set_num_samples(example):\n example['num_samples'] = example['y'].shape[-1]\n return example\n\n if shuffle:\n dataset = dataset.shuffle(reshuffle=True)\n\n dataset = dataset.map(pre_batch_transform)\n dataset = dataset.map(segmenter)\n\n # FilterExceptions are only raised inside the chunking code if the\n # example is too short. If chunk_size == -1, no filter exception is raised.\n catch_exception = segmenter.length > 0\n if prefetch:\n dataset = dataset.prefetch(\n 8, 16, catch_filter_exception=catch_exception)\n elif catch_exception:\n dataset = dataset.catch()\n\n if chunk_size != -1:\n dataset = dataset.unbatch()\n else:\n def unbatch(example):\n assert len(example) == 1, example\n return example[0]\n dataset = dataset.map(unbatch)\n dataset = dataset.map(_set_num_samples)\n\n if shuffle:\n dataset = dataset.shuffle(reshuffle=True, buffer_size=128)\n\n dataset = dataset.batch(batch_size)\n dataset = dataset.map(pt.data.batch.Sorter('num_samples'))\n dataset = dataset.map(pt.data.utils.collate_fn)\n\n return dataset","def load_data(dataset_class, batch_size, shuffle=True, num_workers=4):\n loader = torch.utils.data.TensorDataset(dataset_class.data.float(),\n dataset_class.labels.long(),\n dataset_class.adjacent_matrix.float())\n\n loader_dataset = torch.utils.data.DataLoader(loader,\n batch_size=batch_size,\n shuffle=shuffle,\n num_workers=num_workers)\n return loader_dataset","def get_loader(dataset='train.txt', crop_size=128, image_size=28, batch_size=2, mode='train', num_workers=1): \n transform = [] \n if mode == 'train': \n transform.append(transforms.RandomHorizontalFlip()) \n transform.append(transforms.CenterCrop(crop_size)) \n transform.append(transforms.Resize(image_size)) \n transform.append(transforms.ToTensor()) \n transform.append(transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))) \n transform = transforms.Compose(transform) \n train_data=MyDataset(txt=dataset, transform=transform) \n data_loader = DataLoader(dataset=train_data, \n batch_size=batch_size, \n shuffle=(mode=='train'), \n num_workers=num_workers) \n return data_loader","def load():\n filepath = dirname(abspath(__file__))\n##### EDIT THE FOLLOWING TO POINT TO DatasetName.csv #####\n data = recfromtxt(open(filepath + '/spector.csv',\"rb\"), delimiter=\" \",\n names=True, dtype=float, usecols=(1,2,3,4))\n names = list(data.dtype.names)\n endog = array(data[names[3]], dtype=float)\n endog_name = names[3]\n exog = column_stack(data[i] for i in names[:3]).astype(float)\n exog_name = names[:3]\n dataset = Dataset(data=data, names=names, endog=endog, exog=exog,\n endog_name = endog_name, exog_name=exog_name)\n return dataset","def load_dataset(file_name, model_ver):\n\n print 'Loading dataset ...'\n\n if model_ver == 'dmspline':\n file_path = join(DATA_DIR, file_name)\n id_field = Field(sequential=False, use_vocab=False, dtype=torch.int)\n text_field = Field(pad_token=None, tokenize=_tokenize_str)\n attr_field = Field(sequential=False, use_vocab=False, dtype=torch.float)\n standardzed_attr_field = Field(sequential=False, use_vocab=False, dtype=torch.float)\n\n dataset = TabularDataset(\n path=file_path,\n format='csv',\n fields=[('attr', attr_field), ('id', id_field), ('standardized_attr', standardzed_attr_field), ('text', text_field)],\n skip_header=True)\n\n else:\n file_path = join(DATA_DIR, file_name)\n id_field = Field(sequential=False, use_vocab=False, dtype=torch.int)\n text_field = Field(pad_token=None, tokenize=_tokenize_str)\n\n dataset = TabularDataset(\n path=file_path,\n format='csv',\n fields=[('id', id_field), ('text', text_field)],\n skip_header=True)\n\n text_field.build_vocab(dataset, min_freq=10)\n return dataset","def from_dataset(cls, name, options=None):\n if options is None:\n options = dict()\n if name == 'lin_aaai12':\n return cls.from_lin_aaai12(**options)\n elif name == 'bragg_hcomp13':\n return cls.from_bragg_hcomp13(**options)\n elif name == 'bragg_teach':\n return cls.from_bragg_teach(**options)\n elif name == 'rajpal_icml15':\n return cls.from_rajpal_icml15(**options)\n else:\n raise NotImplementedError","def get(dataset_name: str, split: Union[Tuple[str, float], str, tfds.Split],\n **hyperparameters: Any) -> BaseDataset:\n hyperparameters_py = {\n k: (v.numpy().tolist() if isinstance(v, tf.Tensor) else v)\n for k, v in hyperparameters.items()\n }\n logging.info('Building dataset %s with additional kwargs:\\n%s', dataset_name,\n json.dumps(hyperparameters_py, indent=2, sort_keys=True))\n if dataset_name not in DATASETS:\n raise ValueError('Unrecognized dataset name: {!r}'.format(dataset_name))\n\n dataset_class = DATASETS[dataset_name]\n return dataset_class(split=split, **hyperparameters)","def make_data_loader(examples, batch_size=100, shuffle=True):\n x, y = zip(*examples) # makes lists of windows and tags\n x, y = tr.from_numpy(np.array(x)), tr.from_numpy(np.array(y))\n x, y = x.type(tr.LongTensor), y.type(tr.LongTensor) # convert lists to tensors\n train = utdata.TensorDataset(x, y)\n return utdata.DataLoader(train, batch_size, shuffle)","def __init__(self, name_dataset, reduce=False):\n dataset = TUDataset(root='data/TUDataset', name=name_dataset)\n if reduce:\n new_dataset = []\n for i in tqdm(range(len(dataset))):\n aux_graph = copy.deepcopy(dataset[i])\n aux_graph.edge_index = TUDData.reduce_edges(aux_graph.edge_index)\n new_dataset.append(copy.deepcopy(aux_graph))\n dataset = WrapperSynthetic(new_dataset, dataset.num_node_features,\n dataset.num_classes, None)\n super(TUDData, self).__init__(dataset)","def _create_dataset(options, is_training, input_pipeline_context=None):\n dataset = tf.data.Dataset.list_files(options.input_pattern[:],\n shuffle=is_training)\n\n batch_size = options.batch_size\n if input_pipeline_context:\n if input_pipeline_context.num_input_pipelines > 1:\n dataset = dataset.shard(input_pipeline_context.num_input_pipelines,\n input_pipeline_context.input_pipeline_id)\n batch_size = input_pipeline_context.get_per_replica_batch_size(\n options.batch_size)\n\n if is_training:\n if options.cache_dataset:\n dataset = dataset.cache()\n dataset = dataset.repeat()\n dataset = dataset.shuffle(options.shuffle_buffer_size)\n dataset = dataset.interleave(tf.data.TFRecordDataset,\n cycle_length=options.interleave_cycle_length)\n\n parse_fn = lambda x: _parse_single_example(x, options)\n dataset = dataset.map(map_func=parse_fn,\n num_parallel_calls=options.num_parallel_calls)\n\n padded_shapes = {\n InputFields.img_id: [],\n InputFields.annot_id: [],\n InputFields.answer_label: [],\n InputFields.num_objects: [],\n InputFields.object_bboxes: [None, 4],\n InputFields.object_labels: [None],\n InputFields.object_scores: [None],\n InputFields.object_features: [None, options.frcnn_feature_dims],\n InputFields.cls_bert: [NUM_CHOICES, options.bert_feature_dims],\n InputFields.question: [None],\n InputFields.question_tag: [None],\n InputFields.question_bert: [NUM_CHOICES, None, options.bert_feature_dims],\n InputFields.question_len: [],\n InputFields.answer_choices: [NUM_CHOICES, None],\n InputFields.answer_choices_tag: [NUM_CHOICES, None],\n InputFields.answer_choices_bert: [\n NUM_CHOICES, None, options.bert_feature_dims\n ],\n InputFields.answer_choices_len: [NUM_CHOICES],\n InputFields.answer_choices_with_question: [NUM_CHOICES, None],\n InputFields.answer_choices_with_question_tag: [NUM_CHOICES, None],\n InputFields.answer_choices_with_question_len: [NUM_CHOICES],\n }\n padding_values = {\n InputFields.img_id: '',\n InputFields.annot_id: '',\n InputFields.answer_label: -1,\n InputFields.num_objects: 0,\n InputFields.object_bboxes: 0.0,\n InputFields.object_labels: '',\n InputFields.object_scores: 0.0,\n InputFields.object_features: 0.0,\n InputFields.cls_bert: 0.0,\n InputFields.question: PAD,\n InputFields.question_tag: -1,\n InputFields.question_bert: 0.0,\n InputFields.question_len: 0,\n InputFields.answer_choices: PAD,\n InputFields.answer_choices_tag: -1,\n InputFields.answer_choices_bert: 0.0,\n InputFields.answer_choices_len: 0,\n InputFields.answer_choices_with_question: PAD,\n InputFields.answer_choices_with_question_tag: -1,\n InputFields.answer_choices_with_question_len: 0,\n }\n if options.decode_jpeg:\n padded_shapes.update({\n InputFields.img_data: [None, None, 3],\n InputFields.img_height: [],\n InputFields.img_width: [],\n })\n padding_values.update({\n InputFields.img_data: tf.constant(0, dtype=tf.uint8),\n InputFields.img_height: 0,\n InputFields.img_width: 0,\n })\n dataset = dataset.padded_batch(batch_size,\n padded_shapes=padded_shapes,\n padding_values=padding_values,\n drop_remainder=True)\n dataset = dataset.prefetch(options.prefetch_buffer_size)\n return dataset","def get_one_epoch_dataloader(dataset, micro_batch_size=None):\n args = get_args()\n\n if micro_batch_size is None:\n micro_batch_size = args.micro_batch_size\n num_workers = args.num_workers\n\n # Use megatron's sampler with consumed samples set to 0 as\n # this is only for evaluation and don't intend to resume half way.\n # Also, set the drop last to false as don't intend to remove\n # the last batch\n batch_sampler = MegatronPretrainingSampler(\n total_samples=len(dataset),\n consumed_samples=0,\n micro_batch_size=args.micro_batch_size,\n data_parallel_rank=mpu.get_data_parallel_rank(),\n data_parallel_size=mpu.get_data_parallel_world_size(),\n drop_last=False)\n\n return torch.utils.data.DataLoader(dataset,\n batch_sampler=batch_sampler,\n num_workers=num_workers,\n pin_memory=True)","def prepare_dataset(self, dataset_type: str) -> Dataset:\n\n logger.info(\"Creating features from dataset file at %s\", self.hparams.data_dir)\n\n if dataset_type == \"train\":\n dataset = self.processor.get_train_dataset(self.hparams.data_dir, self.hparams.train_file_name)\n elif dataset_type == \"dev\":\n dataset = self.processor.get_dev_dataset(self.hparams.data_dir, self.hparams.dev_file_name)\n elif dataset_type == \"test\":\n dataset = self.processor.get_test_dataset(self.hparams.data_dir, self.hparams.test_file_name)\n else:\n raise ValueError(f\"{dataset_type} do not support. [train|dev|test]\")\n logger.info(f\"Prepare {dataset_type} dataset (Count: {len(dataset)}) \")\n return dataset","def from_datasets(\n cls,\n train_dataset: Optional[Union[Dataset, Sequence[Dataset], Mapping[str, Dataset]]] = None,\n val_dataset: Optional[Union[Dataset, Sequence[Dataset]]] = None,\n test_dataset: Optional[Union[Dataset, Sequence[Dataset]]] = None,\n batch_size: int = 1,\n num_workers: int = 0,\n ):\n\n def dataloader(ds: Dataset, shuffle: bool = False) -> DataLoader:\n shuffle &= not isinstance(ds, IterableDataset)\n return DataLoader(ds, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers, pin_memory=True)\n\n def train_dataloader():\n if isinstance(train_dataset, Mapping):\n return {key: dataloader(ds, shuffle=True) for key, ds in train_dataset.items()}\n if isinstance(train_dataset, Sequence):\n return [dataloader(ds, shuffle=True) for ds in train_dataset]\n return dataloader(train_dataset, shuffle=True)\n\n def val_dataloader():\n if isinstance(val_dataset, Sequence):\n return [dataloader(ds) for ds in val_dataset]\n return dataloader(val_dataset)\n\n def test_dataloader():\n if isinstance(test_dataset, Sequence):\n return [dataloader(ds) for ds in test_dataset]\n return dataloader(test_dataset)\n\n datamodule = cls()\n if train_dataset is not None:\n datamodule.train_dataloader = train_dataloader\n if val_dataset is not None:\n datamodule.val_dataloader = val_dataloader\n if test_dataset is not None:\n datamodule.test_dataloader = test_dataloader\n return datamodule","def create_ds(self, data, is_train=True):\n ds = tf.data.Dataset.from_tensor_slices(data)\n map_fn = lambda x, y: (cifar_process(x, is_train), y)\n ds = ds.map(map_fn, num_parallel_calls=tf.data.experimental.AUTOTUNE)\n return ds"],"string":"[\n \"def create_dataloader(data):\\r\\n input_ids = torch.LongTensor([sent['input_ids'] for sent in data])\\r\\n input_mask = torch.LongTensor([sent['input_mask'] for sent in data])\\r\\n segment_ids = torch.LongTensor([sent['segment_ids'] for sent in data])\\r\\n label_ids = torch.LongTensor([sent['label_ids'] for sent in data])\\r\\n\\r\\n dataset = TensorDataset(input_ids, input_mask, segment_ids, label_ids)\\r\\n\\r\\n train_sampler = RandomSampler(dataset)\\r\\n dataloader = DataLoader(dataset, sampler=train_sampler, batch_size=BATCH_SIZE)\\r\\n\\r\\n return dataloader\",\n \"def create_dataset(opt):\\n data_loader = CustomDatasetDataLoader(opt)\\n dataset = data_loader.load_data()\\n return dataset\",\n \"def create_dataset(opt):\\n\\tdata_loader = CustomDatasetDataLoader(opt)\\n\\tdataset = data_loader.load_data()\\n\\treturn dataset\",\n \"def train_dataloader(self) -> torch.utils.data.DataLoader: \\n return torch.utils.data.DataLoader(self.dataset_train, **self.dl_kwargs)\",\n \"def dataloader(self):\\n\\n # load / split data\\n train_data = self.data.get_train_data()\\n if self.args.use_dev:\\n train_data, dev_data = self.data.split_data(train_data)\\n test_data = self.data.get_test_data()\\n\\n #print(train_data[0])\\n #print(dev_data[0])\\n #print(test_data[0])\\n\\n # build dataset\\n train_dataset = self.loader.build_dataset(\\n train_data, \\n self.args.train_max_seq_len)\\n train_loader = self.loader.build_dataloader(\\n train_dataset, 'train')\\n\\n test_dataset = self.loader.build_dataset(\\n test_data,\\n self.args.eval_max_seq_len)\\n test_loader = self.loader.build_dataloader(\\n test_dataset, 'test')\\n\\n if self.args.use_dev:\\n dev_dataset = self.loader.build_dataset(\\n dev_data,\\n self.args.eval_max_seq_len)\\n dev_loader = self.loader.build_dataloader(\\n dev_dataset, 'dev')\\n return train_loader, dev_loader, test_loader\\n else:\\n return train_loader, test_loader\",\n \"def torch_dataset_loader(dataset, batch_size, shuffle, kwargs):\\n loader = DataLoader(TorchData(dataset),\\n batch_size=batch_size,\\n shuffle=shuffle,\\n **kwargs)\\n return loader\",\n \"def train_dataloader(self) -> DataLoader:\\n return DataLoader(\\n self.train_dataset,\\n batch_size=self.hparams.batch_size,\\n shuffle=True,\\n num_workers=multiprocessing.cpu_count(),\\n )\",\n \"def dataloader(self):\\n return DataLoader\",\n \"def to_DataLoader(self, **kwargs):\\r\\n return DataLoader(self, **kwargs)\",\n \"def get_dataloader(self):\\n shuffle = True if self.mode == \\\"train\\\" else False\\n return DataLoader(self.get_dataset(), batch_size=self.batch_size, shuffle = shuffle, \\n collate_fn=create_mini_batch)\",\n \"def _get_dataloader(samples, batch_size):\\n print(\\\"Cogiendo dataloader\\\")\\n return DataLoader(samples, shuffle=True, batch_size=batch_size)\",\n \"def test_dataloader(self) -> torch.utils.data.DataLoader: \\n return torch.utils.data.DataLoader(self.dataset_test, **self.dl_kwargs)\",\n \"def create_dataloader(datafile, dataset_type, batch_size, mechanism, shuffle=False):\\n dataset = MazeDataset(datafile, dataset_type)\\n assert dataset.num_actions == mechanism.num_actions\\n return torch.utils.data.DataLoader(\\n dataset, batch_size=batch_size, shuffle=shuffle, num_workers=0)\",\n \"def build_dataloader(bs, shfle):\\n # change get_labels to correct version (classification vs regression)\\n dataset = TensorDataset(rand_data(), get_labels())\\n dataset = TensorDataset(rand_data(), get_regression_labels())\\n\\n return DataLoader(dataset, batch_size=bs, shuffle=shfle, num_workers=0)\",\n \"def get_dataloader(dataset, batchsize):\\n\\n train_set_size = int(0.8 * dataset.__len__())\\n train_indices = np.random.choice(np.arange(dataset.__len__()),\\n train_set_size, replace=False)\\n train_sampler = SubsetRandomSampler(train_indices)\\n\\n val_indices = np.setdiff1d(np.arange(dataset.__len__()),\\n train_indices, assume_unique=True)\\n val_sampler = SubsetRandomSampler(val_indices)\\n\\n trainloader = DataLoader(dataset, batch_size=batchsize,\\n sampler=train_sampler, num_workers=2)\\n valloader = DataLoader(dataset, batch_size=batchsize,\\n sampler=val_sampler, num_workers=2)\\n\\n return trainloader, valloader\",\n \"def create_train_dataloader(configs):\\n train_lidar_aug = OneOf([\\n Random_Rotation(limit_angle=np.pi / 4, p=1.0),\\n Random_Scaling(scaling_range=(0.95, 1.05), p=1.0),\\n ], p=0.66)\\n train_dataset = KittiDataset(configs, mode='train', lidar_aug=train_lidar_aug, hflip_prob=configs.hflip_prob,\\n num_samples=configs.num_samples)\\n train_sampler = None\\n if configs.distributed:\\n train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)\\n train_dataloader = DataLoader(train_dataset, batch_size=configs.batch_size, shuffle=(train_sampler is None),\\n pin_memory=configs.pin_memory, num_workers=configs.num_workers, sampler=train_sampler)\\n\\n return train_dataloader, train_sampler\",\n \"def train_dataloader(self) -> DataLoader:\\n return self._custom_data_loader()\",\n \"def from_torch(\\n dataset: \\\"torch.utils.data.Dataset\\\",\\n) -> Dataset:\\n return from_items(list(dataset))\",\n \"def test_dataloader(self) -> DataLoader:\\n return DataLoader(\\n self.test_dataset,\\n batch_size=self.hparams.batch_size,\\n shuffle=False,\\n num_workers=multiprocessing.cpu_count(),\\n )\",\n \"def get_dataloader(params, format_name='hdf5', **kwargs):\\n \\n Provider = get_proper_provider(format_name)(params.modality)\\n \\n return DataLoader(Provider(params.dataset_path,\\n seq_length=params.seq_length),\\n batch_size=params.batch_size,\\n shuffle=params.is_training,\\n num_workers=params.num_workers,\\n pin_memory=params.cuda,\\n collate_fn=pad_collate)\",\n \"def create_loader(dataset: Dataset, cfg: trainer_configs.BaseDatasetConfig, batch_size: int, *,\\r\\n collate_fn: Optional[Callable[[List[Any]], Any]] = None) -> DataLoader:\\r\\n # return DataLoader(\\r\\n # dataset, batch_size=batch_size, num_workers=cfg.num_workers,\\r\\n # drop_last=cfg.drop_last, collate_fn=collate_fn) # type: ignore\\r\\n return DataLoader(\\r\\n dataset, batch_size=batch_size, shuffle=cfg.shuffle, num_workers=cfg.num_workers,\\r\\n drop_last=cfg.drop_last, collate_fn=collate_fn) # type: ignore\\r\",\n \"def _create_dataset(self, *data):\\n # Make sure data is a tuple of dense tensors\\n data = [self._to_torch(x, dtype=torch.FloatTensor) for x in data]\\n return TensorDataset(*data)\",\n \"def get_dataloader(self, cid, batch_size=None, type=\\\"train\\\"):\\n dataset = self.get_dataset(cid, type)\\n batch_size = len(dataset) if batch_size is None else batch_size\\n data_loader = DataLoader(dataset, batch_size=batch_size)\\n return data_loader\",\n \"def get_loader(data, json, batch_size, shuffle, num_workers):\\n dataset = FinNumDataset(data, json)\\n\\n data_loader = torch.utils.data.DataLoader(dataset=dataset,\\n batch_size=batch_size,\\n shuffle=shuffle,\\n num_workers=num_workers,\\n collate_fn=collate_fn)\\n return data_loader\",\n \"def Dataloader(dataset, batch_size, shuffle=False, drop_last=False, shuffle_buffer_size=10000):\\n\\n if shuffle:\\n dataset = Shuffle(dataset, buffer_size=shuffle_buffer_size)\\n\\n dataset = Batch(dataset, batch_size=batch_size, drop_last=drop_last)\\n dataset = dataset.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)\\n\\n return dataset\",\n \"def _custom_data_loader(self) -> DataLoader:\\n dataloaders = DataLoader(self.dataset, batch_size=1)\\n return dataloaders\",\n \"def test_dataloader(self) -> data.DataLoader:\\n return data.DataLoader(dataset=self.datasets['test'], batch_size=self.batch_size,\\n num_workers=self.num_workers, shuffle=False, pin_memory=False)\",\n \"def create_dataset(dataset_type, soruce, opts): \\n\\n p = PreProcessor(dataset_type, opts)\\n\\n # If we are NOT running \\\"implementation.py\\\", we read the data from file\\n if dataset_type == \\\"train\\\" or dataset_type == \\\"dev\\\" or dataset_type == \\\"test\\\":\\n path_to_data = soruce\\n p.read_labelled_data(path_to_data) \\n # Otherwise, we read the sentence that \\\"implementation.py\\\" gave us\\n elif dataset_type == \\\"submit\\\":\\n submission_sentence = soruce\\n p.read_test_data(submission_sentence)\\n\\n # Encode all the data to a list of torchTensors\\n encoded_tokens, encoded_pred, encoded_tokens_pos, encoded_labels = p.encode_all_data()\\n # Create SRL dataset\\n dataset = SRLDataset(x=encoded_tokens, pr=encoded_pred, p=encoded_tokens_pos, y=encoded_labels)\\n print(\\\"{} dataset size is {}\\\".format(dataset_type, len(dataset)))\\n\\n if dataset_type == \\\"train\\\" or dataset_type == \\\"dev\\\" or dataset_type == \\\"test\\\":\\n return dataset\\n elif dataset_type == \\\"submit\\\":\\n return dataset, p.list_l_original_predicates\",\n \"def data_loader(\\n self, batch_size: int = 1, iter_steps: int = 0, batch_as_list: bool = True\\n ) -> DataLoader:\\n data = self.data\\n datasets = []\\n\\n for _, dat in data.items():\\n datasets.append(dat.dataset())\\n\\n if len(datasets) < 1:\\n raise FileNotFoundError(\\n \\\"no datasets available for this model to create a loader from\\\"\\n )\\n\\n return DataLoader(\\n *datasets,\\n batch_size=batch_size,\\n iter_steps=iter_steps,\\n batch_as_list=batch_as_list,\\n )\",\n \"def get_dataloader(self, hdf_path, data_description=None):\\r\\n if data_description is None:\\r\\n data_description = \\\"data\\\"\\r\\n print(f\\\"* Loading preprocessed {data_description}.\\\", flush=True)\\r\\n\\r\\n dataset = HDFDataset(hdf_path)\\r\\n dataloader = BlockDataLoader(dataset=dataset,\\r\\n batch_size=self.C.batch_size,\\r\\n block_size=self.C.block_size,\\r\\n shuffle=True,\\r\\n n_workers=self.C.n_workers,\\r\\n pin_memory=True)\\r\\n self.print_time_elapsed()\\r\\n\\r\\n return dataloader\",\n \"def data_loader(root, batch_size=64):\\n input_transform = get_transform()\\n dataset = CustomDataset(root, input_transform)\\n return data.DataLoader(dataset=dataset,\\n batch_size=batch_size,\\n shuffle=False)\",\n \"def _init_dataset(self, data_config, split='train'):\\n assert split in {'train', 'valid'}\\n\\n # load datasets\\n print(f'Load {split} dataset')\\n if data_config['type'] == 'npy':\\n dataset = MSDMelDataset(\\n data_config['mel_root'], data_config[f'{split}_tids_fn'],\\n data_config['label_fn'], on_mem=data_config['on_mem'],\\n ignore_intersection=data_config['ignore_label_intersection'],\\n transform=ToVariable())\\n\\n elif data_config['type'] == 'hdf':\\n dataset = MSDMelHDFDataset(\\n data_config['hdf_fn'], data_config[f'{split}_tids_fn'],\\n data_config['label_fn'],\\n ignore_intersection=data_config['ignore_label_intersection'],\\n transform=ToVariable())\\n\\n elif data_config['type'] == 'audio':\\n dataset = MSDAudioDataset(\\n data_config['audio_root'], data_config[f'{split}_tids_fn'],\\n data_config['tid2path_fn'], data_config['label_fn'],\\n ignore_intersection=data_config['ignore_label_intersection'],\\n device='cpu',\\n transform=ToVariable())\\n\\n return dataset\",\n \"def test_dataloader(self) -> DataLoader:\\n return self._custom_data_loader()\",\n \"def create_test_dataloader(configs):\\n\\n test_dataset = KittiDataset(configs, mode='test', lidar_aug=None, hflip_prob=0., num_samples=configs.num_samples)\\n test_sampler = None\\n if configs.distributed:\\n test_sampler = torch.utils.data.distributed.DistributedSampler(test_dataset)\\n test_dataloader = DataLoader(test_dataset, batch_size=configs.batch_size, shuffle=False,\\n pin_memory=configs.pin_memory, num_workers=configs.num_workers, sampler=test_sampler)\\n\\n return test_dataloader\",\n \"def build_dataloader(cfg, augmentor=None, mode='train', dataset=None, rank=None,\\n dataset_class=VolumeDataset, dataset_options={}, cf=collate_fn_train):\\n assert mode in ['train', 'val', 'test']\\n print('Mode: ', mode)\\n\\n if mode == 'train':\\n batch_size = cfg.SOLVER.SAMPLES_PER_BATCH\\n elif mode == 'val':\\n batch_size = cfg.SOLVER.SAMPLES_PER_BATCH * 4\\n else:\\n cf = collate_fn_test # update the collate function\\n batch_size = cfg.INFERENCE.SAMPLES_PER_BATCH * cfg.SYSTEM.NUM_GPUS\\n\\n if dataset is None: # no pre-defined dataset instance\\n if cfg.MODEL.TARGET_OPT_MULTISEG_SPLIT is not None:\\n dataset_class = VolumeDatasetMultiSeg\\n dataset = get_dataset(cfg, augmentor, mode, rank, dataset_class, dataset_options)\\n\\n sampler = None\\n num_workers = cfg.SYSTEM.NUM_CPUS\\n if cfg.SYSTEM.DISTRIBUTED:\\n num_workers = cfg.SYSTEM.NUM_CPUS // cfg.SYSTEM.NUM_GPUS\\n if cfg.DATASET.DISTRIBUTED == False:\\n sampler = torch.utils.data.distributed.DistributedSampler(dataset)\\n\\n # In PyTorch, each worker will create a copy of the Dataset, so if the data\\n # is preload the data, the memory usage should increase a lot.\\n # https://discuss.pytorch.org/t/define-iterator-on-dataloader-is-very-slow/52238/2\\n img_loader = torch.utils.data.DataLoader(\\n dataset, batch_size=batch_size, shuffle=False, collate_fn=cf,\\n sampler=sampler, num_workers=num_workers, pin_memory=True)\\n\\n return img_loader\",\n \"def data_creator(config):\\n train_dataset, val_dataset = LinearDataset(2, 5), LinearDataset(2, 5)\\n train_loader = DataLoader(train_dataset, batch_size=config[\\\"batch_size\\\"])\\n val_loader = DataLoader(val_dataset, batch_size=config[\\\"batch_size\\\"])\\n return train_loader, val_loader\",\n \"def get_loader(\\n data_source: Iterable[dict],\\n open_fn: Callable,\\n dict_transform: Callable = None,\\n sampler=None,\\n collate_fn: Callable = default_collate_fn,\\n batch_size: int = 32,\\n num_workers: int = 4,\\n shuffle: bool = False,\\n drop_last: bool = False,\\n):\\n from catalyst.data.dataset import ListDataset\\n\\n dataset = ListDataset(\\n list_data=data_source, open_fn=open_fn, dict_transform=dict_transform,\\n )\\n loader = torch.utils.data.DataLoader(\\n dataset=dataset,\\n sampler=sampler,\\n collate_fn=collate_fn,\\n batch_size=batch_size,\\n num_workers=num_workers,\\n shuffle=shuffle,\\n pin_memory=torch.cuda.is_available(),\\n drop_last=drop_last,\\n )\\n return loader\",\n \"def prepare_dataloader(opt, dataobj):\\n\\n def load_data(name):\\n with open(name, 'rb') as f:\\n data = pickle.load(f)\\n num_types = 1 # There is no event type prediction, hence using a dummy value, this will basically be a constant value field\\n return data, num_types\\n\\n print('[Info] Loading train data...')\\n train_data, num_types = load_data(opt.data + 'train_ny.pkl')\\n print('[Info] Loading dev data...')\\n val_data, _ = load_data(opt.data + 'val_ny.pkl')\\n print('[Info] Loading test data...')\\n test_data, _ = load_data(opt.data + 'test_ny.pkl')\\n\\n trainloader = get_dataloader(train_data, opt.batch_size, shuffle=True)\\n validationloader = get_dataloader(val_data, opt.batch_size, shuffle=True)\\n testloader = get_dataloader(test_data, opt.batch_size, shuffle=False)\\n return trainloader, validationloader, testloader, num_types\",\n \"def build_dataloader(dataset,\\n samples_per_gpu,\\n workers_per_gpu,\\n num_gpus=1,\\n dist=True,\\n shuffle=True,\\n seed=None,\\n drop_last=False,\\n pin_memory=True,\\n dataloader_type='PoolDataLoader',\\n **kwargs):\\n rank, world_size = get_dist_info()\\n if dist:\\n sampler = DistributedSampler(\\n dataset, world_size, rank, shuffle=shuffle)\\n shuffle = False\\n batch_size = samples_per_gpu\\n num_workers = workers_per_gpu\\n else:\\n sampler = None\\n batch_size = num_gpus * samples_per_gpu\\n num_workers = num_gpus * workers_per_gpu\\n\\n init_fn = partial(\\n worker_init_fn, num_workers=num_workers, rank=rank,\\n seed=seed) if seed is not None else None\\n\\n assert dataloader_type in (\\n 'DataLoader',\\n 'PoolDataLoader'), f'unsupported dataloader {dataloader_type}'\\n\\n if dataloader_type == 'PoolDataLoader':\\n dataloader = PoolDataLoader\\n elif dataloader_type == 'DataLoader':\\n dataloader = DataLoader\\n\\n data_loader = dataloader(\\n dataset,\\n batch_size=batch_size,\\n sampler=sampler,\\n num_workers=num_workers,\\n collate_fn=partial(collate_fn, samples_per_gpu=samples_per_gpu),\\n pin_memory=pin_memory,\\n shuffle=shuffle,\\n worker_init_fn=init_fn,\\n drop_last=drop_last,\\n **kwargs)\\n\\n return data_loader\",\n \"def get_dataloader(dataset, datadir, train_bs, test_bs, dataidxs=None, noise_level=0, net_id=None, total=0):\\n if dataset in ('mnist', 'femnist', 'fmnist', 'cifar10','cifar100', 'svhn', 'generated', 'covtype', 'a9a', 'rcv1', 'SUSY','tinyimagenet'):\\n if dataset == 'mnist':\\n dl_obj = MNIST_truncated\\n\\n transform_train = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n\\n elif dataset == 'femnist':\\n dl_obj = FEMNIST\\n transform_train = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n\\n elif dataset == 'fmnist':\\n dl_obj = FashionMNIST_truncated\\n transform_train = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n\\n elif dataset == 'svhn':\\n dl_obj = SVHN_custom\\n transform_train = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n\\n\\n elif dataset == 'cifar10':\\n dl_obj = CIFAR10_truncated\\n\\n transform_train = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Lambda(lambda x: F.pad(\\n Variable(x.unsqueeze(0), requires_grad=False),\\n (4, 4, 4, 4), mode='reflect').data.squeeze()),\\n transforms.ToPILImage(),\\n transforms.RandomCrop(32),\\n transforms.RandomHorizontalFlip(),\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)\\n ])\\n # data prep for test set\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n AddGaussianNoise(0., noise_level, net_id, total)])\\n \\n elif dataset == 'cifar100':\\n dl_obj = CIFAR100_truncated\\n\\n normalize = transforms.Normalize(mean=[0.5070751592371323, 0.48654887331495095, 0.4409178433670343],\\n std=[0.2673342858792401, 0.2564384629170883, 0.27615047132568404])\\n # transform_train = transforms.Compose([\\n # transforms.RandomCrop(32),\\n # transforms.RandomHorizontalFlip(),\\n # transforms.ToTensor(),\\n # normalize\\n # ])\\n transform_train = transforms.Compose([\\n # transforms.ToPILImage(),\\n transforms.RandomCrop(32, padding=4),\\n transforms.RandomHorizontalFlip(),\\n transforms.RandomRotation(15),\\n transforms.ToTensor(),\\n normalize\\n ])\\n # data prep for test set\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n normalize])\\n\\n elif dataset == 'tinyimagenet': \\n # random_ids = np.random.randint(1000, size=datasize)\\n # train_indices = random_ids\\n\\n imagenet_mean = [0.485, 0.456, 0.406]\\n imagenet_std = [0.229, 0.224, 0.225]\\n\\n train_dl = torch.utils.data.DataLoader(\\n torchvision.datasets.ImageFolder(datadir +\\\"/train\\\",\\n transform=transforms.Compose([\\n transforms.Resize(32), \\n transforms.ToTensor(),\\n # Phuong 09/26 change (mean, std) -> same as pretrained imagenet\\n transforms.Normalize(mean=imagenet_mean, std=imagenet_std)])),\\n #Phuong 09/26 drop_last=False -> True\\n batch_size=train_bs, drop_last=True)\\n \\n test_dl = torch.utils.data.DataLoader(\\n torchvision.datasets.ImageFolder(datadir +\\\"/test\\\",\\n transform=transforms.Compose([\\n transforms.Resize(32), \\n transforms.ToTensor(),\\n # Phuong 09/26 change (mean, std) -> same as pretrained imagenet\\n transforms.Normalize(mean=imagenet_mean, std=imagenet_std)])),\\n #Phuong 09/26 drop_last=False -> True\\n batch_size=test_bs, drop_last=True)\\n\\n return train_dl, test_dl, None, None\\n\\n\\n else:\\n dl_obj = Generated\\n transform_train = None\\n transform_test = None\\n\\n\\n train_ds = dl_obj(datadir, dataidxs=dataidxs, train=True, transform=transform_train, download=True)\\n test_ds = dl_obj(datadir, train=False, transform=transform_test, download=True)\\n\\n train_dl = data.DataLoader(dataset=train_ds, batch_size=train_bs, shuffle=True, drop_last= dataset in ['cifar100'])\\n test_dl = data.DataLoader(dataset=test_ds, batch_size=test_bs, shuffle=False, drop_last=False)\\n\\n return train_dl, test_dl, train_ds, test_ds\",\n \"def _create_data_loader(self, data, **kwargs):\\n if data is None:\\n return None\\n\\n # Set DataLoader config\\n # NOTE: Not applicable if data is already a DataLoader\\n config = {\\n **self.config[\\\"train_config\\\"][\\\"data_loader_config\\\"],\\n **kwargs,\\n \\\"pin_memory\\\": self.config[\\\"device\\\"] != \\\"cpu\\\",\\n }\\n # Return data as DataLoader\\n if isinstance(data, DataLoader):\\n return data\\n elif isinstance(data, Dataset):\\n return DataLoader(data, **config)\\n elif isinstance(data, (tuple, list)):\\n return DataLoader(self._create_dataset(*data), **config)\\n else:\\n raise ValueError(\\\"Input data type not recognized.\\\")\",\n \"def get_data_loader(batch_size=10, num_workers=2):\\n \\n data_loader = torch.utils.data.DataLoader(dataset=TempuckeyDataSet(),\\n batch_size=batch_size,\\n shuffle=True,\\n pin_memory=True,\\n num_workers=num_workers,\\n collate_fn=collate)\\n return data_loader\",\n \"def val_dataloader(self) -> torch.utils.data.DataLoader: \\n return torch.utils.data.DataLoader(self.dataset_valid, **self.dl_kwargs)\",\n \"def train_dataloader(self):\\r\\n\\r\\n # transformation\\r\\n train_transform = Compose(\\r\\n [\\r\\n ApplyTransformToKey(\\r\\n key='video',\\r\\n transform=Compose(\\r\\n [\\r\\n UniformTemporalSubsample(8),\\r\\n Lambda(lambda x: x / 255.0),\\r\\n Normalize((0.45, 0.45, 0.45), (0.225, 0.225, 0.225)),\\r\\n RandomShortSideScale(min_size=256, max_size=320),\\r\\n RandomCrop(244),\\r\\n RandomHorizontalFlip(p=0.5),\\r\\n ]\\r\\n )\\r\\n )\\r\\n ]\\r\\n )\\r\\n\\r\\n train_dataset = pv.data.Kinetics(\\r\\n data_path=os.path.join(self._DATA_PATH, \\\"train\\\"),\\r\\n clip_sampler=pv.data.make_clip_sampler(\\\"random\\\", self._CLIP_DURATION),\\r\\n decode_audio=False,\\r\\n transform=train_transform\\r\\n )\\r\\n return torch.utils.data.DataLoader(\\r\\n train_dataset,\\r\\n batch_size=self._BATCH_SIZE,\\r\\n num_workers=self._NUM_WORKERS,\\r\\n )\",\n \"def create_dataset_downloader(source_uri, **kwargs):\\n downloader_class = _find_downloader(source_uri=source_uri)\\n return downloader_class(**kwargs)\",\n \"def get_dataloader(path, chars_include, transform):\\n return WSDataLoader(path, chars_include=chars_include, batch_size=64, transform=transform, return_path=True)\",\n \"def make_standard_loader(self, dataset):\\n return torch.utils.data.DataLoader(\\n dataset,\\n batch_size=self.batch_size,\\n shuffle=False,\\n drop_last=False,\\n pin_memory=not (cfg.DEBUG > 0),\\n num_workers=self.num_workers,\\n )\",\n \"def train_dataloader(self, batch_size: Optional[int] = None) -> DataLoader:\\n dataset = TabularDataset(\\n task=self.config.task,\\n data=self.train,\\n categorical_cols=self.config.categorical_cols,\\n continuous_cols=self.config.continuous_cols,\\n embed_categorical=(not self.do_leave_one_out_encoder()),\\n target=self.target,\\n )\\n return DataLoader(\\n dataset,\\n batch_size if batch_size is not None else self.batch_size,\\n shuffle=True if self.train_sampler is None else False,\\n num_workers=self.config.num_workers,\\n sampler=self.train_sampler,\\n pin_memory=self.config.pin_memory,\\n )\",\n \"def __init__(self, dataset: Dataset):\\n self.dataset = dataset\",\n \"def batch_loader(data_set: Union[IterableDataset, Dataset],\\n batch_size: bool,\\n shuffle=False) -> DataLoader:\\n return DataLoader(\\n data_set,\\n batch_size=batch_size,\\n collate_fn=lambda x: x,\\n shuffle=shuffle\\n )\",\n \"def load_dataset(dest = \\\"./Datasets/IsophonicsDataset.ds\\\") -> 'IsophonicsDataset':\\n with lzma.open(dest, \\\"rb\\\") as dataset_file:\\n loaded_dataset = pickle.load(dataset_file)\\n\\n data, chords, keys, sample_rate, nfft = loaded_dataset\\n\\n dataset = IsophonicsDataset()\\n\\n dataset.DATA = data\\n dataset.CHORDS = chords\\n dataset.KEYS = keys\\n dataset.SAMPLE_RATE = sample_rate\\n dataset.NFFT = nfft\\n\\n print(\\\"[INFO] The Isophonics Dataset was loaded successfully.\\\")\\n return dataset\",\n \"def __init__(self, dataloader):\\n self._dataloader = dataloader\\n\\n self._iterator = iter(self._dataloader)\",\n \"def get_test_dataset_DataLoader(self):\\n test_info = self.get_test_DataLoader_info()\\n name = test_info[\\\"name\\\"]\\n task = test_info[\\\"task\\\"]\\n data_dir = test_info[\\\"data_dir\\\"]\\n hdf5_file = test_info[\\\"hdf5_file\\\"]\\n\\n data_loader = DataLoader(name, task, data_dir, hdf5_file)\\n\\n return data_loader, self.dataset, self.data_fields\",\n \"def get_data_loader (imgs_path, labels, extra_info=None, transform=None, params=None):\\n\\n\\n dt = BuildDataset(imgs_path, labels, extra_info, transform)\\n\\n # Checking the params values. If it's not defined in params of if params is None, the default values are described\\n # below:\\n batch_size = 30\\n shuf = True\\n num_workers = 4\\n pin_memory = True\\n\\n # However, if the params is defined, we used the values described on it:\\n if (params is not None):\\n if ('batch_size' in params.keys()):\\n batch_size = params['batch_size']\\n if ('shuf' in params.keys()):\\n shuf = params['shuf']\\n if ('num_workers' in params.keys()):\\n num_workers = params['num_workers']\\n if ('pin_memory' in params.keys()):\\n pin_memory = params['pin_memory']\\n\\n # Calling the dataloader\\n dl = data.DataLoader (dataset=dt, batch_size=batch_size, shuffle=shuf, num_workers=num_workers,\\n pin_memory=pin_memory)\\n\\n return dl\",\n \"def __init__(self, **kwargs):\\n DataLoader.__init__(self, **kwargs)\",\n \"def get_dataloader(hp: HParams) \\\\\\n -> Tuple[torch.utils.data.DataLoader, torch.utils.data.DataLoader, int]:\\n if hp.data.dataset == \\\"podcast\\\":\\n dataset = podcast.PODCAST(root=hp.data.path,\\n audio_folder=hp.data.audio_folder,\\n text_file=hp.data.text_file)\\n length = len(dataset)\\n train_length = int(0.9 * length)\\n train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_length,\\n length - train_length])\\n\\n # https://towardsdatascience.com/7-tips-for-squeezing-maximum-performance-from-pytorch-ca4a40951259\\n train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,\\n batch_size=hp.training.batch_size,\\n shuffle=False,\\n num_workers=hp.training.num_workers,\\n collate_fn=collatedata.AudioCollatePodcast(),\\n pin_memory=True)\\n test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,\\n batch_size=hp.training.batch_size,\\n shuffle=False,\\n num_workers=hp.training.num_workers,\\n collate_fn=collatedata.AudioCollatePodcast(),\\n pin_memory=True)\\n return train_dataloader, test_dataloader, int(0.9 * length)\\n\\n elif hp.data.dataset == \\\"librispeech\\\":\\n Path(hp.data.path).mkdir(parents=True, exist_ok=True)\\n dataset = librispeech.download_data(root=hp.data.path, url=hp.data.url)\\n length = len(dataset)\\n train_length = int(0.9 * length)\\n train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_length,\\n length - train_length])\\n train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,\\n batch_size=hp.training.batch_size,\\n shuffle=False,\\n num_workers=hp.training.num_workers,\\n collate_fn=collatedata.AudioCollatePodcast(),\\n pin_memory=True)\\n test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,\\n batch_size=hp.training.batch_size,\\n shuffle=False,\\n num_workers=hp.training.num_workers,\\n collate_fn=collatedata.AudioCollatePodcast(),\\n pin_memory=True)\\n return train_dataloader, test_dataloader, int(0.9 * length)\\n\\n elif hp.data.dataset == \\\"ljspeech\\\":\\n Path(hp.data.path).mkdir(parents=True, exist_ok=True)\\n dataset = ljspeech.download_data(root=hp.data.path)\\n length = len(dataset)\\n train_length = int(0.9 * length)\\n train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_length,\\n length - train_length])\\n train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset,\\n batch_size=hp.training.batch_size,\\n shuffle=False,\\n num_workers=hp.training.num_workers,\\n collate_fn=collatedata.AudioCollatePodcast(),\\n pin_memory=True)\\n test_dataloader = torch.utils.data.DataLoader(dataset=test_dataset,\\n batch_size=hp.training.batch_size,\\n shuffle=False,\\n num_workers=hp.training.num_workers,\\n collate_fn=collatedata.AudioCollatePodcast(),\\n pin_memory=True)\\n\\n return train_dataloader, test_dataloader, int(0.9 * length)\\n\\n else:\\n raise Exception(f\\\"Dataset {hp.data.dataset} does not exist\\\")\",\n \"def creates_data_loader():\\n dataset_faces = FaceDataset(\\n IMG_DIR, transform=transform_train, face=True)\\n\\n dataset_no_faces = FaceDataset(\\n IMG_DIR, transform=transform_train, face=False)\\n\\n datasets_faces_split = train_val_test(dataset_faces, 0.2, 0.0)\\n datasets_no_faces_split = train_val_test(dataset_no_faces, 0.2, 0.0)\\n\\n datasets = {}\\n datasets[\\\"train\\\"] = datasets_faces_split[\\\"train\\\"] + \\\\\\n datasets_no_faces_split[\\\"train\\\"]\\n datasets[\\\"test\\\"] = datasets_no_faces_split[\\\"test\\\"]\\n datasets[\\\"val\\\"] = datasets_faces_split[\\\"val\\\"] + \\\\\\n datasets_no_faces_split[\\\"val\\\"]\\n\\n train_loader = DataLoader(dataset=datasets[\\\"train\\\"], batch_size=BATCH_SIZE,\\n num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=False)\\n\\n val_loader = DataLoader(dataset=datasets[\\\"val\\\"], batch_size=BATCH_SIZE,\\n num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=False)\\n return train_loader, val_loader\",\n \"def load_dataset(self, f_handle):\\n # The file handle might be None in which case an exception is raised\\n if f_handle is None:\\n raise ValueError('unknown file')\\n # Expects a file in a supported tabular data format.\\n if not f_handle.is_tabular:\\n raise ValueError('cannot create dataset from file \\\\'' + f_handle.name + '\\\\'')\\n # Open the file as a csv file. Expects that the first row contains the\\n # column names. Read dataset schema and dataset rows into two separate\\n # lists.\\n columns = []\\n rows = []\\n with f_handle.open() as csvfile:\\n reader = csv.reader(csvfile, delimiter=f_handle.delimiter)\\n for col_name in next(reader):\\n columns.append(\\n DatasetColumn(\\n identifier=len(columns),\\n name=col_name.strip()\\n )\\n )\\n for row in reader:\\n values = [cast(v.strip()) for v in row]\\n rows.append(DatasetRow(identifier=len(rows), values=values))\\n # Get unique identifier and create subfolder for the new dataset\\n identifier = get_unique_identifier()\\n dataset_dir = self.get_dataset_dir(identifier)\\n os.makedirs(dataset_dir)\\n # Write rows to data file\\n data_file = os.path.join(dataset_dir, DATA_FILE)\\n DefaultJsonDatasetReader(data_file).write(rows)\\n # Create dataset an write descriptor to file\\n dataset = FileSystemDatasetHandle(\\n identifier=identifier,\\n columns=columns,\\n data_file=data_file,\\n row_count=len(rows),\\n max_row_id=len(rows) - 1\\n )\\n dataset.to_file(\\n descriptor_file=os.path.join(dataset_dir, DESCRIPTOR_FILE)\\n )\\n return dataset\",\n \"def get_dataloader(self, mode, label_mode, batch_size):\\n cached_features_file = self._feature_file(mode, label_mode)\\n logger.info('Loading features from cached file %s', cached_features_file)\\n features = torch.load(cached_features_file)\\n\\n all_input_ids = torch.tensor([f.input_ids for f in features], dtype=torch.long)\\n all_input_mask = torch.tensor([f.input_mask for f in features], dtype=torch.long)\\n all_segment_ids = torch.tensor([f.segment_ids for f in features], dtype=torch.long)\\n all_label_ids = torch.tensor([f.label_ids for f in features], dtype=torch.long)\\n all_emph_probs = torch.tensor([f.emph_probs for f in features], dtype=torch.float)\\n\\n dataset = TensorDataset(all_input_ids, all_input_mask, all_segment_ids, all_label_ids, all_emph_probs)\\n\\n if mode == 'train':\\n sampler = RandomSampler(dataset)\\n else:\\n sampler = SequentialSampler(dataset)\\n\\n dataloader = DataLoader(dataset=dataset, batch_size=batch_size, sampler=sampler)\\n return dataloader\",\n \"def _init_al_dataset(self):\\n\\n self._init_dataset()\\n\\n train_dataset = self.datasets['train']\\n\\n dataset_size = len(train_dataset)\\n self.budget = math.ceil(self.budget_frac*dataset_size)\\n Sampler.__init__(self, config, self.budget) # TODO: Weird place to initialise this\\n\\n all_indices = set(np.arange(dataset_size))\\n k_initial = math.ceil(len(all_indices)*self.initial_budget_frac)\\n initial_indices = random.sample(list(all_indices), k=k_initial)\\n\\n sampler_init = data.sampler.SubsetRandomSampler(initial_indices) # need to sample from training dataset\\n\\n self.labelled_dataloader = data.DataLoader(train_dataset, sampler=sampler_init, batch_size=self.batch_size, drop_last=True)\\n self.val_dataloader = data.DataLoader(self.datasets['valid'], batch_size=self.batch_size, drop_last=False)\\n self.test_dataloader = data.DataLoader(self.datasets['test'], batch_size=self.batch_size, drop_last=False)\\n\\n return all_indices, initial_indices\",\n \"def create_dataset_sampler_loader(file_path, cuda, batch_size, hvd):\\n # When supported, use 'forkserver' to spawn dataloader workers\\n # instead of 'fork' to prevent issues with Infiniband implementations\\n # that are not fork-safe.\\n kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {}\\n if (kwargs.get('num_workers', 0) > 0 and hasattr(mp, '_supports_context')\\n and 'forkserver' in mp.get_all_start_methods()):\\n kwargs['multiprocessing_context'] = 'forkserver'\\n\\n # create dataset\\n dataset = MNISTDataset(file_path)\\n # Horovod: use DistributedSampler to partition the training data\\n sampler = Data.distributed.DistributedSampler(\\n dataset, num_replicas=hvd.size(), rank=hvd.rank())\\n loader = torch.utils.data.DataLoader(\\n dataset, batch_size=batch_size, sampler=sampler, **kwargs)\\n return dataset, sampler, loader\",\n \"def build_data_loader(dataset, micro_batch_size, num_workers, drop_last,\\n task_collate_fn=None):\\n\\n # Sampler.\\n world_size = mpu.get_data_parallel_world_size()\\n rank = mpu.get_data_parallel_rank()\\n sampler = torch.utils.data.distributed.DistributedSampler(\\n dataset, num_replicas=world_size, rank=rank)\\n\\n # Data loader. Note that batch size is the per GPU batch size.\\n data_loader = torch.utils.data.DataLoader(dataset,\\n batch_size=micro_batch_size,\\n sampler=sampler,\\n shuffle=False,\\n num_workers=num_workers,\\n drop_last=drop_last,\\n pin_memory=True,\\n collate_fn=task_collate_fn)\\n\\n return data_loader\",\n \"def train_dataloader(self) -> data.DataLoader:\\n # Random weighted sampler to approach the imbalanced dataset\\n self.weights = [1.0 / i for i in self.weights]\\n\\n _sample_weights = [0] * len(self.datasets['train'])\\n\\n for idx, (_, label) in enumerate(self.datasets['train']):\\n _weight = self.weights[label]\\n _sample_weights[idx] = _weight\\n\\n random_sampler = data.WeightedRandomSampler(_sample_weights,\\n len(self.datasets['train']), replacement=False)\\n\\n return data.DataLoader(dataset=self.datasets['train'], batch_size=self.batch_size,\\n num_workers=self.num_workers, pin_memory=False,\\n sampler=random_sampler)\",\n \"def __init__(self, dataset):\\n self._dataset = dataset\",\n \"def from_disk(cls, path: Path, loader_func: Callable = read_jsonl):\\n return Dataset(\\n loader_func(path / 'train.jsonl'),\\n loader_func(path / 'dev.jsonl'),\\n test=loader_func(path / 'test.jsonl')\\n )\",\n \"def make_dataloaders(params):\\r\\n transform_train = transforms.Compose([transforms.RandomCrop(32, padding=4),\\r\\n transforms.RandomHorizontalFlip(),\\r\\n transforms.ToTensor(),\\r\\n transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010])])\\r\\n\\r\\n transform_validation = transforms.Compose([transforms.ToTensor(),\\r\\n transforms.Normalize([0.4914, 0.4822, 0.4465],\\r\\n [0.2023, 0.1994, 0.2010])])\\r\\n\\r\\n transform_validation = transforms.Compose([transforms.ToTensor()])\\r\\n\\r\\n trainset = torchvision.datasets.CIFAR10(root=params['path'], train=True, transform=transform_train)\\r\\n testset = torchvision.datasets.CIFAR10(root=params['path'], train=False, transform=transform_validation)\\r\\n\\r\\n trainloader = torch.utils.data.DataLoader(trainset, batch_size=params['batch_size'], shuffle=True, num_workers=4)\\r\\n testloader = torch.utils.data.DataLoader(testset, batch_size=params['batch_size'], shuffle=False, num_workers=4)\\r\\n return trainloader, testloader\",\n \"def get_lsun_dataloader(path_to_data='../lsun', dataset='bedroom_train',\\n batch_size=64):\\n # Compose transforms\\n transform = transforms.Compose([\\n transforms.Resize(128),\\n transforms.CenterCrop(128),\\n transforms.ToTensor()\\n ])\\n\\n # Get dataset\\n lsun_dset = datasets.LSUN(db_path=path_to_data, classes=[dataset],\\n transform=transform)\\n\\n # Create dataloader\\n return DataLoader(lsun_dset, batch_size=batch_size, shuffle=True)\",\n \"def get_loader(file_path, src_word2id, trg_word2id, intent_type=None, intent2index=None, batch_size=1):\\n dials = json.load(open(file_path))\\n dataset_list = []\\n for name in dials.keys():\\n val_file = dials[name]\\n # build a custom dataset\\n dataset = MultiwozSingleDataset(val_file, name, src_word2id, trg_word2id, intent_type, intent2index)\\n dataset_list.append(dataset)\\n datasets = ConcatDataset(dataset_list)\\n # data loader for custome dataset\\n data_loader = DataLoader(dataset=datasets,\\n batch_size=batch_size,\\n shuffle=True,\\n num_workers=0,\\n collate_fn=collate_fn)\\n return data_loader\",\n \"def importDataset():\\n module_path = os.path.join(path, \\\"dataset\\\")\\n module_path = os.path.join(module_path, \\\"dataset.py\\\")\\n dataset_class = importClass(\\\"Dataset\\\", \\\"dataset\\\", module_path)\\n return dataset_class\",\n \"def prepare_demo_dataset(path, reso, batch_size=1):\\r\\n transform = transforms.Compose([\\r\\n transforms.Resize(size=(reso, reso), interpolation=3),\\r\\n transforms.ToTensor()\\r\\n ])\\r\\n\\r\\n img_datasets = DemoDataset(path, transform)\\r\\n dataloader = torch.utils.data.DataLoader(img_datasets, batch_size=batch_size, num_workers=8)\\r\\n\\r\\n return img_datasets, dataloader\",\n \"def create_dataset(fd, dobj, verbose=False, nodata=False):\\n msg = \\\"creating dataset {}, shape: {}, type: {}\\\".format(dobj.name, dobj.shape, dobj.dtype)\\n logging.info(msg)\\n if verbose:\\n print(msg) \\n \\n fillvalue = None\\n try: \\n # can trigger a runtime error if fillvalue is undefined\\n fillvalue = dobj.fillvalue\\n except RuntimeError:\\n pass # ignore\\n chunks=None\\n if dobj.chunks:\\n chunks = tuple(dobj.chunks)\\n try:\\n dset = fd.create_dataset( dobj.name, shape=dobj.shape, dtype=dobj.dtype, chunks=chunks, \\\\\\n compression=dobj.compression, shuffle=dobj.shuffle, \\\\\\n fletcher32=dobj.fletcher32, maxshape=dobj.maxshape, \\\\\\n compression_opts=dobj.compression_opts, fillvalue=fillvalue, \\\\\\n scaleoffset=dobj.scaleoffset)\\n msg = \\\"dataset created, uuid: {}, chunk_size: {}\\\".format(dset.id.id, str(dset.chunks)) \\n logging.info(msg)\\n if verbose:\\n print(msg)\\n except (IOError, TypeError, KeyError) as e:\\n msg = \\\"ERROR: failed to create dataset: {}\\\".format(str(e))\\n logging.error(msg)\\n print(msg)\\n return\\n # create attributes\\n for da in dobj.attrs:\\n copy_attribute(dset, da, dobj)\\n\\n if nodata:\\n msg = \\\"skipping data load\\\"\\n logging.info(msg)\\n if verbose:\\n print(msg)\\n return\\n\\n if dset.shape is None:\\n # null space dataset\\n msg = \\\"no data for null space dataset: {}\\\".format(dobj.name)\\n logging.info(msg)\\n if verbose:\\n print(msg)\\n return # no data \\n\\n if len(dset.shape) == 0:\\n # scalar dataset\\n x = dobj[()]\\n msg = \\\"writing: {} for scalar dataset: {}\\\".format(x, dobj.name)\\n logging.info(msg)\\n if verbose:\\n print(msg)\\n dset[()] = x\\n return\\n\\n msg = \\\"iterating over chunks for {}\\\".format(dobj.name)\\n logging.info(msg)\\n if verbose:\\n print(msg)\\n try:\\n it = ChunkIterator(dset)\\n\\n logging.debug(\\\"src dtype: {}\\\".format(dobj.dtype))\\n logging.debug(\\\"des dtype: {}\\\".format(dset.dtype))\\n \\n for s in it:\\n msg = \\\"writing dataset data for slice: {}\\\".format(s)\\n logging.info(msg)\\n if verbose:\\n print(msg)\\n arr = dobj[s]\\n dset[s] = arr\\n except (IOError, TypeError) as e:\\n msg = \\\"ERROR : failed to copy dataset data : {}\\\".format(str(e))\\n logging.error(msg)\\n print(msg)\\n msg = \\\"done with dataload for {}\\\".format(dobj.name)\\n logging.info(msg)\\n if verbose:\\n print(msg)\",\n \"def CreateDataset(all_arrays):\\n dataset = Dataset()\\n\\n dataset._addData(all_arrays[0])\\n dataset._addData(all_arrays[1])\\n dataset._addData(all_arrays[3])\\n dataset._addData(all_arrays[5])\\n dataset._addData(all_arrays[6])\\n dataset._addData(all_arrays[9])\\n dataset._addData(all_arrays[8])\\n dataset._addData(all_arrays[4])\\n\\n return dataset\",\n \"def create_dataset():\\n ds_train_raw, ds_test_raw = load_raw_datasets()\\n vectorize_layer = create_vectorizer(ds_train_raw)\\n ds_train = ds_train_raw.map(\\n lambda text, label: (vectorize_layer(text), label)\\n ).prefetch(tf.data.experimental.AUTOTUNE)\\n ds_test = ds_test_raw.map(\\n lambda text, label: (vectorize_layer(text), label)\\n ).prefetch(tf.data.experimental.AUTOTUNE)\\n return ds_train, ds_test, vectorize_layer\",\n \"def create_dataloaders(data_dir):\\n\\n trng_dataset = datasets.ImageFolder(data_dir / TRNG_FOLDER,\\n transform=flowernet.trng_transform)\\n trng_dataloader = torch.utils.data.DataLoader(trng_dataset,\\n batch_size=64,\\n shuffle=True)\\n\\n valn_dataset = datasets.ImageFolder(data_dir / VALN_FOLDER,\\n transform=flowernet.pred_transform)\\n valn_dataloader = torch.utils.data.DataLoader(valn_dataset,\\n batch_size=64,\\n shuffle=True)\\n\\n return trng_dataloader, valn_dataloader\",\n \"def initialise_dataset_loader(\\n self, data_param=None, task_param=None, data_partitioner=None):\\n raise NotImplementedError\",\n \"def create_dataset(base_path, batch_size, is_train):\\n columns_list = [\\\"feature\\\", \\\"label\\\"]\\n num_consumer = 4\\n\\n if is_train:\\n path = os.path.join(base_path, 'aclImdb_train.mindrecord0')\\n else:\\n path = os.path.join(base_path, 'aclImdb_test.mindrecord0')\\n\\n data_set = ds.MindDataset(path, columns_list, num_consumer)\\n ds.config.set_seed(0)\\n data_set = data_set.shuffle(buffer_size=data_set.get_dataset_size())\\n data_set = data_set.batch(batch_size, drop_remainder=True)\\n return data_set\",\n \"def make_dataset(self, df, **kwargs):\\n\\t\\treturn df\",\n \"def get_dataloaders(args):\\n if args.dataset == 'heat':\\n dataset_class = heat.HeatDiffusionDataset\\n else:\\n raise ValueError(f'Unknown dataset {args.dataset}')\\n train_dataset = dataset_class(\\n dataset_class.get_train_path(args.data_path), args, train=True)\\n if args.dist:\\n train_sampler = torch.utils.data.distributed.DistributedSampler(\\n train_dataset)\\n else:\\n train_sampler = torch.utils.data.RandomSampler(train_dataset)\\n train_loader = torch.utils.data.DataLoader(\\n train_dataset, batch_size=args.batch_size, num_workers=args.workers,\\n sampler=train_sampler, pin_memory=True, drop_last=args.drop_last)\\n if not args.no_eval:\\n validation_dataset = dataset_class(\\n dataset_class.get_validation_path(args.data_path), args, train=False)\\n if args.dist:\\n validation_sampler = torch.utils.data.distributed.DistributedSampler(\\n validation_dataset, shuffle=False)\\n else:\\n validation_sampler = torch.utils.data.SequentialSampler(\\n validation_dataset)\\n validation_loader = torch.utils.data.DataLoader(\\n validation_dataset, batch_size=args.batch_size,\\n num_workers=args.workers, sampler=validation_sampler,\\n pin_memory=True, drop_last=args.drop_last)\\n\\n test_dataset = dataset_class(\\n dataset_class.get_test_path(args.data_path), args, train=False)\\n if args.dist:\\n test_sampler = torch.utils.data.distributed.DistributedSampler(\\n test_dataset, shuffle=False)\\n else:\\n test_sampler = torch.utils.data.SequentialSampler(\\n test_dataset)\\n test_loader = torch.utils.data.DataLoader(\\n test_dataset, batch_size=args.batch_size,\\n num_workers=args.workers, sampler=test_sampler,\\n pin_memory=True, drop_last=args.drop_last)\\n else:\\n validation_loader = None\\n test_loader = None\\n\\n # Update the data shape if needed.\\n if args.data_shape is None:\\n args.data_shape = train_dataset.get_shape()\\n if args.data_target_shape is None:\\n args.data_target_shape = train_dataset.get_target_shape()\\n\\n return train_loader, validation_loader, test_loader\",\n \"def create_dataset(cfg, xlmr, label2id):\\n assert exists(cfg.data_dir), \\\\\\n '{} does not exist.'.format(cfg.data_dir)\\n\\n metadata_path = join(\\n cfg.data_dir, 'metadata.json')\\n\\n if not exists(metadata_path):\\n # if dataset does not exist then create it\\n # by tokenizing the raw files\\n\\n splits = [\\n join(cfg.data_dir, 'train.jsonl'),\\n join(cfg.data_dir, 'valid.jsonl')\\n ]\\n\\n splits = tqdm(\\n splits, \\n desc='Converting to tfrecord',\\n leave=False\\n )\\n\\n train, valid = [\\n transform_split(\\n cfg=cfg,\\n file_name=file_name,\\n xlmr=xlmr,\\n label2id=label2id)\\n for file_name in splits]\\n\\n train_tfrecords, train_size = train\\n valid_tfrecords, valid_size = valid\\n\\n print('Saving metadata to {}'.format(\\n metadata_path))\\n\\n # save the location of the files in a metadata\\n # json object and delete the file in case of\\n # interrupt so it wont be left in corrupted state\\n with open(metadata_path, 'w') as fh:\\n try:\\n json.dump({\\n 'train': train,\\n 'valid': valid\\n }, fh)\\n except KeyboardInterrupt:\\n shutil.rmtree(metadata_path)\\n\\n print('Loading metadata from {}'.format(\\n metadata_path))\\n\\n with open(metadata_path, 'r') as fh:\\n metadata = json.load(fh)\\n\\n train_tfrecords, train_size = metadata['train']\\n valid_tfrecords, valid_size = metadata['valid']\\n\\n pad_id = xlmr.task.dictionary.pad()\\n\\n train_dataset = create_tfrecord_loader(\\n cfg=cfg,\\n tfrecord_paths=train_tfrecords,\\n size=train_size,\\n pad_id=pad_id,\\n shuffle=True)\\n\\n valid_dataset = create_tfrecord_loader(\\n cfg=cfg,\\n tfrecord_paths=valid_tfrecords,\\n size=valid_size,\\n pad_id=pad_id)\\n\\n return train_dataset, valid_dataset\",\n \"def get_dataloader(data_folder, model_name, data_name, size=\\\"default\\\"):\\n training_set = None\\n validation_set = None\\n\\n if model_name == \\\"Howe_Patterson\\\":\\n if data_name == \\\"combined\\\":\\n partition = []\\n for data_fold in data_folder:\\n partition.append(load_obj(os.path.join(data_fold, 'data_partition.pkl')))\\n\\n elif size == \\\"small\\\":\\n partition = load_obj(os.path.join(data_folder, 'data_partition_small.pkl'))\\n elif size == \\\"tiny\\\":\\n partition = load_obj(os.path.join(data_folder, 'data_partition_tiny.pkl'))\\n else:\\n partition = load_obj(os.path.join(data_folder, 'data_partition.pkl'))\\n\\n\\n if data_name == \\\"SHHS\\\":\\n training_set = Dataset_full_SHHS(partition['train'], data_folder)\\n validation_set = Dataset_full_SHHS(partition['validation'], data_folder)\\n elif data_name == \\\"snooze\\\":\\n training_set = Dataset_full(partition['train'], data_folder)\\n validation_set = Dataset_full(partition['validation'], data_folder)\\n elif data_name == \\\"philips\\\":\\n training_set = Dataset_Philips_full(partition['train'], data_folder)\\n validation_set = Dataset_Philips_full(partition['validation'], data_folder)\\n elif data_name == \\\"HMC\\\":\\n print(\\\"{} not implemented data\\\".format(data_name))\\n exit()\\n elif data_name == \\\"combined\\\":\\n training_set = ConcatDataset(\\n Dataset_full(partition[0]['train'], data_folder[0], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False),\\n Dataset_full_SHHS(partition[1]['train'], data_folder[1], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False))\\n validation_set = ConcatDataset(\\n Dataset_full(partition[0]['validation'], data_folder[0], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False),\\n Dataset_full_SHHS(partition[1]['validation'], data_folder[1], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False))\\n else:\\n print(\\\"{} wrong data for dataloader\\\".format(data_name))\\n exit()\\n elif model_name == \\\"Deep_Sleep\\\":\\n if data_name == \\\"combined\\\":\\n partition = []\\n for data_fold in data_folder:\\n partition.append(load_obj(os.path.join(data_fold, 'data_partition.pkl')))\\n\\n elif size == \\\"small\\\":\\n partition = load_obj(os.path.join(data_folder, 'data_partition_small.pkl'))\\n elif size == \\\"tiny\\\":\\n partition = load_obj(os.path.join(data_folder, 'data_partition_tiny.pkl'))\\n else:\\n partition = load_obj(os.path.join(data_folder, 'data_partition.pkl'))\\n\\n if data_name == \\\"SHHS\\\":\\n training_set = Dataset_full_SHHS(partition['train'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n validation_set = Dataset_full_SHHS(partition['validation'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n elif data_name == \\\"snooze\\\":\\n training_set = Dataset_full(partition['train'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n validation_set = Dataset_full(partition['validation'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n elif data_name == \\\"philips\\\":\\n training_set = Dataset_Philips_full(partition['train'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n validation_set = Dataset_Philips_full(partition['validation'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n elif data_name == \\\"HMC\\\":\\n print(\\\"{} not implemented data\\\".format(data_name))\\n exit()\\n elif data_name == \\\"combined\\\":\\n # TODO combined dataset https://discuss.pytorch.org/t/train-simultaneously-on-two-datasets/649/17\\n training_set = ConcatDataset(\\n Dataset_full(partition[0]['train'], data_folder[0], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False),\\n Dataset_full_SHHS(partition[1]['train'], data_folder[1], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False))\\n validation_set = ConcatDataset(\\n Dataset_full(partition[0]['validation'], data_folder[0], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False),\\n Dataset_full_SHHS(partition[1]['validation'], data_folder[1], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False))\\n else:\\n print(\\\"{} wrong data for dataloader\\\".format(data_name))\\n exit()\\n elif model_name == \\\"ConvNet_IID\\\":\\n if data_name == \\\"combined\\\":\\n partition = []\\n for data_fold in data_folder:\\n partition.append(load_obj(os.path.join(data_fold, 'data_partition_IID_windows.pkl')))\\n else:\\n partition = load_obj(os.path.join(data_folder, 'data_partition_IID_windows.pkl'))\\n if data_name == \\\"SHHS\\\":\\n training_set = Dataset_IID_window_SHHS(partition['train'], data_folder)\\n validation_set = Dataset_IID_window_SHHS(partition['validation'], data_folder)\\n elif data_name == \\\"snooze\\\":\\n training_set = Dataset_IID_window(partition['train'], data_folder)\\n validation_set = Dataset_IID_window(partition['validation'], data_folder)\\n elif data_name == \\\"philips\\\":\\n print(\\\"{} not implemented data\\\".format(data_name))\\n exit()\\n elif data_name == \\\"HMC\\\":\\n print(\\\"{} not implemented data\\\".format(data_name))\\n exit()\\n elif data_name == \\\"combined\\\":\\n training_set = ConcatDataset(\\n Dataset_IID_window(partition[0]['train'], data_folder[0]),\\n Dataset_IID_window_SHHS(partition[1]['train'], data_folder[1]))\\n validation_set = ConcatDataset(\\n Dataset_IID_window(partition[0]['validation'], data_folder[0]),\\n Dataset_IID_window_SHHS(partition[1]['validation'], data_folder[1]))\\n else:\\n print(\\\"{} wrong data for dataloader\\\".format(data_name))\\n exit()\\n\\n else:\\n print(\\\"{} wrong model for dataloader\\\".format(model_name))\\n exit()\\n\\n return training_set, validation_set\",\n \"def get_train_dataloader(self):\\n if self.train_dataloader is not None:\\n return self.train_dataloader\\n\\n assert self.schema is not None, \\\"schema is required to generate Train Dataloader\\\"\\n return T4RecDataLoader.parse(self.args.data_loader_engine).from_schema(\\n self.schema,\\n self.train_dataset_or_path,\\n self.args.per_device_train_batch_size,\\n max_sequence_length=self.args.max_sequence_length,\\n drop_last=self.args.dataloader_drop_last,\\n shuffle=True,\\n shuffle_buffer_size=self.args.shuffle_buffer_size,\\n )\",\n \"def get_loader(split):\\n assert split in ['train', 'val', 'trainval', 'test']\\n image_feature_path = config.rcnn_trainval_path if split != 'test' else config.rcnn_test_path\\n dataset = VQAFeatureDataset(\\n split,\\n image_feature_path,\\n )\\n loader = torch.utils.data.DataLoader(\\n dataset,\\n batch_size=512,\\n shuffle=True if split not in ['val', 'test'] else False, # only shuffle the data in training\\n pin_memory=True,\\n num_workers=config.workers,\\n )\\n return loader\",\n \"def _get_dataset(\\n self,\\n dataset_path: str,\\n data_folder: str = \\\"data/\\\",\\n ):\\n if not os.path.isdir(dataset_path):\\n click.secho(f\\\"{dataset_path} not found!\\\", fg=\\\"red\\\")\\n\\n dataset_hash = (\\n int(hashlib.sha256(dataset_path.encode(\\\"utf-8\\\")).hexdigest(), 16) % 10 ** 8\\n )\\n\\n # To avoid using cache for different models\\n # split(/) for google/electra-base-discriminator\\n pretrained_model = (\\n self.hparams.pretrained_model.split(\\\"/\\\")[1]\\n if \\\"/\\\" in self.hparams.pretrained_model\\n else self.hparams.pretrained_model\\n )\\n dataset_cache = data_folder + \\\".dataset_\\\" + str(dataset_hash) + pretrained_model\\n\\n if os.path.isfile(dataset_cache):\\n click.secho(f\\\"Loading tokenized dataset from cache: {dataset_cache}.\\\")\\n return torch.load(dataset_cache)\\n\\n dataset_path += \\\"\\\" if dataset_path.endswith(\\\"/\\\") else \\\"/\\\"\\n dataset = {\\n \\\"train\\\": pd.read_csv(dataset_path + \\\"train.tsv\\\", sep=\\\"\\\\t\\\").to_dict(\\n \\\"records\\\"\\n ),\\n \\\"valid\\\": pd.read_csv(dataset_path + \\\"valid.tsv\\\", sep=\\\"\\\\t\\\").to_dict(\\n \\\"records\\\"\\n ),\\n \\\"test\\\": pd.read_csv(dataset_path + \\\"test.tsv\\\", sep=\\\"\\\\t\\\").to_dict(\\\"records\\\"),\\n }\\n # Read Labels\\n with open(dataset_path + \\\"labels.txt\\\", \\\"r\\\") as fp:\\n labels = [line.strip() for line in fp.readlines()]\\n label_encoder = {labels[i]: i for i in range(len(labels))}\\n\\n dataset[\\\"label_encoder\\\"] = label_encoder\\n # Tokenize\\n dataset[\\\"train\\\"] = self._tokenize(dataset[\\\"train\\\"])\\n dataset[\\\"valid\\\"] = self._tokenize(dataset[\\\"valid\\\"])\\n dataset[\\\"test\\\"] = self._tokenize(dataset[\\\"test\\\"])\\n torch.save(dataset, dataset_cache)\\n return dataset\",\n \"def get_dataset(self, source='', importer='', parameters=None):\\n if not source:\\n raise aspecd.exceptions.MissingSourceError(\\n 'A source is required to return a dataset')\\n if not self.importer_factory:\\n raise aspecd.exceptions.MissingImporterFactoryError(\\n 'An ImporterFactory is required to return a dataset')\\n dataset_ = self._create_dataset(source=source)\\n importer = self.importer_factory.get_importer(source=source,\\n importer=importer,\\n parameters=parameters)\\n dataset_.import_from(importer)\\n return dataset_\",\n \"def create_val_dataloader(configs, mode):\\n val_sampler = None\\n val_dataset = KittiDataset(configs, mode=mode, lidar_aug=None, hflip_prob=0., num_samples=configs.num_samples)\\n if configs.distributed:\\n val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset, shuffle=False)\\n val_dataloader = DataLoader(val_dataset, batch_size=configs.batch_size, shuffle=False,\\n pin_memory=configs.pin_memory, num_workers=configs.num_workers, sampler=val_sampler)\\n\\n return val_dataloader\",\n \"def get_data_loader_from_data(cls, batch_size, X, Y, **kwargs):\\n X_torch = torch.from_numpy(X).float()\\n\\n if (\\n \\\"classification_problem\\\" in kwargs\\n and kwargs[\\\"classification_problem\\\"] == False\\n ):\\n Y_torch = torch.from_numpy(Y).float()\\n else:\\n Y_torch = torch.from_numpy(Y).long()\\n dataset = TensorDataset(X_torch, Y_torch)\\n kwargs.pop(\\\"classification_problem\\\", None)\\n return DataLoader(dataset, batch_size=batch_size, **kwargs)\",\n \"def prepare_dataset(\\n db, dataset: str, batch_size, chunk_size, shuffle=True,\\n prefetch=True, dataset_slice=None,\\n):\\n dataset = db.get_dataset(dataset)\\n\\n if dataset_slice is not None:\\n dataset = dataset[dataset_slice]\\n\\n segmenter = Segmenter(\\n chunk_size, include_keys=('y', 's'), axis=-1,\\n anchor='random' if shuffle else 'left',\\n )\\n\\n def _set_num_samples(example):\\n example['num_samples'] = example['y'].shape[-1]\\n return example\\n\\n if shuffle:\\n dataset = dataset.shuffle(reshuffle=True)\\n\\n dataset = dataset.map(pre_batch_transform)\\n dataset = dataset.map(segmenter)\\n\\n # FilterExceptions are only raised inside the chunking code if the\\n # example is too short. If chunk_size == -1, no filter exception is raised.\\n catch_exception = segmenter.length > 0\\n if prefetch:\\n dataset = dataset.prefetch(\\n 8, 16, catch_filter_exception=catch_exception)\\n elif catch_exception:\\n dataset = dataset.catch()\\n\\n if chunk_size != -1:\\n dataset = dataset.unbatch()\\n else:\\n def unbatch(example):\\n assert len(example) == 1, example\\n return example[0]\\n dataset = dataset.map(unbatch)\\n dataset = dataset.map(_set_num_samples)\\n\\n if shuffle:\\n dataset = dataset.shuffle(reshuffle=True, buffer_size=128)\\n\\n dataset = dataset.batch(batch_size)\\n dataset = dataset.map(pt.data.batch.Sorter('num_samples'))\\n dataset = dataset.map(pt.data.utils.collate_fn)\\n\\n return dataset\",\n \"def load_data(dataset_class, batch_size, shuffle=True, num_workers=4):\\n loader = torch.utils.data.TensorDataset(dataset_class.data.float(),\\n dataset_class.labels.long(),\\n dataset_class.adjacent_matrix.float())\\n\\n loader_dataset = torch.utils.data.DataLoader(loader,\\n batch_size=batch_size,\\n shuffle=shuffle,\\n num_workers=num_workers)\\n return loader_dataset\",\n \"def get_loader(dataset='train.txt', crop_size=128, image_size=28, batch_size=2, mode='train', num_workers=1): \\n transform = [] \\n if mode == 'train': \\n transform.append(transforms.RandomHorizontalFlip()) \\n transform.append(transforms.CenterCrop(crop_size)) \\n transform.append(transforms.Resize(image_size)) \\n transform.append(transforms.ToTensor()) \\n transform.append(transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))) \\n transform = transforms.Compose(transform) \\n train_data=MyDataset(txt=dataset, transform=transform) \\n data_loader = DataLoader(dataset=train_data, \\n batch_size=batch_size, \\n shuffle=(mode=='train'), \\n num_workers=num_workers) \\n return data_loader\",\n \"def load():\\n filepath = dirname(abspath(__file__))\\n##### EDIT THE FOLLOWING TO POINT TO DatasetName.csv #####\\n data = recfromtxt(open(filepath + '/spector.csv',\\\"rb\\\"), delimiter=\\\" \\\",\\n names=True, dtype=float, usecols=(1,2,3,4))\\n names = list(data.dtype.names)\\n endog = array(data[names[3]], dtype=float)\\n endog_name = names[3]\\n exog = column_stack(data[i] for i in names[:3]).astype(float)\\n exog_name = names[:3]\\n dataset = Dataset(data=data, names=names, endog=endog, exog=exog,\\n endog_name = endog_name, exog_name=exog_name)\\n return dataset\",\n \"def load_dataset(file_name, model_ver):\\n\\n print 'Loading dataset ...'\\n\\n if model_ver == 'dmspline':\\n file_path = join(DATA_DIR, file_name)\\n id_field = Field(sequential=False, use_vocab=False, dtype=torch.int)\\n text_field = Field(pad_token=None, tokenize=_tokenize_str)\\n attr_field = Field(sequential=False, use_vocab=False, dtype=torch.float)\\n standardzed_attr_field = Field(sequential=False, use_vocab=False, dtype=torch.float)\\n\\n dataset = TabularDataset(\\n path=file_path,\\n format='csv',\\n fields=[('attr', attr_field), ('id', id_field), ('standardized_attr', standardzed_attr_field), ('text', text_field)],\\n skip_header=True)\\n\\n else:\\n file_path = join(DATA_DIR, file_name)\\n id_field = Field(sequential=False, use_vocab=False, dtype=torch.int)\\n text_field = Field(pad_token=None, tokenize=_tokenize_str)\\n\\n dataset = TabularDataset(\\n path=file_path,\\n format='csv',\\n fields=[('id', id_field), ('text', text_field)],\\n skip_header=True)\\n\\n text_field.build_vocab(dataset, min_freq=10)\\n return dataset\",\n \"def from_dataset(cls, name, options=None):\\n if options is None:\\n options = dict()\\n if name == 'lin_aaai12':\\n return cls.from_lin_aaai12(**options)\\n elif name == 'bragg_hcomp13':\\n return cls.from_bragg_hcomp13(**options)\\n elif name == 'bragg_teach':\\n return cls.from_bragg_teach(**options)\\n elif name == 'rajpal_icml15':\\n return cls.from_rajpal_icml15(**options)\\n else:\\n raise NotImplementedError\",\n \"def get(dataset_name: str, split: Union[Tuple[str, float], str, tfds.Split],\\n **hyperparameters: Any) -> BaseDataset:\\n hyperparameters_py = {\\n k: (v.numpy().tolist() if isinstance(v, tf.Tensor) else v)\\n for k, v in hyperparameters.items()\\n }\\n logging.info('Building dataset %s with additional kwargs:\\\\n%s', dataset_name,\\n json.dumps(hyperparameters_py, indent=2, sort_keys=True))\\n if dataset_name not in DATASETS:\\n raise ValueError('Unrecognized dataset name: {!r}'.format(dataset_name))\\n\\n dataset_class = DATASETS[dataset_name]\\n return dataset_class(split=split, **hyperparameters)\",\n \"def make_data_loader(examples, batch_size=100, shuffle=True):\\n x, y = zip(*examples) # makes lists of windows and tags\\n x, y = tr.from_numpy(np.array(x)), tr.from_numpy(np.array(y))\\n x, y = x.type(tr.LongTensor), y.type(tr.LongTensor) # convert lists to tensors\\n train = utdata.TensorDataset(x, y)\\n return utdata.DataLoader(train, batch_size, shuffle)\",\n \"def __init__(self, name_dataset, reduce=False):\\n dataset = TUDataset(root='data/TUDataset', name=name_dataset)\\n if reduce:\\n new_dataset = []\\n for i in tqdm(range(len(dataset))):\\n aux_graph = copy.deepcopy(dataset[i])\\n aux_graph.edge_index = TUDData.reduce_edges(aux_graph.edge_index)\\n new_dataset.append(copy.deepcopy(aux_graph))\\n dataset = WrapperSynthetic(new_dataset, dataset.num_node_features,\\n dataset.num_classes, None)\\n super(TUDData, self).__init__(dataset)\",\n \"def _create_dataset(options, is_training, input_pipeline_context=None):\\n dataset = tf.data.Dataset.list_files(options.input_pattern[:],\\n shuffle=is_training)\\n\\n batch_size = options.batch_size\\n if input_pipeline_context:\\n if input_pipeline_context.num_input_pipelines > 1:\\n dataset = dataset.shard(input_pipeline_context.num_input_pipelines,\\n input_pipeline_context.input_pipeline_id)\\n batch_size = input_pipeline_context.get_per_replica_batch_size(\\n options.batch_size)\\n\\n if is_training:\\n if options.cache_dataset:\\n dataset = dataset.cache()\\n dataset = dataset.repeat()\\n dataset = dataset.shuffle(options.shuffle_buffer_size)\\n dataset = dataset.interleave(tf.data.TFRecordDataset,\\n cycle_length=options.interleave_cycle_length)\\n\\n parse_fn = lambda x: _parse_single_example(x, options)\\n dataset = dataset.map(map_func=parse_fn,\\n num_parallel_calls=options.num_parallel_calls)\\n\\n padded_shapes = {\\n InputFields.img_id: [],\\n InputFields.annot_id: [],\\n InputFields.answer_label: [],\\n InputFields.num_objects: [],\\n InputFields.object_bboxes: [None, 4],\\n InputFields.object_labels: [None],\\n InputFields.object_scores: [None],\\n InputFields.object_features: [None, options.frcnn_feature_dims],\\n InputFields.cls_bert: [NUM_CHOICES, options.bert_feature_dims],\\n InputFields.question: [None],\\n InputFields.question_tag: [None],\\n InputFields.question_bert: [NUM_CHOICES, None, options.bert_feature_dims],\\n InputFields.question_len: [],\\n InputFields.answer_choices: [NUM_CHOICES, None],\\n InputFields.answer_choices_tag: [NUM_CHOICES, None],\\n InputFields.answer_choices_bert: [\\n NUM_CHOICES, None, options.bert_feature_dims\\n ],\\n InputFields.answer_choices_len: [NUM_CHOICES],\\n InputFields.answer_choices_with_question: [NUM_CHOICES, None],\\n InputFields.answer_choices_with_question_tag: [NUM_CHOICES, None],\\n InputFields.answer_choices_with_question_len: [NUM_CHOICES],\\n }\\n padding_values = {\\n InputFields.img_id: '',\\n InputFields.annot_id: '',\\n InputFields.answer_label: -1,\\n InputFields.num_objects: 0,\\n InputFields.object_bboxes: 0.0,\\n InputFields.object_labels: '',\\n InputFields.object_scores: 0.0,\\n InputFields.object_features: 0.0,\\n InputFields.cls_bert: 0.0,\\n InputFields.question: PAD,\\n InputFields.question_tag: -1,\\n InputFields.question_bert: 0.0,\\n InputFields.question_len: 0,\\n InputFields.answer_choices: PAD,\\n InputFields.answer_choices_tag: -1,\\n InputFields.answer_choices_bert: 0.0,\\n InputFields.answer_choices_len: 0,\\n InputFields.answer_choices_with_question: PAD,\\n InputFields.answer_choices_with_question_tag: -1,\\n InputFields.answer_choices_with_question_len: 0,\\n }\\n if options.decode_jpeg:\\n padded_shapes.update({\\n InputFields.img_data: [None, None, 3],\\n InputFields.img_height: [],\\n InputFields.img_width: [],\\n })\\n padding_values.update({\\n InputFields.img_data: tf.constant(0, dtype=tf.uint8),\\n InputFields.img_height: 0,\\n InputFields.img_width: 0,\\n })\\n dataset = dataset.padded_batch(batch_size,\\n padded_shapes=padded_shapes,\\n padding_values=padding_values,\\n drop_remainder=True)\\n dataset = dataset.prefetch(options.prefetch_buffer_size)\\n return dataset\",\n \"def get_one_epoch_dataloader(dataset, micro_batch_size=None):\\n args = get_args()\\n\\n if micro_batch_size is None:\\n micro_batch_size = args.micro_batch_size\\n num_workers = args.num_workers\\n\\n # Use megatron's sampler with consumed samples set to 0 as\\n # this is only for evaluation and don't intend to resume half way.\\n # Also, set the drop last to false as don't intend to remove\\n # the last batch\\n batch_sampler = MegatronPretrainingSampler(\\n total_samples=len(dataset),\\n consumed_samples=0,\\n micro_batch_size=args.micro_batch_size,\\n data_parallel_rank=mpu.get_data_parallel_rank(),\\n data_parallel_size=mpu.get_data_parallel_world_size(),\\n drop_last=False)\\n\\n return torch.utils.data.DataLoader(dataset,\\n batch_sampler=batch_sampler,\\n num_workers=num_workers,\\n pin_memory=True)\",\n \"def prepare_dataset(self, dataset_type: str) -> Dataset:\\n\\n logger.info(\\\"Creating features from dataset file at %s\\\", self.hparams.data_dir)\\n\\n if dataset_type == \\\"train\\\":\\n dataset = self.processor.get_train_dataset(self.hparams.data_dir, self.hparams.train_file_name)\\n elif dataset_type == \\\"dev\\\":\\n dataset = self.processor.get_dev_dataset(self.hparams.data_dir, self.hparams.dev_file_name)\\n elif dataset_type == \\\"test\\\":\\n dataset = self.processor.get_test_dataset(self.hparams.data_dir, self.hparams.test_file_name)\\n else:\\n raise ValueError(f\\\"{dataset_type} do not support. [train|dev|test]\\\")\\n logger.info(f\\\"Prepare {dataset_type} dataset (Count: {len(dataset)}) \\\")\\n return dataset\",\n \"def from_datasets(\\n cls,\\n train_dataset: Optional[Union[Dataset, Sequence[Dataset], Mapping[str, Dataset]]] = None,\\n val_dataset: Optional[Union[Dataset, Sequence[Dataset]]] = None,\\n test_dataset: Optional[Union[Dataset, Sequence[Dataset]]] = None,\\n batch_size: int = 1,\\n num_workers: int = 0,\\n ):\\n\\n def dataloader(ds: Dataset, shuffle: bool = False) -> DataLoader:\\n shuffle &= not isinstance(ds, IterableDataset)\\n return DataLoader(ds, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers, pin_memory=True)\\n\\n def train_dataloader():\\n if isinstance(train_dataset, Mapping):\\n return {key: dataloader(ds, shuffle=True) for key, ds in train_dataset.items()}\\n if isinstance(train_dataset, Sequence):\\n return [dataloader(ds, shuffle=True) for ds in train_dataset]\\n return dataloader(train_dataset, shuffle=True)\\n\\n def val_dataloader():\\n if isinstance(val_dataset, Sequence):\\n return [dataloader(ds) for ds in val_dataset]\\n return dataloader(val_dataset)\\n\\n def test_dataloader():\\n if isinstance(test_dataset, Sequence):\\n return [dataloader(ds) for ds in test_dataset]\\n return dataloader(test_dataset)\\n\\n datamodule = cls()\\n if train_dataset is not None:\\n datamodule.train_dataloader = train_dataloader\\n if val_dataset is not None:\\n datamodule.val_dataloader = val_dataloader\\n if test_dataset is not None:\\n datamodule.test_dataloader = test_dataloader\\n return datamodule\",\n \"def create_ds(self, data, is_train=True):\\n ds = tf.data.Dataset.from_tensor_slices(data)\\n map_fn = lambda x, y: (cifar_process(x, is_train), y)\\n ds = ds.map(map_fn, num_parallel_calls=tf.data.experimental.AUTOTUNE)\\n return ds\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80838567","0.7692149","0.7623508","0.76028895","0.752949","0.7343747","0.73312813","0.7285905","0.72848207","0.72800523","0.7233345","0.71680284","0.7144422","0.7127126","0.7112699","0.70464253","0.70323205","0.69610095","0.6957902","0.69366944","0.6930778","0.69191027","0.68280005","0.68049085","0.6794962","0.6790615","0.6783331","0.67748475","0.6771437","0.67695576","0.67369455","0.67253506","0.67250144","0.67067593","0.6703404","0.6689352","0.6683681","0.66801214","0.6650084","0.66467464","0.66374505","0.6630061","0.6585996","0.656532","0.6554718","0.6552627","0.65511996","0.65309846","0.65177333","0.64996475","0.6499115","0.6496805","0.64804083","0.64728063","0.64718086","0.64520985","0.64453423","0.64396095","0.64360243","0.6419457","0.64181864","0.6415786","0.6381134","0.63771224","0.6364515","0.6364254","0.6357448","0.63547474","0.63498855","0.63397765","0.63390774","0.63308865","0.6330348","0.632262","0.6322313","0.6318811","0.6318144","0.6309137","0.6307032","0.6296725","0.6291417","0.6291127","0.62906426","0.62883806","0.6283978","0.6276418","0.62709","0.6270651","0.62697047","0.6265609","0.626478","0.62567425","0.62561464","0.6246893","0.62239903","0.62229896","0.6209317","0.620507","0.6203756","0.61888915"],"string":"[\n \"0.80838567\",\n \"0.7692149\",\n \"0.7623508\",\n \"0.76028895\",\n \"0.752949\",\n \"0.7343747\",\n \"0.73312813\",\n \"0.7285905\",\n \"0.72848207\",\n \"0.72800523\",\n \"0.7233345\",\n \"0.71680284\",\n \"0.7144422\",\n \"0.7127126\",\n \"0.7112699\",\n \"0.70464253\",\n \"0.70323205\",\n \"0.69610095\",\n \"0.6957902\",\n \"0.69366944\",\n \"0.6930778\",\n \"0.69191027\",\n \"0.68280005\",\n \"0.68049085\",\n \"0.6794962\",\n \"0.6790615\",\n \"0.6783331\",\n \"0.67748475\",\n \"0.6771437\",\n \"0.67695576\",\n \"0.67369455\",\n \"0.67253506\",\n \"0.67250144\",\n \"0.67067593\",\n \"0.6703404\",\n \"0.6689352\",\n \"0.6683681\",\n \"0.66801214\",\n \"0.6650084\",\n \"0.66467464\",\n \"0.66374505\",\n \"0.6630061\",\n \"0.6585996\",\n \"0.656532\",\n \"0.6554718\",\n \"0.6552627\",\n \"0.65511996\",\n \"0.65309846\",\n \"0.65177333\",\n \"0.64996475\",\n \"0.6499115\",\n \"0.6496805\",\n \"0.64804083\",\n \"0.64728063\",\n \"0.64718086\",\n \"0.64520985\",\n \"0.64453423\",\n \"0.64396095\",\n \"0.64360243\",\n \"0.6419457\",\n \"0.64181864\",\n \"0.6415786\",\n \"0.6381134\",\n \"0.63771224\",\n \"0.6364515\",\n \"0.6364254\",\n \"0.6357448\",\n \"0.63547474\",\n \"0.63498855\",\n \"0.63397765\",\n \"0.63390774\",\n \"0.63308865\",\n \"0.6330348\",\n \"0.632262\",\n \"0.6322313\",\n \"0.6318811\",\n \"0.6318144\",\n \"0.6309137\",\n \"0.6307032\",\n \"0.6296725\",\n \"0.6291417\",\n \"0.6291127\",\n \"0.62906426\",\n \"0.62883806\",\n \"0.6283978\",\n \"0.6276418\",\n \"0.62709\",\n \"0.6270651\",\n \"0.62697047\",\n \"0.6265609\",\n \"0.626478\",\n \"0.62567425\",\n \"0.62561464\",\n \"0.6246893\",\n \"0.62239903\",\n \"0.62229896\",\n \"0.6209317\",\n \"0.620507\",\n \"0.6203756\",\n \"0.61888915\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6414222"},"document_rank":{"kind":"string","value":"62"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":746,"numItemsPerPage":100,"numTotalItems":95772,"offset":74600,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjY4MjY2OCwianRpIjoiNzEyYmFlMmEtNDU0My00OGM4LWI5ZDQtYzU5ZmI0ZDYzNjBlIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY2ODYyNjgsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.OCz8iWkDD1vfJXCpYh2KZWf7poHWz9VCmzvN_Xb73LNFfOMh-8DfkD9_EJaIdHE3CVppaCgfoxYWvjNbAKWUAQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
The ID or Amazon Resource Name (ARN) of the target group. | def target_group_identifier(self) -> pulumi.Input[str]:
return pulumi.get(self, "target_group_identifier") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def target_group_identifier(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"target_group_identifier\")",
"def get_target_group_arn(self, short_name):\n target_group_info = self.get_target_group_info(short_name)\n return target_group_info['TargetGroupArn']",
"def target_group(self)... | [
"0.8059303",
"0.77209467",
"0.76946956",
"0.76142114",
"0.7459761",
"0.7424217",
"0.7291563",
"0.7291563",
"0.7070664",
"0.7054723",
"0.7054723",
"0.7054723",
"0.7054723",
"0.7054723",
"0.7054723",
"0.700518",
"0.700518",
"0.6932303",
"0.6895912",
"0.68954605",
"0.689537",
... | 0.77805084 | 1 |
Input properties used for looking up and filtering TargetGroupAttachment resources. | def __init__(__self__, *,
target: Optional[pulumi.Input['TargetGroupAttachmentTargetArgs']] = None,
target_group_identifier: Optional[pulumi.Input[str]] = None):
if target is not None:
pulumi.set(__self__, "target", target)
if target_group_identifier is not ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(__self__,\n resource_name: str,\n opts: Optional[pulumi.ResourceOptions] = None,\n target: Optional[pulumi.Input[pulumi.InputType['TargetGroupAttachmentTargetArgs']]] = None,\n target_group_identifier: Optional[pulumi.Input[str]] = None,\... | [
"0.6232913",
"0.6098704",
"0.58432794",
"0.5615819",
"0.5539513",
"0.54342437",
"0.4729805",
"0.4729805",
"0.4729805",
"0.4729805",
"0.4729805",
"0.4729805",
"0.46846697",
"0.46832612",
"0.45703927",
"0.4514953",
"0.45037252",
"0.4499622",
"0.44905135",
"0.44891226",
"0.44881... | 0.6002845 | 2 |
The ID or Amazon Resource Name (ARN) of the target group. | def target_group_identifier(self) -> Optional[pulumi.Input[str]]:
return pulumi.get(self, "target_group_identifier") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def target_group_identifier(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"target_group_identifier\")",
"def target_group_identifier(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"target_group_identifier\")",
"def get_target_group_arn(self, short_name):\n target_group_in... | [
"0.8060474",
"0.7782377",
"0.77201146",
"0.7695647",
"0.74612945",
"0.74235034",
"0.72911525",
"0.72911525",
"0.7071454",
"0.7055554",
"0.7055554",
"0.7055554",
"0.7055554",
"0.7055554",
"0.7055554",
"0.70069563",
"0.70069563",
"0.6934187",
"0.6897746",
"0.6897058",
"0.689599... | 0.76161706 | 4 |
Provides the ability to register a target with an AWS VPC Lattice Target Group. Example Usage Basic Usage ```python import pulumi import pulumi_aws as aws example = aws.vpclattice.TargetGroupAttachment("example", target_group_identifier=aws_vpclattice_target_group["example"]["id"], target=aws.vpclattice.TargetGroupAtta... | def __init__(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
target: Optional[pulumi.Input[pulumi.InputType['TargetGroupAttachmentTargetArgs']]] = None,
target_group_identifier: Optional[pulumi.Input[str]] = None,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(__self__, *,\n target: pulumi.Input['TargetGroupAttachmentTargetArgs'],\n target_group_identifier: pulumi.Input[str]):\n pulumi.set(__self__, \"target\", target)\n pulumi.set(__self__, \"target_group_identifier\", target_group_identifier)",
"def __init__... | [
"0.7431431",
"0.7055174",
"0.66023284",
"0.6325992",
"0.62801075",
"0.62801075",
"0.62801075",
"0.62706286",
"0.62706286",
"0.62706286",
"0.61292464",
"0.5706547",
"0.5595607",
"0.5569349",
"0.5554444",
"0.5554444",
"0.5554444",
"0.5554444",
"0.5554444",
"0.5554444",
"0.55528... | 0.6507032 | 3 |
Provides the ability to register a target with an AWS VPC Lattice Target Group. Example Usage Basic Usage ```python import pulumi import pulumi_aws as aws example = aws.vpclattice.TargetGroupAttachment("example", target_group_identifier=aws_vpclattice_target_group["example"]["id"], target=aws.vpclattice.TargetGroupAtta... | def __init__(__self__,
resource_name: str,
args: TargetGroupAttachmentArgs,
opts: Optional[pulumi.ResourceOptions] = None):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(__self__, *,\n target: pulumi.Input['TargetGroupAttachmentTargetArgs'],\n target_group_identifier: pulumi.Input[str]):\n pulumi.set(__self__, \"target\", target)\n pulumi.set(__self__, \"target_group_identifier\", target_group_identifier)",
"def __init__... | [
"0.74325806",
"0.7056155",
"0.6508622",
"0.63249356",
"0.62815833",
"0.62815833",
"0.62815833",
"0.6272129",
"0.6272129",
"0.6272129",
"0.61320055",
"0.5705912",
"0.5594829",
"0.5568451",
"0.5556853",
"0.5556853",
"0.5556853",
"0.5556853",
"0.5556853",
"0.5556853",
"0.5553764... | 0.6603863 | 2 |
Get an existing TargetGroupAttachment resource's state with the given name, id, and optional extra properties used to qualify the lookup. | def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None,
target: Optional[pulumi.Input[pulumi.InputType['TargetGroupAttachmentTargetArgs']]] = None,
target_group_identifier: Optional[pulumi.Input[str]] = None) -> 'TargetGroupAttach... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_attachment(self,\n attachment_name: Text) -> Optional[test_record.Attachment]:\n # Check current running phase state for the attachment name first.\n if self.running_phase_state:\n if attachment_name in self.running_phase_state.phase_record.attachments:\n attachment = ... | [
"0.5213174",
"0.5193024",
"0.5071051",
"0.50478333",
"0.49847454",
"0.4979039",
"0.48070908",
"0.46779084",
"0.4650041",
"0.4650041",
"0.4650041",
"0.4650041",
"0.4650041",
"0.4650041",
"0.46282402",
"0.461483",
"0.4582758",
"0.4582302",
"0.45697513",
"0.45678928",
"0.4559987... | 0.752676 | 0 |
The ID or Amazon Resource Name (ARN) of the target group. | def target_group_identifier(self) -> pulumi.Output[str]:
return pulumi.get(self, "target_group_identifier") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def target_group_identifier(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"target_group_identifier\")",
"def get_target_group_arn(self, short_name):\n target_group_info = self.get_target_group_info(short_name)\n return target_group_info['TargetGroupArn']",
"def target_group(self) ... | [
"0.7782377",
"0.77201146",
"0.7695647",
"0.76161706",
"0.74612945",
"0.74235034",
"0.72911525",
"0.72911525",
"0.7071454",
"0.7055554",
"0.7055554",
"0.7055554",
"0.7055554",
"0.7055554",
"0.7055554",
"0.70069563",
"0.70069563",
"0.6934187",
"0.6897746",
"0.6897058",
"0.68959... | 0.8060474 | 0 |
Extract color data from the .tiff file | def generate_colour_data(width, height, imagiry_data, pixel2coord):
for i in range(1, height):
for j in range(1, width):
colour_data.append(
[
pixel2coord(j, i)[0],
pixel2coord(j, i)[1],
imagiry_data.read([1])[0][i - 1][... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def readtiff(datafile, sub_im, cr):\n\n with rasterio.open(datafile) as src:\n d = src.read(1, window=Window(cr[0]-sub_im, cr[1]-sub_im, sub_im*2, sub_im*2))\n\n #print(\"Number of elements and size of the array is\",d.size, d.shape)\n #d[d==0]= np.nan # convert zeros to nan\n return d",
"def ... | [
"0.6775925",
"0.64769757",
"0.64712006",
"0.64067876",
"0.6323894",
"0.62590426",
"0.62494826",
"0.6191413",
"0.60908866",
"0.6090622",
"0.60546464",
"0.6032689",
"0.60201806",
"0.59800386",
"0.5953728",
"0.59474844",
"0.59427553",
"0.5886405",
"0.58635443",
"0.58419293",
"0.... | 0.0 | -1 |
Return a count of how many employees this person manages. Return a count of how many people that manager manages. This should include everyone under them, not just people who directly report to them. | def count_employees(self, count=0):
if self.children:
for child in self.children:
count += 1 + child.count_employees() # recursion: count_employees(child)
if not self.children: # base case but that is already covered in line 48
return count
return coun... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def employees_count(self, obj):\n return obj.employees_count()",
"def number_of_employees(self) -> object:\n return self._number_of_employees",
"def display_count():\n print \"There are %d employees\" % Employee.count",
"def getEmpiricalCounts(self):\n return self.empirical_counts... | [
"0.75958306",
"0.70435137",
"0.6484758",
"0.62854797",
"0.6084669",
"0.59884465",
"0.59163004",
"0.587685",
"0.5790845",
"0.5768297",
"0.5670242",
"0.5650915",
"0.5648204",
"0.5602807",
"0.5590338",
"0.5584585",
"0.5559131",
"0.55568874",
"0.5534962",
"0.54872304",
"0.5434427... | 0.6947313 | 2 |
Returns a string containing a random uuid | def generate_uuid():
return uuid.uuid4() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def uuid():\n return ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(32))",
"def __generate_random_string():\n return uuid4().hex[:6].upper()",
"def gen_uuid():\n return str( uuid.uuid4() )",
"def gen_uuid():\n return str( uuid.uuid4() )",
"def gen_uuid() -> str... | [
"0.89296514",
"0.8614583",
"0.8608552",
"0.8608552",
"0.8571099",
"0.85449356",
"0.8490883",
"0.8451079",
"0.84057623",
"0.8386715",
"0.83474123",
"0.8344002",
"0.83331656",
"0.832412",
"0.8317769",
"0.82759994",
"0.8266738",
"0.80771947",
"0.7984721",
"0.7977263",
"0.7977143... | 0.8265079 | 17 |
Construct and return data provider. | def find_provider(self) -> DataProvider:
data_source = self._single_data_source()
identifiers = self._make_identifiers()
return self._create_data_provider(data_source, identifiers) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_data_provider(self, data_source: DataSource, identifiers: Identifiers) -> DataProvider:\n if data_source.driver is not None:\n return DatabaseDataProvider(data_source, identifiers, self._injector)\n elif data_source.mime_type == DataSourceConstants.MIME_TYPE_JSON:\n ... | [
"0.6566284",
"0.64414555",
"0.6421565",
"0.6354318",
"0.62949705",
"0.6272591",
"0.6233643",
"0.6149416",
"0.60801214",
"0.5942076",
"0.5927878",
"0.5916989",
"0.59090745",
"0.5891367",
"0.5875818",
"0.58682203",
"0.58377075",
"0.5828267",
"0.5732329",
"0.56926715",
"0.567040... | 0.6899661 | 0 |
Find an appropriate data provider instance for a data source and return it. | def _create_data_provider(self, data_source: DataSource, identifiers: Identifiers) -> DataProvider:
if data_source.driver is not None:
return DatabaseDataProvider(data_source, identifiers, self._injector)
elif data_source.mime_type == DataSourceConstants.MIME_TYPE_JSON:
return Js... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_provider(self) -> DataProvider:\n data_source = self._single_data_source()\n identifiers = self._make_identifiers()\n return self._create_data_provider(data_source, identifiers)",
"def engine_for_data_source(self, data_source_id):\n engine = None\n\n # find data_source... | [
"0.80434716",
"0.68087965",
"0.6472477",
"0.6324865",
"0.6181027",
"0.6065154",
"0.6047303",
"0.5923456",
"0.5854328",
"0.58054674",
"0.57857233",
"0.57642937",
"0.5744689",
"0.5741175",
"0.5718049",
"0.5650882",
"0.56424963",
"0.56369716",
"0.5622577",
"0.56058973",
"0.55954... | 0.7104102 | 1 |
Find and return data source in the list of columns. | def _single_data_source(self) -> DataSource:
data_source = None
for meta_column in self._meta_columns:
if data_source is None:
data_source = meta_column.data_source
elif data_source is not meta_column.data_source:
raise SomeError('Mixed data source... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data_source_identifiers(self):\n collection_ids = self.am_db_api.get_collections_identifiers()\n for col in collection_ids:\n if col['code'] == self.collection_acronym:\n _raw_data = col\n break\n if _raw_data:\n return [col, ]\n ... | [
"0.630452",
"0.60534185",
"0.60346985",
"0.59439075",
"0.5786718",
"0.57262063",
"0.5580457",
"0.5549795",
"0.5502819",
"0.546728",
"0.54508007",
"0.53607213",
"0.53460145",
"0.5345716",
"0.53440297",
"0.531765",
"0.5290032",
"0.5263445",
"0.52465343",
"0.52288145",
"0.520390... | 0.68384 | 0 |
Construct and return list of all identifiers in a column list. | def _make_identifiers(self) -> Identifiers:
identifier_list = []
for meta_column in self._meta_columns:
idf_string = meta_column.reflected_column_idf
idf = Identifier.from_string(idf_string)
identifier_list.append(idf)
return identifier_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def column_values(table: list[dict[str, str]], column_name: str) -> list[str]:\n column_values: list[str] = []\n for row in table:\n item: str = row[column_name]\n column_values.append(item)\n return column_values",
"def _create_sql_columns(self, a_list):\n result = \"\"\n \n... | [
"0.6425198",
"0.63352287",
"0.62166625",
"0.62166625",
"0.6156101",
"0.61026555",
"0.6070932",
"0.60350156",
"0.60269547",
"0.59695834",
"0.59083545",
"0.5736998",
"0.57237095",
"0.570372",
"0.56879526",
"0.5640683",
"0.5635314",
"0.5628415",
"0.5623144",
"0.56099755",
"0.559... | 0.716665 | 0 |
This is an example test for a Dagster op. | def test_hello():
with build_op_context(
resources={
"partition_start": ResourceDefinition.hardcoded_resource("2020-12-30 00:00:00"),
"partition_end": ResourceDefinition.hardcoded_resource("2020-12-30 01:00:00"),
"hn_client": hn_snapshot_client,
}
) as context... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_drugs_get(self):\n pass",
"def test_basic_execution(self):",
"def test():\n pass",
"def test(self):\n pass",
"def test():",
"def test():",
"def test_doc():\n pass",
"def test_01_visit(self):",
"def tests():",
"def test(ctx):\n pass",
"def _test(self):",
... | [
"0.64674073",
"0.6402451",
"0.6398701",
"0.63896984",
"0.6277145",
"0.6277145",
"0.61513007",
"0.61400527",
"0.60824406",
"0.6073764",
"0.6054717",
"0.6054717",
"0.6054717",
"0.6054717",
"0.6054717",
"0.60486776",
"0.6027375",
"0.60171676",
"0.60171676",
"0.6013399",
"0.59449... | 0.0 | -1 |
Download, parse, and clean the spreads & overunder tables for one game. The columns are pinnacle, betonline, bookmaker each with suffix _spread or _over_under; datetime; hometeam, awayteam, favored; week. The first three are the bookies and give the spreads from the point of view of the favored team (so they're general... | def game(hometeam, awayteam, week, year):
with urlopen(spread_url(hometeam, awayteam, week, year)) as connection:
spreads_page = connection.read()
# Note that infer_types is deprecated and won't work starting in Pandas 0.14
LOG.debug('Getting game %s', (hometeam, awayteam, week, year))
sp = read_html(io=spreads_p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_proboxingodds(soup):\n tables = []\n site = pd.read_html(str(soup))\n for idx, table in enumerate(site):\n if idx == 0:\n pass\n elif idx % 2 != 0:\n sliced = table[(table['Unnamed: 0'].str.contains(':')) | (table['Unnamed: 0'] == 'UTC')]\n sliced =... | [
"0.6246023",
"0.61548907",
"0.60092086",
"0.5975189",
"0.5945373",
"0.58612907",
"0.581316",
"0.57939166",
"0.57939166",
"0.57505715",
"0.5735615",
"0.57076836",
"0.56700265",
"0.56516606",
"0.5643471",
"0.56255335",
"0.56039417",
"0.55867517",
"0.5583636",
"0.5582516",
"0.55... | 0.7500191 | 0 |
Download, parse, and clean a table of games and scores for given season. The columns are week; hometeam; awayteam; winner; date; points, yards, and turn overs for the winning team; points, yards, and turn overs for the losing team; and season. | def season_games(year):
LOG.debug('Getting season %d', year)
data = read_html(io=season_games_url(year),
attrs={'id': 'games'},
infer_types=False,
header=0)
if len(data) != 1:
raise CantFindTheRightTable
data = data.pop()
# Cleaning.
del data["Unnamed: 3"]
# The code below issues "UserWar... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pageScrape(season_url, wr):\r\n\r\n\thtml = urlopen(season_url)\r\n\tsoup = BeautifulSoup(html, \"lxml\")\r\n\r\n\t# our desired table has id = 'results'\r\n\t# we take the rows in the table's children\r\n\t# But we make sure to ignore the first two, since they're unrelated\r\n\ttable = soup.find(id = 'results... | [
"0.72744703",
"0.71057445",
"0.7024942",
"0.6991828",
"0.67987585",
"0.6700538",
"0.6658425",
"0.6575679",
"0.64786863",
"0.64421767",
"0.6356316",
"0.63480973",
"0.6342161",
"0.63054234",
"0.628538",
"0.62465894",
"0.62191725",
"0.6196027",
"0.6153302",
"0.61445725",
"0.6125... | 0.77701926 | 0 |
Convenience wrapper for `game` when you're not sure who's the home team. We first try calling `game` with `team_a` as the home team, and if that doesn't work, we next try `team_b`. In the former case we add a column called `home_away_discrepency` equal to `False`. In the latter case the column contains `True` and the `... | def game_unknown_homeaway(team_a, team_b, week, year):
try:
g = game(team_a, team_b, week, year)
except (CantFindTheRightTable, ValueError):
g = game(team_b, team_a, week, year)
awayteam, hometeam = g.hometeam.copy(), g.awayteam.copy()
g.hometeam, g.awayteam = hometeam, awayteam
g['home_away_discrepency'] =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def game(self, **kw):\n _append_conds(self._default_cond, types.Game, kw)\n if 'team' in kw:\n ors = {'home_team': kw['team'], 'away_team': kw['team']}\n self.andalso(Query(self._db, orelse=True).game(**ors))\n return self",
"def hometeamify(t):\n\tt = t.copy()\n\t# Win... | [
"0.6640279",
"0.64301515",
"0.6302677",
"0.62670434",
"0.6090484",
"0.59702206",
"0.5948577",
"0.5926323",
"0.5851775",
"0.581768",
"0.5812748",
"0.57850784",
"0.5778715",
"0.5760123",
"0.56636155",
"0.5662619",
"0.5662174",
"0.56604946",
"0.5657123",
"0.5652413",
"0.56399506... | 0.685784 | 0 |
Download, parse, and clean the scores & spreads for all games in a season `timeout` is in seconds and `concurrency` is the number of threads to use, defaulting to the number of CPUs. If not `None`, `week` limits the games fetched to those in the given week. This function returns two values. The first is the table, whic... | def season(year, week=None, timeout=None, concurrency=_DEFAULT_CONCURRENCY):
LOG.debug('Concurrency = %d', concurrency)
games = season_games(year)
if week is not None:
games = games[games.week == week]
expected_n = len(games)
tables, futures_to_args, failures = [], {}, []
# See https://docs.python.org/3/library... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def seasons(years, timeout=None, concurrency=_DEFAULT_CONCURRENCY):\n\ttables, failures = [], []\n\tfor year in years:\n\t\tLOG.info('=' * 10 + ' %d ' + '=' * 10, year)\n\t\ttable, failure = season(year, timeout=timeout, concurrency=concurrency)\n\t\ttables.append(table)\n\t\tfailures.extend(failure)\n\treturn pd.... | [
"0.6129513",
"0.5730428",
"0.5411161",
"0.5363586",
"0.5149617",
"0.50999445",
"0.50895286",
"0.50845605",
"0.5071889",
"0.5037335",
"0.50228286",
"0.49968722",
"0.4969007",
"0.49601135",
"0.49494612",
"0.49304613",
"0.49097982",
"0.48657218",
"0.48565075",
"0.4851376",
"0.48... | 0.746054 | 0 |
Download, parse, and clean multiple seasons of NFL games and spreads. `years` is an iterable of integers. `timeout` is measured in seconds. `concurrency is the number of threads to use, defaulting to the number of CPUs. This function returns two values. The first is the table, which is the the merger of the tables that... | def seasons(years, timeout=None, concurrency=_DEFAULT_CONCURRENCY):
tables, failures = [], []
for year in years:
LOG.info('=' * 10 + ' %d ' + '=' * 10, year)
table, failure = season(year, timeout=timeout, concurrency=concurrency)
tables.append(table)
failures.extend(failure)
return pd.concat(tables), failure... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def season(year, week=None, timeout=None, concurrency=_DEFAULT_CONCURRENCY):\n\tLOG.debug('Concurrency = %d', concurrency)\n\tgames = season_games(year)\n\tif week is not None:\n\t\tgames = games[games.week == week]\n\texpected_n = len(games)\n\ttables, futures_to_args, failures = [], {}, []\n\t# See https://docs.... | [
"0.6988165",
"0.53787047",
"0.5354344",
"0.50391036",
"0.48686248",
"0.48666587",
"0.48592305",
"0.48330218",
"0.47225174",
"0.4698474",
"0.46848443",
"0.46690604",
"0.46613982",
"0.4643933",
"0.46422544",
"0.45821732",
"0.4577877",
"0.4571864",
"0.45470133",
"0.45312637",
"0... | 0.742822 | 0 |
Convert a `season`generated table `t` so the data is hometeam centric. `season` generates a table whose points, yards, and turnovers columns are broken down by winning and losing team and whose spreads columns are relative to the favored team. Convert all these winner/loser based columns to be home/away based and conve... | def hometeamify(t):
t = t.copy()
# Winner/loser based columns
hw, aw = t.hometeam == t.winner, t.awayteam == t.winner
assert (hw == ~aw).all()
# Suffix for keys = W for winner L for loser. Values are new names
for old, new in {'Pts': 'points', 'Yds': 'yards', 'TO': 'turn_overs'}.items():
t[new + '_home'] = (hw ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def season_games(year):\n\tLOG.debug('Getting season %d', year)\n\tdata = read_html(io=season_games_url(year),\n\t\t\t\t\t attrs={'id': 'games'},\n\t\t\t\t\t infer_types=False,\n\t\t\t\t\t header=0)\n\tif len(data) != 1:\n\t\traise CantFindTheRightTable\n\tdata = data.pop()\n\n\t# Cleaning.\n\tdel data[\"Unname... | [
"0.63010097",
"0.6165743",
"0.609641",
"0.59280556",
"0.5682527",
"0.5622098",
"0.5577865",
"0.55546534",
"0.5509511",
"0.55027294",
"0.5485158",
"0.54674494",
"0.5361212",
"0.5352292",
"0.5331872",
"0.5305586",
"0.5231739",
"0.5226202",
"0.51555604",
"0.51513076",
"0.5111141... | 0.6389691 | 0 |
Return the latest football season that started before the given `date`. `date` should be a `datetime.date` object. This function merely assumes that football season starts at the beginning of September. | def latest_season_before(date):
if date.month < 9:
return date.year - 1
return date.year | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def return_football_season(date=datetime.datetime.today()):\n date_aux = subtract_months(date, 6)\n beginning_year = str(date_aux.year)\n ending_year = date_aux.year + 1\n ending_year = str(ending_year)[-2:]\n season = ''.join([beginning_year, '-', ending_year])\n return season",
"def getSeason... | [
"0.69180113",
"0.6146285",
"0.57859606",
"0.576548",
"0.56443614",
"0.55603045",
"0.5519733",
"0.54679203",
"0.5379245",
"0.5354513",
"0.5308661",
"0.5244202",
"0.51410407",
"0.51207197",
"0.510111",
"0.5079919",
"0.50713015",
"0.5060351",
"0.5047275",
"0.49737677",
"0.493112... | 0.7798447 | 0 |
Some arbitrary deterministic test function. | def some_mock_f(x):
random_stream = pyrandom.Random(json.dumps(x, sort_keys=True))
y = [random_stream.gauss(0, 1) for _ in OBJECTIVE_NAMES]
return y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def istest(func):\n func.__test__ = True\n return func",
"def test():\r\n\tassert 1609693773.1609693773() == \"1609693773\", \"test failed\"\r\n\t#assert 1609693773.<function>(<values>) == <the result(s) you would like to have>, \"<the fail message>\"\r",
"def test_function(arg):\n return arg * 2",
... | [
"0.68127704",
"0.67535555",
"0.67393816",
"0.6707131",
"0.6696128",
"0.6687894",
"0.6634872",
"0.65684974",
"0.6532523",
"0.6460401",
"0.644191",
"0.64264655",
"0.6384061",
"0.6370439",
"0.634573",
"0.6340645",
"0.6301211",
"0.62693214",
"0.62587863",
"0.6235812",
"0.62279636... | 0.0 | -1 |
Assignes a selfRef to a resource | def set_self_ref(self, resource):
fullname = utils.class_fullname(resource)
if fullname not in self._models_index:
self.send_error(400,
message="Unrecognized resource type: %s" % type(resource))
return -1
resource_name = self._models_index[fullname]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def self_uri(self, self_uri):\n \n self._self_uri = self_uri",
"def self_uri(self, self_uri):\n \n self._self_uri = self_uri",
"def self_uri(self, self_uri):\n \n self._self_uri = self_uri",
"def self_uri(self, self_uri):\n \n self._self_uri = self_uri"... | [
"0.69215506",
"0.69215506",
"0.69215506",
"0.69215506",
"0.6608306",
"0.6608306",
"0.62731814",
"0.6217579",
"0.6217579",
"0.61596036",
"0.6048173",
"0.59555393",
"0.5861509",
"0.5775239",
"0.5726745",
"0.56997484",
"0.5627227",
"0.562261",
"0.562261",
"0.5587249",
"0.5512516... | 0.81884384 | 0 |
Resolves self hyperlinks (JSONPath and JSONPointers. | def _complete_href_links(self, parent_collection, current):
if isinstance(current, HyperLink) or \
(isinstance(current, dict) and "href" in current):
if isinstance(current["href"], (bytes, str)):
resource = None
if current["href"] in self._cache:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_self_href(response):\n data = jsonutils.loads(response.body)\n for link in data['versions'][0]['links']:\n if link['rel'] == 'self':\n return link['href']\n return ''",
"def self_link(self):\n return self._json['coredata'].get('link', [])[0].get('@href')",
"def Self(s... | [
"0.602833",
"0.5747524",
"0.53852236",
"0.5332049",
"0.53265524",
"0.52382493",
"0.52201176",
"0.52140194",
"0.52034295",
"0.5167555",
"0.50881326",
"0.50849515",
"0.5083651",
"0.50580704",
"0.5019191",
"0.49718055",
"0.4957375",
"0.4956555",
"0.4889869",
"0.48428294",
"0.483... | 0.67970556 | 0 |
This method is called when the spider is opened. | def open_spider(self,Spider):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_spider(self, spider):\n pass",
"def open_spider(self, spider):\n assert spider not in self.sites, \"Spider already opened: %s\" % spider\n self.sites[spider] = SpiderInfo(spider)",
"def __init__(self, spider):\n\n super(SprintBehavior, self).__init__(spider)\n self.r... | [
"0.83981526",
"0.7474456",
"0.6518192",
"0.6464361",
"0.64332694",
"0.6359454",
"0.6268794",
"0.6236614",
"0.62211096",
"0.62166256",
"0.6149158",
"0.6127409",
"0.61030036",
"0.60981435",
"0.60644287",
"0.6060854",
"0.6018061",
"0.60120916",
"0.59972566",
"0.59972566",
"0.599... | 0.79172105 | 1 |
Get an image set. | def get(log, session, args):
log('imageset id: {highlight}{id}{reset}',
highlight=Fore.GREEN,
id=args.id,
reset=Style.RESET_ALL)
log.warn('Get imageset command coming soon.') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetImageSet(cls, ID):\n if ID in cls._imageSets:\n return cls._imageSets[ID]",
"def get_image_set(image_set, depth=False, scale=1):\n image_files = glob.glob(image_set)\n loaded_images = []\n\n # reorder file names to be in numbering order\n filenames_in_order = ['' for _ in ran... | [
"0.7954262",
"0.6740134",
"0.64645076",
"0.62871885",
"0.6021483",
"0.601437",
"0.599391",
"0.5967952",
"0.5960324",
"0.59564406",
"0.5953417",
"0.5952895",
"0.59492964",
"0.59325",
"0.5910726",
"0.5877919",
"0.5854985",
"0.58473265",
"0.5806738",
"0.57102996",
"0.56972474",
... | 0.7376378 | 1 |
Return executable tasks with image uploads in batches. Instead of performing image uploads and updating the imageset one at a time, we reduce load on the API server by uploading many images and updating the api server in one go, consequently making upload faster. | def _get_chunk_upload_futures(
executor, paths, session, create_url,
complete_url, log, workload_size, offset
):
total_work = len(paths)
workloads = []
temp = []
i = 0
while i < total_work:
path = paths[i]
temp.append(path)
i += 1
if len(temp) == workload_siz... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _process_image_files(name, cnts, roots, num_shards): \n \n # Break all images into batches with a [ranges[i][0], ranges[i][1]].\n spacing = np.linspace(0, sum(cnts), FLAGS.num_threads + 1).astype(np.int)\n ranges = []\n for i in range(len(spacing) - 1):\n ranges.append([spacing[i], spacing[i +... | [
"0.6663598",
"0.63845474",
"0.62568337",
"0.6249887",
"0.618294",
"0.60570496",
"0.60385495",
"0.5976142",
"0.596462",
"0.5929896",
"0.5870594",
"0.58550143",
"0.5847463",
"0.5847073",
"0.58429337",
"0.5841489",
"0.5832478",
"0.5810369",
"0.5801244",
"0.5747127",
"0.57306874"... | 0.70541716 | 0 |
Update an image set. | def update_from_dict(log, session, configuration):
# check for config
ims_type = configuration["imageset_type"]
ims_id = configuration["id"]
ims_url = "{}imagesets/{}".format(
http.get_api_url(configuration["url"], configuration["project"]),
ims_id,
)
ims = http.get(session, ims_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_image(self, image):\n raise NotImplementedError()",
"def update_image(self):\n self.image = Image.fromarray(self.img)",
"def update_img(self):\n self.img = np.array(self.image)",
"def update_image(self):\n if self.filenames:\n pos = self.slider.value()\n ... | [
"0.6671458",
"0.6253759",
"0.61016107",
"0.6100223",
"0.60599226",
"0.5962895",
"0.5962895",
"0.5962895",
"0.5962895",
"0.5943573",
"0.5916061",
"0.5887711",
"0.5863244",
"0.5825705",
"0.5805472",
"0.5747548",
"0.57276976",
"0.57228637",
"0.56967413",
"0.56580544",
"0.5621037... | 0.5917782 | 10 |
Delete an image set. | def delete(log, session, args):
log('imageset id: {highlight}{id}{reset}',
highlight=Fore.GREEN,
id=args.id,
reset=Style.RESET_ALL)
log.warn('delete imageset command coming soon.') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_set(set_name):\n\n flg = logging.getLogger(\"lettuce.xgenSetup.delete_set\")\n\n flg.info(\"Set to delete: {}\".format(set_name))\n\n if mc.objExists(set_name):\n mc.select(set_name)\n old_objects = mc.ls(selection=True)\n flg.debug(\"Old Objects:\")\n for o in old_o... | [
"0.7083559",
"0.6625625",
"0.65320134",
"0.6487162",
"0.6302784",
"0.62108546",
"0.61581236",
"0.61563313",
"0.6123999",
"0.6080582",
"0.6059259",
"0.6047355",
"0.6043354",
"0.60260856",
"0.600469",
"0.6001009",
"0.5964619",
"0.5953437",
"0.5917767",
"0.5909501",
"0.58970803"... | 0.81307465 | 0 |
Resolve all paths to a list of files. | def _resolve_paths(paths):
allowed_ext = tuple(MIMES.keys())
resolved = []
for path in paths:
if os.path.isdir(path):
resolved.extend(
entry.path for entry in os.scandir(path)
if entry.is_file() and entry.name.lower().endswith(allowed_ext)
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resolve_specs(paths):\n specs = []\n for path in paths:\n if os.path.isdir(path):\n _, _, files = os.walk(path).next()\n specs.extend(os.path.join(path, fname) for fname in files)\n else:\n specs.append(path)\n return specs",
"def handle_files_args(*pat... | [
"0.70843834",
"0.7008949",
"0.7005918",
"0.6991757",
"0.6980533",
"0.6943847",
"0.6908536",
"0.6815965",
"0.6810721",
"0.67709655",
"0.66659486",
"0.66539854",
"0.6626398",
"0.6625859",
"0.660965",
"0.65911394",
"0.6577185",
"0.6509825",
"0.6505772",
"0.64861",
"0.64778113",
... | 0.7782248 | 0 |
Store SLR data in a dataset | def _write_to_dataset(parser1, parser2, dset, rundate):
data_all1 = parser1.as_dict()
data_all2 = parser2.as_dict()
if parser1.file_path == parser2.file_path:
collection = [data_all1]
else:
collection = [data_all1, data_all2]
# Meta information
dset.meta["tech"] = "slr"
dse... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_data():\r\n #if not os.path.exists(filepath):\r\n #download_data()\r\n metadata = read(filepath + flist[-1])\r\n ndata = metadata['num_cases_per_batch']\r\n ndim = metadata['num_vis']\r\n\r\n data, train, test = {}, {}, {}\r\n data['labels'] = metadata['label_names']\r\n data['n... | [
"0.6032091",
"0.60181564",
"0.5990172",
"0.59721607",
"0.59474033",
"0.5929216",
"0.59091103",
"0.5888812",
"0.586171",
"0.5857652",
"0.58549386",
"0.5849131",
"0.5848328",
"0.5759807",
"0.5758934",
"0.5748189",
"0.57465774",
"0.57341397",
"0.57004267",
"0.56873584",
"0.56487... | 0.0 | -1 |
Write the meteorological data from the parser to the dataset | def _write_met_to_dataset(dset, data, rundate):
data = _interpolate_meteorological_data(dset, data, rundate)
met_fields = set().union(*[v.keys() for k, v in data.items() if k.startswith("met_")])
for field in met_fields:
dset.add_float(field, val=np.diag([data["met_" + s][field] for s in dset.stati... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _write_to_dataset(parser1, parser2, dset, rundate):\n\n data_all1 = parser1.as_dict()\n data_all2 = parser2.as_dict()\n if parser1.file_path == parser2.file_path:\n collection = [data_all1]\n else:\n collection = [data_all1, data_all2]\n\n # Meta information\n dset.meta[\"tech\"... | [
"0.64577776",
"0.64060456",
"0.61828107",
"0.6066828",
"0.58823055",
"0.5870293",
"0.58422923",
"0.5788097",
"0.57642424",
"0.5742792",
"0.5716306",
"0.5624275",
"0.5606775",
"0.55803984",
"0.55746037",
"0.5545224",
"0.55425394",
"0.55351293",
"0.5533233",
"0.55117476",
"0.54... | 0.59315515 | 4 |
Calculate temperature, humidity and pressure at observation epochs Meteorological data are calculated at observation epochs by interpolating in the data given on the observation file for each station. Missing meteorological data are currently not handled. | def _interpolate_meteorological_data(dset, data, rundate):
rundate = datetime(rundate.year, rundate.month, rundate.day)
for field, station in [(f, f[4:]) for f in data.keys() if f.startswith("met_")]:
log.debug(f"Meteorological data available for station {station}")
met_time = data[field].pop("... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTemperatureMeasurements(self):\n # self.board.readline()\n self.stop = False\n times = []\n temps = [[], [], []]\n \n # A synchronisation string containing the characters tx is sent before each set of measurements,\n # we ensure correct reading of the measure... | [
"0.63405967",
"0.63176763",
"0.60726416",
"0.60086864",
"0.6006904",
"0.5976299",
"0.5911458",
"0.585778",
"0.5847371",
"0.58325535",
"0.58182263",
"0.5791185",
"0.5782068",
"0.576098",
"0.5759699",
"0.5731579",
"0.5731077",
"0.57164955",
"0.5713108",
"0.5697223",
"0.5689423"... | 0.62920344 | 2 |
Make sure email not in use. | def validate_email(form, field):
if User.query.filter_by(email=form.email.data).first():
form.email.errors.append(
"Email already associated with account!")
raise ValidationError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_invalid_email_when_logging_in(self):\n pass",
"def clean_email(self):\r\n if User.objects.filter(email__iexact=self.cleaned_data['email']):\r\n raise forms.ValidationError(_(u'This email address is already in use. Please supply a different email address.'))\r\n return sel... | [
"0.7547832",
"0.69692755",
"0.68943226",
"0.68845636",
"0.68845636",
"0.6878333",
"0.6797547",
"0.6777223",
"0.67052704",
"0.66979927",
"0.6694335",
"0.66453594",
"0.66256976",
"0.66151065",
"0.6599791",
"0.6570279",
"0.65497637",
"0.65465266",
"0.6540458",
"0.65211236",
"0.6... | 0.0 | -1 |
Make sure username not in use. | def validate_username(form, field):
if User.query.filter_by(username=form.username.data).first():
form.username.errors.append("Username already taken!")
raise ValidationError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_auth_none(self, username):\n return AUTH_FAILED",
"def clean_username(self):\n username = self.cleaned_data['username']\n\n try:\n User.objects.get(username=username)\n except ObjectDoesNotExist:\n return username\n\n raise forms.ValidationError(... | [
"0.72980964",
"0.7277678",
"0.71732837",
"0.71541303",
"0.7144778",
"0.7115024",
"0.7101641",
"0.7087915",
"0.7060178",
"0.7016285",
"0.69974613",
"0.69890416",
"0.6978878",
"0.6956085",
"0.6935131",
"0.69266754",
"0.68790114",
"0.6853017",
"0.6840044",
"0.68063754",
"0.68047... | 0.6258547 | 83 |
Make sure email is not in use unless it's the current user's email. | def validate_email(form, field):
user = User.query.filter_by(email=form.email.data).first()
if user and not user == g.user:
form.email.errors = [
"Email already associated with account!",
*form.email.errors
]
raise ValidationError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_email(self):\r\n if User.objects.filter(email__iexact=self.cleaned_data['email']):\r\n raise forms.ValidationError(_(u'This email address is already in use. Please supply a different email address.'))\r\n return self.cleaned_data['email']",
"def clean_email(self):\n if U... | [
"0.7446851",
"0.739905",
"0.739905",
"0.7380747",
"0.73281556",
"0.72398597",
"0.72120744",
"0.72011906",
"0.7174148",
"0.71672803",
"0.7081384",
"0.70392203",
"0.7017105",
"0.6994809",
"0.69502664",
"0.6879769",
"0.6850791",
"0.67699957",
"0.67592144",
"0.6754703",
"0.668111... | 0.66117746 | 24 |
Make sure username is not in use unless it's the current user's username. | def validate_username(form, field):
user = User.query.filter_by(username=form.username.data).first()
if user and not user == g.user:
form.username.errors = [
"Username already taken!",
*form.username.errors
]
raise ValidationError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_username(self):\n username = self.cleaned_data['username']\n\n try:\n User.objects.get(username=username)\n except ObjectDoesNotExist:\n return username\n\n raise forms.ValidationError('Login is already in use.')",
"def clean_username(self):\r\n ... | [
"0.73932433",
"0.7269057",
"0.7248478",
"0.7208094",
"0.715533",
"0.71511453",
"0.70808494",
"0.70128983",
"0.7008816",
"0.69899356",
"0.6968489",
"0.6933201",
"0.69043255",
"0.6860258",
"0.6844749",
"0.6816242",
"0.6789844",
"0.6788677",
"0.6784953",
"0.6778212",
"0.6778212"... | 0.66590476 | 22 |
Constraint the output of detector to lie within the image. Also check if the detection is valid by measuring area of BB. | def get_refined_detection(detections, im_shape, conf):
refined_detection = []
for dets in detections:
score = dets[-1]
if score<conf:
continue
dets = constraint_boxes(dets, im_shape)
if check_area(dets, im_shape) is False:
continue
refined_detectio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_boundary_boxes(gt_detection_combo):\n found = False\n overlap_threshold = 0.7\n\n for found_box in gt_detection_combo.detected_boxes:\n if overlap_between(gt_detection_combo.gt_box, found_box) > overlap_threshold:\n found = True\n break\n\n assert found is True",
... | [
"0.63479084",
"0.62445164",
"0.62041825",
"0.605389",
"0.59362656",
"0.59316784",
"0.5855736",
"0.5836759",
"0.58320904",
"0.58183193",
"0.5813324",
"0.58023053",
"0.5775182",
"0.57734776",
"0.5770503",
"0.5768477",
"0.57378244",
"0.56990397",
"0.5648787",
"0.5648514",
"0.563... | 0.0 | -1 |
Convert (x_min, y_min, x_max, y_max) to (x_centroid, y_centroid, aspect_ratio, height) | def coord_shift(std_coord):
std_coord = np.array(std_coord)
x_c, y_c = compute_centroid(std_coord)
height = std_coord[3] - std_coord[1]
width = std_coord[2] - std_coord[0]
aspect_ratio = height/width
return np.array([x_c, y_c, aspect_ratio, height]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transform_coords(x, y, w, h, nw, nh):\r\n return ((((x / w) - 0.5) * nw), (((h - y) / h) - 0.5) * nh)",
"def normalize_coords(xx, yy, width, height):\n xx = (2.0 / (width - 1.0)) * xx.float() - 1.0\n yy = (2.0 / (height - 1.0)) * yy.float() - 1.0\n return xx, yy",
"def _xywh2cs(self, x, y, w, h... | [
"0.6549811",
"0.6173128",
"0.6143023",
"0.61052555",
"0.60435134",
"0.5976582",
"0.5964702",
"0.5933406",
"0.59303606",
"0.59181345",
"0.590507",
"0.5885561",
"0.58818907",
"0.58802193",
"0.5839666",
"0.57727206",
"0.5764812",
"0.5732082",
"0.5715445",
"0.5713514",
"0.5708426... | 0.5307831 | 58 |
opposite of `def coord_shift` | def inverse_coord_shift(kalman_coord):
x_c, y_c, aspect_ratio, height = kalman_coord[:4]
width = height / aspect_ratio
x_min = x_c - width / 2
x_max = x_c + width / 2
y_min = y_c - height / 2
y_max = y_c + height / 2
std_coord = np.array([x_min, y_min, x_max, y_max])
return np.int_(np.ro... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_to(self, shift: Move) -> Coordinate:\n if shift.direction == \"U\":\n new_coordinate = Coordinate(x=self.x, y=self.y + shift.dist)\n elif shift.direction == \"D\":\n new_coordinate = Coordinate(x=self.x, y=self.y - shift.dist)\n elif shift.direction == \"L\":\n ... | [
"0.63441014",
"0.62020755",
"0.61686033",
"0.6162898",
"0.61144555",
"0.607844",
"0.6076379",
"0.6066273",
"0.6032216",
"0.6012332",
"0.5981737",
"0.5956843",
"0.58499765",
"0.5840761",
"0.57823914",
"0.5777684",
"0.5755403",
"0.5743055",
"0.57391936",
"0.5738413",
"0.5735400... | 0.56250626 | 30 |
Convert (x_centroid, y_centroid, width, height) to (x_min, y_min, x_max, y_max) | def box_from_centroid(boxes):
boxes = np.array(boxes)
if len(boxes.shape) > 1:
mins = boxes[:, 0:2] - boxes[:, 2:4]//2
maxes = boxes[:, 0:2] + boxes[:, 2:4]//2
boxes = np.c_[mins, maxes]
else:
mins = boxes[0:2] - boxes[2:4]//2
maxes = boxes[0:2] + boxes[2:4]//2
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _xywh2min_max(box):\n x, y, w, h = box\n return np.array([x, y, x+w, y+h])",
"def convert_bbox(bbox, width, height):\n min_x, min_y, max_x, max_y = bbox\n # scale X axis\n min_x *= width\n max_x *= width\n # invert Y axis and scale\n min_y = (1 - min_y) * height\n max_y = (1 - max_... | [
"0.69743425",
"0.6879865",
"0.6665653",
"0.6642741",
"0.66418016",
"0.64907706",
"0.63931614",
"0.6312063",
"0.6281699",
"0.6257308",
"0.6256554",
"0.6223768",
"0.6211792",
"0.61935616",
"0.61682916",
"0.6108087",
"0.6095347",
"0.6067567",
"0.6064313",
"0.6063418",
"0.6047971... | 0.5560307 | 81 |
This method is used to initialise bounding boxes around initial detection for particles. | def scatter_particles(box, cent_disp=(-3,0,3), max_particles=100):
box = np.array(box)
init_val = [i for i in combinations_with_replacement(list(cent_disp), 4)]
disp_list = []
for k in init_val:
for i in permutations(k):
disp_list.append(i)
unique_disp_list = np.unique(np.array(d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _initial_normal_bbox(self):\n cx = cy = .5\n width = FLAGS.bbox_grid / float(FLAGS.cropbox_grid)\n x1 = cx - width / 2\n x2 = cx + width / 2\n y1 = cy - width / 2\n y2 = cy + width / 2\n return [y1,x1,y2,x2]",
"def create_prior_boxes(self):\n # value of... | [
"0.6935602",
"0.6608635",
"0.66064626",
"0.6469737",
"0.63891006",
"0.63366115",
"0.62954956",
"0.6258402",
"0.62572044",
"0.6242446",
"0.6229715",
"0.61691654",
"0.61258924",
"0.6112904",
"0.610026",
"0.6094922",
"0.6093308",
"0.6046396",
"0.6010858",
"0.60028255",
"0.599828... | 0.0 | -1 |
ARCHIVED!!! Test code not using anymore! | def get_neighbour_loc(box, p_noise, min_hw=10, h_variance=0.25,
ar_range=(0.7, 1.4), max_particles=100):
box = np.array(box)
final_box = []
x_c, y_c = compute_centroid(box)
h,w = box[2:4] - box[0:2]
h_min = max(min_hw, h-h*h_variance)
h_max = h+h*h_variance
p_noise = i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_4_4_1_1(self):\n pass",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def _test(self):\n pass",
"def _test(self):\n pass",
"def _test(self):\n pass",
"def unitary_test():",
"def test(self):\n pass... | [
"0.7265025",
"0.70079964",
"0.70079964",
"0.70079964",
"0.70079964",
"0.70079964",
"0.6839366",
"0.6839366",
"0.6839366",
"0.67159957",
"0.6635851",
"0.6512066",
"0.6482012",
"0.6477105",
"0.6477105",
"0.64568764",
"0.64359695",
"0.6346702",
"0.6346702",
"0.6346105",
"0.62854... | 0.0 | -1 |
Illuminance and Gamma invariant HSV | def compute_new_hsv(im):
eps = 1e-10
r,g,b = np.array(cv2.split(im)) + eps
traditional_hsv = cv2.cvtColor(im, cv2.COLOR_RGB2HSV)
numerator = np.log(r) - np.log(g)
denominator = np.log(r) + np.log(g) - 2*np.log(b) + eps
new_hue = np.clip(np.round(numerator/denominator).astype(np.uint8), 0, 180)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hsv(img):\n\tif img is None:\n\t\tprint \"Img is None\"\n\t\tsys.exit()\n\tif len(img.shape) > 2:\n\t\treturn cv2.cvtColor(img, cv2.COLOR_BGR2HSV)\n\treturn None",
"def applyHSV(img):\n\treturn applyColorMap(img, \"hsv\")",
"def rgb_to_hsv(x):\n # separating channels\n R = x[:,:,0]\n G = x[:,:,1]\... | [
"0.6549909",
"0.6278752",
"0.61685187",
"0.61676866",
"0.61129785",
"0.60947835",
"0.6063609",
"0.60199535",
"0.60035217",
"0.5999966",
"0.59681344",
"0.596583",
"0.5963666",
"0.5957139",
"0.5953068",
"0.59217805",
"0.5900227",
"0.5840088",
"0.5821216",
"0.58200157",
"0.58166... | 0.6006632 | 8 |
Check if Public box has Y coordinate > head box's | def check_yposition(public_box, head_box):
# Higher Y centroid condition
h_centroid = compute_centroid(head_box)
box_centroid = compute_centroid(public_box)
if box_centroid[1] > h_centroid[1]:
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def in_box(coords, box):\n\tif box[0][0] < coords[0] < box[1][0] and box[1][1] < coords[1] < box[0][1]:\n\t\treturn True\n\treturn False",
"def check():\n mouse = pygame.mouse.get_pos()\n\n # mouse[0] = x-coordinate of mouse position.\n # mouse[1] = y-coordinate of mouse position.\n if box1.x + box1.... | [
"0.68767154",
"0.6867427",
"0.6867155",
"0.68380576",
"0.67364043",
"0.6676998",
"0.65949243",
"0.6590243",
"0.659016",
"0.65420324",
"0.6540078",
"0.6508726",
"0.64178467",
"0.64138055",
"0.63922703",
"0.636486",
"0.63461787",
"0.6325837",
"0.62986743",
"0.6255579",
"0.62415... | 0.84469277 | 0 |
Warping position for camera motion compensation | def warp_pos(pos, warp_matrix):
import torch
p1 = torch.Tensor([pos[0], pos[1], 1]).view(3, 1)
p2 = torch.Tensor([pos[2], pos[3], 1]).view(3, 1)
p1_n = torch.mm(warp_matrix, p1).view(1, 2)
p2_n = torch.mm(warp_matrix, p2).view(1, 2)
return torch.cat((p1_n, p2_n), 1).view(1, -1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def adjust_camera(self):\n pose = deepcopy(self.data['poses']['marker']) # PoseStamped()\n eye_pose = deepcopy(pose)\n eye_pose.pose.position.x += 0.60\n eye_pose.pose.position.z += 0.20\n focus_pose = PoseStamped()\n base_eye_pose = PoseStamped()\n\n try:\n ... | [
"0.6999849",
"0.6293164",
"0.6187928",
"0.61723226",
"0.6152385",
"0.6121566",
"0.6087216",
"0.6058499",
"0.5968891",
"0.5954549",
"0.59318614",
"0.59167844",
"0.58837736",
"0.58698213",
"0.58682966",
"0.5845259",
"0.5835952",
"0.5831883",
"0.5797068",
"0.57966304",
"0.573792... | 0.0 | -1 |
Calculates the attribustes x_axis and y_axis of the image. These are the spatial axes, and \ can be used to find the spatial location of a pixel and are used in the plotting functions. If one wants to alter these axis, one can do this manually by running image.x_axis = ..., \ and image.y_axis = .... Returns None. | def calc_axes(self):
y_axis = np.linspace(0, self.image_shape[0] - 1, self.image_shape[0])
x_axis = np.linspace(0, self.image_shape[1] - 1, self.image_shape[1])
if hasattr(self, 'pixelsize'):
y_axis *= self.pixelsize[0]
x_axis *= self.pixelsize[1]
return x_axis, y... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_axes(self):\n self.y_axis = np.linspace(0, self.image_shape[0] - 1, self.image_shape[0])\n self.x_axis = np.linspace(0, self.image_shape[1] - 1, self.image_shape[1])\n if hasattr(self, 'pixelsize'):\n self.y_axis *= self.pixelsize[0]\n self.x_axis *= self.pixelsi... | [
"0.75874233",
"0.5822837",
"0.5817969",
"0.57584405",
"0.57190233",
"0.57038426",
"0.5673402",
"0.5554586",
"0.54701406",
"0.544219",
"0.54328954",
"0.5411503",
"0.5408289",
"0.5349925",
"0.5347552",
"0.5324715",
"0.5292402",
"0.5288886",
"0.52761215",
"0.52639616",
"0.524531... | 0.7306818 | 1 |
Generates ticks of (spatial) x and y axis for plotting perposes. | def get_ticks(self, sig=2, n_tick=10):
fmt = '%.' + str(sig) + 'g'
xlabels = np.zeros(self.x_axis.shape, dtype=object)
xlabels[:] = ""
each_n_pixels = math.floor(len(xlabels) / n_tick)
for i in range(len(xlabels)):
if i % each_n_pixels == 0:
xlabels[i]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __draw_xaxis(self):\n self.ax.set_xlim(self.xlims)\n # put x ticks on top\n xticks = [1]\n xticks.extend(range(5, self.xmax+5, 5))\n fs = self.settings.rcParams[\"axes.labelsize\"] if self.settings.otherParams[\n \"xlabel.fontsize\"] is None else self.settings.othe... | [
"0.685796",
"0.683631",
"0.6493824",
"0.6489116",
"0.6280993",
"0.6253217",
"0.6213189",
"0.62066805",
"0.61965775",
"0.6185663",
"0.6183213",
"0.6158319",
"0.6151242",
"0.61462426",
"0.614514",
"0.60663545",
"0.6061497",
"0.6052717",
"0.6010763",
"0.6005849",
"0.59700614",
... | 0.5936412 | 21 |
returns length of spectra, i.e. num energy loss bins | def l(self):
return self.data.shape[2] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def len(self):\n return len(self.spectrae)",
"def n_spectra(self):\n return np.product(self.image_shape)",
"def get_length(self):\r\n check_mixer()\r\n frequency, format, channels = (ffi.new('int*'), ffi.new('uint16_t*'),\r\n ffi.new('int*'))\r\... | [
"0.70883423",
"0.6979756",
"0.68218476",
"0.6779714",
"0.6756354",
"0.66088486",
"0.66071105",
"0.6516876",
"0.6474125",
"0.6472874",
"0.64442796",
"0.64272666",
"0.64053273",
"0.6404178",
"0.6366925",
"0.63087887",
"0.63034546",
"0.63007635",
"0.62594527",
"0.6221866",
"0.62... | 0.0 | -1 |
return 2Dshape of spectral image | def image_shape(self):
return self.data.shape[:2] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shape(self):\n return self._spectral_shape",
"def n_spectra(self):\n return np.product(self.image_shape)",
"def get_shape(self):\n if not self.channels_first:\n return [None] + self.w + [self.numoffeatures]\n else:\n return [None] + [self.numoffeatures] + s... | [
"0.7009999",
"0.6421456",
"0.64017713",
"0.62458396",
"0.622019",
"0.62103504",
"0.61071396",
"0.6098754",
"0.60419506",
"0.59981734",
"0.5972207",
"0.59172094",
"0.5889621",
"0.5889621",
"0.57486176",
"0.5729457",
"0.5722359",
"0.57197887",
"0.56805056",
"0.56609035",
"0.565... | 0.603204 | 10 |
Return True if each character in pattern is found in order in instring. | def fuzzy_match_simple(pattern, instring):
p_idx, s_idx, p_len, s_len = 0, 0, len(pattern), len(instring)
while (p_idx != p_len) and (s_idx != s_len):
if pattern[p_idx].lower() == instring[s_idx].lower():
p_idx += 1
s_idx += 1
return p_len != 0 and s_len != 0 and p_idx == p_len | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fn(query):\n i = 0\n for x in query:\n if i < len(pattern) and x == pattern[i]: i += 1\n elif x.isupper(): return False\n return i == len(pattern)",
"def search_string(self, pattern):\n if not pattern:\n return True\n\n l... | [
"0.6986734",
"0.63803357",
"0.6278569",
"0.6240252",
"0.6181874",
"0.6150704",
"0.61025155",
"0.6093655",
"0.60356295",
"0.60251266",
"0.6010011",
"0.5930002",
"0.58766013",
"0.58752376",
"0.58708507",
"0.58647394",
"0.5857319",
"0.58516085",
"0.58455545",
"0.5821804",
"0.579... | 0.68680596 | 1 |
Return match boolean and match score. | def fuzzy_match(pattern, instring, adj_bonus=5, sep_bonus=10, camel_bonus=10,
lead_penalty=-3, max_lead_penalty=-9, unmatched_penalty=-1):
score, p_idx, s_idx, p_len, s_len = 0, 0, 0, len(pattern), len(instring)
prev_match, prev_lower = False, False
prev_sep = True # so that matching first ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def match_score(self):\n return self._match_score",
"def matchscore(self):\n print(self.team1.name + \" \" + str(self.team1score) + \" - \" + str(self.team2score) + \" \" + self.team2.name)",
"def _exact_match_score_(prediction, ground_truth):\n return _normalize_answer(prediction) == _normalize... | [
"0.77264833",
"0.6901766",
"0.6428443",
"0.6412519",
"0.6410612",
"0.6404016",
"0.6386512",
"0.63160306",
"0.6315266",
"0.6290225",
"0.62550575",
"0.6250385",
"0.6244538",
"0.62204444",
"0.62137514",
"0.61782926",
"0.61713946",
"0.6165614",
"0.6165092",
"0.61639434",
"0.61604... | 0.0 | -1 |
The mocked value when mocked_translate is called | def mocked_translate(lur):
lur = {
"success": {"total": 1},
"contents": {
"translated": "Hi,Zaafira, I am",
"text": "Hi, I am Zaafira",
"translation": "yoda",
},
}
json_response_mock = mock.Mock()
json_response_mock.json.return_value = lur
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_translation(self):",
"def test_simple_translation_using_get(self):\n pass",
"def translate():\n pass",
"def translate(self):\n pass",
"def test_translation_smoke():\n english_to_morse = get_translator(\"english\", \"morse\")\n morse_to_english = get_translator(\"morse\", ... | [
"0.71579444",
"0.6881472",
"0.6809995",
"0.6740325",
"0.6596415",
"0.65692574",
"0.63575834",
"0.6336652",
"0.6304506",
"0.62915236",
"0.6259732",
"0.62328964",
"0.6221216",
"0.6167749",
"0.6110162",
"0.6085425",
"0.6049397",
"0.6040752",
"0.60180646",
"0.5991216",
"0.5950553... | 0.7410818 | 0 |
The value when mocked_pun is called | def mocked_pun(lur):
lur = {
"error": "false",
"category": "Pun",
"type": "single",
"joke": "How do you make holy water? You freeze it and drill holes in it.",
"flags": {
"nsfw": "false",
"religious": "true",
"political": "false",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def native_value(self) -> int | float | None:\n if unit := self.entity_description.native_unit_of_measurement:\n with suppress(KeyError):\n return self._gateway.data[self._mtu][unit]\n return None",
"def __call__(self):\n return self.value",
"def native_value(self... | [
"0.62340176",
"0.6050914",
"0.6029403",
"0.5947733",
"0.5904513",
"0.5900864",
"0.5865688",
"0.58591336",
"0.58540183",
"0.58415765",
"0.5830056",
"0.5816821",
"0.58057034",
"0.5774541",
"0.5767923",
"0.57539093",
"0.57487166",
"0.57286894",
"0.57249993",
"0.57249993",
"0.569... | 0.56409425 | 27 |
Mocks the requests.get method in app.py with a given translate | def test_parse_message_success(self):
for test_case in self.success_test_params:
expected = test_case[KEY_EXPECTED]
with mock.patch("requests.get", mocked_translate):
bring_message = app.on_new_address(test_case)
self.assertEqual(expected, bring_message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_translate(self):\n result = self.app.get('/translate?text=Something')\n self.assertEqual(result.status_code, 200)\n\n result = self.app.get('/translate')\n self.assertEqual(result.status_code, 500)",
"def test_simple_translation_using_get(self):\n pass",
"def mocked_... | [
"0.7905929",
"0.6907052",
"0.6885581",
"0.65317535",
"0.62674296",
"0.61959946",
"0.6195798",
"0.61866117",
"0.6023579",
"0.6014453",
"0.6010995",
"0.60024124",
"0.59135413",
"0.59132636",
"0.5901935",
"0.5898458",
"0.58547974",
"0.5806662",
"0.5758713",
"0.57383454",
"0.5732... | 0.535832 | 69 |
Mocks the requests.get method in app.py with a given pun | def test_parse_message_pun(self):
for test_case in self.success_test_pun:
expected = test_case[KEY_EXPECTED]
with mock.patch("requests.get", mocked_pun):
bring_message = app.on_new_address(test_case)
self.assertEqual(expected, bring_message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get(self):\n client = RestClient(host=self.host, username='')\n rest_url = 'some/url/'\n \n # Mock good response\n with responses.RequestsMock() as rsps:\n rsps.add(responses.GET, f'{self.host}/{rest_url}', status=200,\n json={'value':\"goo... | [
"0.69669604",
"0.67627823",
"0.6592265",
"0.65826535",
"0.6497083",
"0.64620715",
"0.6438313",
"0.6414112",
"0.6376383",
"0.636982",
"0.63449466",
"0.63231426",
"0.63054174",
"0.6286555",
"0.61875427",
"0.6182093",
"0.6159612",
"0.61394614",
"0.60945237",
"0.609397",
"0.60508... | 0.0 | -1 |
Mocks the google login in app.py | def test_parse_message_google_login(self):
for test_case in self.success_test_google_login:
expected = test_case[KEY_EXPECTED]
google_obj = app.on_new_google_user(test_case[KEY_INPUT])
self.assertEqual(expected, google_obj) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def google_login():\n # If a logged-in user goes to \"/google-login\", that user won't need to\n # log-in again, and automatically go back to the home page.\n if current_user.is_authenticated:\n return redirect(url_for('main.home'))\n\n # Google Sign-In constants\n GOOGLE_APP_CLIENT_ID = os.e... | [
"0.6950064",
"0.6899369",
"0.6833176",
"0.67480683",
"0.668549",
"0.6654326",
"0.662798",
"0.6426083",
"0.6347506",
"0.63022953",
"0.62749",
"0.624253",
"0.62268525",
"0.6206372",
"0.61844385",
"0.61392105",
"0.61314225",
"0.6110542",
"0.6109147",
"0.6103422",
"0.6095651",
... | 0.6566431 | 7 |
Mocks the requests.get method in app.py | def test_parse_message_failure_translation(self):
for test_case in self.failure_test_params:
expected = test_case[KEY_EXPECTED]
with mock.patch("requests.get", mocked_translate):
bring_message = app.on_new_address(test_case)
self.assertNotEqual(expected, bring_me... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get(self):\n client = RestClient(host=self.host, username='')\n rest_url = 'some/url/'\n \n # Mock good response\n with responses.RequestsMock() as rsps:\n rsps.add(responses.GET, f'{self.host}/{rest_url}', status=200,\n json={'value':\"goo... | [
"0.757244",
"0.7426668",
"0.7414589",
"0.72550845",
"0.7225032",
"0.7213081",
"0.70949316",
"0.704562",
"0.7016927",
"0.6952909",
"0.6937874",
"0.6872953",
"0.68185633",
"0.6812734",
"0.6795233",
"0.6713535",
"0.67129856",
"0.671215",
"0.6706005",
"0.6678081",
"0.66740376",
... | 0.0 | -1 |
Mocks the connect method in app.py | def test_parse_message_failure_connect(self):
for test_case in self.failure_test_params_wrong_connect:
expected = test_case[KEY_EXPECTED]
mock_connect = app.on_connect()
self.assertNotEqual(expected, mock_connect) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_connection(self):\n self._bind_to_service()",
"def test_connect_opens_connection(self):\n\n mock_connector = MagicMock()\n database = Database()\n\n database.connect(connector_impl=mock_connector)\n\n self.assertTrue(mock_connector.connect.called)",
"def test_connect(self):\n ... | [
"0.6830517",
"0.6756951",
"0.6701353",
"0.656319",
"0.644824",
"0.6433424",
"0.64212114",
"0.64014095",
"0.63124925",
"0.62617815",
"0.6254651",
"0.62454945",
"0.6245166",
"0.6238087",
"0.6238087",
"0.6233201",
"0.6230148",
"0.6220331",
"0.62118423",
"0.6202078",
"0.61952484"... | 0.5798926 | 80 |
Mocks the connect method in app.py | def test_parse_message_success_connect(self, mock_connect):
for test_case in self.success_test_params_connect:
expected = test_case[KEY_EXPECTED]
mock_connect = app.on_connect()
self.assertNotEqual(expected, mock_connect) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_connection(self):\n self._bind_to_service()",
"def test_connect_opens_connection(self):\n\n mock_connector = MagicMock()\n database = Database()\n\n database.connect(connector_impl=mock_connector)\n\n self.assertTrue(mock_connector.connect.called)",
"def test_connect(self):\n ... | [
"0.68321073",
"0.67585236",
"0.6702276",
"0.6563183",
"0.64499116",
"0.64343023",
"0.64209443",
"0.6402553",
"0.63121194",
"0.62629735",
"0.6255002",
"0.6245169",
"0.624482",
"0.62380844",
"0.62380844",
"0.62337166",
"0.62314856",
"0.6221396",
"0.6212393",
"0.62029994",
"0.61... | 0.5937141 | 62 |
Mocks the disconnect method in app.py | def test_parse_message_success_disconnect(self):
for test_case in self.success_test_params_disconnect:
expected = test_case[KEY_EXPECTED]
mock_disconnect = app.on_disconnect()
self.assertEqual(expected, mock_disconnect) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def disconnect(self) -> None:\n ...",
"def disconnect(self):",
"def disconnect(self):\n pass",
"def disconnect(self):\n pass",
"def disconnect(self):\n pass",
"def disconnect(self):\n pass",
"def disconnect(self):\n pass",
"async def test_disconnect(self):\n ... | [
"0.7235118",
"0.7185853",
"0.6926002",
"0.6926002",
"0.6926002",
"0.6926002",
"0.6926002",
"0.69075775",
"0.68698186",
"0.68698186",
"0.6831722",
"0.6776029",
"0.6724207",
"0.6720808",
"0.6720613",
"0.66972715",
"0.66972715",
"0.6688903",
"0.6668982",
"0.6634627",
"0.66278213... | 0.61994046 | 37 |
Mocks the disconnect method in app.py | def test_parse_message_failure_disconnect(self, mock_disconnect):
for test_case in self.failure_test_params_disconnect:
expected = test_case[KEY_EXPECTED]
mock_disconnect = app.on_disconnect()
self.assertNotEqual(expected, mock_disconnect) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def disconnect(self) -> None:\n ...",
"def disconnect(self):",
"def disconnect(self):\n pass",
"def disconnect(self):\n pass",
"def disconnect(self):\n pass",
"def disconnect(self):\n pass",
"def disconnect(self):\n pass",
"async def test_disconnect(self):\n ... | [
"0.7235118",
"0.7185853",
"0.6926002",
"0.6926002",
"0.6926002",
"0.6926002",
"0.6926002",
"0.69075775",
"0.68698186",
"0.68698186",
"0.6831722",
"0.6776029",
"0.6724207",
"0.6720808",
"0.6720613",
"0.66972715",
"0.66972715",
"0.6688903",
"0.6668982",
"0.6634627",
"0.66278213... | 0.61715174 | 38 |
Mocks the index method in app.py | def test_parse_message_success_load_page(self):
for test_case in self.success_test_params_load_page:
expected = test_case[KEY_EXPECTED]
try:
app.index()
bring_message = "finishedLoading"
except:
bring_message = "finishedLoading"... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_index(self):\n tester = app.test_client(self) # You can use self.app in place of tester\n response = tester.get('/', content_type='html/text')\n self.assertEqual(response.status_code, 200)",
"def test_index_view(self):\n response = self.client.get(url_for('main.index')... | [
"0.756429",
"0.7450295",
"0.7273167",
"0.72171074",
"0.713972",
"0.70764107",
"0.7024345",
"0.700154",
"0.6995603",
"0.6955005",
"0.69039184",
"0.68204653",
"0.6817888",
"0.67863053",
"0.6782207",
"0.6770325",
"0.6768245",
"0.6750743",
"0.67223954",
"0.6701688",
"0.66842735",... | 0.0 | -1 |
Mocks the index method in app.py | def test_parse_message_failure_load_page(self):
for test_case in self.failure_test_params_load_page:
expected = test_case[KEY_EXPECTED]
try:
app.index()
bring_message = "finishedLoading"
except:
bring_message = "notfinishedLoadi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_index(self):\n tester = app.test_client(self) # You can use self.app in place of tester\n response = tester.get('/', content_type='html/text')\n self.assertEqual(response.status_code, 200)",
"def test_index_view(self):\n response = self.client.get(url_for('main.index')... | [
"0.7563205",
"0.7449145",
"0.727243",
"0.72170496",
"0.7139567",
"0.70759034",
"0.70236087",
"0.700091",
"0.6994253",
"0.6953592",
"0.69042593",
"0.68208843",
"0.681823",
"0.6785938",
"0.67808765",
"0.67698324",
"0.676912",
"0.67513835",
"0.6721882",
"0.6701293",
"0.6684354",... | 0.0 | -1 |
Make the matrix look pretty | def pretty_print(self):
out = ""
rows,cols = self.matrix.shape
for row in xrange(0,rows):
out += "["
for col in xrange(0,cols):
out += "%+0.2f "%self.matrix[row][col]
out += "]\n"
return out | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __repr__(self):\n return self.matrix and '\\n'.join([\"|%s|\" % s for s in [' '.join([\"%-6.3f\" % e for e in w]) for w in self.matrix]]) or \"<pusta macierz>\"",
"def print_matrix_on_screen(matrix, width=5):\n for row in matrix:\n print(''.join(['{0:>{w}}'.format(item, w=width) for item in ... | [
"0.71262836",
"0.69080645",
"0.6853885",
"0.66841817",
"0.66777855",
"0.6670398",
"0.6620714",
"0.65799606",
"0.6577681",
"0.65713257",
"0.65455055",
"0.6541483",
"0.64739263",
"0.64697397",
"0.64694947",
"0.64253175",
"0.6413195",
"0.6405803",
"0.6385066",
"0.6358517",
"0.63... | 0.7403584 | 0 |
Override the `create` function to add extra functinality. | def create(self, validated_data):
# STEP 1 - Get validated POST data.
task_item = validated_data.get('task_item', None)
number_of_visits = validated_data.get('number_of_visits', 0)
# Go through the number of visits and create a new WorkOrder per visit.
for visit in range(0, numb... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create(*args):",
"def creates(f):\n f.creates = True\n return f",
"def create(self, *args, **kwargs):\n pass",
"def Create(self):\n raise NotImplementedError()",
"def create():\n pass",
"def _Create(self):\n pass",
"def addOnCreate(call, args=(), kwargs={}, nodeClass='*'):\n ... | [
"0.6564043",
"0.6538325",
"0.6369618",
"0.6267383",
"0.62032413",
"0.61438775",
"0.6055754",
"0.602165",
"0.602165",
"0.599945",
"0.5951197",
"0.59097826",
"0.5909072",
"0.5906299",
"0.5906299",
"0.5906299",
"0.5906299",
"0.5906299",
"0.5906299",
"0.5906299",
"0.5906299",
"... | 0.0 | -1 |
tearDown destroys any existing objects and processes | def tearDown(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tearDown(self):\r\n testing.tearDown()",
"def tearDown(self):\n self.tmp.cleanup()",
"def tearDown(self):\n util.delete_mocks()",
"def tearDown(self):\n util.delete_mocks()",
"def tearDown(self):\n util.delete_mocks()",
"def tearDown(self):\n util.delete_mock... | [
"0.8303317",
"0.82350826",
"0.82248276",
"0.82248276",
"0.82248276",
"0.82248276",
"0.82248276",
"0.82248276",
"0.8189078",
"0.81885344",
"0.8152555",
"0.8152555",
"0.8152555",
"0.8152002",
"0.8152002",
"0.8152002",
"0.8139147",
"0.8139147",
"0.8139147",
"0.8132551",
"0.81095... | 0.0 | -1 |
Tests if Rectangle inherits Base. | def test_inheritance(self):
self.assertTrue(issubclass(Rectangle, Base)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_0_is_Rectangle_class(self):\r\n self.assertTrue(issubclass(type(self.S0), Rectangle) and\r\n type(self.S0) != Rectangle)",
"def test_SquareinheritancefromRectangle(self):\n Square.reset_objects()\n self.assertEqual(issubclass(Square, Rectangle), True)",
"def... | [
"0.7410984",
"0.73879737",
"0.71916723",
"0.6733655",
"0.64805657",
"0.6343817",
"0.61637074",
"0.6104673",
"0.59940827",
"0.590253",
"0.58446425",
"0.5831769",
"0.57768166",
"0.5750307",
"0.5746952",
"0.574595",
"0.57251126",
"0.571214",
"0.5711103",
"0.56737524",
"0.5669128... | 0.86079776 | 0 |
Tests if id is inherited from Base. | def test_id_inherited(self):
Base._Base__nb_objects = 98
r = Rectangle(2, 4)
self.assertEqual(r.id, 99) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_baseid(self):\n self.assertEqual(str, type(BaseModel().id))",
"def _has_base(cls, base):\n if cls is base:\n return True\n elif cls is None:\n return False\n try:\n for bs in cls.__bases__:\n if _has_base(bs, base):\n return True\n except... | [
"0.7071606",
"0.68614566",
"0.6663652",
"0.6555642",
"0.65274465",
"0.6456492",
"0.64129174",
"0.6386005",
"0.63816565",
"0.6371645",
"0.63647985",
"0.6364053",
"0.6361062",
"0.6350097",
"0.63280857",
"0.6287805",
"0.6272882",
"0.6255194",
"0.6255194",
"0.6244298",
"0.6238731... | 0.6967543 | 1 |
Tests area() method signature. | def test_area_no_args(self):
r = Rectangle(5, 6)
with self.assertRaises(TypeError) as e:
Rectangle.area()
s = "area() missing 1 required positional argument: 'self'"
self.assertEqual(str(e.exception), s) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def area(self):\n raise Exception('area() is not implemented')",
"def area(self):\n raise Exception('area() is not implemented')",
"def area(self):\n raise Exception(\"area() is not implemented\")",
"def area(self):\n raise Exception(\"area() is not implemented\")",
"def test_ar... | [
"0.7761191",
"0.7761191",
"0.76756704",
"0.76756704",
"0.7654037",
"0.76147753",
"0.75531185",
"0.75346404",
"0.74885106",
"0.74715465",
"0.7454449",
"0.7454449",
"0.744922",
"0.74276274",
"0.7393726",
"0.7391685",
"0.73708904",
"0.7359716",
"0.73506284",
"0.7303255",
"0.7282... | 0.62658966 | 53 |
Tests area() method compuation. | def test_area(self):
r = Rectangle(5, 6)
self.assertEqual(r.area(), 30)
w = randrange(10) + 1
h = randrange(10) + 1
r.width = w
r.height = h
self.assertEqual(r.area(), w * h)
w = randrange(10) + 1
h = randrange(10) + 1
r = Rectangle(w, h, 7... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_area(self):\n r1 = Rectangle(3, 2)\n self.assertEqual(r1.area(), 6)\n\n r2 = Rectangle(2, 10)\n self.assertEqual(r2.area(), 20)\n\n r3 = Rectangle(10, 10)\n self.assertEqual(r3.area(), 100)",
"def test_area1(self):\n r1 = Rectangle(3, 2)\n self.ass... | [
"0.83019114",
"0.8017923",
"0.80146426",
"0.8005159",
"0.7995337",
"0.7947589",
"0.79453653",
"0.79390806",
"0.79390806",
"0.7928512",
"0.78742164",
"0.78742164",
"0.7852106",
"0.78420675",
"0.7834758",
"0.77837646",
"0.7741229",
"0.7740818",
"0.7740818",
"0.76975816",
"0.763... | 0.7638582 | 20 |
Tests display() method signature. | def test_display_no_args(self):
r = Rectangle(9, 8)
with self.assertRaises(TypeError) as e:
Rectangle.display()
s = "display() missing 1 required positional argument: 'self'"
self.assertEqual(str(e.exception), s) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_display__method(self):\n Rectangle.reset_objects()\n s1 = Square(5)\n f = io.StringIO()\n with contextlib.redirect_stdout(f):\n s1.display()\n self.assertEqual(f.getvalue(), \"#####\\n#####\\n#####\\n#####\\n#####\\n\")",
"def test_display_method4(self):\n ... | [
"0.72286975",
"0.7220992",
"0.7171832",
"0.71217597",
"0.71199435",
"0.7091923",
"0.7068505",
"0.7067569",
"0.705811",
"0.6985495",
"0.6922923",
"0.6909551",
"0.6879732",
"0.6846518",
"0.6839326",
"0.6823341",
"0.6788506",
"0.67868525",
"0.67603636",
"0.6748174",
"0.6736388",... | 0.645122 | 33 |
Tests display() method output. | def test_display_simple(self):
r = Rectangle(1, 1)
f = io.StringIO()
with redirect_stdout(f):
r.display()
s = "#\n"
self.assertEqual(f.getvalue(), s)
r.width = 2
r.height = 2
f = io.StringIO()
with redirect_stdout(f):
r.disp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_display_method1(self):\n capturedOutput = io.StringIO()\n sys.stdout = capturedOutput\n r1 = Rectangle(4, 6)\n r1.display()\n sys.stdout = sys.__stdout__\n desired = '####\\n####\\n####\\n####\\n####\\n####\\n'\n self.assertEqual(capturedOutput.getvalue(), ... | [
"0.7984882",
"0.7975976",
"0.7949459",
"0.7943532",
"0.79417163",
"0.7919054",
"0.7876275",
"0.78596795",
"0.7641263",
"0.7537544",
"0.7532322",
"0.74249905",
"0.7285819",
"0.70703816",
"0.7018516",
"0.696649",
"0.69599384",
"0.6948042",
"0.69043356",
"0.68679106",
"0.6840440... | 0.7197419 | 13 |
Tests __str__() method signature. | def test_K_str_no_args(self):
r = Rectangle(5, 2)
with self.assertRaises(TypeError) as e:
Rectangle.__str__()
s = "__str__() missing 1 required positional argument: 'self'"
self.assertEqual(str(e.exception), s) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_str_method(self):\n s1 = Square(4, 6, 2, 12)\n self.assertEqual(s1.__str__(), '[Square] (12) 6/2 - 4')",
"def test_strmethod(self):\n b1 = BaseModel()\n self.assertEqual(type(str(b1)), str)",
"def test_str_method(self):\n b1 = BaseModel()\n b1printed =... | [
"0.7903349",
"0.7795397",
"0.7790063",
"0.7765625",
"0.774312",
"0.75303704",
"0.74712944",
"0.74447334",
"0.7424896",
"0.735923",
"0.735923",
"0.735923",
"0.735923",
"0.7346667",
"0.73428327",
"0.73418957",
"0.7332717",
"0.7289573",
"0.7279956",
"0.7278092",
"0.7265257",
"... | 0.7410371 | 9 |
Tests __str__() method return. | def test_K_str(self):
r = Rectangle(5, 2)
s = '[Rectangle] (1) 0/0 - 5/2'
self.assertEqual(str(r), s)
r = Rectangle(1, 1, 1)
s = '[Rectangle] (2) 1/0 - 1/1'
self.assertEqual(str(r), s)
r = Rectangle(3, 4, 5, 6)
s = '[Rectangle] (3) 5/6 - 3/4'
self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_str_method(self):\n b1 = BaseModel()\n b1printed = b1.__str__()\n self.assertEqual(b1printed,\n \"[BaseModel] ({}) {}\".format(b1.id, b1.__dict__))",
"def test_str_magic_method(self):\n correct_output = \"[User] ({}) {}\".format(\n self.user... | [
"0.8076664",
"0.7979401",
"0.78803456",
"0.7769605",
"0.7743831",
"0.77330804",
"0.7694057",
"0.7694057",
"0.7666207",
"0.76300365",
"0.76118594",
"0.76118594",
"0.76118594",
"0.76118594",
"0.75641793",
"0.7534076",
"0.7477838",
"0.7465533",
"0.7428464",
"0.7426698",
"0.74242... | 0.0 | -1 |
Tests update() postional args. | def test_update_args(self):
r = Rectangle(5, 2)
d = r.__dict__.copy()
r.update(10)
d["id"] = 10
self.assertEqual(r.__dict__, d)
r.update(10, 5)
d["_Rectangle__width"] = 5
self.assertEqual(r.__dict__, d)
r.update(10, 5, 17)
d["_Rectangle_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_update(self):\n pass",
"def test_update(self):\n pass",
"def test_update(self):\n pass",
"def update(*args):",
"def test_update_case(self):\n pass",
"def test_update(self):\n # this is tested graphically, as it is UI\n pass",
"def test_21_update_args(s... | [
"0.78976095",
"0.78976095",
"0.78976095",
"0.7831367",
"0.77857095",
"0.7644135",
"0.7635107",
"0.7419102",
"0.7413974",
"0.7362397",
"0.73514724",
"0.73471075",
"0.7343083",
"0.7343083",
"0.7343083",
"0.7343083",
"0.7343083",
"0.7343083",
"0.7310264",
"0.72708553",
"0.715508... | 0.72341317 | 20 |
Tests update() positional arg bad values. | def test_update_args_bad(self):
r = Rectangle(5, 2)
d = r.__dict__.copy()
r.update(10)
d["id"] = 10
self.assertEqual(r.__dict__, d)
with self.assertRaises(ValueError) as e:
r.update(10, -5)
s = "width must be > 0"
self.assertEqual(str(e.excep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_invalid_update_kwarg(self):\r\n m0 = TestUpdateModel.create(count=5, text='monkey')\r\n with self.assertRaises(ValidationError):\r\n m0.update(numbers=20)",
"def test_invalid_update_kwarg(self):\n m0 = TestUpdateModel.create(count=5, text='monkey')\n with self.asse... | [
"0.75484985",
"0.7544116",
"0.7184915",
"0.7156995",
"0.7053883",
"0.7009638",
"0.6897584",
"0.6860641",
"0.66748905",
"0.6668533",
"0.6648059",
"0.65885854",
"0.65509695",
"0.6534375",
"0.6524069",
"0.64533055",
"0.6448236",
"0.64405257",
"0.64405257",
"0.64405257",
"0.64384... | 0.7652585 | 0 |
Tests update() keyword args. | def test_update_kwargs(self):
r = Rectangle(5, 2)
d = r.__dict__.copy()
r.update(id=10)
d["id"] = 10
self.assertEqual(r.__dict__, d)
r.update(width=5)
d["_Rectangle__width"] = 5
self.assertEqual(r.__dict__, d)
r.update(height=17)
d["_Rec... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(*args):",
"def test_update(self):\n pass",
"def test_update(self):\n pass",
"def test_update(self):\n pass",
"def test_update_case(self):\n pass",
"def test_22_update_kwargs(self):\n r = Rectangle(10, 10, 10, 10, 1)\n r.update(height=1)\n self.a... | [
"0.7933049",
"0.7655731",
"0.7655731",
"0.7655731",
"0.7525596",
"0.7503009",
"0.74636483",
"0.74636483",
"0.74636483",
"0.74636483",
"0.74636483",
"0.74636483",
"0.7429537",
"0.73988676",
"0.73822886",
"0.727029",
"0.7252961",
"0.71389437",
"0.7127599",
"0.7118577",
"0.70688... | 0.65902525 | 48 |
Tests update() keyword args. | def test_update_kwargs_2(self):
r = Rectangle(5, 2)
d = r.__dict__.copy()
r.update(id=10)
d["id"] = 10
self.assertEqual(r.__dict__, d)
r.update(id=10, width=5)
d["_Rectangle__width"] = 5
self.assertEqual(r.__dict__, d)
r.update(id=10, width=5, h... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(*args):",
"def test_update(self):\n pass",
"def test_update(self):\n pass",
"def test_update(self):\n pass",
"def test_update_case(self):\n pass",
"def test_22_update_kwargs(self):\n r = Rectangle(10, 10, 10, 10, 1)\n r.update(height=1)\n self.a... | [
"0.7933049",
"0.7655731",
"0.7655731",
"0.7655731",
"0.7525596",
"0.7503009",
"0.74636483",
"0.74636483",
"0.74636483",
"0.74636483",
"0.74636483",
"0.74636483",
"0.7429537",
"0.73988676",
"0.73822886",
"0.727029",
"0.7252961",
"0.71389437",
"0.7127599",
"0.7118577",
"0.70688... | 0.63131505 | 70 |
Fetch public transport stations. | def fetch_public_transport(lat, lon, radius, results=10):
headers = {'X-Identifier': 'olli-simulation'}
params = {'latitude': lat, 'longitude': lon, 'distance': radius, 'results': results}
response = requests.get(url=BASE_URL, params=params, headers=headers)
return response.json() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stations():\n\n return station_list",
"def get_stations(self):\n return self.__request('stations')['stations']",
"async def _get_stations_remote() -> List[WeatherStation]:\n LOGGER.info('Using WFWX to retrieve station list')\n async with ClientSession() as session:\n # Get the authen... | [
"0.652366",
"0.64384484",
"0.6400441",
"0.63273543",
"0.60794353",
"0.6060445",
"0.6023141",
"0.5923451",
"0.591057",
"0.58895737",
"0.58801377",
"0.58708596",
"0.58183354",
"0.57893187",
"0.5763391",
"0.5755471",
"0.5719387",
"0.5708214",
"0.56968224",
"0.56882566",
"0.56855... | 0.6247813 | 4 |
Returns a protobuf serialization of self. As a requirement of all objects which inherit from Serializable, this method transforms the current object into the corresponding Protobuf object so that it can be further serialized. | def _object2proto(self) -> Metadata_PB:
return Metadata_PB(
name=self.name, id=serialize(self.id), node=serialize(self.node)
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def serialize(self) -> typing.Any:\n return self._serialize(self.__dict__)",
"def serialize(self) -> bytes:\n return pickle.dumps(self)",
"def serialize(self):\n raise NotImplementedError(\n \"Subclasses of Serializable must implement serialize\"\n )",
"def _serialize(\... | [
"0.7394982",
"0.7394048",
"0.7250269",
"0.7047218",
"0.70303553",
"0.70303553",
"0.70303553",
"0.7026158",
"0.69605255",
"0.69605255",
"0.69462675",
"0.6899246",
"0.687692",
"0.68090254",
"0.6795104",
"0.6707859",
"0.66748744",
"0.66719115",
"0.66151845",
"0.66151845",
"0.661... | 0.67812586 | 15 |
Creates a ObjectWithID from a protobuf As a requirement of all objects which inherit from Serializable, this method transforms a protobuf object into an instance of this class. | def _proto2object(proto: Metadata_PB) -> "Metadata":
return Metadata(
id=validate_type(_deserialize(blob=proto.id), UID, optional=True),
name=proto.name,
node=validate_type(_deserialize(blob=proto.node), Location),
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _proto2object(\n proto: CreateGroupMessage_PB,\n ) -> \"CreateGroupMessage\":\n\n return CreateGroupMessage(\n msg_id=_deserialize(blob=proto.msg_id),\n address=_deserialize(blob=proto.address),\n content=json.loads(proto.content),\n reply_to=_deseri... | [
"0.70799685",
"0.6824257",
"0.67300284",
"0.6629282",
"0.66131353",
"0.65628207",
"0.65527236",
"0.65504444",
"0.65402055",
"0.6278673",
"0.627125",
"0.6209945",
"0.6203828",
"0.6177975",
"0.6148224",
"0.6105038",
"0.60929835",
"0.60874814",
"0.5987831",
"0.59861207",
"0.5970... | 0.667701 | 3 |
Return the type of protobuf object which stores a class of this type As a part of serialization and deserialization, we need the ability to lookup the protobuf object type directly from the object type. This static method allows us to do this. Importantly, this method is also used to create the reverse lookup ability w... | def get_protobuf_schema() -> GeneratedProtocolMessageType:
return Metadata_PB | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetProtobufType(cls):\n return _GetFactory(cls).protobuf_type",
"def get_obj_class(self, obj_type: str) -> Type[TgnObject]:\n pass",
"def get_type ( self, object ):\n return self.type",
"def get_type ( self, object ):\n return self.type",
"def getMetaType(self, object) :\n\t\tif c... | [
"0.7063471",
"0.6982377",
"0.6548026",
"0.6548026",
"0.65435624",
"0.6421704",
"0.63375413",
"0.63375413",
"0.63375413",
"0.63375413",
"0.63375413",
"0.63375413",
"0.63375413",
"0.63375413",
"0.63375413",
"0.63375413",
"0.63375413",
"0.63375413",
"0.63375413",
"0.63375413",
"... | 0.0 | -1 |
Function to perform hierarchical clustering of the 16S data matrix. | def cluster16SMatrix(dataMatrix, distanceMetric='jensenshannon', clusterMethod='ward', nClusters=5):
# Cluster the data matrix using the desired metrics
distanceCalc = distance.pdist(dataMatrix.values, distanceMetric)
distanceCalc[np.isnan(distanceCalc)] = 0
colLinkage = hierarchy.linkage(distanceCalc, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hierarchicalClustering(distanceMatrix, withDendrogram=False):\n\n # convert symmetric distance matrix into upper triangular array\n distArray = ssd.squareform(np.asmatrix(distanceMatrix), checks=False)\n # find \"best\" method\n methods = [\"ward\", \"median\", \"average\", \"single\", \"complet... | [
"0.71700925",
"0.7048514",
"0.6960884",
"0.6786377",
"0.6780482",
"0.6740712",
"0.6685286",
"0.663984",
"0.6570671",
"0.6514675",
"0.6510114",
"0.65045625",
"0.6497484",
"0.64436615",
"0.64186096",
"0.64010465",
"0.6389351",
"0.6367447",
"0.6346259",
"0.634564",
"0.6306024",
... | 0.6460729 | 13 |
Function to assess the "optimal" number of clusters for hierarchical clustering. | def validateClusters(dataMatrix, distanceMetric='jensenshannon', clusterMethod='ward', method='silhouette', maxClusters=25):
distanceCalc = distance.pdist(dataMatrix.values, distanceMetric)
distanceCalc[np.isnan(distanceCalc)] = 0
colLinkage = hierarchy.linkage(distanceCalc, method=clusterMethod)
distMa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_nb_clusters(self):\n \n print(\"Finding the optimal number of clusters...\")\n \n sample = ro.r.matrix(self.df[self.df[\"filename\"].between(1, 4)][\"active_power\"].to_numpy())\n \n r=ro.r(\"\"\"\n check = function(matrix) {\n n_clust = fviz... | [
"0.71986145",
"0.6878082",
"0.6713189",
"0.66142327",
"0.6468205",
"0.6460931",
"0.6435595",
"0.63791865",
"0.6353146",
"0.63363975",
"0.62885153",
"0.6247442",
"0.61853504",
"0.6152921",
"0.6150224",
"0.6145353",
"0.6141246",
"0.60855657",
"0.60784227",
"0.60701925",
"0.6041... | 0.0 | -1 |
Append raw report item or bytes to HID report | def add_report_raw(self, report_data):
self._reports.append(report_data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_report_item(self, report_prefix, *report_data):\n hid_report = ReportDescriptorEmitter()\n report_len = _hid_item_length.index(len(report_data))\n hid_report.bHeader = {\n \"prefix\": report_prefix,\n \"bSize\": report_len\n }\n hid_report.data = re... | [
"0.7176925",
"0.5762664",
"0.56536555",
"0.5579736",
"0.5500773",
"0.5449259",
"0.5405908",
"0.5357833",
"0.52661437",
"0.5226669",
"0.5153525",
"0.51037776",
"0.5079036",
"0.5062024",
"0.5052433",
"0.50386965",
"0.50331897",
"0.5029711",
"0.5022681",
"0.50067246",
"0.5004431... | 0.66093427 | 1 |
Convenience function to add formatted HID report item | def add_report_item(self, report_prefix, *report_data):
hid_report = ReportDescriptorEmitter()
report_len = _hid_item_length.index(len(report_data))
hid_report.bHeader = {
"prefix": report_prefix,
"bSize": report_len
}
hid_report.data = report_data
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_report_formatting(self, cell_range: str, fmt_spec: gsfmt.CellFormat):\n self.report_formatting.append((cell_range, fmt_spec))",
"def format(self, item):\n raise NotImplementedError()",
"def addItem(self, track_dict):\n for i in ['order_id', 'sku', 'name', 'price', 'quantity']: # ... | [
"0.58909196",
"0.57545817",
"0.5592168",
"0.5580048",
"0.55122375",
"0.54767895",
"0.54133266",
"0.53118646",
"0.5274623",
"0.52535117",
"0.5248676",
"0.523191",
"0.5217867",
"0.5205428",
"0.515771",
"0.5144452",
"0.51378083",
"0.51216",
"0.5105966",
"0.51056516",
"0.5085843"... | 0.70738643 | 0 |
Convenience function to add HID input item with preformatted flags. See HID 1.11 section 6.2.2.5 for flag meanings. | def add_input_item(self,
data_constant = False,
array_variable = True,
absolute_relative = False,
wrap = False,
linear = False,
preferred = True,
null = False,
volatile = False... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_flag_entry(entry_message, data=''):\n return partial(__add_entry,\n event_type='FLAG',\n entry_message=entry_message,\n data=data)",
"def add_special_input(self, input, number, logid='default-log'):\n cell = self.get_cell(number, logid)\n ... | [
"0.57880765",
"0.5669327",
"0.56324345",
"0.55200225",
"0.54979795",
"0.5425436",
"0.53873056",
"0.5352823",
"0.5308463",
"0.5291668",
"0.52721167",
"0.52556586",
"0.5171872",
"0.5164225",
"0.515738",
"0.5134334",
"0.5124091",
"0.5116217",
"0.50476795",
"0.5022534",
"0.502253... | 0.56855875 | 1 |
Convenience function to add HID output item with preformatted flags. See HID 1.11 section 6.2.2.5 for flag meanings. | def add_output_item(self,
data_constant = False,
array_variable = True,
absolute_relative = False,
wrap = False,
linear = False,
preferred = True,
null = False,
volatile = Fals... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_flags_into(into, flags):\n field_added = False\n \n for flag_name in flags:\n if field_added:\n into.append(', ')\n else:\n field_added = True\n \n into.append(flag_name.replace('_', ' '))\n \n return into",
"def add_item(self, command, ... | [
"0.566925",
"0.5456259",
"0.53306985",
"0.53150094",
"0.518418",
"0.51789975",
"0.5112157",
"0.5067346",
"0.5030945",
"0.49701762",
"0.494928",
"0.49411944",
"0.49125028",
"0.49066538",
"0.48974305",
"0.48620847",
"0.48526123",
"0.48305097",
"0.483018",
"0.48075736",
"0.48072... | 0.5750249 | 0 |
Auxiliary function (K' in the paper) | def B(self, s, t, n):
if n == 0:
return 1
elif min(len(s), len(t)) < n:
return 0
if (s[:-1], t, n) in self.B_st.keys():
B1 = self.B_st[(s[:-1], t, n)]
else:
B1 = self.B(s[:-1], t, n)
#self.B_st[(s[:-1], t, n)] = B1
if (... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fn(k):\n if k <= 1: return 1\n return fn(k-1) + fn(k-2)",
"def getK2(inp):\n\treturn 0.9/(1-math.exp(-getLambda(inp)))",
"def fn(m, k):\n if m == 0 or k == 0: return 0 \n return 1 + fn(m-1, k-1) + fn(m-1, k)",
"def f(X_,K_):\r\n return max(exp(X_)-K_,0)",
... | [
"0.63933635",
"0.6363057",
"0.63177955",
"0.62598974",
"0.62358433",
"0.62325853",
"0.6205404",
"0.61867553",
"0.61731815",
"0.6159942",
"0.61560804",
"0.6133259",
"0.6103906",
"0.609453",
"0.60727435",
"0.60464805",
"0.600266",
"0.6000921",
"0.59985346",
"0.59777886",
"0.596... | 0.0 | -1 |
Rabbits and recurrence relations | def fib(m, k):
assert m > 2
first = 1
second = 1
generation = 3
while generation <= m:
result = second + first * k
second, first = result, second
generation += 1
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rabbits(n, k):\n prev, nxt = 1, 1\n for _ in range(2, n):\n prev, nxt = nxt, prev * k + nxt\n return nxt",
"def setup_RR(self):\n for n in range(self.L - 1, -1, -1):\n self.update_RR(n)\n return self.R[-1]",
"def SingleQubitRB(qubit: qreg, seqs, purity=False, add_ca... | [
"0.58385503",
"0.57514787",
"0.5736917",
"0.5587354",
"0.55848575",
"0.5511443",
"0.55083007",
"0.5465466",
"0.54601455",
"0.54573774",
"0.54498184",
"0.54476917",
"0.54418176",
"0.5397274",
"0.53703415",
"0.53316414",
"0.53296494",
"0.5311462",
"0.5302778",
"0.5293368",
"0.5... | 0.0 | -1 |
Lint the code with flake8. | def lint(session):
session.install("flake8")
session.run("flake8", "") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flake8():\n call([\"flake8\"])",
"def flake8(context):\n exec_cmd = \"flake8 .\"\n run_cmd(context, exec_cmd)",
"def lint(session):\n session.install(\"flake8\", BLACK_VERSION)\n session.run(\n \"black\",\n \"--check\",\n *BLACK_PATHS,\n )\n session.run(\"flake8\",... | [
"0.7826502",
"0.7439914",
"0.7414755",
"0.7378273",
"0.71720546",
"0.6855276",
"0.68128854",
"0.6767506",
"0.6689481",
"0.66845065",
"0.66831493",
"0.66447073",
"0.66055167",
"0.6570661",
"0.656754",
"0.6563536",
"0.65325195",
"0.65315926",
"0.65244573",
"0.65235114",
"0.6497... | 0.83361983 | 0 |
Get next prime number. | def __next__(self):
self.index = self.__get_next_unmarked(self.index)
if self.index > self.limit:
raise StopIteration
self.primes.append(self.index)
return self.index | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nextPrime(self):\n\t\tnum = self.cur + 1\n\t\twhile not self.isPrime(num):\n\t\t\tnum += 1\n\t\tself.cur = num\n\t\tself.prev.append(num)\n\t\t# print num\n\t\treturn num",
"def next_prime(n):\n i = n + 1\n while not is_prime(i):\n i += 1\n return i",
"def next(self):\n nextPrime = N... | [
"0.7907222",
"0.76951885",
"0.7654759",
"0.71056986",
"0.7048942",
"0.69492847",
"0.6936683",
"0.6892645",
"0.68164766",
"0.68124247",
"0.67196745",
"0.6714677",
"0.6711068",
"0.66861314",
"0.6676425",
"0.6606492",
"0.6604533",
"0.6596021",
"0.6593638",
"0.6583414",
"0.655728... | 0.6296308 | 37 |
Get the next unmarked number. | def __get_next_unmarked(self, current):
while self.__is_multiple(current):
current += 1
return current | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_next_sequence_number(self):\n cur = self._next_sequence_number\n self._next_sequence_number += 1\n return cur",
"def next_num(cls):\r\n cls.num += 1\r\n return cls.num",
"def next(self) -> int:\n value = self.inorder[self.index]\n self.index = self.inde... | [
"0.70734465",
"0.6977527",
"0.6927917",
"0.69086856",
"0.6900802",
"0.6900802",
"0.67605877",
"0.6751186",
"0.67221344",
"0.66767734",
"0.6674278",
"0.66321826",
"0.66191983",
"0.6531785",
"0.6526116",
"0.6522179",
"0.6513542",
"0.6510174",
"0.6490269",
"0.6476114",
"0.644534... | 0.76074725 | 0 |
Check, whether current index is a multiple of one of the already discovered primes. | def __is_multiple(self, current):
for prime in self.primes:
if current % prime == 0:
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def esPrimo(self, x):\r\n divisor = 0\r\n for i in range(2, x+1):\r\n if x%i == 0:\r\n divisor = divisor + 1\r\n if divisor > 1:\r\n return False\r\n return True",
"def is_prime(a):\n return all(a % i for i in xrange(2, a))",
"... | [
"0.68746513",
"0.68040067",
"0.6702705",
"0.6702675",
"0.6682332",
"0.66237456",
"0.6601964",
"0.65563357",
"0.6531201",
"0.652898",
"0.65209794",
"0.6499448",
"0.6499271",
"0.64508814",
"0.6449261",
"0.6444774",
"0.6443582",
"0.64350456",
"0.6424135",
"0.6399239",
"0.6384989... | 0.7993067 | 0 |
Parses arguments from command line | def arg_parsing():
# parser instance
parser = argparse.ArgumentParser(description="Neural Network Settings")
# select data directory
parser.add_argument('--data_dir',
type=str,
help='Data directory.')
# select architecture
parser.add_argum... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parse_command_line(self, argv):\n from optparse import OptionParser\n usage = \"usage: %prog [options]\"\n parser = OptionParser(usage)\n\n (options, args) = parser.parse_args(argv)",
"def process_command_line_arguments() -> Namespace:\n\n parser... | [
"0.82391286",
"0.761403",
"0.7605433",
"0.75999135",
"0.7588268",
"0.7584151",
"0.7485596",
"0.7418313",
"0.7409787",
"0.7405591",
"0.7386275",
"0.73807216",
"0.7370799",
"0.736445",
"0.7352877",
"0.7339369",
"0.73152745",
"0.7292983",
"0.7279095",
"0.7278008",
"0.7266839",
... | 0.0 | -1 |
Performs training transformations on dataset. | def transformation_for_training(train_dir):
train_transforms = transforms.Compose([transforms.RandomRotation(30),
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
tr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _transform(self, dataset):\n raise NotImplementedError()",
"def train(self, training_data):\n pass",
"def train(self, dataset) -> None:\n raise NotImplementedError()",
"def transform_data(dataset_train, dataset_test):\n\n #transform dataset using fit_transform\n dataset_train =... | [
"0.74984956",
"0.714322",
"0.7125565",
"0.7067932",
"0.70065993",
"0.684767",
"0.67919225",
"0.6773342",
"0.6690853",
"0.66440636",
"0.6640035",
"0.6621524",
"0.6609387",
"0.65764475",
"0.65696764",
"0.6529118",
"0.65197486",
"0.6495644",
"0.64931464",
"0.6469883",
"0.64534",... | 0.62729067 | 34 |
Performs test transformations on a dataset. | def transformation_for_testing(test_dir):
# Define transformation
test_transforms = transforms.Compose([transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Nor... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test(self, dataset) -> None:\n raise NotImplementedError()",
"def test(self, dataset):\n\n outputs, errors = self.use(dataset)\n\n ## PUT CODE HERE ##\n # I put the code in the \"use\" function, seems better :-)\n\n return outputs, errors",
"def transform_data(dataset_tra... | [
"0.7348205",
"0.7184683",
"0.71561563",
"0.7091412",
"0.7063284",
"0.7034932",
"0.68949515",
"0.68701756",
"0.6851518",
"0.6554057",
"0.6454966",
"0.63948965",
"0.63236576",
"0.62374663",
"0.6223602",
"0.61879635",
"0.6180748",
"0.6177663",
"0.6177561",
"0.6172904",
"0.615515... | 0.6279633 | 13 |
Creates a dataloader from dataset | def data_loader(data, train=True):
loader_config = {
'batch_size':64,
'shuffle':train
}
return torch.utils.data.DataLoader(data, **loader_config) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_dataloader(data):\r\n input_ids = torch.LongTensor([sent['input_ids'] for sent in data])\r\n input_mask = torch.LongTensor([sent['input_mask'] for sent in data])\r\n segment_ids = torch.LongTensor([sent['segment_ids'] for sent in data])\r\n label_ids = torch.LongTensor([sent['label_ids'] for... | [
"0.80838567",
"0.7692149",
"0.7623508",
"0.76028895",
"0.752949",
"0.7343747",
"0.73312813",
"0.7285905",
"0.72848207",
"0.72800523",
"0.7233345",
"0.71680284",
"0.7144422",
"0.7127126",
"0.7112699",
"0.70464253",
"0.70323205",
"0.69610095",
"0.6957902",
"0.69366944",
"0.6930... | 0.6414222 | 62 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.