torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_train, **self.dl_kwargs)","def dataset(request):\n X, y = make_classification(\n n_samples=700, n_features=10, n_informative=8, n_redundant=2,\n n_classes=2, n_clusters_per_class=2, random_state=6483\n )\n\n request.cls.dataset = Dataset(X, y)","def to_DataLoader(self, **kwargs):\r\n return DataLoader(self, **kwargs)","def get_dataset(self):\n\n trainset = datasets.SVHN('datasets/SVHN/train/', split='train', transform=self.train_transforms,\n target_transform=None, download=True)\n valset = datasets.SVHN('datasets/SVHN/test/', split='test', transform=self.val_transforms,\n target_transform=None, download=True)\n extraset = datasets.SVHN('datasets/SVHN/extra', split='extra', transform=self.train_transforms,\n target_transform=None, download=True)\n\n trainset = torch.utils.data.ConcatDataset([trainset, extraset])\n\n return trainset, valset","def datasets(self):\n return [Dataset.ENSEMBL]","def to_dataset(df, batch_size=5):\n df = df.copy()\n labels = df.pop('Relevant')\n ds = tf.data.Dataset.from_tensor_slices((dict(df), labels))\n ds = ds.batch(batch_size)\n return ds","def _dataset(self, split, directory, data_file):\n del split\n\n filenames = generate_filenames(self.name, directory, data_file)\n\n def parse_function(record):\n image_dim = self.IMAGE_SIZE_PX\n features = tf.parse_single_example(\n record,\n features={\n 'image_raw': tf.FixedLenFeature([], tf.string),\n 'label': tf.FixedLenFeature([], tf.int64),\n 'height': tf.FixedLenFeature([], tf.int64),\n 'width': tf.FixedLenFeature([], tf.int64),\n 'depth': tf.FixedLenFeature([], tf.int64)\n })\n\n # Convert from a scalar string tensor (whose single string has\n # length image_pixel*image_pixel) to a uint8 tensor with shape\n # [image_pixel, image_pixel, 1].\n image = tf.decode_raw(features['image_raw'], tf.uint8)\n image = tf.reshape(image, [image_dim, image_dim, 1])\n image.set_shape([image_dim, image_dim, 1])\n\n # Convert from [0, 255] -> [-0.5, 0.5] floats.\n image = tf.cast(image, tf.float32) * (1. / 255)\n\n label = tf.cast(features['label'], tf.int32)\n\n return image, label\n\n dataset = tf.data.TFRecordDataset(filenames)\n dataset = dataset.map(parse_function, num_parallel_calls=4)\n\n return dataset","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","def load_data(self):\n params = self.params\n catg = params.data_category\n langs = ['en', params.target_lang]\n data = {lang: {splt: {} for splt in (['train', 'valid'] if lang == 'en' else ['test'])} for lang in langs}\n clf_dataset_path = {\n lang: {\n splt: {\n 'x': os.path.join(params.data_path, '%s_%s_%s_x.bpe.pth' % (splt, lang, catg)),\n 'y': os.path.join(params.data_path, '%s_%s_%s_y.txt' % (splt, lang, catg)),\n } for splt in (['train', 'valid'] if lang == 'en' else ['test'])\n } for lang in langs\n }\n for splt in ['train', 'valid', 'test']:\n for lang in langs:\n if lang == 'en' and splt in ['train', 'valid'] or lang != 'en' and splt == 'test':\n # load data and dictionary\n data1 = load_binarized(clf_dataset_path[lang][splt]['x'], params)\n data['dico'] = data.get('dico', data1['dico'])\n # set dictionary parameters\n set_dico_parameters(params, data, data1['dico'])\n # create dataset\n data[lang][splt]['x'] = Dataset(data1['sentences'], data1['positions'], params)\n # load labels\n with open(clf_dataset_path[lang][splt]['y'], 'r') as f:\n labels = [int(l) for l in f]\n data[lang][splt]['y'] = torch.LongTensor(labels)\n assert len(data[lang][splt]['x']) == len(data[lang][splt]['y'])\n\n return data","def load():\n filepath = dirname(abspath(__file__))\n data = recfromtxt(filepath + '/scotvote.csv', delimiter=\",\",\n names=True, dtype=float, usecols=(1,2,3,4,5,6,7,8))\n names = list(data.dtype.names)\n endog = array(data[names[0]], dtype=float)\n endog_name = names[0]\n exog = column_stack(data[i] for i in names[1:]).astype(float)\n exog_name = names[1:]\n dataset = Dataset(data=data, names=names, endog=endog, exog=exog,\n endog_name = endog_name, exog_name=exog_name)\n return dataset","def __init__(self, dataset: Dataset):\n self.dataset = dataset","def buildDataSet():\n (x_train_origin, y_train_origin), (x_test_origin, y_test_origin) = mnist.load_data()\n\n assert K.image_data_format() == 'channels_last'\n x_train_origin = x_train_origin.reshape(x_train_origin.shape[0], h, w, 1)\n x_test_origin = x_test_origin.reshape(x_test_origin.shape[0], h, w, 1)\n\n dataset_train = []\n dataset_test = []\n\n #Sorting images by classes and normalize values 0=>1\n for n in range(nb_classes):\n images_class_n = np.asarray([row for idx,row in enumerate(x_train_origin) if y_train_origin[idx]==n])\n dataset_train.append(images_class_n/255)\n\n images_class_n = np.asarray([row for idx,row in enumerate(x_test_origin) if y_test_origin[idx]==n])\n dataset_test.append(images_class_n/255)\n\n return dataset_train,dataset_test,x_train_origin,y_train_origin,x_test_origin,y_test_origin","def _prepare_data(self, dataset: DatasetH, reweighter=None) -> List[Tuple[lgb.Dataset, str]]:\n ds_l = []\n assert \"train\" in dataset.segments\n for key in [\"train\", \"valid\"]:\n if key in dataset.segments:\n df = dataset.prepare(key, col_set=[\"feature\", \"label\"], data_key=DataHandlerLP.DK_L)\n if df.empty:\n raise ValueError(\"Empty data from dataset, please check your dataset config.\")\n x, y = df[\"feature\"], df[\"label\"]\n\n # Lightgbm need 1D array as its label\n if y.values.ndim == 2 and y.values.shape[1] == 1:\n y = np.squeeze(y.values)\n else:\n raise ValueError(\"LightGBM doesn't support multi-label training\")\n\n if reweighter is None:\n w = None\n elif isinstance(reweighter, Reweighter):\n w = reweighter.reweight(df)\n else:\n raise ValueError(\"Unsupported reweighter type.\")\n ds_l.append((lgb.Dataset(x.values, label=y, weight=w), key))\n return ds_l","def get_datasets():\n # Get data\n dataframe = pandas.read_csv('agaricus-lepiota.data')\n\n # Convert data type for all variables\n for column in dataframe:\n dataframe[column] = pandas.Categorical(dataframe[column])\n dataframe[column] = dataframe[column].cat.codes\n\n # Get labels\n target = dataframe.pop('p')\n\n # Get tensors, and split data into training and test sets\n split = int(len(dataframe) * 0.8)\n train_dataset = tf.data.Dataset.from_tensor_slices(\n (dataframe[:split].values, target[:split].values))\n\n train_dataset = train_dataset.shuffle(len(dataframe)).batch(1)\n\n test_dataset = tf.data.Dataset.from_tensor_slices(\n (dataframe[split:].values, target[split:].values))\n\n test_dataset = test_dataset.shuffle(len(dataframe)).batch(1)\n\n return train_dataset, test_dataset","def load_data_from_inds(data_set, inds):\n\n data = torch.cat([data_set[ind_][0].unsqueeze_(0) for ind_ in inds], 0)\n labels = torch.cat([torch.from_numpy(np.array(data_set[ind_][1])).unsqueeze_(0) for ind_ in inds], 0)\n\n return data, labels","def get_dataset(data_pars=None, **kw):\n\n\n print('Loading data...')\n maxlen = data_pars['data_info']['maxlen']\n\n loader = DataLoader(data_pars)\n loader.compute()\n dataset, internal_states = loader.get_data()\n\n # return dataset\n Xtrain, ytrain, Xtest, ytest = dataset\n Xtrain = sequence.pad_sequences(Xtrain, maxlen=maxlen)\n Xtest = sequence.pad_sequences(Xtest, maxlen=maxlen)\n return Xtrain, Xtest, ytrain, ytest","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 get_dataset(args):\n\n if args.dataset == 'cifar':\n data_dir = 'data/cifar/'\n apply_transform = transforms.Compose(\n [transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n\n train_dataset = datasets.CIFAR10(data_dir, train=True, download=True,\n transform=apply_transform)\n\n test_dataset = datasets.CIFAR10(data_dir, train=False, download=True,\n transform=apply_transform)\n\n # sample training data amongst users\n if args.iid:\n user_groups = cifar_iid(train_dataset, args.num_users)\n else:\n if args.unequal:\n # Chose euqal splits for every user\n user_groups = cifar_noniid(train_dataset, args.num_users)\n else:\n user_groups = cifar_noniid_class(train_dataset, args.num_users, args.class_per_user)\n \n elif args.dataset == 'mnist' or 'fmnist':\n if args.dataset == 'mnist':\n data_dir = 'data/mnist/'\n else:\n data_dir = 'data/fmnist/'\n\n apply_transform = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.1307,), (0.3081,))])\n\n train_dataset = datasets.MNIST(data_dir, train=True, download=True,\n transform=apply_transform)\n\n test_dataset = datasets.MNIST(data_dir, train=False, download=True,\n transform=apply_transform)\n\n # sample training data amongst users\n if args.iid:\n # Sample IID user data from Mnist\n user_groups = mnist_iid(train_dataset, args.num_users)\n else:\n # Sample Non-IID user data from Mnist\n if args.unequal:\n # Chose uneuqal splits for every user\n user_groups = mnist_noniid_unequal(train_dataset, args.num_users)\n else:\n # Chose euqal splits for every user\n user_groups = mnist_noniid_class(train_dataset, args.num_users, args.class_per_user)\n\n return train_dataset, test_dataset, user_groups","def _make_data(self):\n pdf_datasets_all = make_pdf_datasets(self.pdf_list, self.xlims, self.ylims, self.tlims, self.dims, 9)\n self.pdf_dataset = np.concatenate(pdf_datasets_all, axis = 0)\n self.PDE_dataset = make_PDE_dataset(self.num_collocation, self.xlims, self.ylims, self.tlims, self.dims)\n self.BC_dataset = make_BC_dataset(self.num_BC, self.xlims, self.ylims, self.tlims, self.dims)","def prep_data(self):\n\n self.fit_tokenizer(texts=self.texts)\n sequences = self.get_sequences(self.texts)\n self.text_data = pad_sequences(sequences, maxlen=self.MAX_SEQUENCE_LENGTH)\n\n self.labels = to_categorical(np.asarray(self.labels))\n print('Shape of data tensor:', self.text_data.shape)\n print('Shape of label tensor:', self.labels.shape)\n\n # split the data into a training set and a validation set\n indices = np.arange(self.text_data.shape[0])\n np.random.shuffle(indices)\n self.text_data = self.text_data[indices]\n self.labels = self.labels[indices]\n nb_validation_samples = int(self.VALIDATION_SPLIT * self.text_data.shape[0])\n\n x_train = self.text_data[:-nb_validation_samples]\n y_train = self.labels[:-nb_validation_samples]\n x_val = self.text_data[-nb_validation_samples:]\n y_val = self.labels[-nb_validation_samples:]\n\n return x_train,y_train, x_val, y_val","def iris():\n return IrisDataset()","def _dataset():\n dataset = tf_record_dataset(DatasetName.SIGNUM, DatasetType.TRAIN)\n dataset = dataset.batch(1)\n dataset = dataset.map(transform_for_prediction)\n dataset = dataset.unbatch()\n dataset = dataset.filter(lambda frames, label, signer: tf.math.equal(label, 420) and tf.math.equal(signer, 1))\n dataset = dataset.batch(1)\n return dataset.take(1)","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 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)","def get_train_data(batch_size=8):\n transform_train = transforms.Compose([\n transforms.RandomResizedCrop(224),\n transforms.RandomFlipLeftRight(),\n transforms.RandomColorJitter(brightness=0.4, contrast=0.4, saturation=0.4),\n transforms.RandomLighting(0.1),\n transforms.ToTensor(),\n transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))\n ])\n\n img_folder, img_file = get_data_path()\n td = MultilabelDataset(data_folder=img_folder, data_file=img_file)\n train_data = DataLoader(td.transform_first(transform_train), batch_size=batch_size, shuffle=True)\n return train_data","def get_dataset(self):\n\n trainset = datasets.CIFAR100('datasets/CIFAR100/train/', train=True, transform=self.train_transforms,\n target_transform=None, download=True)\n valset = datasets.CIFAR100('datasets/CIFAR100/test/', train=False, transform=self.val_transforms,\n target_transform=None, download=True)\n\n return trainset, valset","def dataset(self):\n return self.predictor_data_manager.dataset(\n self.data_name, self.trait_name, data=self._data, trait=self.trait,\n categorical_trait=self.categorical_trait)","def TensorFlowDataset(\n self,\n options: dataset_options.TensorFlowDatasetOptions) -> tf.data.Dataset:","def load_data_labels(datasets):\n # Split by words\n x_text = datasets['data']\n x_text = [clean_str(sent) for sent in x_text]\n # Generate labels\n labels = []\n for i in range(len(x_text)):\n label = [0 for j in datasets['target_names']]\n #print('target={}, i={}'.format(datasets['target'], i))\n label[datasets['target'][i]] = 1\n labels.append(label)\n y = np.array(labels)\n return [x_text, y]","def get_data(dataset: str = None, scale: bool = True) -> tuple:\n \n if dataset not in ['ecoli', 'glass', 'letter-recognition', 'lymphography', 'yeast', \n 'digits', 'breast-cancer', 'wine', 'mnist']:\n raise ValueError(\"Invalid dataset provided.\")\n \n if dataset in dataset in ['ecoli', 'glass', 'letter-recognition', 'lymphography', 'yeast']:\n path = 'https://archive.ics.uci.edu/ml/machine-learning-databases/' \n f = path + dataset + \"/\" + dataset + \".data\"\n \n if dataset in ['ecoli', 'yeast']:\n df = pd.read_table(f, delim_whitespace=True, header=None)\n elif dataset in [ 'glass', 'letter-recognition', 'lymphography']:\n df = pd.read_csv(f, header=None)\n elif dataset == 'digits':\n df = load_digits()\n X = df.data\n y = df.target\n elif dataset == 'breast-cancer':\n df = load_breast_cancer()\n X = df.data\n y = df.target\n elif dataset == 'wine':\n df = load_wine()\n X = df.data\n y = df.target\n \n if dataset == 'ecoli':\n y = preprocessing.LabelEncoder().fit_transform(df.iloc[:,-1])\n X = df.iloc[:,1:8].values\n \n elif dataset == 'glass':\n y = df.iloc[:,-1].values\n X = df.iloc[:, 1:(df.shape[1]-1)].values\n \n elif dataset in ['letter-recognition', 'lymphography']:\n y = preprocessing.LabelEncoder().fit_transform(df.iloc[:,0])\n X = df.iloc[:, 1:(df.shape[1])].values\n \n elif dataset == 'yeast':\n y = preprocessing.LabelEncoder().fit_transform(df.iloc[:,-1])\n X = df.iloc[:,1:9].values\n \n elif dataset == 'mnist':\n X, y = fetch_openml('mnist_784', version=1, return_X_y=True)\n y = y.astype('int64') \n\n if scale==True:\n scaler = preprocessing.StandardScaler()\n X = scaler.fit_transform(X)\n \n return X, y","def load_torch_data(load_data_func):\n\n def torch_loader(dataset, data_path, batch_size, shuffle=True, cuda_device=None, num_workers=1):\n (train_data, val_data), (train_labels, val_labels), label_names = load_data_func(dataset, data_path)\n\n kwargs = {'num_workers': num_workers, 'pin_memory': True} if cuda_device is not None else {}\n kwargs['drop_last'] = True\n\n if type(train_data) == numpy.ndarray:\n train_dataset = TensorDataset(torch.from_numpy(train_data), torch.from_numpy(train_labels))\n val_dataset = TensorDataset(torch.from_numpy(val_data), torch.from_numpy(val_labels))\n elif type(train_data) == scipy.sparse.csr.csr_matrix:\n from sklearn.feature_extraction.text import TfidfTransformer\n tfidf_trans = TfidfTransformer(norm=None)\n tfidf_trans.fit(train_data)\n train_dataset = SparseDataset(train_data, tfidf_trans.idf_)\n val_dataset = SparseDataset(val_data, tfidf_trans.idf_)\n else:\n train_dataset = torchvision.datasets.ImageFolder(train_data)\n val_dataset = torchvision.datasets.ImageFolder(val_data)\n\n train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, **kwargs)\n val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, **kwargs)\n\n return train_loader, val_loader, label_names\n\n return torch_loader","def parse_dataset(self, data):\n pass","def _get_dataset(self, dir_data, row_indices):\n\n ds_files, ds_labels = self._get_ds_files_labels(\n dir_data, row_indices)\n\n ds_images = ds_files.map(self._load_preprocess_image)\n\n ds_images_labels = tf.data.Dataset.zip((ds_images, ds_labels))\n\n return ds_images_labels","def load_data(self):\n print('Loading {} dataset'.format(self.split))\n data_split_path = os.path.join(self.root_dir, 'splits', '{}.csv'.format(self.split))\n with open(data_split_path,'r') as f:\n reader = csv.reader(f, delimiter=',')\n data_classes = {}\n for i,row in enumerate(reader):\n if i==0:\n continue\n data_classes[row[1]] = 1\n data_classes = data_classes.keys()\n print(data_classes)\n\n n_classes = len(data_classes)\n print('n_classes:{}, n_label:{}, n_unlabel:{}'.format(n_classes,self.n_label,self.n_unlabel))\n dataset_l = np.zeros([n_classes, self.n_label, self.im_height, self.im_width, self.channels], dtype=np.float32)\n if self.n_unlabel>0:\n dataset_u = np.zeros([n_classes, self.n_unlabel, self.im_height, self.im_width, self.channels], dtype=np.float32)\n else:\n dataset_u = []\n\n for i, cls in enumerate(data_classes):\n im_dir = os.path.join(self.root_dir, 'data/{}/'.format(self.split), cls)\n im_files = sorted(glob.glob(os.path.join(im_dir, '*.jpg')))\n np.random.RandomState(self.seed).shuffle(im_files) # fix the seed to keep label,unlabel fixed\n for j, im_file in enumerate(im_files):\n im = np.array(Image.open(im_file).resize((self.im_width, self.im_height)), \n np.float32, copy=False)\n if j<self.n_label:\n dataset_l[i, j] = im\n else:\n dataset_u[i,j-self.n_label] = im\n print('labeled data:', np.shape(dataset_l))\n print('unlabeled data:', np.shape(dataset_u))\n \n self.dataset_l = dataset_l\n self.dataset_u = dataset_u\n self.n_classes = n_classes","def load_data_labels(datasets):\n # Split by words\n x_text = datasets['data']\n x_text = [clean_str(sent) for sent in x_text]\n # Generate labels\n labels = [0, 1, 2, 3, 4]\n print(len(x_text))\n for i in range(len(x_text)):\n label = [0 for j in datasets['target_names']] \n label[datasets['target'][i]] = labels[i]\n labels.append(label)\n y = np.array(labels)\n return [x_text, y]","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 datasets(self):\n pass","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 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 from_label(self, data):\n out = data.copy()\n if isinstance(data, pd.DataFrame) or isinstance(data, dict):\n for column in self.categorical_feature_names:\n out[column] = self.labelencoder[column].inverse_transform(out[column].round().astype(int).tolist())\n return out\n elif isinstance(data, list):\n for column in self.categorical_feature_indexes:\n out[column] = self.labelencoder[self.feature_names[column]].inverse_transform([round(out[column])])[0]\n return out","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 create_dataset(filenames, labels):\n \n dataset = tf.data.Dataset.from_tensor_slices((filenames, labels))\n \n dataset.shuffle(buffer_size=SHUFFLE_BUFFER_SIZE)\n \n dataset = dataset.map(parse_function, num_parallel_calls=AUTOTUNE)\n \n dataset = dataset.batch(BATCH_SIZE)\n\n dataset = dataset.prefetch(buffer_size=AUTOTUNE)\n \n return dataset","def dataset(self):\n if self.X is not None and self.y is not None:\n return self.X, self.y\n\n self.X, self.y = self.get_BOW_from_file(self.labels[0])\n for label in self.labels[1:]:\n X_temp, y_temp = self.get_BOW_from_file(label)\n self.X = np.concatenate((self.X, X_temp))\n self.y = np.concatenate((self.y, y_temp))\n\n return self.X, self.y","def cast(cls, datasets, datatype=None, cast_type=None):\n datatype = datatype or cls.datatype\n cast = []\n for ds in datasets:\n if cast_type is not None or ds.interface.datatype != datatype:\n ds = ds.clone(ds, datatype=[datatype], new_type=cast_type)\n cast.append(ds)\n return cast","def _convert_dataset(split_name, filenames, class_names_to_ids, dataset_dir, image_dir):\n assert split_name in ['train', 'validation']\n\n num_per_shard = int(math.ceil(len(filenames) / float(_NUM_SHARDS)))\n\n with tf.Graph().as_default():\n image_reader = ImageReader()\n\n with tf.Session('') as sess:\n\n for shard_id in range(_NUM_SHARDS):\n output_filename = _get_dataset_filename(\n dataset_dir, split_name, shard_id)\n\n with tf.python_io.TFRecordWriter(output_filename) as tfrecord_writer:\n start_ndx = shard_id * num_per_shard\n end_ndx = min((shard_id+1) * num_per_shard, len(filenames))\n for i in range(start_ndx, end_ndx):\n sys.stdout.write('\\r>> Converting image %d/%d shard %d' % (\n i+1, len(filenames), shard_id))\n sys.stdout.flush()\n\n # Read the filename:\n image_data = tf.gfile.FastGFile(image_dir + '/' + filenames[i], 'rb').read()\n height, width = image_reader.read_image_dims(sess, image_data)\n\n class_name = os.path.basename(os.path.dirname(filenames[i]))\n class_id = class_names_to_ids[class_name]\n\n example = image_to_tfexample( # dataset_utils\n image_data, b'png', height, width, class_id)\n tfrecord_writer.write(example.SerializeToString())\n\n sys.stdout.write('\\n')\n sys.stdout.flush()","def load_dataset(self, subset):\n assert subset in ('train', 'val')\n\n # Add classes\n for id, name in self.class_mapper.items():\n self.add_class('nodule', id, name)\n\n # Add images\n self.df = self.df_all[self.df_all['subset'] == subset]\n\n image_ids = set()\n for row in self.df.itertuples():\n image_id = (row.seriesuid, row.coordZ)\n path = os.path.join(cur_dir, 'data', 'train', '{}_{}.npy'.format(row.seriesuid, row.coordZ))\n if image_id in image_ids:\n continue\n self.add_image(\"nodule\", image_id=image_id, path=path)\n image_ids.add(image_id)","def load_data(self):\n with open(self.file_name) as f:\n lines = f.readlines()\n\n labels = list()\n all_dat = list()\n for i, l in enumerate(lines):\n\n labels.append(int(l[0]))\n\n l = gensim.utils.any2unicode(l)\n all_dat.append(LabeledSentence(l.split(\"\\t\")[-1], [i]))\n\n return all_dat, np.asarray(labels)","def transform(self, dataset):\n loader = DataLoader(\n dataset, batch_size=self.batch_size, shuffle=False, num_workers=8)\n\n feature_paths = []\n with torch.no_grad():\n for batch_samples in tqdm(loader):\n img = batch_samples['img']\n\n if self.USE_CUDA:\n img = img.cuda()\n\n img_features = self.features(img)\n img_features = torch.unbind(img_features, dim=0)\n batch_feature_paths = batch_samples['img_path']\n for i, img_feature in enumerate(img_features):\n f = batch_feature_paths[i]\n f = os.path.join(\n self.save_dir,\n f.rpartition('/')[-1].replace('.jpg', '.pth'))\n torch.save(img_feature.cpu(), f)\n feature_paths.append(f)\n\n metadata = loader.dataset.metadata\n metadata['feature_paths'] = feature_paths\n\n return metadata","def fixture_input_data(wrapper_arguments):\n n_features, classes = wrapper_arguments\n num_data = 50\n data = np.random.rand(num_data, n_features)\n labels = np.random.choice(classes, size=num_data)\n\n return data, labels","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 getData(data, featurecols, labelencoder, classconversion=None):\n for i in range(0, len(labelencoder)):\n le = preprocessing.LabelEncoder()\n le.fit(labelencoder[i][1:])\n notnullidx = np.transpose(np.argwhere(np.array(~pd.isnull(data.iloc[:, labelencoder[i][0]])) == True))[0]\n nullidx = np.transpose(np.argwhere(np.array(pd.isnull(data.iloc[:, labelencoder[i][0]])) == True))[0]\n data.iloc[notnullidx, labelencoder[i][0]] = le.transform(data.iloc[notnullidx, labelencoder[i][0]].values)\n data.iloc[nullidx, labelencoder[i][0]] = np.nan\n \n features = data.iloc[:, featurecols].values\n features = features.astype(float)\n \n featurelabels = data.columns[featurecols].values\n if classconversion is not None:\n classes = np.empty(len(features))\n classes[:] = -1\n for i in range(0, len(classconversion)):\n classcol = np.array(data.iloc[:, classconversion[i,0]].values)\n classes[classcol.astype(str) == str(classconversion[i,1])] = classconversion[i,2]\n classes = classes.astype(int)\n indices = classes[:] > -1\n ids = data.iloc[indices, 0:3]\n \n return features[indices,:], classes[indices], featurelabels, ids\n \n return features, None, featurelabels, data.iloc[:, 0:3]"],"string":"[\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 labels_to_dataset(labels, label_mode, num_classes):\\n label_ds = dataset_ops.Dataset.from_tensor_slices(labels)\\n if label_mode == 'binary':\\n label_ds = label_ds.map(\\n lambda x: array_ops.expand_dims(math_ops.cast(x, 'float32'), axis=-1))\\n elif label_mode == 'categorical':\\n label_ds = label_ds.map(lambda x: array_ops.one_hot(x, num_classes))\\n return label_ds\",\n \"def from_torch(\\n dataset: \\\"torch.utils.data.Dataset\\\",\\n) -> Dataset:\\n return from_items(list(dataset))\",\n \"def build_dataset(self, X, y=None):\\n X = np.array(X)\\n self.input_dim = X.shape[1]\\n X = torch.FloatTensor(X)\\n if y is None:\\n dataset = torch.utils.data.TensorDataset(X)\\n else:\\n self.classes_ = sorted(set(y))\\n self.n_classes_ = len(self.classes_)\\n class2index = dict(zip(self.classes_, range(self.n_classes_)))\\n y = [class2index[label] for label in y]\\n y = torch.tensor(y)\\n dataset = torch.utils.data.TensorDataset(X, y)\\n return dataset\",\n \"def _prepare_data(self, examples, labels):\\n\\n if self.to_tensor:\\n examples = torch.Tensor(examples)\\n labels = torch.Tensor(labels)\\n\\n if self.use_gpu:\\n examples = examples.cuda()\\n labels = labels.cuda()\\n\\n return (examples, labels)\",\n \"def to_dataset(self):\\n return self._data._copy_listed(self._names)\",\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 prepare_data(self,d):\\n train_loaders, train_iters = {}, {}\\n unlabeled_loaders, unlabeled_iters = {}, {}\\n for domain in opt.domains:\\n #CONVERT TO FLOAT32\\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape((-1,1))\\n train = data_utils.TensorDataset(features,target)\\n train_loaders[domain] = DataLoader(train, opt.batch_size, shuffle = True)\\n train_iters[domain] = iter(train_loaders[domain])\\n for domain in opt.unlabeled_domains:\\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape(-1,1))\\n uset = data_utils.TensorDataset(features,target)\\n unlabeled_loaders[domain] = DataLoader(uset,opt.batch_size, shuffle = True)\\n unlabeled_iters[domain] = iter(unlabeled_loaders[domain])\\n \\n return train_loaders, train_iters, unlabeled_loaders, unlabeled_iters\",\n \"def init_datasets(self, data_dict, label_dict):\\n\\n ## If data is count, then convert any sparse inputs to sparse tensors\\n convert_sparse = self.config_dict.get(\\\"sparse_mode\\\") == \\\"count\\\"\\n\\n splits = data_dict.keys()\\n dataset_dict = {\\n key: ArrayDataset(\\n data_dict[key],\\n torch.LongTensor(label_dict[key]),\\n convert_sparse=convert_sparse,\\n )\\n for key in splits\\n }\\n return dataset_dict\",\n \"def get_dataset(args):\\n\\n if args['experiment']['dataset'] == Dataset.mindsets:\\n xs, ys, cs = make_mindsets(mindset_sizes=args['dataset']['mindset_sizes'],\\n nb_questions=args['dataset']['nb_questions'],\\n nb_useless=args['dataset']['nb_useless'],\\n noise=args['dataset']['noise'],\\n seed=args['experiment']['seed'])\\n\\n return Data(xs=xs, ys=ys, cs=cs)\\n\\n if args['experiment']['dataset'] == Dataset.questionnaire_likert:\\n xs, ys, cs = make_likert_questionnaire(nb_samples=args['dataset']['nb_samples'],\\n nb_features=args['dataset']['nb_features'],\\n nb_mindsets=args['dataset']['nb_mindsets'],\\n centers=args['dataset']['centers'],\\n range_answers=args['dataset']['range_answers'],\\n seed=args['experiment']['seed'])\\n\\n return Data(xs=xs, ys=ys, cs=cs)\\n\\n if args['experiment']['dataset'] == Dataset.retinal:\\n xs, ys = load_RETINAL(root_path=args['root_dir'],\\n nb_bins=args['dataset']['nb_bins'],\\n max_idx=args['dataset']['max_idx'])\\n\\n return Data(xs=xs, ys=ys)\\n\\n if args['experiment']['dataset'] == Dataset.moons:\\n xs, ys = make_moons(n_samples=args['dataset']['n_samples'],\\n noise=args['dataset']['noise'],\\n random_state=args['experiment']['seed'])\\n\\n return Data(xs=xs, ys=ys)\\n\\n if args['experiment']['dataset'] == Dataset.breast_cancer_wisconsin:\\n xs, ys = load_CANCER(args['dataset']['nb_bins'])\\n\\n return Data(xs=xs, ys=ys)\\n\\n if args['experiment']['dataset'] == Dataset.SBM:\\n A, ys, G = load_SBM(block_sizes=args['dataset']['block_sizes'],\\n p_in=args['dataset']['p'],\\n p_out=args['dataset']['q'],\\n seed=args['experiment']['seed'])\\n\\n return Data(ys=ys, A=A, G=G)\\n\\n if args['experiment']['dataset'] == Dataset.gaussian_mixture:\\n xs, ys = make_blobs(n_samples=args['dataset']['blob_sizes'],\\n centers=args['dataset']['blob_centers'],\\n n_features=args['dataset']['blob_centers'],\\n cluster_std=args['dataset']['blob_variances'],\\n random_state=args['experiment']['seed'])\\n\\n return Data(xs=xs, ys=ys)\\n\\n if args['experiment']['dataset'] == Dataset.LFR:\\n A, ys, G = load_LFR(nb_nodes=args['dataset']['nb_nodes'],\\n tau1=args['dataset']['tau1'],\\n tau2=args['dataset']['tau2'],\\n mu=args['dataset']['mu'],\\n average_degree=args['dataset']['average_degree'],\\n min_community=args['dataset']['min_community'],\\n seed=args['experiment']['seed'])\\n\\n return Data(ys=ys, A=A, G=G)\\n\\n if args['experiment']['dataset'] == Dataset.wave:\\n df = pd.read_csv('datasets/waveform.csv')\\n xs = df[df.columns[:-1]].to_numpy()\\n ys = df[df.columns[-1]].to_numpy()\\n\\n return Data(xs=xs, ys=ys)\\n\\n raise ValueError('Wrong name for a dataset')\",\n \"def get_datasets(data):\\n train_dataset, test_dataset = None, None\\n data_dir = '../data'\\n\\n if data == 'fmnist':\\n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize(mean=[0.2860], std=[0.3530])])\\n train_dataset = datasets.FashionMNIST(data_dir, train=True, download=True, transform=transform)\\n test_dataset = datasets.FashionMNIST(data_dir, train=False, download=True, transform=transform)\\n \\n elif data == 'fedemnist':\\n train_dir = '../data/Fed_EMNIST/fed_emnist_all_trainset.pt'\\n test_dir = '../data/Fed_EMNIST/fed_emnist_all_valset.pt'\\n train_dataset = torch.load(train_dir)\\n test_dataset = torch.load(test_dir) \\n \\n elif data == 'cifar10':\\n transform_train = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010)),\\n ])\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010)),\\n ])\\n train_dataset = datasets.CIFAR10(data_dir, train=True, download=True, transform=transform_train)\\n test_dataset = datasets.CIFAR10(data_dir, train=False, download=True, transform=transform_test)\\n train_dataset.targets, test_dataset.targets = torch.LongTensor(train_dataset.targets), torch.LongTensor(test_dataset.targets) \\n \\n return train_dataset, test_dataset\",\n \"def make_dataset(self) -> torch.utils.data.Dataset:\\n transform = cnn_utils.ToTensor()\\n return cnn_utils.ArtifactDataset(self.stamps, transform)\",\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 data_loader(edges,features,y):\\n\\n\\n edge_index = torch.tensor(edges, dtype=torch.long)\\n edge_index = edge_index.t().contiguous()\\n x = torch.tensor(features.todense(), dtype=torch.float)\\n\\n y = torch.tensor(y)\\n\\n data = Data(x=x, edge_index=edge_index, y = y)\\n\\n return data\",\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 init_datasets(self, data_dict, label_dict):\\n splits = data_dict.keys()\\n dataset_dict = {\\n key: ArrayDataset(data_dict[key], torch.LongTensor(label_dict[key]))\\n for key in splits\\n }\\n return dataset_dict\",\n \"def GetDataset():\\n x_train = []\\n x_test = []\\n y_train = []\\n y_test = []\\n\\n classes1 = set()\\n classes2 = set()\\n for f in GetInputFiles():\\n class1, class2, fold, fname = f.split('\\\\\\\\')[-4:]\\n classes1.add(class1)\\n classes2.add(class2)\\n class1 = class1.split('_')[0]\\n class2 = class2.split('_')[0]\\n\\n x = ReadAndTokenize(f)\\n y = [int(class1 == 'positive'), int(class2 == 'truthful')]\\n if fold == 'fold4':\\n x_test.append(x)\\n y_test.append(y)\\n else:\\n x_train.append(x)\\n y_train.append(y)\\n\\n ### Make numpy arrays.\\n x_test = MakeDesignMatrix(x_test)\\n x_train = MakeDesignMatrix(x_train)\\n y_test = numpy.array(y_test, dtype='float32')\\n y_train = numpy.array(y_train, dtype='float32')\\n\\n dataset = (x_train, y_train, x_test, y_test)\\n with open('dataset.pkl', 'wb') as fout:\\n pickle.dump(dataset, fout)\\n return dataset\",\n \"def loadData(self):\\n batch_size = 256\\n \\n #if self.conv_sg == True:\\n # batch_size = 1 \\n \\n download = True\\n root = self.root + self.dataset\\n if self.dataset == \\\"MNIST\\\": \\n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])\\n trainset = torchvision.datasets.MNIST(root, train=True, download=download, transform=transform)\\n testset = torchvision.datasets.MNIST(root, train=False, download=download, transform=transform)\\n \\n if self.dataset == \\\"CIFAR10\\\":\\n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465,), (0.2023, 0.1994, 0.2010,))])\\n trainset = torchvision.datasets.CIFAR10(root, train=True, download=download, transform=transform)\\n testset = torchvision.datasets.CIFAR10(root, train=False, download=download, transform=transform)\\n \\n if self.dataset == \\\"CIFAR100\\\":\\n transform = transforms.Compose([transforms.ToTensor()])\\n trainset = torchvision.datasets.CIFAR100(root, train=True, download=download, transform=transform)\\n testset = torchvision.datasets.CIFAR100(root, train=False, download=download, transform=transform)\\n \\n \\n trainloader = torch.utils.data.DataLoader(trainset, batch_size = batch_size,\\n shuffle=False, num_workers=0, pin_memory = False)\\n \\n testloader = torch.utils.data.DataLoader(testset, batch_size= batch_size,\\n shuffle=False, num_workers=2, pin_memory = False)\\n \\n return trainloader, testloader\",\n \"def init_datasets(self, data_dict, label_dict):\\n splits = data_dict.keys()\\n dataset_dict = {\\n key: ArrayDataset(\\n data_dict[key], torch.LongTensor(label_dict[key]), convert_sparse=False\\n )\\n for key in splits\\n }\\n return dataset_dict\",\n \"def transform(self, dataset, labels):\\n print(f\\\"Dropping {len(self.deficient)} deficient features...\\\")\\n dataset.drop(columns=self.deficient, inplace=True)\\n print(f\\\"Scanning {len(dataset)} samples for duplicates...\\\")\\n duplicates = dataset.duplicated()\\n print(f\\\"Dropping {sum(duplicates)} duplicate samples...\\\")\\n dataset.drop(index=dataset.index[duplicates], inplace=True)\\n dataset.reset_index(drop=True, inplace=True)\\n labels.drop(labels=labels.index[duplicates], inplace=True)\\n labels.reset_index(drop=True, inplace=True)\\n return dataset, labels\",\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 prepare_data(self):\\n data = self._get_dataset(self.hparams.dataset_path)\\n label_encoder = data[\\\"label_encoder\\\"]\\n del data[\\\"label_encoder\\\"]\\n\\n click.secho(\\\"Building inputs and labels.\\\", fg=\\\"yellow\\\")\\n datasets = {\\n \\\"train\\\": defaultdict(list),\\n \\\"valid\\\": defaultdict(list),\\n \\\"test\\\": defaultdict(list),\\n }\\n for dataset_name, dataset in data.items():\\n for sample in dataset:\\n instance = self.build_input(\\n self.tokenizer, sample[\\\"text\\\"], label_encoder, sample[\\\"label\\\"]\\n )\\n for input_name, input_array in instance.items():\\n datasets[dataset_name][input_name].append(input_array)\\n\\n click.secho(\\\"Padding inputs and building tensors.\\\", fg=\\\"yellow\\\")\\n tensor_datasets = {\\\"train\\\": [], \\\"valid\\\": [], \\\"test\\\": []}\\n for dataset_name, dataset in datasets.items():\\n dataset = self.pad_dataset(dataset, padding=self.tokenizer.pad_index)\\n for input_name in MODEL_INPUTS:\\n if input_name == \\\"labels\\\":\\n tensor = torch.tensor(dataset[input_name], dtype=torch.float32)\\n else:\\n tensor = torch.tensor(dataset[input_name])\\n tensor_datasets[dataset_name].append(tensor)\\n\\n self.train_dataset = TensorDataset(*tensor_datasets[\\\"train\\\"])\\n self.valid_dataset = TensorDataset(*tensor_datasets[\\\"valid\\\"])\\n self.test_dataset = TensorDataset(*tensor_datasets[\\\"test\\\"])\\n click.secho(\\n \\\"Train dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.train_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n \\\"Valid dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.valid_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n \\\"Test dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.test_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\",\n \"def __prepare_dataset(dataset, verbose=True):\\r\\n supported_datasets = ['coco', 'voc']\\r\\n if isinstance(dataset, ExternalDataset):\\r\\n if dataset.dataset_type.lower() not in supported_datasets:\\r\\n raise UserWarning(\\\"ExternalDataset dataset_type must be one of: \\\", supported_datasets)\\r\\n\\r\\n dataset_root = dataset.path\\r\\n\\r\\n if verbose:\\r\\n print(\\\"Loading {} type dataset...\\\".format(dataset.dataset_type))\\r\\n\\r\\n if dataset.dataset_type.lower() == 'voc':\\r\\n from gluoncv.data import VOCDetection\\r\\n\\r\\n dataset = VOCDetection(root=dataset_root,\\r\\n splits=[(2007, 'trainval'), (2012, 'trainval')])\\r\\n\\r\\n elif dataset.dataset_type.lower() == 'coco':\\r\\n from gluoncv.data import COCODetection\\r\\n\\r\\n dataset = COCODetection(root=dataset_root,\\r\\n splits=['instances_train2017'])\\r\\n if verbose:\\r\\n print(\\\"ExternalDataset loaded.\\\")\\r\\n return dataset\\r\\n elif isinstance(dataset, DetectionDataset) or issubclass(type(dataset), DetectionDataset):\\r\\n dataset.set_image_transform(ImageToNDArrayTransform())\\r\\n dataset.set_target_transform(BoundingBoxListToNumpyArray())\\r\\n return dataset\\r\\n else:\\r\\n raise ValueError(\\\"Dataset type {} not supported\\\".format(type(dataset)))\",\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 \"def prepare_train_dataset(name, reso, batch_size=32):\\r\\n transform = transforms.Compose([\\r\\n transforms.RandomResizedCrop(size=reso, interpolation=3),\\r\\n transforms.ColorJitter(brightness=1.5, saturation=1.5, hue=0.2),\\r\\n transforms.RandomVerticalFlip(),\\r\\n transforms.ToTensor()\\r\\n ])\\r\\n\\r\\n path = config.datasets[name]\\r\\n\\r\\n if name == 'coco':\\r\\n img_datasets = CocoDataset(root=path['train_imgs'], annFile=path['train_anno'], transform=transform)\\r\\n dataloder = torch.utils.data.DataLoader(img_datasets, batch_size=batch_size, num_workers=4, shuffle=True, collate_fn=CocoDataset.collate_fn)\\r\\n elif name == 'voc':\\r\\n img_datasets = VocDataset(train_list=path['train_imgs'], transform=transform)\\r\\n dataloder = torch.utils.data.DataLoader(img_datasets, batch_size=batch_size, num_workers=4, shuffle=True, collate_fn=VocDataset.collate_fn)\\r\\n\\r\\n return img_datasets, dataloder\",\n \"def make_dataset(self):\\n # Read raw data\\n data = self.read_raw_data()\\n self.default_header = list(data.columns.values)\\n # Fit the variables on the raw dataset\\n self.fit(data.copy())\\n return make_df(data, self.features), make_df(data, self.targets)\",\n \"def collect_datset(self):\\n response = requests.get(self.url)\\n lines = response.text.splitlines()\\n data = []\\n for item in lines:\\n item = item.split(\\\",\\\")\\n data.append(item)\\n data.pop(0) # to remove labels from list\\n dataset = np.matrix(data)\\n return dataset\",\n \"def _convert_dataset(self):\\n allowed_vars = ['x', 'y', 'z', 'tvu', 'thu']\\n dtyp = [(varname, self.data[varname].dtype) for varname in allowed_vars if varname in self.data]\\n empty_struct = np.empty(len(self.data['x']), dtype=dtyp)\\n for varname, vartype in dtyp:\\n empty_struct[varname] = self.data[varname].values\\n self.data = empty_struct\",\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 get_inference_dataset(dataset_path,debug=False):\\n\\n if not os.path.exists(dataset_path):\\n assert False, \\\"Couldn't find path : '{}'\\\".format(dataset_path)\\n print(\\\"\\\\nprocessing data :'{}'\\\\n\\\".format(dataset_path))\\n\\n path = os.getcwd()\\n os.chdir(dataset_path)\\n\\n dataset = []\\n for file in tqdm(os.listdir('.')):\\n if not file.endswith('features'):\\n continue\\n name = file.replace(\\\".features\\\", \\\"\\\") # removing \\\"features\\\"\\n x = np.loadtxt(name + '.features')\\n np.nan_to_num(x, copy=False)\\n #get labels file\\n if os.path.exists(name + '.test.labels'):\\n labels_file = open(name + '.test.labels').readlines()\\n elif os.path.exists(name + '.labels'):\\n labels_file = open(name + '.labels').readlines()\\n else:\\n continue\\n file_info = (name , float(labels_file[-2].split(' ')[-1]),\\n np.fromstring(labels_file[1].strip(), sep=' ')[:2],\\n float(labels_file[2]))#(file name,window_offset,(onset,offset),vot_type)\\n\\n dataset.append([torch.from_numpy(x).float(), file_info])\\n if debug and len(dataset)>100:\\n break\\n os.chdir(path)\\n\\n return DataLoader(dataset,shuffle=False)\",\n \"def dataset(self, data_size: float = 1.0, features=None):\\n from collections import Counter\\n import nltk\\n\\n utterances, labels = self.read_json()\\n\\n size = int(len(utterances) * data_size)\\n utterances = utterances[:size]\\n labels = labels[:size]\\n\\n if features is None:\\n counter = Counter()\\n for u in utterances:\\n # print(u)\\n tokens = nltk.word_tokenize(u)\\n counter.update(tokens)\\n\\n features = [w for w, _ in counter.most_common()]\\n\\n vecs = []\\n for u in utterances:\\n tokens = nltk.word_tokenize(u)\\n c = Counter(tokens)\\n vec = tuple([c[t] for t in features]) # type: Tuple[float]\\n vecs.append(vec)\\n\\n from dataset import Dataset\\n\\n return Dataset(tuple(features), tuple(labels), tuple(vecs))\",\n \"def build_dataset(self):\\n print(\\\"reading data of images currently , please wait......\\\")\\n x_train, y_train, _ = get_images(self.train_directory)\\n x_test, y_test, _ = get_images(self.test_directory)\\n x_train, y_train = image_subset(self.num_classes, x_train, y_train)\\n x_test, y_test = image_subset(self.num_classes, x_test, y_test)\\n x_train = x_train.astype('float32')\\n x_test = x_test.astype('float32')\\n self.x_train = x_train / 255\\n self.x_test = x_test / 255\\n self.y_train = utils.to_categorical(y_train, self.num_classes)\\n self.y_test = utils.to_categorical(y_test, self.num_classes)\",\n \"def dataset(options):\\n pass\",\n \"def to_dataset(self):\\n if not self.type:\\n raise aspecd.exceptions.MissingDatasetError\\n dataset = aspecd.utils.object_from_class_name(self.type)\\n dataset.id = self.id\\n for history_record in self.history:\\n history_record.replay(dataset)\\n return dataset\",\n \"def prepare_data_for_training(args):\\n # Form the train/test splits and write them to disk\\n dataset = data.Dataset(args)\\n # get image classes and image counts in each class\\n label_map = dataset.get_class_info()\\n class_count = len(list(label_map.values()))\\n # split the data and store it in log dir\\n df_train, df_test = dataset.split_dataset()\\n\\n # perform dataset augmentations\\n image_data = augment.Augmentation(args)\\n # get the data gens for training and test images\\n train_data_gen, _ = image_data.map_fn_train(df_train)\\n test_data_gen, _ = image_data.map_fn_test(df_test)\\n\\n return train_data_gen, test_data_gen, df_train, df_test, class_count\",\n \"def getDataset(self, train=True):\\n \\n device = torch.device(\\\"cuda:0\\\" if torch.cuda.is_available() else \\\"cpu\\\") \\n \\n if self.dataset == \\\"ELLIPSE\\\":\\n a = np.array([[0,1.0],[1.0,2.0]]) \\n b = a*0.5 \\n myE = el.ellipse(device, 500, 100, a, b) \\n if train == True:\\n return myE.create_dataset(myE.examples)\\n return myE.create_dataset(myE.valid) \\n \\n if self.dataset == \\\"SWISS\\\": \\n myS = sw.SwissRoll(device, 500, 0.2) \\n if train == True:\\n return myS.create_dataset(myS.examples)\\n return myS.create_dataset(myS.valid)\\n \\n \\n #open file\\n myFile = h5py.File(self.dataString, 'r', self.driver)\\n \\n if train == True: \\n inputString = \\\"train_inputs\\\"\\n labelsString = \\\"train_labels\\\"\\n \\n else:\\n inputString = \\\"test_inputs\\\"\\n labelsString = \\\"test_labels\\\"\\n \\n #get hdf5 datsets\\n features = myFile.get(inputString)\\n labels = myFile.get(labelsString)\\n \\n #convert to tensors\\n features = torch.from_numpy(np.array(features))\\n labels = torch.from_numpy(np.array(labels))\\n \\n #close file to ensure dataset is in memory\\n myFile.close()\\n \\n #conver to correct datatypes\\n features = features.float()\\n \\n if self.conv_sg == False:\\n labels = labels.long() \\n \\n dataset = torch.utils.data.TensorDataset(features, labels)\\n \\n return dataset\",\n \"def initialize(labels, init_data):\\n ds = None\\n init_data = {k: list(v) for k, v in init_data.items()}\\n\\n logger.info(\\n \\\"Initializing dataset from metadata:\\\\n %s\\\",\\n '\\\\n '.join(\\\"{}: {}\\\".format(k, len(init_data[k])) for k in sorted(init_data.keys())))\\n\\n first_data = list(init_data.values())[0]\\n if not all(len(first_data) == len(data) for data in init_data.values()):\\n logger.error(\\\"Cannot initialize dataset from metadata dictionary that has values of different lengths\\\")\\n return\\n\\n ds = tf.data.Dataset.from_tensor_slices(init_data)\\n label2int, _ = tf_utils.make_label2onehot(tf.constant(labels, tf.string))\\n logger.info(\\n \\\"Generated label2target lookup table from indexes of array:\\\\n %s\\\",\\n '\\\\n '.join(\\\"{:s} {:d}\\\".format(l, label2int.lookup(tf.constant(l, tf.string))) for l in labels))\\n\\n append_labels_as_targets = lambda x: dict(x, target=label2int.lookup(x[\\\"label\\\"]))\\n return ds.map(append_labels_as_targets, num_parallel_calls=TF_AUTOTUNE)\",\n \"def as_dataset(self) -> \\\"Dataset\\\":\\n \\n freq_def = {\\n 1: \\\"L1\\\", # G\\n 2: \\\"L2\\\", # G\\n 5: \\\"L5\\\", # G\\n 20: \\\"L2C\\\", # G\\n 101: \\\"L1\\\", # R\\n 102: \\\"L2\\\", # R\\n 201: \\\"E1\\\", # E \\n 205: \\\"E5a\\\", # E\\n 206: \\\"E6\\\", # E\\n 207: \\\"E5b\\\", # E\\n 208: \\\"E5\\\", # E\\n 302: \\\"B1_2\\\", # C\\n 306: \\\"B3\\\", # C\\n 307: \\\"B2b\\\", # C\\n }\\n\\n float_fields = {\\n \\\"amplitude\\\": None,\\n \\\"azimuth\\\": \\\"radian\\\",\\n \\\"peak2noise\\\": None, \\n \\\"reflection_height\\\": \\\"meter\\\", \\n }\\n\\n # Initialize dataset\\n dset = dataset.Dataset()\\n if not self.data:\\n log.warn(\\\"No data in {self.file_path}.\\\")\\n return dset\\n dset.num_obs = len(self.data[\\\"time\\\"])\\n\\n # Add text fields\\n satellite = list()\\n system = list()\\n for sat in self.data[\\\"satellite\\\"]:\\n if sat >= 1 and sat < 100: # GPS satellites\\n system.append(\\\"G\\\")\\n satellite.append(\\\"G\\\" + str(int(sat)).zfill(2))\\n elif sat >= 101 and sat < 200: # GLONASS satellites\\n system.append(\\\"R\\\")\\n satellite.append(\\\"R\\\" + str(int(sat))[1:3])\\n elif sat >= 201 and sat < 300: # Galileo satellites\\n system.append(\\\"E\\\")\\n satellite.append(\\\"E\\\" + str(int(sat))[1:3])\\n elif sat >= 301 and sat < 400: # BeiDou satellites\\n system.append(\\\"C\\\")\\n satellite.append(\\\"C\\\" + str(int(sat))[1:3])\\n else:\\n log.fatal(\\\"GNSSREFL satellite number {sat} is not defined. Valid satellite numbers are between [1-399].\\\")\\n\\n dset.add_text(\\n name=\\\"system\\\", \\n val=system, \\n write_level=\\\"operational\\\",\\n )\\n\\n dset.add_text(\\n name=\\\"satellite\\\", \\n val=satellite, \\n write_level=\\\"operational\\\",\\n )\\n\\n dset.add_text(\\n name=\\\"frequency\\\", \\n val=[freq_def[v] for v in self.data[\\\"frequency\\\"]], \\n write_level=\\\"operational\\\",\\n ) \\n \\n # Add time field\\n dset.add_time(\\n name=\\\"time\\\", \\n val=self.data[\\\"time\\\"], \\n scale=\\\"utc\\\", \\n fmt=\\\"datetime\\\", \\n write_level=\\\"operational\\\",\\n )\\n \\n # Add float fields\\n for field in float_fields.keys():\\n if field not in self.data.keys():\\n log.warn(f\\\"Field '{field}' does not exist in file {self.meta['__data_path__']}.\\\")\\n continue\\n \\n value = np.deg2rad(self.data[field]) if field == \\\"azimuth\\\" else self.data[field]\\n unit = \\\"\\\" if float_fields[field] is None else float_fields[field]\\n \\n dset.add_float(name=field, val=value, unit=unit, write_level=\\\"operational\\\")\\n \\n return dset\",\n \"def normalize_dataset(self):\",\n \"def prepare_val_dataset(name, reso, batch_size=32):\\r\\n transform = transforms.Compose([\\r\\n transforms.Resize(size=(reso, reso), interpolation=3),\\r\\n transforms.ToTensor()\\r\\n ])\\r\\n\\r\\n path = config.datasets[name]\\r\\n\\r\\n if name == 'coco':\\r\\n img_datasets = CocoDataset(root=path['val_imgs'], annFile=path['val_anno'], transform=transform)\\r\\n dataloder = torch.utils.data.DataLoader(img_datasets, batch_size=batch_size, num_workers=4, collate_fn=CocoDataset.collate_fn, shuffle=True)\\r\\n elif name == 'voc':\\r\\n img_datasets = VocDataset(train_list=path['val_imgs'], transform=transform)\\r\\n dataloder = torch.utils.data.DataLoader(img_datasets, batch_size=batch_size, num_workers=4, collate_fn=VocDataset.collate_fn, shuffle=True)\\r\\n\\r\\n\\r\\n return img_datasets, dataloder\",\n \"def _transform(self, dataset):\\n raise NotImplementedError()\",\n \"def get_dataset(dataset_type = \\\"training\\\"):\\n X, Y = None, None\\n #1. Pobieramy obrazki i etykiety\\n images, labels = get_MNIST_dataset(range(10), dataset_type)\\n #2. Konwersja do X,Y (czyli wiersz to jeden przyklad, X - dwuwymiarowa macierz), Y po prostu przepisujemy\\n # hint : reshape, np.zeros, przez macierz mozna latwo iterowac w petli (for row in matrix)\\n #TODO: fill in\\n Y = labels\\n X = images.reshape((images.shape[0], images.shape[1]*images.shape[2]))\\n\\n #for id, digit in enumerate(images):\\n # pl.imshow(digit, cmap=pl.cm.gray)\\n # X[id, :] = digit.reshape((digit.shape[0]*digit.shape[1],))\\n # if id % 1000 == 0: print \\\"Converted \\\",id\\n\\n # Czy da sie szybciej?\\n\\n #3. Return X,Y\\n return X, Y\",\n \"def convert_to_dataset(obj, *, group=\\\"posterior\\\", coords=None, dims=None):\\n inference_data = convert_to_inference_data(obj, group=group, coords=coords, dims=dims)\\n dataset = getattr(inference_data, group, None)\\n if dataset is None:\\n raise ValueError(\\n \\\"Can not extract {group} from {obj}! See {filename} for other \\\"\\n \\\"conversion utilities.\\\".format(group=group, obj=obj, filename=__file__)\\n )\\n return dataset\",\n \"def to_dataloader(texts, extras, ys,\\n tokenizer,\\n max_seq_length,\\n batch_size,\\n dataset_cls=TensorDataset,\\n sampler_cls=RandomSampler):\\n #train_y = train_df[labels].values\\n\\n # Labels\\n train_y_tensor = torch.tensor(ys).float()\\n\\n if texts is not None and extras is not None:\\n # All features\\n train_tokens_tensor, train_masks_tensor = text_to_train_tensors(texts, tokenizer, max_seq_length)\\n train_extras_tensor = torch.tensor(extras, dtype=torch.float)\\n\\n train_dataset = dataset_cls(train_tokens_tensor, train_masks_tensor, train_extras_tensor, train_y_tensor)\\n elif texts is not None and extras is None:\\n # Text only\\n train_tokens_tensor, train_masks_tensor = text_to_train_tensors(texts, tokenizer, max_seq_length)\\n train_dataset = dataset_cls(train_tokens_tensor, train_masks_tensor, train_y_tensor)\\n elif texts is None and extras is not None:\\n\\n train_extras_tensor = torch.tensor(extras, dtype=torch.float)\\n train_dataset = dataset_cls(train_extras_tensor, train_y_tensor)\\n else:\\n raise ValueError('Either texts or extra must be set.')\\n\\n train_sampler = sampler_cls(train_dataset)\\n \\n return DataLoader(train_dataset, sampler=train_sampler, batch_size=batch_size)\",\n \"def prepare_iris_data(data):\\n\\n # One-Hot Encode target variable y\\n \\n X = data.iloc[:, 0:4]\\n y = data.iloc[:,-1]\\n Y = pd.get_dummies(y)\\n \\n # Recombine X and Y\\n \\n data_w_dummies = pd.concat([X, Y], axis=1)\\n data_w_dummies.head()\\n \\n \\n # Split data into train and test sets and \\n # Make data iterable by batches with DataLoader\\n \\n train, test = train_test_split(data_w_dummies, test_size=0.2, shuffle=True)\\n \\n \\n trainset = torch.Tensor(train.values)\\n \\n testset = torch.Tensor(test.values)\\n \\n return trainset, testset\",\n \"def 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 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 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_dataset(self):\\n\\n trainset = datasets.ImageNet('datasets/ImageNet/train/', split='train', transform=self.train_transforms,\\n target_transform=None, download=True)\\n valset = datasets.ImageNet('datasets/ImageNet/val/', split='val', transform=self.val_transforms,\\n target_transform=None, download=True)\\n\\n return trainset, valset\",\n \"def train_dataloader(self) -> torch.utils.data.DataLoader: \\n return torch.utils.data.DataLoader(self.dataset_train, **self.dl_kwargs)\",\n \"def dataset(request):\\n X, y = make_classification(\\n n_samples=700, n_features=10, n_informative=8, n_redundant=2,\\n n_classes=2, n_clusters_per_class=2, random_state=6483\\n )\\n\\n request.cls.dataset = Dataset(X, y)\",\n \"def to_DataLoader(self, **kwargs):\\r\\n return DataLoader(self, **kwargs)\",\n \"def get_dataset(self):\\n\\n trainset = datasets.SVHN('datasets/SVHN/train/', split='train', transform=self.train_transforms,\\n target_transform=None, download=True)\\n valset = datasets.SVHN('datasets/SVHN/test/', split='test', transform=self.val_transforms,\\n target_transform=None, download=True)\\n extraset = datasets.SVHN('datasets/SVHN/extra', split='extra', transform=self.train_transforms,\\n target_transform=None, download=True)\\n\\n trainset = torch.utils.data.ConcatDataset([trainset, extraset])\\n\\n return trainset, valset\",\n \"def datasets(self):\\n return [Dataset.ENSEMBL]\",\n \"def to_dataset(df, batch_size=5):\\n df = df.copy()\\n labels = df.pop('Relevant')\\n ds = tf.data.Dataset.from_tensor_slices((dict(df), labels))\\n ds = ds.batch(batch_size)\\n return ds\",\n \"def _dataset(self, split, directory, data_file):\\n del split\\n\\n filenames = generate_filenames(self.name, directory, data_file)\\n\\n def parse_function(record):\\n image_dim = self.IMAGE_SIZE_PX\\n features = tf.parse_single_example(\\n record,\\n features={\\n 'image_raw': tf.FixedLenFeature([], tf.string),\\n 'label': tf.FixedLenFeature([], tf.int64),\\n 'height': tf.FixedLenFeature([], tf.int64),\\n 'width': tf.FixedLenFeature([], tf.int64),\\n 'depth': tf.FixedLenFeature([], tf.int64)\\n })\\n\\n # Convert from a scalar string tensor (whose single string has\\n # length image_pixel*image_pixel) to a uint8 tensor with shape\\n # [image_pixel, image_pixel, 1].\\n image = tf.decode_raw(features['image_raw'], tf.uint8)\\n image = tf.reshape(image, [image_dim, image_dim, 1])\\n image.set_shape([image_dim, image_dim, 1])\\n\\n # Convert from [0, 255] -> [-0.5, 0.5] floats.\\n image = tf.cast(image, tf.float32) * (1. / 255)\\n\\n label = tf.cast(features['label'], tf.int32)\\n\\n return image, label\\n\\n dataset = tf.data.TFRecordDataset(filenames)\\n dataset = dataset.map(parse_function, num_parallel_calls=4)\\n\\n return dataset\",\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 load_data(self):\\n params = self.params\\n catg = params.data_category\\n langs = ['en', params.target_lang]\\n data = {lang: {splt: {} for splt in (['train', 'valid'] if lang == 'en' else ['test'])} for lang in langs}\\n clf_dataset_path = {\\n lang: {\\n splt: {\\n 'x': os.path.join(params.data_path, '%s_%s_%s_x.bpe.pth' % (splt, lang, catg)),\\n 'y': os.path.join(params.data_path, '%s_%s_%s_y.txt' % (splt, lang, catg)),\\n } for splt in (['train', 'valid'] if lang == 'en' else ['test'])\\n } for lang in langs\\n }\\n for splt in ['train', 'valid', 'test']:\\n for lang in langs:\\n if lang == 'en' and splt in ['train', 'valid'] or lang != 'en' and splt == 'test':\\n # load data and dictionary\\n data1 = load_binarized(clf_dataset_path[lang][splt]['x'], params)\\n data['dico'] = data.get('dico', data1['dico'])\\n # set dictionary parameters\\n set_dico_parameters(params, data, data1['dico'])\\n # create dataset\\n data[lang][splt]['x'] = Dataset(data1['sentences'], data1['positions'], params)\\n # load labels\\n with open(clf_dataset_path[lang][splt]['y'], 'r') as f:\\n labels = [int(l) for l in f]\\n data[lang][splt]['y'] = torch.LongTensor(labels)\\n assert len(data[lang][splt]['x']) == len(data[lang][splt]['y'])\\n\\n return data\",\n \"def load():\\n filepath = dirname(abspath(__file__))\\n data = recfromtxt(filepath + '/scotvote.csv', delimiter=\\\",\\\",\\n names=True, dtype=float, usecols=(1,2,3,4,5,6,7,8))\\n names = list(data.dtype.names)\\n endog = array(data[names[0]], dtype=float)\\n endog_name = names[0]\\n exog = column_stack(data[i] for i in names[1:]).astype(float)\\n exog_name = names[1:]\\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 __init__(self, dataset: Dataset):\\n self.dataset = dataset\",\n \"def buildDataSet():\\n (x_train_origin, y_train_origin), (x_test_origin, y_test_origin) = mnist.load_data()\\n\\n assert K.image_data_format() == 'channels_last'\\n x_train_origin = x_train_origin.reshape(x_train_origin.shape[0], h, w, 1)\\n x_test_origin = x_test_origin.reshape(x_test_origin.shape[0], h, w, 1)\\n\\n dataset_train = []\\n dataset_test = []\\n\\n #Sorting images by classes and normalize values 0=>1\\n for n in range(nb_classes):\\n images_class_n = np.asarray([row for idx,row in enumerate(x_train_origin) if y_train_origin[idx]==n])\\n dataset_train.append(images_class_n/255)\\n\\n images_class_n = np.asarray([row for idx,row in enumerate(x_test_origin) if y_test_origin[idx]==n])\\n dataset_test.append(images_class_n/255)\\n\\n return dataset_train,dataset_test,x_train_origin,y_train_origin,x_test_origin,y_test_origin\",\n \"def _prepare_data(self, dataset: DatasetH, reweighter=None) -> List[Tuple[lgb.Dataset, str]]:\\n ds_l = []\\n assert \\\"train\\\" in dataset.segments\\n for key in [\\\"train\\\", \\\"valid\\\"]:\\n if key in dataset.segments:\\n df = dataset.prepare(key, col_set=[\\\"feature\\\", \\\"label\\\"], data_key=DataHandlerLP.DK_L)\\n if df.empty:\\n raise ValueError(\\\"Empty data from dataset, please check your dataset config.\\\")\\n x, y = df[\\\"feature\\\"], df[\\\"label\\\"]\\n\\n # Lightgbm need 1D array as its label\\n if y.values.ndim == 2 and y.values.shape[1] == 1:\\n y = np.squeeze(y.values)\\n else:\\n raise ValueError(\\\"LightGBM doesn't support multi-label training\\\")\\n\\n if reweighter is None:\\n w = None\\n elif isinstance(reweighter, Reweighter):\\n w = reweighter.reweight(df)\\n else:\\n raise ValueError(\\\"Unsupported reweighter type.\\\")\\n ds_l.append((lgb.Dataset(x.values, label=y, weight=w), key))\\n return ds_l\",\n \"def get_datasets():\\n # Get data\\n dataframe = pandas.read_csv('agaricus-lepiota.data')\\n\\n # Convert data type for all variables\\n for column in dataframe:\\n dataframe[column] = pandas.Categorical(dataframe[column])\\n dataframe[column] = dataframe[column].cat.codes\\n\\n # Get labels\\n target = dataframe.pop('p')\\n\\n # Get tensors, and split data into training and test sets\\n split = int(len(dataframe) * 0.8)\\n train_dataset = tf.data.Dataset.from_tensor_slices(\\n (dataframe[:split].values, target[:split].values))\\n\\n train_dataset = train_dataset.shuffle(len(dataframe)).batch(1)\\n\\n test_dataset = tf.data.Dataset.from_tensor_slices(\\n (dataframe[split:].values, target[split:].values))\\n\\n test_dataset = test_dataset.shuffle(len(dataframe)).batch(1)\\n\\n return train_dataset, test_dataset\",\n \"def load_data_from_inds(data_set, inds):\\n\\n data = torch.cat([data_set[ind_][0].unsqueeze_(0) for ind_ in inds], 0)\\n labels = torch.cat([torch.from_numpy(np.array(data_set[ind_][1])).unsqueeze_(0) for ind_ in inds], 0)\\n\\n return data, labels\",\n \"def get_dataset(data_pars=None, **kw):\\n\\n\\n print('Loading data...')\\n maxlen = data_pars['data_info']['maxlen']\\n\\n loader = DataLoader(data_pars)\\n loader.compute()\\n dataset, internal_states = loader.get_data()\\n\\n # return dataset\\n Xtrain, ytrain, Xtest, ytest = dataset\\n Xtrain = sequence.pad_sequences(Xtrain, maxlen=maxlen)\\n Xtest = sequence.pad_sequences(Xtest, maxlen=maxlen)\\n return Xtrain, Xtest, ytrain, ytest\",\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 get_dataset(args):\\n\\n if args.dataset == 'cifar':\\n data_dir = 'data/cifar/'\\n apply_transform = transforms.Compose(\\n [transforms.ToTensor(),\\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\\n\\n train_dataset = datasets.CIFAR10(data_dir, train=True, download=True,\\n transform=apply_transform)\\n\\n test_dataset = datasets.CIFAR10(data_dir, train=False, download=True,\\n transform=apply_transform)\\n\\n # sample training data amongst users\\n if args.iid:\\n user_groups = cifar_iid(train_dataset, args.num_users)\\n else:\\n if args.unequal:\\n # Chose euqal splits for every user\\n user_groups = cifar_noniid(train_dataset, args.num_users)\\n else:\\n user_groups = cifar_noniid_class(train_dataset, args.num_users, args.class_per_user)\\n \\n elif args.dataset == 'mnist' or 'fmnist':\\n if args.dataset == 'mnist':\\n data_dir = 'data/mnist/'\\n else:\\n data_dir = 'data/fmnist/'\\n\\n apply_transform = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Normalize((0.1307,), (0.3081,))])\\n\\n train_dataset = datasets.MNIST(data_dir, train=True, download=True,\\n transform=apply_transform)\\n\\n test_dataset = datasets.MNIST(data_dir, train=False, download=True,\\n transform=apply_transform)\\n\\n # sample training data amongst users\\n if args.iid:\\n # Sample IID user data from Mnist\\n user_groups = mnist_iid(train_dataset, args.num_users)\\n else:\\n # Sample Non-IID user data from Mnist\\n if args.unequal:\\n # Chose uneuqal splits for every user\\n user_groups = mnist_noniid_unequal(train_dataset, args.num_users)\\n else:\\n # Chose euqal splits for every user\\n user_groups = mnist_noniid_class(train_dataset, args.num_users, args.class_per_user)\\n\\n return train_dataset, test_dataset, user_groups\",\n \"def _make_data(self):\\n pdf_datasets_all = make_pdf_datasets(self.pdf_list, self.xlims, self.ylims, self.tlims, self.dims, 9)\\n self.pdf_dataset = np.concatenate(pdf_datasets_all, axis = 0)\\n self.PDE_dataset = make_PDE_dataset(self.num_collocation, self.xlims, self.ylims, self.tlims, self.dims)\\n self.BC_dataset = make_BC_dataset(self.num_BC, self.xlims, self.ylims, self.tlims, self.dims)\",\n \"def prep_data(self):\\n\\n self.fit_tokenizer(texts=self.texts)\\n sequences = self.get_sequences(self.texts)\\n self.text_data = pad_sequences(sequences, maxlen=self.MAX_SEQUENCE_LENGTH)\\n\\n self.labels = to_categorical(np.asarray(self.labels))\\n print('Shape of data tensor:', self.text_data.shape)\\n print('Shape of label tensor:', self.labels.shape)\\n\\n # split the data into a training set and a validation set\\n indices = np.arange(self.text_data.shape[0])\\n np.random.shuffle(indices)\\n self.text_data = self.text_data[indices]\\n self.labels = self.labels[indices]\\n nb_validation_samples = int(self.VALIDATION_SPLIT * self.text_data.shape[0])\\n\\n x_train = self.text_data[:-nb_validation_samples]\\n y_train = self.labels[:-nb_validation_samples]\\n x_val = self.text_data[-nb_validation_samples:]\\n y_val = self.labels[-nb_validation_samples:]\\n\\n return x_train,y_train, x_val, y_val\",\n \"def iris():\\n return IrisDataset()\",\n \"def _dataset():\\n dataset = tf_record_dataset(DatasetName.SIGNUM, DatasetType.TRAIN)\\n dataset = dataset.batch(1)\\n dataset = dataset.map(transform_for_prediction)\\n dataset = dataset.unbatch()\\n dataset = dataset.filter(lambda frames, label, signer: tf.math.equal(label, 420) and tf.math.equal(signer, 1))\\n dataset = dataset.batch(1)\\n return dataset.take(1)\",\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 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 get_train_data(batch_size=8):\\n transform_train = transforms.Compose([\\n transforms.RandomResizedCrop(224),\\n transforms.RandomFlipLeftRight(),\\n transforms.RandomColorJitter(brightness=0.4, contrast=0.4, saturation=0.4),\\n transforms.RandomLighting(0.1),\\n transforms.ToTensor(),\\n transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))\\n ])\\n\\n img_folder, img_file = get_data_path()\\n td = MultilabelDataset(data_folder=img_folder, data_file=img_file)\\n train_data = DataLoader(td.transform_first(transform_train), batch_size=batch_size, shuffle=True)\\n return train_data\",\n \"def get_dataset(self):\\n\\n trainset = datasets.CIFAR100('datasets/CIFAR100/train/', train=True, transform=self.train_transforms,\\n target_transform=None, download=True)\\n valset = datasets.CIFAR100('datasets/CIFAR100/test/', train=False, transform=self.val_transforms,\\n target_transform=None, download=True)\\n\\n return trainset, valset\",\n \"def dataset(self):\\n return self.predictor_data_manager.dataset(\\n self.data_name, self.trait_name, data=self._data, trait=self.trait,\\n categorical_trait=self.categorical_trait)\",\n \"def TensorFlowDataset(\\n self,\\n options: dataset_options.TensorFlowDatasetOptions) -> tf.data.Dataset:\",\n \"def load_data_labels(datasets):\\n # Split by words\\n x_text = datasets['data']\\n x_text = [clean_str(sent) for sent in x_text]\\n # Generate labels\\n labels = []\\n for i in range(len(x_text)):\\n label = [0 for j in datasets['target_names']]\\n #print('target={}, i={}'.format(datasets['target'], i))\\n label[datasets['target'][i]] = 1\\n labels.append(label)\\n y = np.array(labels)\\n return [x_text, y]\",\n \"def get_data(dataset: str = None, scale: bool = True) -> tuple:\\n \\n if dataset not in ['ecoli', 'glass', 'letter-recognition', 'lymphography', 'yeast', \\n 'digits', 'breast-cancer', 'wine', 'mnist']:\\n raise ValueError(\\\"Invalid dataset provided.\\\")\\n \\n if dataset in dataset in ['ecoli', 'glass', 'letter-recognition', 'lymphography', 'yeast']:\\n path = 'https://archive.ics.uci.edu/ml/machine-learning-databases/' \\n f = path + dataset + \\\"/\\\" + dataset + \\\".data\\\"\\n \\n if dataset in ['ecoli', 'yeast']:\\n df = pd.read_table(f, delim_whitespace=True, header=None)\\n elif dataset in [ 'glass', 'letter-recognition', 'lymphography']:\\n df = pd.read_csv(f, header=None)\\n elif dataset == 'digits':\\n df = load_digits()\\n X = df.data\\n y = df.target\\n elif dataset == 'breast-cancer':\\n df = load_breast_cancer()\\n X = df.data\\n y = df.target\\n elif dataset == 'wine':\\n df = load_wine()\\n X = df.data\\n y = df.target\\n \\n if dataset == 'ecoli':\\n y = preprocessing.LabelEncoder().fit_transform(df.iloc[:,-1])\\n X = df.iloc[:,1:8].values\\n \\n elif dataset == 'glass':\\n y = df.iloc[:,-1].values\\n X = df.iloc[:, 1:(df.shape[1]-1)].values\\n \\n elif dataset in ['letter-recognition', 'lymphography']:\\n y = preprocessing.LabelEncoder().fit_transform(df.iloc[:,0])\\n X = df.iloc[:, 1:(df.shape[1])].values\\n \\n elif dataset == 'yeast':\\n y = preprocessing.LabelEncoder().fit_transform(df.iloc[:,-1])\\n X = df.iloc[:,1:9].values\\n \\n elif dataset == 'mnist':\\n X, y = fetch_openml('mnist_784', version=1, return_X_y=True)\\n y = y.astype('int64') \\n\\n if scale==True:\\n scaler = preprocessing.StandardScaler()\\n X = scaler.fit_transform(X)\\n \\n return X, y\",\n \"def load_torch_data(load_data_func):\\n\\n def torch_loader(dataset, data_path, batch_size, shuffle=True, cuda_device=None, num_workers=1):\\n (train_data, val_data), (train_labels, val_labels), label_names = load_data_func(dataset, data_path)\\n\\n kwargs = {'num_workers': num_workers, 'pin_memory': True} if cuda_device is not None else {}\\n kwargs['drop_last'] = True\\n\\n if type(train_data) == numpy.ndarray:\\n train_dataset = TensorDataset(torch.from_numpy(train_data), torch.from_numpy(train_labels))\\n val_dataset = TensorDataset(torch.from_numpy(val_data), torch.from_numpy(val_labels))\\n elif type(train_data) == scipy.sparse.csr.csr_matrix:\\n from sklearn.feature_extraction.text import TfidfTransformer\\n tfidf_trans = TfidfTransformer(norm=None)\\n tfidf_trans.fit(train_data)\\n train_dataset = SparseDataset(train_data, tfidf_trans.idf_)\\n val_dataset = SparseDataset(val_data, tfidf_trans.idf_)\\n else:\\n train_dataset = torchvision.datasets.ImageFolder(train_data)\\n val_dataset = torchvision.datasets.ImageFolder(val_data)\\n\\n train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, **kwargs)\\n val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, **kwargs)\\n\\n return train_loader, val_loader, label_names\\n\\n return torch_loader\",\n \"def parse_dataset(self, data):\\n pass\",\n \"def _get_dataset(self, dir_data, row_indices):\\n\\n ds_files, ds_labels = self._get_ds_files_labels(\\n dir_data, row_indices)\\n\\n ds_images = ds_files.map(self._load_preprocess_image)\\n\\n ds_images_labels = tf.data.Dataset.zip((ds_images, ds_labels))\\n\\n return ds_images_labels\",\n \"def load_data(self):\\n print('Loading {} dataset'.format(self.split))\\n data_split_path = os.path.join(self.root_dir, 'splits', '{}.csv'.format(self.split))\\n with open(data_split_path,'r') as f:\\n reader = csv.reader(f, delimiter=',')\\n data_classes = {}\\n for i,row in enumerate(reader):\\n if i==0:\\n continue\\n data_classes[row[1]] = 1\\n data_classes = data_classes.keys()\\n print(data_classes)\\n\\n n_classes = len(data_classes)\\n print('n_classes:{}, n_label:{}, n_unlabel:{}'.format(n_classes,self.n_label,self.n_unlabel))\\n dataset_l = np.zeros([n_classes, self.n_label, self.im_height, self.im_width, self.channels], dtype=np.float32)\\n if self.n_unlabel>0:\\n dataset_u = np.zeros([n_classes, self.n_unlabel, self.im_height, self.im_width, self.channels], dtype=np.float32)\\n else:\\n dataset_u = []\\n\\n for i, cls in enumerate(data_classes):\\n im_dir = os.path.join(self.root_dir, 'data/{}/'.format(self.split), cls)\\n im_files = sorted(glob.glob(os.path.join(im_dir, '*.jpg')))\\n np.random.RandomState(self.seed).shuffle(im_files) # fix the seed to keep label,unlabel fixed\\n for j, im_file in enumerate(im_files):\\n im = np.array(Image.open(im_file).resize((self.im_width, self.im_height)), \\n np.float32, copy=False)\\n if j<self.n_label:\\n dataset_l[i, j] = im\\n else:\\n dataset_u[i,j-self.n_label] = im\\n print('labeled data:', np.shape(dataset_l))\\n print('unlabeled data:', np.shape(dataset_u))\\n \\n self.dataset_l = dataset_l\\n self.dataset_u = dataset_u\\n self.n_classes = n_classes\",\n \"def load_data_labels(datasets):\\n # Split by words\\n x_text = datasets['data']\\n x_text = [clean_str(sent) for sent in x_text]\\n # Generate labels\\n labels = [0, 1, 2, 3, 4]\\n print(len(x_text))\\n for i in range(len(x_text)):\\n label = [0 for j in datasets['target_names']] \\n label[datasets['target'][i]] = labels[i]\\n labels.append(label)\\n y = np.array(labels)\\n return [x_text, y]\",\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 datasets(self):\\n pass\",\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 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 from_label(self, data):\\n out = data.copy()\\n if isinstance(data, pd.DataFrame) or isinstance(data, dict):\\n for column in self.categorical_feature_names:\\n out[column] = self.labelencoder[column].inverse_transform(out[column].round().astype(int).tolist())\\n return out\\n elif isinstance(data, list):\\n for column in self.categorical_feature_indexes:\\n out[column] = self.labelencoder[self.feature_names[column]].inverse_transform([round(out[column])])[0]\\n return out\",\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 create_dataset(filenames, labels):\\n \\n dataset = tf.data.Dataset.from_tensor_slices((filenames, labels))\\n \\n dataset.shuffle(buffer_size=SHUFFLE_BUFFER_SIZE)\\n \\n dataset = dataset.map(parse_function, num_parallel_calls=AUTOTUNE)\\n \\n dataset = dataset.batch(BATCH_SIZE)\\n\\n dataset = dataset.prefetch(buffer_size=AUTOTUNE)\\n \\n return dataset\",\n \"def dataset(self):\\n if self.X is not None and self.y is not None:\\n return self.X, self.y\\n\\n self.X, self.y = self.get_BOW_from_file(self.labels[0])\\n for label in self.labels[1:]:\\n X_temp, y_temp = self.get_BOW_from_file(label)\\n self.X = np.concatenate((self.X, X_temp))\\n self.y = np.concatenate((self.y, y_temp))\\n\\n return self.X, self.y\",\n \"def cast(cls, datasets, datatype=None, cast_type=None):\\n datatype = datatype or cls.datatype\\n cast = []\\n for ds in datasets:\\n if cast_type is not None or ds.interface.datatype != datatype:\\n ds = ds.clone(ds, datatype=[datatype], new_type=cast_type)\\n cast.append(ds)\\n return cast\",\n \"def _convert_dataset(split_name, filenames, class_names_to_ids, dataset_dir, image_dir):\\n assert split_name in ['train', 'validation']\\n\\n num_per_shard = int(math.ceil(len(filenames) / float(_NUM_SHARDS)))\\n\\n with tf.Graph().as_default():\\n image_reader = ImageReader()\\n\\n with tf.Session('') as sess:\\n\\n for shard_id in range(_NUM_SHARDS):\\n output_filename = _get_dataset_filename(\\n dataset_dir, split_name, shard_id)\\n\\n with tf.python_io.TFRecordWriter(output_filename) as tfrecord_writer:\\n start_ndx = shard_id * num_per_shard\\n end_ndx = min((shard_id+1) * num_per_shard, len(filenames))\\n for i in range(start_ndx, end_ndx):\\n sys.stdout.write('\\\\r>> Converting image %d/%d shard %d' % (\\n i+1, len(filenames), shard_id))\\n sys.stdout.flush()\\n\\n # Read the filename:\\n image_data = tf.gfile.FastGFile(image_dir + '/' + filenames[i], 'rb').read()\\n height, width = image_reader.read_image_dims(sess, image_data)\\n\\n class_name = os.path.basename(os.path.dirname(filenames[i]))\\n class_id = class_names_to_ids[class_name]\\n\\n example = image_to_tfexample( # dataset_utils\\n image_data, b'png', height, width, class_id)\\n tfrecord_writer.write(example.SerializeToString())\\n\\n sys.stdout.write('\\\\n')\\n sys.stdout.flush()\",\n \"def load_dataset(self, subset):\\n assert subset in ('train', 'val')\\n\\n # Add classes\\n for id, name in self.class_mapper.items():\\n self.add_class('nodule', id, name)\\n\\n # Add images\\n self.df = self.df_all[self.df_all['subset'] == subset]\\n\\n image_ids = set()\\n for row in self.df.itertuples():\\n image_id = (row.seriesuid, row.coordZ)\\n path = os.path.join(cur_dir, 'data', 'train', '{}_{}.npy'.format(row.seriesuid, row.coordZ))\\n if image_id in image_ids:\\n continue\\n self.add_image(\\\"nodule\\\", image_id=image_id, path=path)\\n image_ids.add(image_id)\",\n \"def load_data(self):\\n with open(self.file_name) as f:\\n lines = f.readlines()\\n\\n labels = list()\\n all_dat = list()\\n for i, l in enumerate(lines):\\n\\n labels.append(int(l[0]))\\n\\n l = gensim.utils.any2unicode(l)\\n all_dat.append(LabeledSentence(l.split(\\\"\\\\t\\\")[-1], [i]))\\n\\n return all_dat, np.asarray(labels)\",\n \"def transform(self, dataset):\\n loader = DataLoader(\\n dataset, batch_size=self.batch_size, shuffle=False, num_workers=8)\\n\\n feature_paths = []\\n with torch.no_grad():\\n for batch_samples in tqdm(loader):\\n img = batch_samples['img']\\n\\n if self.USE_CUDA:\\n img = img.cuda()\\n\\n img_features = self.features(img)\\n img_features = torch.unbind(img_features, dim=0)\\n batch_feature_paths = batch_samples['img_path']\\n for i, img_feature in enumerate(img_features):\\n f = batch_feature_paths[i]\\n f = os.path.join(\\n self.save_dir,\\n f.rpartition('/')[-1].replace('.jpg', '.pth'))\\n torch.save(img_feature.cpu(), f)\\n feature_paths.append(f)\\n\\n metadata = loader.dataset.metadata\\n metadata['feature_paths'] = feature_paths\\n\\n return metadata\",\n \"def fixture_input_data(wrapper_arguments):\\n n_features, classes = wrapper_arguments\\n num_data = 50\\n data = np.random.rand(num_data, n_features)\\n labels = np.random.choice(classes, size=num_data)\\n\\n return data, labels\",\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 getData(data, featurecols, labelencoder, classconversion=None):\\n for i in range(0, len(labelencoder)):\\n le = preprocessing.LabelEncoder()\\n le.fit(labelencoder[i][1:])\\n notnullidx = np.transpose(np.argwhere(np.array(~pd.isnull(data.iloc[:, labelencoder[i][0]])) == True))[0]\\n nullidx = np.transpose(np.argwhere(np.array(pd.isnull(data.iloc[:, labelencoder[i][0]])) == True))[0]\\n data.iloc[notnullidx, labelencoder[i][0]] = le.transform(data.iloc[notnullidx, labelencoder[i][0]].values)\\n data.iloc[nullidx, labelencoder[i][0]] = np.nan\\n \\n features = data.iloc[:, featurecols].values\\n features = features.astype(float)\\n \\n featurelabels = data.columns[featurecols].values\\n if classconversion is not None:\\n classes = np.empty(len(features))\\n classes[:] = -1\\n for i in range(0, len(classconversion)):\\n classcol = np.array(data.iloc[:, classconversion[i,0]].values)\\n classes[classcol.astype(str) == str(classconversion[i,1])] = classconversion[i,2]\\n classes = classes.astype(int)\\n indices = classes[:] > -1\\n ids = data.iloc[indices, 0:3]\\n \\n return features[indices,:], classes[indices], featurelabels, ids\\n \\n return features, None, featurelabels, data.iloc[:, 0:3]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7115415","0.694991","0.6914352","0.6845197","0.67110246","0.66670096","0.66645527","0.66255164","0.65189576","0.6509893","0.64952195","0.64838934","0.6474416","0.64262444","0.6405279","0.6367776","0.6365836","0.63566065","0.6337854","0.6322987","0.63042396","0.6289342","0.6273321","0.6268611","0.6251395","0.62492055","0.6242134","0.6223605","0.6199089","0.6197334","0.61878926","0.61708397","0.61706746","0.6162011","0.61543494","0.6152109","0.6147042","0.61457545","0.61453396","0.6140119","0.6128848","0.6125232","0.61249876","0.6123848","0.6123211","0.61109596","0.6105588","0.61018246","0.60975164","0.6091708","0.608137","0.605761","0.60531706","0.60473645","0.60460144","0.6035014","0.60320807","0.6026549","0.602272","0.6020765","0.60179883","0.6008196","0.6006973","0.6000085","0.5986757","0.5983466","0.5982916","0.59772575","0.5976631","0.59764934","0.5972169","0.5971427","0.59691805","0.59638435","0.5963034","0.59488004","0.59402955","0.5938341","0.5936582","0.59352225","0.5932806","0.59294236","0.59274536","0.5926205","0.5923254","0.5923078","0.5920502","0.5918367","0.59176075","0.5911896","0.5909496","0.5907534","0.5903237","0.5900674","0.5897496","0.58952004","0.58950895","0.58719313","0.58713204","0.5868688"],"string":"[\n \"0.7115415\",\n \"0.694991\",\n \"0.6914352\",\n \"0.6845197\",\n \"0.67110246\",\n \"0.66670096\",\n \"0.66645527\",\n \"0.66255164\",\n \"0.65189576\",\n \"0.6509893\",\n \"0.64952195\",\n \"0.64838934\",\n \"0.6474416\",\n \"0.64262444\",\n \"0.6405279\",\n \"0.6367776\",\n \"0.6365836\",\n \"0.63566065\",\n \"0.6337854\",\n \"0.6322987\",\n \"0.63042396\",\n \"0.6289342\",\n \"0.6273321\",\n \"0.6268611\",\n \"0.6251395\",\n \"0.62492055\",\n \"0.6242134\",\n \"0.6223605\",\n \"0.6199089\",\n \"0.6197334\",\n \"0.61878926\",\n \"0.61708397\",\n \"0.61706746\",\n \"0.6162011\",\n \"0.61543494\",\n \"0.6152109\",\n \"0.6147042\",\n \"0.61457545\",\n \"0.61453396\",\n \"0.6140119\",\n \"0.6128848\",\n \"0.6125232\",\n \"0.61249876\",\n \"0.6123848\",\n \"0.6123211\",\n \"0.61109596\",\n \"0.6105588\",\n \"0.61018246\",\n \"0.60975164\",\n \"0.6091708\",\n \"0.608137\",\n \"0.605761\",\n \"0.60531706\",\n \"0.60473645\",\n \"0.60460144\",\n \"0.6035014\",\n \"0.60320807\",\n \"0.6026549\",\n \"0.602272\",\n \"0.6020765\",\n \"0.60179883\",\n \"0.6008196\",\n \"0.6006973\",\n \"0.6000085\",\n \"0.5986757\",\n \"0.5983466\",\n \"0.5982916\",\n \"0.59772575\",\n \"0.5976631\",\n \"0.59764934\",\n \"0.5972169\",\n \"0.5971427\",\n \"0.59691805\",\n \"0.59638435\",\n \"0.5963034\",\n \"0.59488004\",\n \"0.59402955\",\n \"0.5938341\",\n \"0.5936582\",\n \"0.59352225\",\n \"0.5932806\",\n \"0.59294236\",\n \"0.59274536\",\n \"0.5926205\",\n \"0.5923254\",\n \"0.5923078\",\n \"0.5920502\",\n \"0.5918367\",\n \"0.59176075\",\n \"0.5911896\",\n \"0.5909496\",\n \"0.5907534\",\n \"0.5903237\",\n \"0.5900674\",\n \"0.5897496\",\n \"0.58952004\",\n \"0.58950895\",\n \"0.58719313\",\n \"0.58713204\",\n \"0.5868688\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65559363"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":91494,"cells":{"query":{"kind":"string","value":"Method that converts data and labels to instances of class torch.utils.data.DataLoader"},"document":{"kind":"string","value":"def init_loaders(self, *args, **kwargs):\n\n # Convert the data to Dataset\n dataset_dict = self.init_datasets(*args, **kwargs)\n\n # If the Dataset implements collate_fn, that is used. Otherwise, default_collate is used\n if hasattr(dataset_dict[\"train\"], \"collate_fn\") and callable(\n getattr(dataset_dict[\"train\"], \"collate_fn\")\n ):\n collate_fn = dataset_dict[\"train\"].collate_fn\n else:\n collate_fn = default_collate\n\n # If 'iters_per_epoch' is defined, then a fixed number of random sample batches from the training set\n # are drawn per epoch.\n # Otherwise, an epoch is defined by a full run through all of the data in the dataloader.\n #\n if self.config_dict.get(\"iters_per_epoch\") is not None:\n num_samples = (\n self.config_dict[\"iters_per_epoch\"] * self.config_dict[\"batch_size\"]\n )\n loaders_dict = {}\n for key in dataset_dict.keys():\n if key == \"train\":\n loaders_dict[key] = DataLoader(\n dataset_dict[key],\n batch_sampler=BatchSampler(\n RandomSampler(\n dataset_dict[key],\n replacement=True,\n num_samples=num_samples,\n ),\n batch_size=self.config_dict[\"batch_size\"],\n drop_last=False,\n ),\n collate_fn=collate_fn,\n )\n else:\n loaders_dict[key] = DataLoader(\n dataset_dict[key],\n batch_size=self.config_dict[\"batch_size\"],\n collate_fn=collate_fn,\n )\n else:\n loaders_dict = {\n key: DataLoader(\n dataset_dict[key],\n batch_size=self.config_dict[\"batch_size\"],\n collate_fn=collate_fn,\n )\n for key in data_dict.keys()\n }\n\n return loaders_dict"},"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 dataloaders():\n # train data path\n data_train = '../dataset/train/'\n # set transformations\n train_transforms = transforms.Compose([\n transforms.Resize((224, 224)),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406],\n [0.229, 0.224, 0.225])])\n \n train_data = datasets.ImageFolder(data_train, transform = train_transforms)\n trainloader = torch.utils.data.DataLoader(train_data, batch_size = 16, shuffle = True)\n \n return trainloader","def train_dataloader(self) -> torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_train, **self.dl_kwargs)","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 prepare_data(self,d):\n train_loaders, train_iters = {}, {}\n unlabeled_loaders, unlabeled_iters = {}, {}\n for domain in opt.domains:\n #CONVERT TO FLOAT32\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape((-1,1))\n train = data_utils.TensorDataset(features,target)\n train_loaders[domain] = DataLoader(train, opt.batch_size, shuffle = True)\n train_iters[domain] = iter(train_loaders[domain])\n for domain in opt.unlabeled_domains:\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape(-1,1))\n uset = data_utils.TensorDataset(features,target)\n unlabeled_loaders[domain] = DataLoader(uset,opt.batch_size, shuffle = True)\n unlabeled_iters[domain] = iter(unlabeled_loaders[domain])\n \n return train_loaders, train_iters, unlabeled_loaders, unlabeled_iters","def to_DataLoader(self, **kwargs):\r\n return DataLoader(self, **kwargs)","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_torch_data(load_data_func):\n\n def torch_loader(dataset, data_path, batch_size, shuffle=True, cuda_device=None, num_workers=1):\n (train_data, val_data), (train_labels, val_labels), label_names = load_data_func(dataset, data_path)\n\n kwargs = {'num_workers': num_workers, 'pin_memory': True} if cuda_device is not None else {}\n kwargs['drop_last'] = True\n\n if type(train_data) == numpy.ndarray:\n train_dataset = TensorDataset(torch.from_numpy(train_data), torch.from_numpy(train_labels))\n val_dataset = TensorDataset(torch.from_numpy(val_data), torch.from_numpy(val_labels))\n elif type(train_data) == scipy.sparse.csr.csr_matrix:\n from sklearn.feature_extraction.text import TfidfTransformer\n tfidf_trans = TfidfTransformer(norm=None)\n tfidf_trans.fit(train_data)\n train_dataset = SparseDataset(train_data, tfidf_trans.idf_)\n val_dataset = SparseDataset(val_data, tfidf_trans.idf_)\n else:\n train_dataset = torchvision.datasets.ImageFolder(train_data)\n val_dataset = torchvision.datasets.ImageFolder(val_data)\n\n train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, **kwargs)\n val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, **kwargs)\n\n return train_loader, val_loader, label_names\n\n return torch_loader","def get_data_loaders(args, tokenizer):\n personachat = get_dataset(tokenizer, args.dataset_path, args.dataset_cache, args.train_lang)\n _ = personachat.pop(\"test\", None)\n logger.info(\"Build inputs and labels\")\n datasets = {\"train\": [], \"valid\": []}\n\n if args.train_lang in [\"En\", \"Fr\", \"It\", \"Id\", \"Jp\", \"Ko\", \"Zh\"]: #monolingual data\n for dataset_name, dataset in personachat.items():\n for dial in dataset[args.train_lang]: #dial: {\"persona\":[], \"history\":[], \"response\":str}\n instance = build_input_from_segments(dial[\"persona\"], dial[\"history\"][-args.max_turns:], dial[\"response\"], tokenizer, lm_labels = True)\n datasets[dataset_name].append(instance) \n else: #multilingual data\n for dataset_name, dataset in personachat.items():\n for lang, dials in dataset.items():\n for dial in dials: #dial: {\"persona\":[], \"history\":[], \"response\":str}\n instance = build_input_from_segments(dial[\"persona\"], dial[\"history\"][-args.max_turns:], dial[\"response\"], tokenizer, lang_id=\"<{}>\".format(lang.lower()), lm_labels = True)\n datasets[dataset_name].append(instance) #all langs together\n\n\n logger.info(\"Build train and validation dataloaders\")\n train_dataset = DatasetTrain(datasets[\"train\"])\n valid_dataset = DatasetTrain(datasets[\"valid\"])\n\n #logger.info(\"Build train and validation dataloaders\")\n #train_dataset, valid_dataset = TensorDataset(*tensor_datasets[\"train\"]), TensorDataset(*tensor_datasets[\"valid\"])\n train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) if args.distributed else None\n valid_sampler = torch.utils.data.distributed.DistributedSampler(valid_dataset) if args.distributed else None\n train_loader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.train_batch_size, shuffle=(not args.distributed), collate_fn=collate_fn)\n valid_loader = DataLoader(valid_dataset, sampler=valid_sampler, batch_size=args.valid_batch_size, shuffle=False, collate_fn=collate_fn)\n\n # logger.info(\"Train dataset (Batch, Candidates, Seq length): {}\".format(train_dataset.tensors[0].shape))\n # #logger.info(\"Train dataset (Batch, Candidates, Seq length): {}\".format(train_dataset.tensors[1].shape))\n # logger.info(\"Valid dataset (Batch, Candidates, Seq length): {}\".format(valid_dataset.tensors[0].shape))\n logger.info(\"Train dataset length: {}\".format(len(train_dataset)))\n logger.info(\"Valid dataset length: {}\".format(len(valid_dataset)))\n return train_loader, valid_loader, train_sampler, valid_sampler","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 data_loaders(args):\n\n transform = transforms.Compose([\n transforms.Resize(64),\n transforms.ToTensor(),\n lambda image: (image - 0.5) * 2\n ])\n\n train_mnist = datasets.MNIST(\n root=args.database_root,\n train=True,\n download=True,\n transform=transform\n )\n train_loader = DataLoader(\n dataset=train_mnist,\n batch_size=args.train_batch_size,\n shuffle=True,\n num_workers=1,\n pin_memory=True\n )\n\n test_mnist = datasets.MNIST(\n root=args.database_root,\n train=False,\n download=True,\n transform=transform\n )\n test_loader = DataLoader(\n dataset=test_mnist,\n batch_size=args.test_batch_size,\n shuffle=True,\n num_workers=1,\n pin_memory=True\n )\n\n return train_loader, test_loader","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 loadData(self):\n batch_size = 256\n \n #if self.conv_sg == True:\n # batch_size = 1 \n \n download = True\n root = self.root + self.dataset\n if self.dataset == \"MNIST\": \n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])\n trainset = torchvision.datasets.MNIST(root, train=True, download=download, transform=transform)\n testset = torchvision.datasets.MNIST(root, train=False, download=download, transform=transform)\n \n if self.dataset == \"CIFAR10\":\n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465,), (0.2023, 0.1994, 0.2010,))])\n trainset = torchvision.datasets.CIFAR10(root, train=True, download=download, transform=transform)\n testset = torchvision.datasets.CIFAR10(root, train=False, download=download, transform=transform)\n \n if self.dataset == \"CIFAR100\":\n transform = transforms.Compose([transforms.ToTensor()])\n trainset = torchvision.datasets.CIFAR100(root, train=True, download=download, transform=transform)\n testset = torchvision.datasets.CIFAR100(root, train=False, download=download, transform=transform)\n \n \n trainloader = torch.utils.data.DataLoader(trainset, batch_size = batch_size,\n shuffle=False, num_workers=0, pin_memory = False)\n \n testloader = torch.utils.data.DataLoader(testset, batch_size= batch_size,\n shuffle=False, num_workers=2, pin_memory = False)\n \n return trainloader, testloader","def 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 _custom_data_loader(self) -> DataLoader:\n dataloaders = DataLoader(self.dataset, batch_size=1)\n return dataloaders","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 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 get_loaders(img_size=CONFIG[\"matrix_size\"], batch_size=CONFIG[\"batch_size\"],\n used_keypoints=CONFIG[\"used_keypoints\"], interpolation_frames=CONFIG[\"interpolation_frames\"],\n noise_frames=CONFIG[\"noise_frames\"], all_data=None, all_labels=None):\n\n if all_data is None or all_labels is None:\n all_data, all_labels = load_video_data_labels(interpolation_frames, noise_frames, used_keypoints, img_size)\n\n p = np.random.permutation(len(all_data))\n train_len = int(len(p) / 80)\n others_len = int((len(p) - train_len) / 2)\n\n train_data, train_labels = all_data[p[:train_len]], all_labels[p[:train_len]]\n val_data = all_data[p[train_len:train_len + others_len]]\n val_labels = all_labels[p[train_len:train_len + others_len]]\n test_data, test_labels = all_data[p[-others_len:]], all_labels[p[-others_len:]]\n\n # Transform to tensor\n train_data_tensor, train_labels_tensor = torch.from_numpy(train_data), torch.from_numpy(train_labels)\n val_data_tensor, val_labels_tensor = torch.from_numpy(val_data), torch.from_numpy(val_labels)\n test_data_tensor, test_labels_tensor = torch.from_numpy(test_data), torch.from_numpy(test_labels)\n\n # Data Loader for easy mini-batch return in training, load the Dataset from the numpy arrays\n train_loader = DataLoader(TensorDataset(train_data_tensor, train_labels_tensor), batch_size=batch_size)\n val_loader = DataLoader(TensorDataset(val_data_tensor, val_labels_tensor), batch_size=batch_size)\n test_loader = DataLoader(TensorDataset(test_data_tensor, test_labels_tensor), batch_size=batch_size)\n\n data = {\"train_data\": train_data,\n \"train_labels\": train_labels,\n \"val_data\": val_data,\n \"val_labels\": val_labels,\n \"test_data\": test_data,\n \"test_labels\": test_labels,\n \"all_data\": all_data[p],\n \"all_labels\": all_labels[p]}\n\n return data, train_loader, val_loader, test_loader","def load_data(data_dir):\n train_dir = data_dir + '/train'\n valid_dir = data_dir + '/valid'\n test_dir = data_dir + '/test'\n\n # define your transforms for the training, validation, and testing sets\n data_transforms_training = transforms.Compose([\n transforms.RandomRotation(30),\n transforms.RandomResizedCrop(224),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n ])\n\n data_transforms_validation = transforms.Compose([\n transforms.Resize(224),\n transforms.CenterCrop(224),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n ])\n\n data_transforms_test = transforms.Compose([\n transforms.Resize(224),\n transforms.CenterCrop(224),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n ])\n\n # Load the datasets with ImageFolder\n image_datasets_training = datasets.ImageFolder(train_dir, transform=data_transforms_training)\n image_datasets_validation = datasets.ImageFolder(valid_dir, transform=data_transforms_validation)\n image_datasets_test = datasets.ImageFolder(test_dir, transform=data_transforms_test)\n\n # Using the image datasets and the trainforms, define the dataloaders\n dataloaders_training = torch.utils.data.DataLoader(image_datasets_training, shuffle=True, batch_size=128)\n dataloaders_validation = torch.utils.data.DataLoader(image_datasets_validation, shuffle=True, batch_size=128)\n dataloaders_test = torch.utils.data.DataLoader(image_datasets_test, shuffle=True, batch_size=128)\n\n return {\"training_dataloader\": dataloaders_training,\n \"validation_dataloader\": dataloaders_validation,\n \"testing_dataloader\": dataloaders_test,\n \"class_to_idx\": image_datasets_training.class_to_idx}","def train_dataloader(self) -> DataLoader:\n return self._custom_data_loader()","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_train_loader(self):\n # Choose the right dataset type\n if self.config_args[\"num_members\"] > 1:\n class_dataset_wrapper = dataset_wrapper.MixMoDataset\n else:\n class_dataset_wrapper = dataset_wrapper.MSDADataset\n\n # Load augmentations\n self.traindatasetwrapper = class_dataset_wrapper(\n dataset=self.train_dataset,\n num_classes=int(self.config_args[\"data\"][\"num_classes\"]),\n num_members=self.config_args[\"num_members\"],\n dict_config=self.config_args[\"training\"][\"dataset_wrapper\"],\n properties=self.properties\n )\n\n # Build standard sampler\n _train_sampler = torch.utils.data.sampler.RandomSampler(\n data_source=self.traindatasetwrapper, ## only needed for its length\n num_samples=None,\n replacement=False,\n )\n\n # Wrap it with the repeating sampler used for multi-input models\n batch_sampler = batch_repetition_sampler.BatchRepetitionSampler(\n sampler=_train_sampler,\n batch_size=self.batch_size,\n num_members=self.config_args[\"num_members\"],\n drop_last=True,\n config_batch_sampler=self.config_args[\"training\"][\"batch_sampler\"]\n )\n\n self.train_loader = torch.utils.data.DataLoader(\n self.traindatasetwrapper,\n batch_sampler=batch_sampler,\n num_workers=self.num_workers,\n batch_size=1,\n shuffle=False,\n sampler=None,\n drop_last=False,\n pin_memory=True,\n )","def build_training_data_loader(self) -> DataLoader:\n pass","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)","def get_data_loader(target_classes, batch_size):\n classes = ('plane', 'car', 'bird', 'cat',\n 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n ########################################################################\n # The output of torchvision datasets are PILImage images of range [0, 1].\n # We transform them to Tensors of normalized range [-1, 1].\n transform = transforms.Compose(\n [transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n trainset = torchvision.datasets.CIFAR10(root='./data', train=True,\n download=True, transform=transform)\n # Get the list of indices to sample from\n relevant_train_indices = get_relevant_indices(\n trainset,\n classes,\n target_classes)\n # Split into train and validation\n np.random.seed(1000) # Fixed numpy random seed for reproducible shuffling\n np.random.shuffle(relevant_train_indices)\n split = int(len(relevant_train_indices) * 0.8)\n relevant_train_indices, relevant_val_indices = relevant_train_indices[:split], relevant_train_indices[split:]\n train_sampler = SubsetRandomSampler(relevant_train_indices)\n train_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n num_workers=0, sampler=train_sampler)\n val_sampler = SubsetRandomSampler(relevant_val_indices)\n val_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n num_workers=0, sampler=val_sampler)\n testset = torchvision.datasets.CIFAR10(root='./data', train=False,\n download=True, transform=transform)\n relevant_test_indices = get_relevant_indices(testset, classes, target_classes)\n test_sampler = SubsetRandomSampler(relevant_test_indices)\n test_loader = torch.utils.data.DataLoader(testset, batch_size=batch_size,\n num_workers=0, sampler=test_sampler)\n return train_loader, val_loader, test_loader, classes","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 load_dataloaders(args):\n logger.info(\"Loading dataloaders...\")\n p_path = os.path.join(\"./data/\", \"df_unencoded.pkl\")\n train_path = os.path.join(\"./data/\", \"df_encoded.pkl\")\n if (not os.path.isfile(p_path)) and (not os.path.isfile(train_path)):\n df = get_data(args, load_extracted=False)\n elif os.path.isfile(p_path) and (not os.path.isfile(train_path)):\n df = get_data(args, load_extracted=True)\n elif os.path.isfile(train_path):\n df = load_pickle(\"df_encoded.pkl\")\n \n # Train-Test split\n msk = np.random.rand(len(df)) < args.train_test_ratio\n trainset = df[msk]\n testset = df[~msk]\n \n trainset = text_dataset(trainset, args)\n max_features_length = trainset.max_x_len\n max_seq_len = trainset.max_y_len\n train_length = len(trainset)\n train_loader = DataLoader(trainset, batch_size=args.batch_size, shuffle=True,\\\n num_workers=0, collate_fn=Pad_Sequence(), pin_memory=False)\n \n testset = text_dataset(testset, args)\n test_length = len(testset)\n test_loader = DataLoader(testset, batch_size=args.batch_size, shuffle=True,\\\n num_workers=0, collate_fn=Pad_Sequence(), pin_memory=False)\n return train_loader, train_length, max_features_length, max_seq_len, test_loader, test_length","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 load_data(self) -> tuple:\n label_num = {}\n data_set = pathlib.Path(self.path)\n data = []\n\n # create the label lookup dict for verifcation later\n for i, v in enumerate(data_set.iterdir()):\n label_num[v.name] = i\n self.labels[i] = v.name\n # end\n\n # read images\n for img_path in data_set.rglob(\"*.jpg\"):\n lbl = label_num[str(img_path.parent.stem)]\n img = cv2.imread(str(img_path))\n img = cv2.resize(img, self.dims, interpolation=cv2.INTER_AREA)\n\n # flatten RGB data into a vector\n # NOTE: NOT ACTUALLY NECESSARY! \n img.flatten()\n\n # label the sample and append to temp data list\n sample = np.append(lbl, img)\n data.append(sample)\n # end\n\n # partition and package the data (*_ ensures safe unpacking)\n train, test, validate, *_ = Data.partition(data, self.parts, 0.7, 0.2)\n self.train = Data(train)\n self.test = Data(test)\n self.validate = Data(validate)","def load_data(self):\n print('Loading {} dataset'.format(self.split))\n data_split_path = os.path.join(self.root_dir, 'splits', '{}.csv'.format(self.split))\n with open(data_split_path,'r') as f:\n reader = csv.reader(f, delimiter=',')\n data_classes = {}\n for i,row in enumerate(reader):\n if i==0:\n continue\n data_classes[row[1]] = 1\n data_classes = data_classes.keys()\n print(data_classes)\n\n n_classes = len(data_classes)\n print('n_classes:{}, n_label:{}, n_unlabel:{}'.format(n_classes,self.n_label,self.n_unlabel))\n dataset_l = np.zeros([n_classes, self.n_label, self.im_height, self.im_width, self.channels], dtype=np.float32)\n if self.n_unlabel>0:\n dataset_u = np.zeros([n_classes, self.n_unlabel, self.im_height, self.im_width, self.channels], dtype=np.float32)\n else:\n dataset_u = []\n\n for i, cls in enumerate(data_classes):\n im_dir = os.path.join(self.root_dir, 'data/{}/'.format(self.split), cls)\n im_files = sorted(glob.glob(os.path.join(im_dir, '*.jpg')))\n np.random.RandomState(self.seed).shuffle(im_files) # fix the seed to keep label,unlabel fixed\n for j, im_file in enumerate(im_files):\n im = np.array(Image.open(im_file).resize((self.im_width, self.im_height)), \n np.float32, copy=False)\n if j<self.n_label:\n dataset_l[i, j] = im\n else:\n dataset_u[i,j-self.n_label] = im\n print('labeled data:', np.shape(dataset_l))\n print('unlabeled data:', np.shape(dataset_u))\n \n self.dataset_l = dataset_l\n self.dataset_u = dataset_u\n self.n_classes = n_classes","def _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 load_data(data_dir):\n \n #Define training, validation, and testing directories, structured for use with ImageFolder Class\n train_dir = data_dir + '/train'\n valid_dir = data_dir + '/valid'\n test_dir = data_dir + '/test'\n \n #Define image transforms for training, validation, and testing\n training_transforms = transforms.Compose([transforms.RandomRotation(30),\n transforms.RandomResizedCrop(224),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406],\n [0.229, 0.224, 0.225])])\n\n validation_transforms = transforms.Compose([transforms.Resize(224),\n transforms.CenterCrop(224),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406],\n [0.229, 0.224, 0.225])])\n\n testing_transforms = validation_transforms\n\n\n #Load the datasets with ImageFolder\n training_data = datasets.ImageFolder(train_dir, transform = training_transforms)\n validation_data = datasets.ImageFolder(valid_dir, transform = validation_transforms)\n testing_data = datasets.ImageFolder(test_dir, transform = testing_transforms)\n\n #Using the image datasets and the trainforms, define the dataloaders\n training_loader = torch.utils.data.DataLoader(training_data, batch_size = 64, shuffle = True)\n validation_loader = torch.utils.data.DataLoader(validation_data, batch_size = 64, shuffle = False)\n testing_loader = torch.utils.data.DataLoader(testing_data, batch_size = 64, shuffle = False)\n \n return training_loader, validation_loader, testing_loader","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 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 get_each_loader(data_path, batch_size, trn_negnum, shuffle=True, num_workers=0):\n \n dataset = ML_Dataset(data_path, trn_negnum)\n \n if data_path.endswith('trn') == True:\n collate = dataset.train_collate\n else:\n collate = test_collate\n\n data_loader = data.DataLoader(dataset=dataset,\n batch_size=batch_size,\n shuffle=shuffle,\n num_workers=num_workers,\n collate_fn=collate)\n\n return data_loader","def get_loaders(\n data_dir,\n train_transforms=None,\n val_transforms=None,\n train_test_split=0.85,\n train_val_split=0.15,\n batch_size=16,\n shuffle=True):\n np.random.seed(24)\n train_ds = ImageFolder(root=data_dir, transform=train_transforms)\n val_ds = ImageFolder(root=data_dir, transform=val_transforms)\n test_ds = ImageFolder(root=data_dir, transform=val_transforms)\n img_count = len(train_ds)\n indices = list(range(img_count))\n test_split = int(img_count * train_test_split)\n if shuffle:\n np.random.shuffle(indices)\n train_idx, test_idx = indices[:test_split], indices[test_split:]\n train_count = len(train_idx)\n val_split = int(train_count * (1 - train_val_split))\n train_idx, val_idx = train_idx[:val_split], train_idx[val_split:]\n train_sample = SubsetRandomSampler(train_idx)\n val_sample = SubsetRandomSampler(val_idx)\n test_sample = SubsetRandomSampler(test_idx)\n train_loader = DataLoader(train_ds, batch_size=batch_size, sampler=train_sample)\n val_loader = DataLoader(val_ds, batch_size=batch_size, sampler=val_sample)\n test_loader = DataLoader(test_ds, batch_size=batch_size, sampler=test_sample)\n\n return train_loader, val_loader, test_loader","def get_data_loaders(data, batch_size, ratio=0.8, num_workers=1):\n train_size = int(len(data) * ratio)\n val_size = len(data) - train_size\n train_set, val_set = random_split(data, [train_size, val_size])\n data_train_loader = DataLoader(train_set, batch_size=batch_size, num_workers=num_workers, shuffle=True)\n data_val_loader = DataLoader(val_set, batch_size=batch_size, num_workers=num_workers, shuffle=True)\n return data_train_loader, data_val_loader","def data_loader(edges,features,y):\n\n\n edge_index = torch.tensor(edges, dtype=torch.long)\n edge_index = edge_index.t().contiguous()\n x = torch.tensor(features.todense(), dtype=torch.float)\n\n y = torch.tensor(y)\n\n data = Data(x=x, edge_index=edge_index, y = y)\n\n return data","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 __init__(self, **kwargs):\n DataLoader.__init__(self, **kwargs)","def load_torchvision_data(data, label, test_size = 0.2, valid_size=0.1, splits=None, shuffle=True,\n stratified=False, random_seed=None, batch_size = 64,\n maxsize = None, maxsize_test=None, num_workers = 0):\n\n x_train, x_test, y_train, y_test = train_test_split(data, label, test_size = test_size, stratify=label)\n train, test = CERDataset(x_train, y_train), CERDataset(x_test, y_test)\n\n if type(train.targets) is list or type(train.targets) is np.ndarray:\n train.targets = torch.LongTensor(train.targets)\n test.targets = torch.LongTensor(test.targets)\n\n if not hasattr(train, 'classes') or not train.classes:\n train.classes = sorted(torch.unique(train.targets).tolist())\n test.classes = sorted(torch.unique(train.targets).tolist())\n\n ### Data splitting\n fold_idxs = {}\n if splits is None and valid_size == 0:\n ## Only train\n fold_idxs['train'] = np.arange(len(train))\n elif splits is None and valid_size > 0:\n ## Train/Valid\n train_idx, valid_idx = random_index_split(len(train), 1-valid_size, (maxsize, None)) # No maxsize for validation\n fold_idxs['train'] = train_idx\n fold_idxs['valid'] = valid_idx\n\n for k, idxs in fold_idxs.items():\n if maxsize and maxsize < len(idxs):\n fold_idxs[k] = np.sort(np.random.choice(idxs, maxsize, replace = False))\n\n sampler_class = SubsetRandomSampler if shuffle else SubsetSampler\n fold_samplers = {k: sampler_class(idxs) for k,idxs in fold_idxs.items()}\n\n ### Create DataLoaders\n dataloader_args = dict(batch_size=batch_size,num_workers=num_workers)\n\n fold_loaders = {k:dataloader.DataLoader(train, sampler=sampler,**dataloader_args)\n for k,sampler in fold_samplers.items()}\n\n if maxsize_test and maxsize_test < len(test):\n test_idxs = np.sort(np.random.choice(len(test), maxsize_test, replace = False))\n sampler_test = SubsetSampler(test_idxs) # For test don't want Random\n dataloader_args['sampler'] = sampler_test\n else:\n dataloader_args['shuffle'] = False\n test_loader = dataloader.DataLoader(test, **dataloader_args)\n fold_loaders['test'] = test_loader\n\n fnames, flens = zip(*[[k,len(v)] for k,v in fold_idxs.items()])\n fnames = '/'.join(list(fnames) + ['test'])\n flens = '/'.join(map(str, list(flens) + [len(test)]))\n\n if hasattr(train, 'data'):\n logger.info('Input Dim: {}'.format(train.data.shape[1:]))\n logger.info('Classes: {} (effective: {})'.format(len(train.classes), len(torch.unique(train.targets))))\n print(f'Fold Sizes: {flens} ({fnames})')\n\n return fold_loaders, {'train': train, 'test':test}","def make_loader(dataset, train_batch_size, validation_split=0.2):\n # number of samples in train and test set\n train_len = int(len(dataset) * (1 - validation_split))\n test_len = len(dataset) - train_len\n train_set, test_set = torch.utils.data.random_split(dataset, [train_len, test_len])\n # create train_loader\n train_loader = torch.utils.data.DataLoader(\n train_set, batch_size=train_batch_size, shuffle=True,\n )\n # create test_loader\n test_loader = torch.utils.data.DataLoader(test_set, batch_size=1, shuffle=False,)\n return train_loader, test_loader","def test_dataloader(self) -> torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_test, **self.dl_kwargs)","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 get_data_loaders(train_batch_size : int, val_batch_size : int) -> tuple[DataLoader, DataLoader]:\n \n data_transform = Compose([ToTensor(), ReshapeTransform((-1,))]) \n #torchvision provides datasets adapted for CNNs, so each MNIST sample is a tensor of shape (1, 28, 28) \n #representing respectively the number of channels (1, since they are greyscale images), the height in pixels (28)\n #and the width in pixels (28). But for a fully-connected network, we want to \"flatten\" this tensor into a 1D tensor \n #of size 28**2. This is accomplished by the ReshapeTransform.\n #Data offered by torchvision is already normalized in [0, 1], so no need to divide it by 255.\n \n train_loader = DataLoader(\n MNIST(download=True, root=\".\", transform=data_transform, train=True), batch_size=train_batch_size, shuffle=True\n )\n \n val_loader = DataLoader(\n MNIST(download=False, root=\".\", transform=data_transform, train=False), batch_size=val_batch_size, shuffle=False\n )\n \n return train_loader, val_loader","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_loaders(opt):\n train_samples, val_samples = get_train_val_metadata(opt.dataset_dir,\n opt.validation_cities,\n opt.patch_size,\n opt.stride)\n print('train samples : ', len(train_samples))\n print('val samples : ', len(val_samples))\n\n logging.info('STARTING Dataset Creation')\n\n full_load = full_onera_loader(opt.dataset_dir, opt)\n\n train_dataset = OneraPreloader(opt.dataset_dir,\n train_samples,\n full_load,\n opt.patch_size,\n opt.augmentation)\n val_dataset = OneraPreloader(opt.dataset_dir,\n val_samples,\n full_load,\n opt.patch_size,\n False)\n\n logging.info('STARTING Dataloading')\n\n train_loader = torch.utils.data.DataLoader(train_dataset,\n batch_size=opt.batch_size,\n shuffle=True,\n num_workers=opt.num_workers)\n val_loader = torch.utils.data.DataLoader(val_dataset,\n batch_size=opt.batch_size,\n shuffle=False,\n num_workers=opt.num_workers)\n return train_loader, val_loader","def data_loaders(dataset_path):\n dataset_path = dataset_path\n news_stock_dataset = NewsStockDataLoader(dataset_path)\n \n dataset_size = len(news_stock_dataset)\n indices = list(range(dataset_size))\n training_split = int(0.8 * dataset_size)\n validation_split = int(0.9 * dataset_size)\n\n np.random.seed(96)\n np.random.shuffle(indices)\n\n train_indices = indices[:training_split]\n valid_indices = indices[training_split:validation_split]\n test_indices = indices[validation_split:]\n\n train_sampler = SubsetRandomSampler(train_indices)\n valid_sampler = SubsetRandomSampler(valid_indices)\n test_sampler = SubsetRandomSampler(test_indices)\n \n collate = PadSequence()\n\n training_loader = DataLoader(news_stock_dataset,\n num_workers = 1,\n batch_size = Config.get(\"training_batch_size\"),\n sampler = train_sampler,\n collate_fn = collate)\n\n validation_loader = DataLoader(news_stock_dataset,\n num_workers = 1,\n batch_size = Config.get(\"validation_batch_size\"),\n sampler = valid_sampler,\n collate_fn = collate)\n\n testing_loader = DataLoader(news_stock_dataset,\n num_workers = 1,\n batch_size = Config.get(\"testing_batch_size\"),\n sampler= test_sampler,\n collate_fn = collate)\n \n return training_loader, validation_loader, testing_loader","def get_loaders(train_dataset, val_dataset, test_dataset, batch_size=128):\n train_loader = DataLoader(train_dataset, batch_size=batch_size, num_workers=8,\n shuffle=True)\n\n val_loader = DataLoader(val_dataset, batch_size=batch_size, num_workers=8,\n shuffle=False)\n\n test_loader = DataLoader(test_dataset, batch_size=batch_size, num_workers=8,\n shuffle=False)\n\n return train_loader, val_loader, test_loader","def DataLoader(data_place):\n # Nd = []\n # Np = []\n # Nz = []\n # channel_num = []\n # images = []\n # id_labels = []\n # pose_labels = []\n\n # mycase\n # Nz = 50\n # channel_num = 3\n # images = np.load('{}/images.npy'.format(data_place))\n # id_labels = np.load('{}/ids.npy'.format(data_place))\n # pose_labels = np.load('{}/yaws.npy'.format(data_place))\n #\n # Np = int(pose_labels.max() + 1)\n # Nd = int(id_labels.max() + 1)\n #\n # return [images, id_labels, pose_labels, Nd, Np, Nz, channel_num]\n\n # mycase MultiPIE\n Nz = 50\n channel_num = 3\n image_attributes_df = pd.read_csv(data_place)\n\n Nd = int(np.max(image_attributes_df['Id'])+1)\n Np = int(np.max(image_attributes_df['pose'])+1)\n Ni = int(np.max(image_attributes_df['illum'])+1)\n\n return [image_attributes_df, Nd, Np, Ni, Nz, channel_num]","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 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 get_loader(sentences, conversation_length, sentence_length, vocab, batch_size=100, data=None, shuffle=True):\n\n def collate_fn(data):\n \"\"\"\n Collate list of data in to batch\n\n Args:\n data: list of tuple(source, target, conversation_length, source_length, target_length)\n Return:\n Batch of each feature\n - source (LongTensor): [batch_size, max_conversation_length, max_source_length]\n - target (LongTensor): [batch_size, max_conversation_length, max_source_length]\n - conversation_length (np.array): [batch_size]\n - source_length (LongTensor): [batch_size, max_conversation_length]\n \"\"\"\n # Sort by conversation length (descending order) to use 'pack_padded_sequence'\n data.sort(key=lambda x: x[1], reverse=True)\n\n # Separate\n sentences, conversation_length, sentence_length = zip(*data)\n\n # return sentences, conversation_length, sentence_length.tolist()\n return sentences, conversation_length, sentence_length\n\n dataset = DialogDataset(sentences, conversation_length,\n sentence_length, vocab, data=data)\n\n data_loader = DataLoader(\n dataset=dataset,\n batch_size=batch_size,\n shuffle=shuffle,\n collate_fn=collate_fn)\n\n return data_loader","def load_data(self):\n params = self.params\n catg = params.data_category\n langs = ['en', params.target_lang]\n data = {lang: {splt: {} for splt in (['train', 'valid'] if lang == 'en' else ['test'])} for lang in langs}\n clf_dataset_path = {\n lang: {\n splt: {\n 'x': os.path.join(params.data_path, '%s_%s_%s_x.bpe.pth' % (splt, lang, catg)),\n 'y': os.path.join(params.data_path, '%s_%s_%s_y.txt' % (splt, lang, catg)),\n } for splt in (['train', 'valid'] if lang == 'en' else ['test'])\n } for lang in langs\n }\n for splt in ['train', 'valid', 'test']:\n for lang in langs:\n if lang == 'en' and splt in ['train', 'valid'] or lang != 'en' and splt == 'test':\n # load data and dictionary\n data1 = load_binarized(clf_dataset_path[lang][splt]['x'], params)\n data['dico'] = data.get('dico', data1['dico'])\n # set dictionary parameters\n set_dico_parameters(params, data, data1['dico'])\n # create dataset\n data[lang][splt]['x'] = Dataset(data1['sentences'], data1['positions'], params)\n # load labels\n with open(clf_dataset_path[lang][splt]['y'], 'r') as f:\n labels = [int(l) for l in f]\n data[lang][splt]['y'] = torch.LongTensor(labels)\n assert len(data[lang][splt]['x']) == len(data[lang][splt]['y'])\n\n return data","def get_loader(config):\n train_transform = [T.Resize((256, 128)), T.RandomHorizontalFlip(), T.ToTensor(),\n T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])]\n train_transform = T.Compose(train_transform)\n\n test_transform = [T.Resize((256, 128)), T.ToTensor(),\n T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])]\n test_transform = T.Compose(test_transform)\n\n # Datasets.\n if config.source_dataset in ['duke'] and config.target_dataset in ['market']:\n source_image_dir = config.duke_image_dir\n target_image_dir = config.market_image_dir\n elif config.source_dataset in ['market'] and config.target_dataset in ['duke']:\n source_image_dir = config.market_image_dir\n target_image_dir = config.duke_image_dir\n else:\n assert 'Dataset not support!'\n source_set = ReidDataset(source_image_dir, train_transform)\n target_set = ReidDataset(target_image_dir, train_transform, config.expanding_cam)\n test_set = ReidDataset(source_image_dir, test_transform)\n\n # Dataloader.\n source_loader = data.DataLoader(dataset=source_set, batch_size=config.batch_size,\n num_workers=config.num_workers, shuffle=True, pin_memory=True, drop_last=True)\n\n target_loader = data.DataLoader(dataset=target_set, batch_size=config.batch_size,\n num_workers=config.num_workers, shuffle=True, pin_memory=True, drop_last=True)\n\n test_loader = data.DataLoader(dataset=test_set, batch_size=config.batch_size, num_workers=config.num_workers,\n shuffle=False, pin_memory=True, drop_last=False)\n\n return {'source_loader': source_loader, 'target_loader': target_loader, 'test_loader': test_loader}","def load_dataset(data_dir='flowers'):\n train_dir = data_dir + '/train'\n valid_dir = data_dir + '/valid'\n test_dir = data_dir + '/test'\n \n # Apply transformations on training set, leave alone validation and testing sets:\n data_transforms = {\n \"training\" : transforms.Compose([transforms.RandomRotation(30),\n transforms.RandomResizedCrop(224),\n transforms.RandomHorizontalFlip(),\n transforms.RandomVerticalFlip(),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406],\n [0.229, 0.224, 0.225])]),\n # For validation and tesing sets, since they are the \"unseen\" data that used to measure the model performance, so they should not be applied by any transformations, however, resizing is stil needed.\n \"validation\" : transforms.Compose([transforms.Resize(256),\n transforms.CenterCrop(224),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406],\n [0.229, 0.224, 0.225])]),\n \"testing\" : transforms.Compose([transforms.Resize(256),\n transforms.CenterCrop(224),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406],\n [0.229, 0.224, 0.225])])\n }\n \n # Load datasets with ImageFolder:\n image_datasets = {\n \"training\" : datasets.ImageFolder(train_dir, transform = data_transforms[\"training\"]),\n \"validation\" : datasets.ImageFolder(valid_dir, transform = data_transforms[\"validation\"]),\n \"testing\" : datasets.ImageFolder(test_dir, transform = data_transforms[\"testing\"])\n }\n \n # Using the image datasets and the trainforms, define the dataloaders: \n dataloaders = {\n \"training\" : torch.utils.data.DataLoader(image_datasets[\"training\"], batch_size = 64, shuffle = True),\n \"validation\" : torch.utils.data.DataLoader(image_datasets[\"validation\"], batch_size = 64),\n \"testing\" : torch.utils.data.DataLoader(image_datasets[\"testing\"], batch_size = 64)\n }\n \n return (dataloaders['training'],\n dataloaders['validation'],\n dataloaders['testing'],\n image_datasets['training'],\n image_datasets['validation'],\n image_datasets['testing'])","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 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 val_dataloader(self) -> torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_valid, **self.dl_kwargs)","def get_driving_data_loaders(batch_size, train_dataset, valid_dataset, test_dataset, num_workers=0): \n\n valid_loader = DataLoader(dataset=valid_dataset,\n batch_size=batch_size,\n num_workers=num_workers,\n shuffle=True)\n\n train_loader = DataLoader(dataset=train_dataset,\n batch_size=batch_size,\n num_workers=num_workers,\n drop_last=True, \n shuffle=True)\n\n test_loader = DataLoader(dataset=test_dataset,\n batch_size=batch_size,\n num_workers=num_workers,\n shuffle=False)\n\n return train_loader, valid_loader, test_loader","def get_faces_loaders(batch_size=128, test=True, data_path=\"./data/\"):\n\n dat = np.load(data_path + \"rotated_faces_data.npz\")\n train_images = torch.FloatTensor(dat['train_images'])\n train_targets = torch.FloatTensor(dat['train_angles'])\n\n traindata = torch.utils.data.TensorDataset(train_images, train_targets)\n trainloader = torch.utils.data.DataLoader(traindata, batch_size=batch_size,\n shuffle=True)\n\n if test:\n test_images = torch.FloatTensor(dat['test_images'])\n test_targets = torch.FloatTensor(dat['test_angles'])\n\n testdata = torch.utils.data.TensorDataset(test_images, test_targets)\n testloader = torch.utils.data.DataLoader(testdata, batch_size=batch_size)\n\n return trainloader, testloader\n\n return trainloader","def dataloader(self):\n return DataLoader","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 load_data(dataset, root, batch_size, workers):\n # Data transform\n normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225])\n train_transform = transforms.Compose([\n transforms.RandomResizedCrop(224),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n normalize,\n ])\n query_transform = transforms.Compose([\n transforms.Resize(256),\n transforms.CenterCrop(224),\n transforms.ToTensor(),\n normalize,\n ])\n\n # Construct data loader\n index = dataset.index(\"IF\")\n sub = dataset[index:]\n if sub == 'IF100':\n train_dir = os.path.join(root, 'train-IF100')\n elif sub == 'IF50':\n train_dir = os.path.join(root, 'train-IF50')\n elif sub == 'IF20':\n train_dir = os.path.join(root, 'train-IF20')\n elif sub == 'IF10':\n train_dir = os.path.join(root, 'train-IF10')\n elif sub == 'IF1':\n train_dir = os.path.join(root, 'train-IF1')\n else:\n print('train path error')\n return\n # train_dir = os.path.join(root, 'train')\n query_dir = os.path.join(root, 'query')\n database_dir = os.path.join(root, 'database')\n\n train_dataset = ImagenetDataset(\n train_dir,\n transform=train_transform,\n targets_transform=Onehot(100),\n )\n\n train_dataloader = DataLoader(\n train_dataset,\n batch_size=batch_size,\n shuffle=True,\n num_workers=workers,\n pin_memory=True,\n )\n\n query_dataset = ImagenetDataset(\n query_dir,\n transform=query_transform,\n targets_transform=Onehot(100),\n )\n\n query_dataloader = DataLoader(\n query_dataset,\n batch_size=batch_size,\n num_workers=workers,\n pin_memory=True,\n )\n\n database_dataset = ImagenetDataset(\n database_dir,\n transform=query_transform,\n targets_transform=Onehot(100),\n )\n\n database_dataloader = DataLoader(\n database_dataset,\n batch_size=batch_size,\n num_workers=workers,\n pin_memory=True,\n )\n\n return train_dataloader, query_dataloader, database_dataloader","def get_train_test_loaders(self, num_workers=2):\n print('Loading the image data...')\n \n train_path_info, test_path_info = self.get_train_test_info()\n\n train_transform = transforms.Compose([transforms.Resize((self.image_width, self.image_height)),\n transforms.RandomAffine(10,translate=(0.1,0.1)),\n transforms.ToTensor()])\n\n test_transform = transforms.Compose([transforms.Resize((self.image_width, self.image_height)),\n transforms.ToTensor()])\n\n trainset = PocovidDataset(train_path_info, transform = train_transform)\n testset = PocovidDataset(test_path_info, transform = test_transform)\n \n self.class_map = trainset.get_class_map()\n self.classes = [self.class_map[key] for key in sorted(self.class_map)]\n\n train_loader = torch.utils.data.DataLoader(trainset, num_workers=num_workers, shuffle=True,\n batch_size=self.batch_size, drop_last=True)\n\n test_loader = torch.utils.data.DataLoader(testset, num_workers=num_workers, shuffle=True,\n batch_size=self.batch_size)\n \n print('Image data is loaded with fold {} as the test data'.format(self.fold))\n print('Number of training images:', len(trainset))\n print('Number of testing images:', len(testset))\n print('*'*100)\n print('The classes are:', self.classes)\n print('*'*100)\n \n return train_loader, test_loader","def to_dataloader(texts, extras, ys,\n tokenizer,\n max_seq_length,\n batch_size,\n dataset_cls=TensorDataset,\n sampler_cls=RandomSampler):\n #train_y = train_df[labels].values\n\n # Labels\n train_y_tensor = torch.tensor(ys).float()\n\n if texts is not None and extras is not None:\n # All features\n train_tokens_tensor, train_masks_tensor = text_to_train_tensors(texts, tokenizer, max_seq_length)\n train_extras_tensor = torch.tensor(extras, dtype=torch.float)\n\n train_dataset = dataset_cls(train_tokens_tensor, train_masks_tensor, train_extras_tensor, train_y_tensor)\n elif texts is not None and extras is None:\n # Text only\n train_tokens_tensor, train_masks_tensor = text_to_train_tensors(texts, tokenizer, max_seq_length)\n train_dataset = dataset_cls(train_tokens_tensor, train_masks_tensor, train_y_tensor)\n elif texts is None and extras is not None:\n\n train_extras_tensor = torch.tensor(extras, dtype=torch.float)\n train_dataset = dataset_cls(train_extras_tensor, train_y_tensor)\n else:\n raise ValueError('Either texts or extra must be set.')\n\n train_sampler = sampler_cls(train_dataset)\n \n return DataLoader(train_dataset, sampler=train_sampler, batch_size=batch_size)","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 __init__(self, **kwargs):\n DataLoader.__init__(self, **kwargs)\n \n self._results_ = None","def train_test_loaders(dataset, validation_ratio=0.2, **kwargs):\n dataset_size = len(dataset)\n test_size = int(np.floor(validation_ratio * dataset_size))\n train_size = dataset_size - test_size\n print('TRAIN SIZE {}'.format(train_size))\n print('TEST SIZE {}'.format(test_size))\n train_dataset, test_dataset = random_split(dataset, (train_size, test_size),\n generator=torch.Generator().manual_seed(RANDOM_SEED))\n train_loader = torch.utils.data.DataLoader(train_dataset, **kwargs)\n test_loader = torch.utils.data.DataLoader(test_dataset, **kwargs)\n return train_loader, test_loader","def get_data_loader(\n name: str, **kwargs) -> data_loader.DataLoader:\n\n if name == \"synthetic_images\":\n logging.info(\"Creating synthetic image data loader.\")\n return synthetic_image.SyntheticImageDataLoader(**kwargs)\n elif name == \"synthetic_bert\":\n logging.info(\"Creating synthetic bert data loader.\")\n return synthetic_bert.SyntheticBertLoader(**kwargs)\n elif name == \"squad_bert\":\n logging.info(\"Creating SQuAD 1.1 bert data loader.\")\n return squad_bert.SquadBertLoader(**kwargs)\n elif name == \"sentiment_bert\":\n logging.info(\"Creating IMDB sentiment analysis data loader.\")\n return generic_jsonl.GenericJsonlLoader(**kwargs)\n elif name == \"criteo\":\n logging.info(\"Creating Criteo data loader.\")\n return criteo.CriteoLoader(**kwargs)\n elif name == \"generic_jsonl\":\n logging.info(\"Creating generic jsonl file data loader.\")\n return generic_jsonl.GenericJsonlLoader(**kwargs)\n else:\n raise ValueError(\"Unsupported data loader type.\")","def load_data(path):\n # Training Images Details\n IMG_SIZE = 224 # Size of images used for training\n IMG_MEAN = [0.485, 0.456, 0.406] # image normalization mean\n IMG_SDEV = [0.229, 0.224, 0.225] # image normalization standard deviation\n\n # Training phases\n phases = ['train', 'valid', 'test']\n\n # Define data locations\n data_dir = {n: path + n for n in phases}\n\n # Define transforms for the training, validation, and testing sets\n data_transforms = {\n 'train':\n transforms.Compose([\n transforms.RandomRotation(30),\n transforms.RandomResizedCrop(IMG_SIZE),\n transforms.RandomHorizontalFlip(p=0.5),\n transforms.ToTensor(),\n transforms.Normalize(IMG_MEAN, IMG_SDEV)]),\n 'valid':\n transforms.Compose([\n transforms.Resize(256),\n transforms.CenterCrop(IMG_SIZE),\n transforms.ToTensor(),\n transforms.Normalize(IMG_MEAN, IMG_SDEV)]),\n 'test':\n transforms.Compose([\n transforms.Resize(256),\n transforms.CenterCrop(IMG_SIZE),\n transforms.ToTensor(),\n transforms.Normalize(IMG_MEAN, IMG_SDEV)])\n }\n\n # Load the datasets\n image_datasets = {n: datasets.ImageFolder(\n data_dir[n], transform=data_transforms[n])\n for n in phases}\n\n # Create the PyTorch dataloaders\n dataloaders = {n: torch.utils.data.DataLoader(\n image_datasets[n], batch_size=64, shuffle=True)\n for n in phases}\n\n # mapping of classes to training indices\n class_to_idx = image_datasets['train'].class_to_idx\n\n return dataloaders, class_to_idx","def _prepare_data(self, examples, labels):\n\n if self.to_tensor:\n examples = torch.Tensor(examples)\n labels = torch.Tensor(labels)\n\n if self.use_gpu:\n examples = examples.cuda()\n labels = labels.cuda()\n\n return (examples, labels)","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_batch_data(train_loader, device, unlabelled_data, batch_size):\n labelled_data, labelled_target = next(iter(train_loader))\n labelled_target = labelled_target[3]\n unlabelled_data = unlabelled_data.to(device)\n labelled_target = labelled_target.to(device=device, dtype=torch.int64)\n labelled_data = labelled_data.to(device)\n labelled_target = labelled_target.squeeze()\n # print(\"labelled_target\", labelled_target.shape)\n\n labelled_data = labelled_data.view(batch_size, 1, 3750)\n unlabelled_data = unlabelled_data.view(batch_size, 1, 3750)\n\n labelled_data = pp.Preprocessor().forward(labelled_data)\n unlabelled_data = pp.Preprocessor().forward(unlabelled_data)\n\n labelled_data = labelled_data.view(batch_size, 1, 3750)\n unlabelled_data = unlabelled_data.view(batch_size, 1, 3750)\n\n return labelled_data, labelled_target, unlabelled_data","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 get_data_loaders(img_dir, img_height, img_width, batch_size=8):\n total_count = sum([len(files) for r, d, files in os.walk(img_dir)])\n\n data_transform = torchvision.transforms.Compose(\n [\n transforms.Resize((img_height, img_width)),\n transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n ]\n )\n \n # build a dataset of images from the img_dir directory\n im_folder = torchvision.datasets.ImageFolder(img_dir, transform=data_transform)\n model_dataset = td.datasets.WrapDataset(im_folder)\n\n dataset_loader = torch.utils.data.DataLoader(model_dataset, batch_size=batch_size)\n\n return dataset_loader, total_count","def load_data(data_dir):\n train_dir = data_dir + '/train'\n valid_dir = data_dir + '/valid'\n test_dir = data_dir + '/test'\n \n for directory in [train_dir, valid_dir, test_dir]:\n if not os.path.isdir(directory):\n raise IOError(\"Directory \" + directory + \" does not exist\")\n \n # Define transforms for the training, validation, and testing sets\n train_transforms = transforms.Compose([transforms.RandomRotation(30),\n transforms.RandomHorizontalFlip(),\n transforms.Resize(255),\n transforms.CenterCrop(224),\n transforms.ToTensor(),\n transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\n data_transforms = transforms.Compose([transforms.Resize(255),\n transforms.CenterCrop(224),\n transforms.ToTensor()])\n \n # Load the datasets with ImageFolder\n train_datasets = datasets.ImageFolder(train_dir, transform=train_transforms)\n valid_datasets = datasets.ImageFolder(valid_dir, transform=data_transforms)\n test_datasets = datasets.ImageFolder(test_dir, transform=data_transforms)\n \n # Using the image datasets and the trainforms, define the dataloaders\n trainloader = torch.utils.data.DataLoader(train_datasets, batch_size=64, shuffle=True)\n validloader = torch.utils.data.DataLoader(valid_datasets, batch_size=32, shuffle=True)\n testloader = torch.utils.data.DataLoader(test_datasets, batch_size=32, shuffle=True)\n \n return {\n 'datasets': {\n 'train': train_datasets,\n 'valid': valid_datasets,\n 'test': test_datasets\n },\n 'loader': {\n 'train': trainloader,\n 'valid': validloader,\n 'test': testloader\n }\n }","def load_test_dataset(self):\n test_data_path = \"testdata\"\n root = Path(test_data_path)\n classes = sorted([j.name.split('/')[-1] for j in root.iterdir()])\n print(classes)\n\n transform = transforms.Compose([\n transforms.Resize(300),\n transforms.RandomHorizontalFlip(),\n transforms.CenterCrop(250),\n transforms.ToTensor(),\n transforms.Normalize(mean=[0.6071, 0.4828, 0.3934], std=[0.2845, 0.3187, 0.3240])\n ])\n\n dataset = datasets.ImageFolder(test_data_path, transform=transform)\n testloader = DataLoader(dataset, batch_size=4, shuffle=True)\n print(\"Loaded data\")\n return testloader","def load_data_and_labels(self):\n gen = image.ImageDataGenerator()\n target_size = (224,224)\n if self.preprocess:\n print('Preprocessing data...')\n if not os.path.isdir(self.pproc_dir()):\n os.mkdir(self.pproc_dir())\n \n batch_arr = []\n for ld,segment in [(self.train_dir(), 'train'),\n (self.valid_dir(), 'valid')]:\n # TODO(ness): segment = os.basename(ld)\n flowgen = gen.flow_from_directory(\n ld,\n target_size=target_size,\n shuffle=False,\n class_mode=None,\n batch_size=1)\n # Save the batches using method defined in utils.py\n data = np.concatenate([flowgen.next() for i in range(flowgen.n)])\n batches_dir = self.pproc_dir() + segment + '-bc'\n save_array(batches_dir, data)\n \n # Save the classes.\n cls_dir = self.pproc_dir() + segment + '-cl'\n save_array(cls_dir, flowgen.classes)\n \n batch_arr.append((data, flowgen.classes, flowgen.class_indices))\n \n # Set the data.\n self.training_data = batch_arr[0][0]\n self.validation_data = batch_arr[1][0]\n \n # Classes are zero-indexed and represent a category in\n # numerical form. So if the classes are 'dog' and 'cat',\n # the possible class values will be 0 and 1.\n self.trn_classes = batch_arr[0][1]\n self.val_classes = batch_arr[1][1]\n \n # Labels are the one-hot encoded (i.e. categorical)\n # version of the classes. In other words, if there are\n # 5 classes and an element belongs to class 2,\n # its label will be [0,0,1,0,0] (index 1).\n self.training_labels = to_categorical(batch_arr[0][1])\n self.validation_labels = to_categorical(batch_arr[1][1])\n \n # Class indices are dictionaries of the form\n # {'category_name': 0, 'category_name_2: 1}. They\n # make the mapping between numerical class indices and\n # a human-readable category name. They are (should be...)\n # the same for validation and training, so only load them\n # once, after sanity checking.\n self.cindices = batch_arr[0][2]\n print('Done preprocessing.')\n else:\n print('Loading data...')\n # Load the pre-saved data using methods defined in utils.py. See\n # preprocessing branch for the meaning of the data.\n self.training_data = load_array(self.pproc_dir() + 'train-bc')\n self.validation_data = load_array(self.pproc_dir() + 'valid-bc')\n self.trn_classes = load_array(self.pproc_dir() + 'train-cl')\n self.val_classes = load_array(self.pproc_dir() + 'valid-cl')\n self.training_labels = to_categorical(self.trn_classes)\n self.validation_labels = to_categorical(self.val_classes)\n \n # To get the class indices, we create the generator. It's cheap to\n # run since it doesn't actually load all the data.\n flowgen = gen.flow_from_directory(\n self.train_dir(),\n target_size=target_size,\n shuffle=False,\n class_mode=None,\n batch_size=1) \n self.cindices = flowgen.class_indices\n print('Done loading.')","def 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 get_dataloader(\n path='data/interim/data.json',\n train_test_split=0.8,\n batch_size_train=5,\n batch_size_test=5,\n shuffle_train=True,\n perm_images=True,\n transform_train=True,\n transform_test=False,\n class_names=None):\n\n # use our dataset and defined transformations\n if class_names is None:\n dataset = ProdigyDataReader(path, get_transforms(train=transform_train))\n dataset_test = ProdigyDataReader(path, get_transforms(train=transform_test))\n else:\n dataset = ProdigyDataReader(path, get_transforms(train=transform_train),\n object_categories=class_names)\n dataset_test = ProdigyDataReader(path, get_transforms(train=transform_test),\n object_categories=class_names)\n\n # split the dataset in train and test set\n if perm_images:\n indices = torch.randperm(len(dataset)).tolist()\n else:\n indices = list(range(len(dataset)))\n\n len_train = int(len(indices) * train_test_split)\n dataset = torch.utils.data.Subset(dataset, indices[:len_train])\n dataset_test = torch.utils.data.Subset(dataset_test, indices[len_train:])\n\n # define training and validation data loaders\n data_loader = torch.utils.data.DataLoader(\n dataset, batch_size=batch_size_train, shuffle=shuffle_train, num_workers=0,\n collate_fn=collate_fn)\n\n data_loader_test = torch.utils.data.DataLoader(\n dataset_test, batch_size=batch_size_test, shuffle=False, num_workers=0,\n collate_fn=collate_fn)\n\n return [data_loader, data_loader_test]","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 get_dataloaders(logging, batch_size):\n # Load Data\n logging.info(\"Reading Train and Test data...\")\n train_df = pd.read_csv(\"C:/tmp/avila_classification/data/avila-tr.txt\", header=None)\n test_df = pd.read_csv(\"C:/tmp/avila_classification/data/avila-ts.txt\", header=None)\n\n # Fix column names\n col_names = ['col_' + str(j + 1) for j in range(train_df.shape[1] - 1)]\n indep_cols = col_names.copy()\n col_names.append('y')\n\n logging.debug(\"Assigning columns\")\n train_df.columns = col_names\n test_df.columns = col_names\n\n # Encode dependent variable column\n le = LabelEncoder()\n le.fit(train_df['y'])\n logging.debug(f\"Classes: {le.classes_}\")\n logging.debug(f\"Transformed Classes: {le.transform(le.classes_)}\")\n\n train_df['y_enc'] = le.transform(train_df['y'])\n test_df['y_enc'] = le.transform(test_df['y'])\n\n # train_df.head()\n logging.debug(f\"Shape of train data: {train_df.shape}\")\n logging.debug(f\"Shape of test data: {test_df.shape}\")\n\n # Create train and validation dataloaders\n train_ds = AvilaDataset(data_frame=train_df, indep_cols=indep_cols, dep_col='y_enc')\n valid_ds = AvilaDataset(data_frame=test_df, indep_cols=indep_cols, dep_col='y_enc')\n\n # Should be some exponent of 2 (128, 256)\n # batch_size = 256\n train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True)\n valid_dl = DataLoader(valid_ds, batch_size=batch_size, shuffle=False)\n\n return train_dl, valid_dl, le","def _loadTrain(self, features, labels):\n\t\tself.trainX_, self.trainY_, self.trainLabel_ = self.__load(features, labels)","def _get_data(\n self, train_dataset: TensorDataset, validation_dataset: TensorDataset\n ):\n return (\n DataLoader(train_dataset, batch_size=self.batch_size, shuffle=True),\n DataLoader(validation_dataset, batch_size=self.batch_size * 2),\n )","def prepare_dataloaders(data,\n seq_len,\n batch_size=64,\n validation_set=False,\n validation_size=0.1,\n random_seed=42):\n vocab = set(data)\n token2id = {k: v for v, k in enumerate(vocab)}\n id2token = {k: v for v, k in token2id.items()}\n data_range = range(0, len(data) - seq_len, seq_len)\n\n data = [token2id[t] for t in data]\n data = np.array([data[i:i + seq_len] for i in data_range])\n tensor_data = torch.from_numpy(data)\n\n if validation_set:\n np.random.seed(random_seed)\n idx = np.random.choice(\n range(len(tensor_data)), size=len(tensor_data), replace=False)\n split = int(len(idx) * (1 - validation_size))\n train_idx = idx[:split]\n valid_idx = idx[split:]\n\n train_data = TensorDataset(torch.LongTensor(tensor_data[train_idx]))\n valid_data = TensorDataset(torch.LongTensor(tensor_data[valid_idx]))\n\n train_loader = DataLoader(\n train_data, shuffle=True, batch_size=batch_size)\n valid_loader = DataLoader(\n valid_data, shuffle=True, batch_size=batch_size)\n\n return train_loader, valid_loader, vocab, token2id, id2token\n else:\n train_data = TensorDataset(torch.LongTensor(tensor_data))\n train_loader = DataLoader(\n train_data, shuffle=True, batch_size=batch_size)\n return train_loader, vocab, token2id, id2token","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 get_train_loader(batch_size, train_set, train_sampler):\n train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, sampler=train_sampler, num_workers=4)\n\n return train_loader","def init_loaders_predict(self, data_dict, label_dict):\n return self.init_loaders(data_dict, label_dict)","def get_loader(data_list, config, train=True):\n \n with open(config[\"label_map\"], \"r\") as f:\n label_map = json.load(f)\n\n dataset = GoogleSpeechDataset(\n data_list=data_list,\n label_map=label_map,\n audio_settings=config[\"hparams\"][\"audio\"],\n aug_settings=config[\"hparams\"][\"augment\"] if train else None,\n cache=config[\"exp\"][\"cache\"]\n )\n\n dataloader = DataLoader(\n dataset,\n batch_size=config[\"hparams\"][\"batch_size\"],\n num_workers=config[\"exp\"][\"n_workers\"],\n pin_memory=config[\"exp\"][\"pin_memory\"],\n shuffle=True if train else False\n )\n\n return dataloader","def get_dataloaders(data_dir, hyp):\n \n # Grab data, targets\n data_file_paths, targets = get_files_paths_and_labels(data_dir)\n \n # Split into train/validation\n train_data, val_data, train_labels, val_labels = train_test_split(data_file_paths,\n targets,\n train_size=hyp['perc_train'],\n shuffle=hyp['shuffle'],\n stratify=targets)\n\n # Create train/validation augmentation handler\n train_aug = get_training_augmentations(hyp)\n val_aug = get_validation_augmentations(hyp)\n \n # Create datasets\n train_dset = SETIDataset(train_data, train_labels, transform=train_aug)\n val_dset = SETIDataset(val_data, val_labels, transform=val_aug)\n \n # Create dataloaders\n train_loader = DataLoader(train_dset, shuffle=True, batch_size=hyp['batch_size'], \n pin_memory=True, num_workers=8)\n \n val_loader = DataLoader(val_dset, batch_size=hyp['batch_size'], \n pin_memory=True, num_workers=8)\n \n return train_loader, val_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_loader(self):\n # load data to memory.\n if self.is_cifar100:\n (x_train, y_train), (x_test,\n y_test) = tf.keras.datasets.cifar100.load_data()\n else:\n (x_train, y_train), (x_test,\n y_test) = tf.keras.datasets.cifar10.load_data()\n\n y_train = y_train.astype(np.int32)\n y_test = y_test.astype(np.int32)\n\n x_train, y_train = shuffle_dataset(x_train, y_train)\n n_probe = int(math.floor(x_train.shape[0] * FLAGS.probe_dataset_hold_ratio))\n\n # TODO(zizhaoz): add other noise types.\n if 'asymmetric' in self.dataset_name:\n assert 'cifar100' not in self.dataset_name, 'Asymmetric only has CIFAR10'\n (x_train, y_train, y_gold), (x_probe, y_probe) = load_asymmetric(\n x_train,\n y_train,\n noise_ratio=self.noise_ratio,\n n_val=n_probe,\n random_seed=FLAGS.seed)\n elif 'uniform' in self.dataset_name:\n (x_train, y_train, y_gold), (x_probe,\n y_probe) = load_train_val_uniform_noise(\n x_train,\n y_train,\n n_classes=self.num_classes,\n noise_ratio=self.noise_ratio,\n n_val=n_probe)\n else:\n assert self.dataset_name in ['cifar10', 'cifar100']\n\n if not self.split_probe and x_probe is not None:\n # Usually used for supervised comparison.\n tf.logging.info('Merge train and probe')\n x_train = np.concatenate([x_train, x_probe], axis=0)\n y_train = np.concatenate([y_train, y_probe], axis=0)\n y_gold = np.concatenate([y_gold, y_probe], axis=0)\n\n conf_mat = sklearn_metrics.confusion_matrix(y_gold, y_train)\n conf_mat = conf_mat / np.sum(conf_mat, axis=1, keepdims=True)\n tf.logging.info('Corrupted confusion matirx\\n {}'.format(conf_mat))\n x_test, y_test = shuffle_dataset(x_test, y_test)\n self.train_dataset_size = x_train.shape[0]\n self.val_dataset_size = x_test.shape[0]\n if self.split_probe:\n self.probe_size = x_probe.shape[0]\n\n input_tuple = (x_train, y_train.squeeze())\n self.train_dataflow = self.create_ds(input_tuple, is_train=True)\n self.val_dataflow = self.create_ds((x_test, y_test.squeeze()),\n is_train=False)\n if self.split_probe:\n self.probe_dataflow = self.create_ds((x_probe, y_probe.squeeze()),\n is_train=True)\n\n tf.logging.info('Init [{}] dataset loader'.format(self.dataset_name))\n verbose_data('train', x_train, y_train)\n verbose_data('test', x_test, y_test)\n if self.split_probe:\n verbose_data('probe', x_probe, y_probe)\n\n return self","def load_mnist(data_filename, batch_size):\n\n train_data, valid_data, test_data = unpickle_mnist(data_filename)\n\n train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)\n valid_loader = DataLoader(valid_data, batch_size=batch_size, shuffle=True)\n test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=True)\n\n return train_loader, valid_loader, test_loader","def load_data(batch_size=batch_size):\n trainset = LibriSpeechDataset(training_set, int(LIBRISPEECH_SAMPLING_RATE * n_seconds))\n testset = LibriSpeechDataset(validation_set, int(LIBRISPEECH_SAMPLING_RATE * n_seconds), stochastic=False)\n\n train_loader = DataLoader(trainset, batch_size=batch_size, num_workers=1, shuffle=True, drop_last=True)\n test_loader = DataLoader(testset, batch_size=1, num_workers=1, drop_last=True)\n\n return train_loader, test_loader","def get_test_loader(id_list = './data/sample_submission.csv', root_dir = './data/test/'):\n data = HumanProteinDataset(id_list, root_dir, transform = transforms.Compose([\n Rescale((256, 256)), \n ToTensor()\n ]))\n\n indices = np.arange(len(data))\n dataloader_test = DataLoader(data, batch_size=10, num_workers=5)\n\n return dataloader_test","def test_dataloader(self) -> DataLoader:\n return self._custom_data_loader()","def get_data_loader(image_type, image_dir, \n image_size=128, batch_size=16, num_workers=0):\n \n # resize and normalize the images\n transform = transforms.Compose([transforms.Resize(image_size), # resize to 128x128\n transforms.ToTensor()])\n\n # get training and test directories\n image_path = './' + image_dir\n train_path = os.path.join(image_path, image_type)\n test_path = os.path.join(image_path, 'test_{}'.format(image_type))\n\n # define datasets using ImageFolder\n train_dataset = datasets.ImageFolder(train_path, transform)\n test_dataset = datasets.ImageFolder(test_path, transform)\n\n # create and return DataLoaders\n train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers)\n test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers)\n\n return train_loader, test_loader","def make_loader(model, dataset, batch_size, workers, eval_proportion):\n dataset_extra_args = dict(\n num_frames=model['num_frames'],\n channels=model['input_type'],\n action_space=model['action_space'],\n steps_action=model['steps_action'],\n num_signals=model['num_signals'],\n num_skills=model['num_skills'])\n if model['mode'] == 'regression':\n dataset_class = RegressionDataset\n else:\n dataset_class = ImitationDataset\n\n im_dataset = dataset_class(**dataset, **dataset_extra_args)\n train_dataset, eval_dataset = split_dataset(im_dataset, eval_proportion)\n train_loader = torch.utils.data.DataLoader(\n train_dataset,\n batch_size,\n num_workers=workers,\n shuffle=True,\n drop_last=False)\n if eval_dataset is not None:\n eval_loader = torch.utils.data.DataLoader(\n eval_dataset,\n batch_size,\n num_workers=workers,\n shuffle=True,\n drop_last=False)\n else:\n eval_loader = None\n\n env_name = im_dataset._frames.infos['env_name']\n return (train_loader, eval_loader, env_name, im_dataset.get_statistics())","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_train_loaders(config):\n assert 'loaders' in config, 'Could not find data loaders configuration'\n loaders_config = config['loaders']\n\n logger.info('Creating training and validation set loaders...')\n\n # get dataset class\n dataset_cls_str = loaders_config.get('dataset', None)\n if dataset_cls_str is None:\n dataset_cls_str = 'StandardHDF5Dataset'\n logger.warning(f\"Cannot find dataset class in the config. Using default '{dataset_cls_str}'.\")\n dataset_class = _loader_classes(dataset_cls_str)\n\n assert set(loaders_config['train']['file_paths']).isdisjoint(loaders_config['val']['file_paths']), \\\n \"Train and validation 'file_paths' overlap. One cannot use validation data for training!\"\n\n train_datasets = dataset_class.create_datasets(loaders_config, phase='train')\n\n val_datasets = dataset_class.create_datasets(loaders_config, phase='val')\n\n num_workers = loaders_config.get('num_workers', 1)\n logger.info(f'Number of workers for train/val dataloader: {num_workers}')\n batch_size = loaders_config.get('batch_size', 1)\n if torch.cuda.device_count() > 1 and not config['device'] == 'cpu':\n logger.info(\n f'{torch.cuda.device_count()} GPUs available. Using batch_size = {torch.cuda.device_count()} * {batch_size}')\n batch_size = batch_size * torch.cuda.device_count()\n\n logger.info(f'Batch size for train/val loader: {batch_size}')\n # when training with volumetric data use batch_size of 1 due to GPU memory constraints\n return {\n 'train': DataLoader(ConcatDataset(train_datasets), batch_size=batch_size, shuffle=True, pin_memory=True,\n num_workers=num_workers),\n # don't shuffle during validation: useful when showing how predictions for a given batch get better over time\n 'val': DataLoader(ConcatDataset(val_datasets), batch_size=batch_size, shuffle=False, pin_memory=True,\n num_workers=num_workers)\n }"],"string":"[\n \"def dataloaders():\\n # train data path\\n data_train = '../dataset/train/'\\n # set transformations\\n train_transforms = transforms.Compose([\\n transforms.Resize((224, 224)),\\n transforms.ToTensor(),\\n transforms.Normalize([0.485, 0.456, 0.406],\\n [0.229, 0.224, 0.225])])\\n \\n train_data = datasets.ImageFolder(data_train, transform = train_transforms)\\n trainloader = torch.utils.data.DataLoader(train_data, batch_size = 16, shuffle = True)\\n \\n return trainloader\",\n \"def train_dataloader(self) -> torch.utils.data.DataLoader: \\n return torch.utils.data.DataLoader(self.dataset_train, **self.dl_kwargs)\",\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 prepare_data(self,d):\\n train_loaders, train_iters = {}, {}\\n unlabeled_loaders, unlabeled_iters = {}, {}\\n for domain in opt.domains:\\n #CONVERT TO FLOAT32\\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape((-1,1))\\n train = data_utils.TensorDataset(features,target)\\n train_loaders[domain] = DataLoader(train, opt.batch_size, shuffle = True)\\n train_iters[domain] = iter(train_loaders[domain])\\n for domain in opt.unlabeled_domains:\\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape(-1,1))\\n uset = data_utils.TensorDataset(features,target)\\n unlabeled_loaders[domain] = DataLoader(uset,opt.batch_size, shuffle = True)\\n unlabeled_iters[domain] = iter(unlabeled_loaders[domain])\\n \\n return train_loaders, train_iters, unlabeled_loaders, unlabeled_iters\",\n \"def to_DataLoader(self, **kwargs):\\r\\n return DataLoader(self, **kwargs)\",\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_torch_data(load_data_func):\\n\\n def torch_loader(dataset, data_path, batch_size, shuffle=True, cuda_device=None, num_workers=1):\\n (train_data, val_data), (train_labels, val_labels), label_names = load_data_func(dataset, data_path)\\n\\n kwargs = {'num_workers': num_workers, 'pin_memory': True} if cuda_device is not None else {}\\n kwargs['drop_last'] = True\\n\\n if type(train_data) == numpy.ndarray:\\n train_dataset = TensorDataset(torch.from_numpy(train_data), torch.from_numpy(train_labels))\\n val_dataset = TensorDataset(torch.from_numpy(val_data), torch.from_numpy(val_labels))\\n elif type(train_data) == scipy.sparse.csr.csr_matrix:\\n from sklearn.feature_extraction.text import TfidfTransformer\\n tfidf_trans = TfidfTransformer(norm=None)\\n tfidf_trans.fit(train_data)\\n train_dataset = SparseDataset(train_data, tfidf_trans.idf_)\\n val_dataset = SparseDataset(val_data, tfidf_trans.idf_)\\n else:\\n train_dataset = torchvision.datasets.ImageFolder(train_data)\\n val_dataset = torchvision.datasets.ImageFolder(val_data)\\n\\n train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, **kwargs)\\n val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, **kwargs)\\n\\n return train_loader, val_loader, label_names\\n\\n return torch_loader\",\n \"def get_data_loaders(args, tokenizer):\\n personachat = get_dataset(tokenizer, args.dataset_path, args.dataset_cache, args.train_lang)\\n _ = personachat.pop(\\\"test\\\", None)\\n logger.info(\\\"Build inputs and labels\\\")\\n datasets = {\\\"train\\\": [], \\\"valid\\\": []}\\n\\n if args.train_lang in [\\\"En\\\", \\\"Fr\\\", \\\"It\\\", \\\"Id\\\", \\\"Jp\\\", \\\"Ko\\\", \\\"Zh\\\"]: #monolingual data\\n for dataset_name, dataset in personachat.items():\\n for dial in dataset[args.train_lang]: #dial: {\\\"persona\\\":[], \\\"history\\\":[], \\\"response\\\":str}\\n instance = build_input_from_segments(dial[\\\"persona\\\"], dial[\\\"history\\\"][-args.max_turns:], dial[\\\"response\\\"], tokenizer, lm_labels = True)\\n datasets[dataset_name].append(instance) \\n else: #multilingual data\\n for dataset_name, dataset in personachat.items():\\n for lang, dials in dataset.items():\\n for dial in dials: #dial: {\\\"persona\\\":[], \\\"history\\\":[], \\\"response\\\":str}\\n instance = build_input_from_segments(dial[\\\"persona\\\"], dial[\\\"history\\\"][-args.max_turns:], dial[\\\"response\\\"], tokenizer, lang_id=\\\"<{}>\\\".format(lang.lower()), lm_labels = True)\\n datasets[dataset_name].append(instance) #all langs together\\n\\n\\n logger.info(\\\"Build train and validation dataloaders\\\")\\n train_dataset = DatasetTrain(datasets[\\\"train\\\"])\\n valid_dataset = DatasetTrain(datasets[\\\"valid\\\"])\\n\\n #logger.info(\\\"Build train and validation dataloaders\\\")\\n #train_dataset, valid_dataset = TensorDataset(*tensor_datasets[\\\"train\\\"]), TensorDataset(*tensor_datasets[\\\"valid\\\"])\\n train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) if args.distributed else None\\n valid_sampler = torch.utils.data.distributed.DistributedSampler(valid_dataset) if args.distributed else None\\n train_loader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.train_batch_size, shuffle=(not args.distributed), collate_fn=collate_fn)\\n valid_loader = DataLoader(valid_dataset, sampler=valid_sampler, batch_size=args.valid_batch_size, shuffle=False, collate_fn=collate_fn)\\n\\n # logger.info(\\\"Train dataset (Batch, Candidates, Seq length): {}\\\".format(train_dataset.tensors[0].shape))\\n # #logger.info(\\\"Train dataset (Batch, Candidates, Seq length): {}\\\".format(train_dataset.tensors[1].shape))\\n # logger.info(\\\"Valid dataset (Batch, Candidates, Seq length): {}\\\".format(valid_dataset.tensors[0].shape))\\n logger.info(\\\"Train dataset length: {}\\\".format(len(train_dataset)))\\n logger.info(\\\"Valid dataset length: {}\\\".format(len(valid_dataset)))\\n return train_loader, valid_loader, train_sampler, valid_sampler\",\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 data_loaders(args):\\n\\n transform = transforms.Compose([\\n transforms.Resize(64),\\n transforms.ToTensor(),\\n lambda image: (image - 0.5) * 2\\n ])\\n\\n train_mnist = datasets.MNIST(\\n root=args.database_root,\\n train=True,\\n download=True,\\n transform=transform\\n )\\n train_loader = DataLoader(\\n dataset=train_mnist,\\n batch_size=args.train_batch_size,\\n shuffle=True,\\n num_workers=1,\\n pin_memory=True\\n )\\n\\n test_mnist = datasets.MNIST(\\n root=args.database_root,\\n train=False,\\n download=True,\\n transform=transform\\n )\\n test_loader = DataLoader(\\n dataset=test_mnist,\\n batch_size=args.test_batch_size,\\n shuffle=True,\\n num_workers=1,\\n pin_memory=True\\n )\\n\\n return train_loader, test_loader\",\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 loadData(self):\\n batch_size = 256\\n \\n #if self.conv_sg == True:\\n # batch_size = 1 \\n \\n download = True\\n root = self.root + self.dataset\\n if self.dataset == \\\"MNIST\\\": \\n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])\\n trainset = torchvision.datasets.MNIST(root, train=True, download=download, transform=transform)\\n testset = torchvision.datasets.MNIST(root, train=False, download=download, transform=transform)\\n \\n if self.dataset == \\\"CIFAR10\\\":\\n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465,), (0.2023, 0.1994, 0.2010,))])\\n trainset = torchvision.datasets.CIFAR10(root, train=True, download=download, transform=transform)\\n testset = torchvision.datasets.CIFAR10(root, train=False, download=download, transform=transform)\\n \\n if self.dataset == \\\"CIFAR100\\\":\\n transform = transforms.Compose([transforms.ToTensor()])\\n trainset = torchvision.datasets.CIFAR100(root, train=True, download=download, transform=transform)\\n testset = torchvision.datasets.CIFAR100(root, train=False, download=download, transform=transform)\\n \\n \\n trainloader = torch.utils.data.DataLoader(trainset, batch_size = batch_size,\\n shuffle=False, num_workers=0, pin_memory = False)\\n \\n testloader = torch.utils.data.DataLoader(testset, batch_size= batch_size,\\n shuffle=False, num_workers=2, pin_memory = False)\\n \\n return trainloader, testloader\",\n \"def 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 _custom_data_loader(self) -> DataLoader:\\n dataloaders = DataLoader(self.dataset, batch_size=1)\\n return dataloaders\",\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 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 get_loaders(img_size=CONFIG[\\\"matrix_size\\\"], batch_size=CONFIG[\\\"batch_size\\\"],\\n used_keypoints=CONFIG[\\\"used_keypoints\\\"], interpolation_frames=CONFIG[\\\"interpolation_frames\\\"],\\n noise_frames=CONFIG[\\\"noise_frames\\\"], all_data=None, all_labels=None):\\n\\n if all_data is None or all_labels is None:\\n all_data, all_labels = load_video_data_labels(interpolation_frames, noise_frames, used_keypoints, img_size)\\n\\n p = np.random.permutation(len(all_data))\\n train_len = int(len(p) / 80)\\n others_len = int((len(p) - train_len) / 2)\\n\\n train_data, train_labels = all_data[p[:train_len]], all_labels[p[:train_len]]\\n val_data = all_data[p[train_len:train_len + others_len]]\\n val_labels = all_labels[p[train_len:train_len + others_len]]\\n test_data, test_labels = all_data[p[-others_len:]], all_labels[p[-others_len:]]\\n\\n # Transform to tensor\\n train_data_tensor, train_labels_tensor = torch.from_numpy(train_data), torch.from_numpy(train_labels)\\n val_data_tensor, val_labels_tensor = torch.from_numpy(val_data), torch.from_numpy(val_labels)\\n test_data_tensor, test_labels_tensor = torch.from_numpy(test_data), torch.from_numpy(test_labels)\\n\\n # Data Loader for easy mini-batch return in training, load the Dataset from the numpy arrays\\n train_loader = DataLoader(TensorDataset(train_data_tensor, train_labels_tensor), batch_size=batch_size)\\n val_loader = DataLoader(TensorDataset(val_data_tensor, val_labels_tensor), batch_size=batch_size)\\n test_loader = DataLoader(TensorDataset(test_data_tensor, test_labels_tensor), batch_size=batch_size)\\n\\n data = {\\\"train_data\\\": train_data,\\n \\\"train_labels\\\": train_labels,\\n \\\"val_data\\\": val_data,\\n \\\"val_labels\\\": val_labels,\\n \\\"test_data\\\": test_data,\\n \\\"test_labels\\\": test_labels,\\n \\\"all_data\\\": all_data[p],\\n \\\"all_labels\\\": all_labels[p]}\\n\\n return data, train_loader, val_loader, test_loader\",\n \"def load_data(data_dir):\\n train_dir = data_dir + '/train'\\n valid_dir = data_dir + '/valid'\\n test_dir = data_dir + '/test'\\n\\n # define your transforms for the training, validation, and testing sets\\n data_transforms_training = transforms.Compose([\\n transforms.RandomRotation(30),\\n transforms.RandomResizedCrop(224),\\n transforms.RandomHorizontalFlip(),\\n transforms.ToTensor(),\\n transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\\n ])\\n\\n data_transforms_validation = transforms.Compose([\\n transforms.Resize(224),\\n transforms.CenterCrop(224),\\n transforms.ToTensor(),\\n transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\\n ])\\n\\n data_transforms_test = transforms.Compose([\\n transforms.Resize(224),\\n transforms.CenterCrop(224),\\n transforms.ToTensor(),\\n transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\\n ])\\n\\n # Load the datasets with ImageFolder\\n image_datasets_training = datasets.ImageFolder(train_dir, transform=data_transforms_training)\\n image_datasets_validation = datasets.ImageFolder(valid_dir, transform=data_transforms_validation)\\n image_datasets_test = datasets.ImageFolder(test_dir, transform=data_transforms_test)\\n\\n # Using the image datasets and the trainforms, define the dataloaders\\n dataloaders_training = torch.utils.data.DataLoader(image_datasets_training, shuffle=True, batch_size=128)\\n dataloaders_validation = torch.utils.data.DataLoader(image_datasets_validation, shuffle=True, batch_size=128)\\n dataloaders_test = torch.utils.data.DataLoader(image_datasets_test, shuffle=True, batch_size=128)\\n\\n return {\\\"training_dataloader\\\": dataloaders_training,\\n \\\"validation_dataloader\\\": dataloaders_validation,\\n \\\"testing_dataloader\\\": dataloaders_test,\\n \\\"class_to_idx\\\": image_datasets_training.class_to_idx}\",\n \"def train_dataloader(self) -> DataLoader:\\n return self._custom_data_loader()\",\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_train_loader(self):\\n # Choose the right dataset type\\n if self.config_args[\\\"num_members\\\"] > 1:\\n class_dataset_wrapper = dataset_wrapper.MixMoDataset\\n else:\\n class_dataset_wrapper = dataset_wrapper.MSDADataset\\n\\n # Load augmentations\\n self.traindatasetwrapper = class_dataset_wrapper(\\n dataset=self.train_dataset,\\n num_classes=int(self.config_args[\\\"data\\\"][\\\"num_classes\\\"]),\\n num_members=self.config_args[\\\"num_members\\\"],\\n dict_config=self.config_args[\\\"training\\\"][\\\"dataset_wrapper\\\"],\\n properties=self.properties\\n )\\n\\n # Build standard sampler\\n _train_sampler = torch.utils.data.sampler.RandomSampler(\\n data_source=self.traindatasetwrapper, ## only needed for its length\\n num_samples=None,\\n replacement=False,\\n )\\n\\n # Wrap it with the repeating sampler used for multi-input models\\n batch_sampler = batch_repetition_sampler.BatchRepetitionSampler(\\n sampler=_train_sampler,\\n batch_size=self.batch_size,\\n num_members=self.config_args[\\\"num_members\\\"],\\n drop_last=True,\\n config_batch_sampler=self.config_args[\\\"training\\\"][\\\"batch_sampler\\\"]\\n )\\n\\n self.train_loader = torch.utils.data.DataLoader(\\n self.traindatasetwrapper,\\n batch_sampler=batch_sampler,\\n num_workers=self.num_workers,\\n batch_size=1,\\n shuffle=False,\\n sampler=None,\\n drop_last=False,\\n pin_memory=True,\\n )\",\n \"def build_training_data_loader(self) -> DataLoader:\\n pass\",\n \"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)\",\n \"def get_data_loader(target_classes, batch_size):\\n classes = ('plane', 'car', 'bird', 'cat',\\n 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\\n ########################################################################\\n # The output of torchvision datasets are PILImage images of range [0, 1].\\n # We transform them to Tensors of normalized range [-1, 1].\\n transform = transforms.Compose(\\n [transforms.ToTensor(),\\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\\n trainset = torchvision.datasets.CIFAR10(root='./data', train=True,\\n download=True, transform=transform)\\n # Get the list of indices to sample from\\n relevant_train_indices = get_relevant_indices(\\n trainset,\\n classes,\\n target_classes)\\n # Split into train and validation\\n np.random.seed(1000) # Fixed numpy random seed for reproducible shuffling\\n np.random.shuffle(relevant_train_indices)\\n split = int(len(relevant_train_indices) * 0.8)\\n relevant_train_indices, relevant_val_indices = relevant_train_indices[:split], relevant_train_indices[split:]\\n train_sampler = SubsetRandomSampler(relevant_train_indices)\\n train_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\\n num_workers=0, sampler=train_sampler)\\n val_sampler = SubsetRandomSampler(relevant_val_indices)\\n val_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\\n num_workers=0, sampler=val_sampler)\\n testset = torchvision.datasets.CIFAR10(root='./data', train=False,\\n download=True, transform=transform)\\n relevant_test_indices = get_relevant_indices(testset, classes, target_classes)\\n test_sampler = SubsetRandomSampler(relevant_test_indices)\\n test_loader = torch.utils.data.DataLoader(testset, batch_size=batch_size,\\n num_workers=0, sampler=test_sampler)\\n return train_loader, val_loader, test_loader, classes\",\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 load_dataloaders(args):\\n logger.info(\\\"Loading dataloaders...\\\")\\n p_path = os.path.join(\\\"./data/\\\", \\\"df_unencoded.pkl\\\")\\n train_path = os.path.join(\\\"./data/\\\", \\\"df_encoded.pkl\\\")\\n if (not os.path.isfile(p_path)) and (not os.path.isfile(train_path)):\\n df = get_data(args, load_extracted=False)\\n elif os.path.isfile(p_path) and (not os.path.isfile(train_path)):\\n df = get_data(args, load_extracted=True)\\n elif os.path.isfile(train_path):\\n df = load_pickle(\\\"df_encoded.pkl\\\")\\n \\n # Train-Test split\\n msk = np.random.rand(len(df)) < args.train_test_ratio\\n trainset = df[msk]\\n testset = df[~msk]\\n \\n trainset = text_dataset(trainset, args)\\n max_features_length = trainset.max_x_len\\n max_seq_len = trainset.max_y_len\\n train_length = len(trainset)\\n train_loader = DataLoader(trainset, batch_size=args.batch_size, shuffle=True,\\\\\\n num_workers=0, collate_fn=Pad_Sequence(), pin_memory=False)\\n \\n testset = text_dataset(testset, args)\\n test_length = len(testset)\\n test_loader = DataLoader(testset, batch_size=args.batch_size, shuffle=True,\\\\\\n num_workers=0, collate_fn=Pad_Sequence(), pin_memory=False)\\n return train_loader, train_length, max_features_length, max_seq_len, test_loader, test_length\",\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 load_data(self) -> tuple:\\n label_num = {}\\n data_set = pathlib.Path(self.path)\\n data = []\\n\\n # create the label lookup dict for verifcation later\\n for i, v in enumerate(data_set.iterdir()):\\n label_num[v.name] = i\\n self.labels[i] = v.name\\n # end\\n\\n # read images\\n for img_path in data_set.rglob(\\\"*.jpg\\\"):\\n lbl = label_num[str(img_path.parent.stem)]\\n img = cv2.imread(str(img_path))\\n img = cv2.resize(img, self.dims, interpolation=cv2.INTER_AREA)\\n\\n # flatten RGB data into a vector\\n # NOTE: NOT ACTUALLY NECESSARY! \\n img.flatten()\\n\\n # label the sample and append to temp data list\\n sample = np.append(lbl, img)\\n data.append(sample)\\n # end\\n\\n # partition and package the data (*_ ensures safe unpacking)\\n train, test, validate, *_ = Data.partition(data, self.parts, 0.7, 0.2)\\n self.train = Data(train)\\n self.test = Data(test)\\n self.validate = Data(validate)\",\n \"def load_data(self):\\n print('Loading {} dataset'.format(self.split))\\n data_split_path = os.path.join(self.root_dir, 'splits', '{}.csv'.format(self.split))\\n with open(data_split_path,'r') as f:\\n reader = csv.reader(f, delimiter=',')\\n data_classes = {}\\n for i,row in enumerate(reader):\\n if i==0:\\n continue\\n data_classes[row[1]] = 1\\n data_classes = data_classes.keys()\\n print(data_classes)\\n\\n n_classes = len(data_classes)\\n print('n_classes:{}, n_label:{}, n_unlabel:{}'.format(n_classes,self.n_label,self.n_unlabel))\\n dataset_l = np.zeros([n_classes, self.n_label, self.im_height, self.im_width, self.channels], dtype=np.float32)\\n if self.n_unlabel>0:\\n dataset_u = np.zeros([n_classes, self.n_unlabel, self.im_height, self.im_width, self.channels], dtype=np.float32)\\n else:\\n dataset_u = []\\n\\n for i, cls in enumerate(data_classes):\\n im_dir = os.path.join(self.root_dir, 'data/{}/'.format(self.split), cls)\\n im_files = sorted(glob.glob(os.path.join(im_dir, '*.jpg')))\\n np.random.RandomState(self.seed).shuffle(im_files) # fix the seed to keep label,unlabel fixed\\n for j, im_file in enumerate(im_files):\\n im = np.array(Image.open(im_file).resize((self.im_width, self.im_height)), \\n np.float32, copy=False)\\n if j<self.n_label:\\n dataset_l[i, j] = im\\n else:\\n dataset_u[i,j-self.n_label] = im\\n print('labeled data:', np.shape(dataset_l))\\n print('unlabeled data:', np.shape(dataset_u))\\n \\n self.dataset_l = dataset_l\\n self.dataset_u = dataset_u\\n self.n_classes = n_classes\",\n \"def _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 load_data(data_dir):\\n \\n #Define training, validation, and testing directories, structured for use with ImageFolder Class\\n train_dir = data_dir + '/train'\\n valid_dir = data_dir + '/valid'\\n test_dir = data_dir + '/test'\\n \\n #Define image transforms for training, validation, and testing\\n training_transforms = transforms.Compose([transforms.RandomRotation(30),\\n transforms.RandomResizedCrop(224),\\n transforms.RandomHorizontalFlip(),\\n transforms.ToTensor(),\\n transforms.Normalize([0.485, 0.456, 0.406],\\n [0.229, 0.224, 0.225])])\\n\\n validation_transforms = transforms.Compose([transforms.Resize(224),\\n transforms.CenterCrop(224),\\n transforms.ToTensor(),\\n transforms.Normalize([0.485, 0.456, 0.406],\\n [0.229, 0.224, 0.225])])\\n\\n testing_transforms = validation_transforms\\n\\n\\n #Load the datasets with ImageFolder\\n training_data = datasets.ImageFolder(train_dir, transform = training_transforms)\\n validation_data = datasets.ImageFolder(valid_dir, transform = validation_transforms)\\n testing_data = datasets.ImageFolder(test_dir, transform = testing_transforms)\\n\\n #Using the image datasets and the trainforms, define the dataloaders\\n training_loader = torch.utils.data.DataLoader(training_data, batch_size = 64, shuffle = True)\\n validation_loader = torch.utils.data.DataLoader(validation_data, batch_size = 64, shuffle = False)\\n testing_loader = torch.utils.data.DataLoader(testing_data, batch_size = 64, shuffle = False)\\n \\n return training_loader, validation_loader, testing_loader\",\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 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 get_each_loader(data_path, batch_size, trn_negnum, shuffle=True, num_workers=0):\\n \\n dataset = ML_Dataset(data_path, trn_negnum)\\n \\n if data_path.endswith('trn') == True:\\n collate = dataset.train_collate\\n else:\\n collate = test_collate\\n\\n data_loader = data.DataLoader(dataset=dataset,\\n batch_size=batch_size,\\n shuffle=shuffle,\\n num_workers=num_workers,\\n collate_fn=collate)\\n\\n return data_loader\",\n \"def get_loaders(\\n data_dir,\\n train_transforms=None,\\n val_transforms=None,\\n train_test_split=0.85,\\n train_val_split=0.15,\\n batch_size=16,\\n shuffle=True):\\n np.random.seed(24)\\n train_ds = ImageFolder(root=data_dir, transform=train_transforms)\\n val_ds = ImageFolder(root=data_dir, transform=val_transforms)\\n test_ds = ImageFolder(root=data_dir, transform=val_transforms)\\n img_count = len(train_ds)\\n indices = list(range(img_count))\\n test_split = int(img_count * train_test_split)\\n if shuffle:\\n np.random.shuffle(indices)\\n train_idx, test_idx = indices[:test_split], indices[test_split:]\\n train_count = len(train_idx)\\n val_split = int(train_count * (1 - train_val_split))\\n train_idx, val_idx = train_idx[:val_split], train_idx[val_split:]\\n train_sample = SubsetRandomSampler(train_idx)\\n val_sample = SubsetRandomSampler(val_idx)\\n test_sample = SubsetRandomSampler(test_idx)\\n train_loader = DataLoader(train_ds, batch_size=batch_size, sampler=train_sample)\\n val_loader = DataLoader(val_ds, batch_size=batch_size, sampler=val_sample)\\n test_loader = DataLoader(test_ds, batch_size=batch_size, sampler=test_sample)\\n\\n return train_loader, val_loader, test_loader\",\n \"def get_data_loaders(data, batch_size, ratio=0.8, num_workers=1):\\n train_size = int(len(data) * ratio)\\n val_size = len(data) - train_size\\n train_set, val_set = random_split(data, [train_size, val_size])\\n data_train_loader = DataLoader(train_set, batch_size=batch_size, num_workers=num_workers, shuffle=True)\\n data_val_loader = DataLoader(val_set, batch_size=batch_size, num_workers=num_workers, shuffle=True)\\n return data_train_loader, data_val_loader\",\n \"def data_loader(edges,features,y):\\n\\n\\n edge_index = torch.tensor(edges, dtype=torch.long)\\n edge_index = edge_index.t().contiguous()\\n x = torch.tensor(features.todense(), dtype=torch.float)\\n\\n y = torch.tensor(y)\\n\\n data = Data(x=x, edge_index=edge_index, y = y)\\n\\n return data\",\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 __init__(self, **kwargs):\\n DataLoader.__init__(self, **kwargs)\",\n \"def load_torchvision_data(data, label, test_size = 0.2, valid_size=0.1, splits=None, shuffle=True,\\n stratified=False, random_seed=None, batch_size = 64,\\n maxsize = None, maxsize_test=None, num_workers = 0):\\n\\n x_train, x_test, y_train, y_test = train_test_split(data, label, test_size = test_size, stratify=label)\\n train, test = CERDataset(x_train, y_train), CERDataset(x_test, y_test)\\n\\n if type(train.targets) is list or type(train.targets) is np.ndarray:\\n train.targets = torch.LongTensor(train.targets)\\n test.targets = torch.LongTensor(test.targets)\\n\\n if not hasattr(train, 'classes') or not train.classes:\\n train.classes = sorted(torch.unique(train.targets).tolist())\\n test.classes = sorted(torch.unique(train.targets).tolist())\\n\\n ### Data splitting\\n fold_idxs = {}\\n if splits is None and valid_size == 0:\\n ## Only train\\n fold_idxs['train'] = np.arange(len(train))\\n elif splits is None and valid_size > 0:\\n ## Train/Valid\\n train_idx, valid_idx = random_index_split(len(train), 1-valid_size, (maxsize, None)) # No maxsize for validation\\n fold_idxs['train'] = train_idx\\n fold_idxs['valid'] = valid_idx\\n\\n for k, idxs in fold_idxs.items():\\n if maxsize and maxsize < len(idxs):\\n fold_idxs[k] = np.sort(np.random.choice(idxs, maxsize, replace = False))\\n\\n sampler_class = SubsetRandomSampler if shuffle else SubsetSampler\\n fold_samplers = {k: sampler_class(idxs) for k,idxs in fold_idxs.items()}\\n\\n ### Create DataLoaders\\n dataloader_args = dict(batch_size=batch_size,num_workers=num_workers)\\n\\n fold_loaders = {k:dataloader.DataLoader(train, sampler=sampler,**dataloader_args)\\n for k,sampler in fold_samplers.items()}\\n\\n if maxsize_test and maxsize_test < len(test):\\n test_idxs = np.sort(np.random.choice(len(test), maxsize_test, replace = False))\\n sampler_test = SubsetSampler(test_idxs) # For test don't want Random\\n dataloader_args['sampler'] = sampler_test\\n else:\\n dataloader_args['shuffle'] = False\\n test_loader = dataloader.DataLoader(test, **dataloader_args)\\n fold_loaders['test'] = test_loader\\n\\n fnames, flens = zip(*[[k,len(v)] for k,v in fold_idxs.items()])\\n fnames = '/'.join(list(fnames) + ['test'])\\n flens = '/'.join(map(str, list(flens) + [len(test)]))\\n\\n if hasattr(train, 'data'):\\n logger.info('Input Dim: {}'.format(train.data.shape[1:]))\\n logger.info('Classes: {} (effective: {})'.format(len(train.classes), len(torch.unique(train.targets))))\\n print(f'Fold Sizes: {flens} ({fnames})')\\n\\n return fold_loaders, {'train': train, 'test':test}\",\n \"def make_loader(dataset, train_batch_size, validation_split=0.2):\\n # number of samples in train and test set\\n train_len = int(len(dataset) * (1 - validation_split))\\n test_len = len(dataset) - train_len\\n train_set, test_set = torch.utils.data.random_split(dataset, [train_len, test_len])\\n # create train_loader\\n train_loader = torch.utils.data.DataLoader(\\n train_set, batch_size=train_batch_size, shuffle=True,\\n )\\n # create test_loader\\n test_loader = torch.utils.data.DataLoader(test_set, batch_size=1, shuffle=False,)\\n return train_loader, test_loader\",\n \"def test_dataloader(self) -> torch.utils.data.DataLoader: \\n return torch.utils.data.DataLoader(self.dataset_test, **self.dl_kwargs)\",\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 get_data_loaders(train_batch_size : int, val_batch_size : int) -> tuple[DataLoader, DataLoader]:\\n \\n data_transform = Compose([ToTensor(), ReshapeTransform((-1,))]) \\n #torchvision provides datasets adapted for CNNs, so each MNIST sample is a tensor of shape (1, 28, 28) \\n #representing respectively the number of channels (1, since they are greyscale images), the height in pixels (28)\\n #and the width in pixels (28). But for a fully-connected network, we want to \\\"flatten\\\" this tensor into a 1D tensor \\n #of size 28**2. This is accomplished by the ReshapeTransform.\\n #Data offered by torchvision is already normalized in [0, 1], so no need to divide it by 255.\\n \\n train_loader = DataLoader(\\n MNIST(download=True, root=\\\".\\\", transform=data_transform, train=True), batch_size=train_batch_size, shuffle=True\\n )\\n \\n val_loader = DataLoader(\\n MNIST(download=False, root=\\\".\\\", transform=data_transform, train=False), batch_size=val_batch_size, shuffle=False\\n )\\n \\n return train_loader, val_loader\",\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_loaders(opt):\\n train_samples, val_samples = get_train_val_metadata(opt.dataset_dir,\\n opt.validation_cities,\\n opt.patch_size,\\n opt.stride)\\n print('train samples : ', len(train_samples))\\n print('val samples : ', len(val_samples))\\n\\n logging.info('STARTING Dataset Creation')\\n\\n full_load = full_onera_loader(opt.dataset_dir, opt)\\n\\n train_dataset = OneraPreloader(opt.dataset_dir,\\n train_samples,\\n full_load,\\n opt.patch_size,\\n opt.augmentation)\\n val_dataset = OneraPreloader(opt.dataset_dir,\\n val_samples,\\n full_load,\\n opt.patch_size,\\n False)\\n\\n logging.info('STARTING Dataloading')\\n\\n train_loader = torch.utils.data.DataLoader(train_dataset,\\n batch_size=opt.batch_size,\\n shuffle=True,\\n num_workers=opt.num_workers)\\n val_loader = torch.utils.data.DataLoader(val_dataset,\\n batch_size=opt.batch_size,\\n shuffle=False,\\n num_workers=opt.num_workers)\\n return train_loader, val_loader\",\n \"def data_loaders(dataset_path):\\n dataset_path = dataset_path\\n news_stock_dataset = NewsStockDataLoader(dataset_path)\\n \\n dataset_size = len(news_stock_dataset)\\n indices = list(range(dataset_size))\\n training_split = int(0.8 * dataset_size)\\n validation_split = int(0.9 * dataset_size)\\n\\n np.random.seed(96)\\n np.random.shuffle(indices)\\n\\n train_indices = indices[:training_split]\\n valid_indices = indices[training_split:validation_split]\\n test_indices = indices[validation_split:]\\n\\n train_sampler = SubsetRandomSampler(train_indices)\\n valid_sampler = SubsetRandomSampler(valid_indices)\\n test_sampler = SubsetRandomSampler(test_indices)\\n \\n collate = PadSequence()\\n\\n training_loader = DataLoader(news_stock_dataset,\\n num_workers = 1,\\n batch_size = Config.get(\\\"training_batch_size\\\"),\\n sampler = train_sampler,\\n collate_fn = collate)\\n\\n validation_loader = DataLoader(news_stock_dataset,\\n num_workers = 1,\\n batch_size = Config.get(\\\"validation_batch_size\\\"),\\n sampler = valid_sampler,\\n collate_fn = collate)\\n\\n testing_loader = DataLoader(news_stock_dataset,\\n num_workers = 1,\\n batch_size = Config.get(\\\"testing_batch_size\\\"),\\n sampler= test_sampler,\\n collate_fn = collate)\\n \\n return training_loader, validation_loader, testing_loader\",\n \"def get_loaders(train_dataset, val_dataset, test_dataset, batch_size=128):\\n train_loader = DataLoader(train_dataset, batch_size=batch_size, num_workers=8,\\n shuffle=True)\\n\\n val_loader = DataLoader(val_dataset, batch_size=batch_size, num_workers=8,\\n shuffle=False)\\n\\n test_loader = DataLoader(test_dataset, batch_size=batch_size, num_workers=8,\\n shuffle=False)\\n\\n return train_loader, val_loader, test_loader\",\n \"def DataLoader(data_place):\\n # Nd = []\\n # Np = []\\n # Nz = []\\n # channel_num = []\\n # images = []\\n # id_labels = []\\n # pose_labels = []\\n\\n # mycase\\n # Nz = 50\\n # channel_num = 3\\n # images = np.load('{}/images.npy'.format(data_place))\\n # id_labels = np.load('{}/ids.npy'.format(data_place))\\n # pose_labels = np.load('{}/yaws.npy'.format(data_place))\\n #\\n # Np = int(pose_labels.max() + 1)\\n # Nd = int(id_labels.max() + 1)\\n #\\n # return [images, id_labels, pose_labels, Nd, Np, Nz, channel_num]\\n\\n # mycase MultiPIE\\n Nz = 50\\n channel_num = 3\\n image_attributes_df = pd.read_csv(data_place)\\n\\n Nd = int(np.max(image_attributes_df['Id'])+1)\\n Np = int(np.max(image_attributes_df['pose'])+1)\\n Ni = int(np.max(image_attributes_df['illum'])+1)\\n\\n return [image_attributes_df, Nd, Np, Ni, Nz, channel_num]\",\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 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 get_loader(sentences, conversation_length, sentence_length, vocab, batch_size=100, data=None, shuffle=True):\\n\\n def collate_fn(data):\\n \\\"\\\"\\\"\\n Collate list of data in to batch\\n\\n Args:\\n data: list of tuple(source, target, conversation_length, source_length, target_length)\\n Return:\\n Batch of each feature\\n - source (LongTensor): [batch_size, max_conversation_length, max_source_length]\\n - target (LongTensor): [batch_size, max_conversation_length, max_source_length]\\n - conversation_length (np.array): [batch_size]\\n - source_length (LongTensor): [batch_size, max_conversation_length]\\n \\\"\\\"\\\"\\n # Sort by conversation length (descending order) to use 'pack_padded_sequence'\\n data.sort(key=lambda x: x[1], reverse=True)\\n\\n # Separate\\n sentences, conversation_length, sentence_length = zip(*data)\\n\\n # return sentences, conversation_length, sentence_length.tolist()\\n return sentences, conversation_length, sentence_length\\n\\n dataset = DialogDataset(sentences, conversation_length,\\n sentence_length, vocab, data=data)\\n\\n data_loader = DataLoader(\\n dataset=dataset,\\n batch_size=batch_size,\\n shuffle=shuffle,\\n collate_fn=collate_fn)\\n\\n return data_loader\",\n \"def load_data(self):\\n params = self.params\\n catg = params.data_category\\n langs = ['en', params.target_lang]\\n data = {lang: {splt: {} for splt in (['train', 'valid'] if lang == 'en' else ['test'])} for lang in langs}\\n clf_dataset_path = {\\n lang: {\\n splt: {\\n 'x': os.path.join(params.data_path, '%s_%s_%s_x.bpe.pth' % (splt, lang, catg)),\\n 'y': os.path.join(params.data_path, '%s_%s_%s_y.txt' % (splt, lang, catg)),\\n } for splt in (['train', 'valid'] if lang == 'en' else ['test'])\\n } for lang in langs\\n }\\n for splt in ['train', 'valid', 'test']:\\n for lang in langs:\\n if lang == 'en' and splt in ['train', 'valid'] or lang != 'en' and splt == 'test':\\n # load data and dictionary\\n data1 = load_binarized(clf_dataset_path[lang][splt]['x'], params)\\n data['dico'] = data.get('dico', data1['dico'])\\n # set dictionary parameters\\n set_dico_parameters(params, data, data1['dico'])\\n # create dataset\\n data[lang][splt]['x'] = Dataset(data1['sentences'], data1['positions'], params)\\n # load labels\\n with open(clf_dataset_path[lang][splt]['y'], 'r') as f:\\n labels = [int(l) for l in f]\\n data[lang][splt]['y'] = torch.LongTensor(labels)\\n assert len(data[lang][splt]['x']) == len(data[lang][splt]['y'])\\n\\n return data\",\n \"def get_loader(config):\\n train_transform = [T.Resize((256, 128)), T.RandomHorizontalFlip(), T.ToTensor(),\\n T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])]\\n train_transform = T.Compose(train_transform)\\n\\n test_transform = [T.Resize((256, 128)), T.ToTensor(),\\n T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])]\\n test_transform = T.Compose(test_transform)\\n\\n # Datasets.\\n if config.source_dataset in ['duke'] and config.target_dataset in ['market']:\\n source_image_dir = config.duke_image_dir\\n target_image_dir = config.market_image_dir\\n elif config.source_dataset in ['market'] and config.target_dataset in ['duke']:\\n source_image_dir = config.market_image_dir\\n target_image_dir = config.duke_image_dir\\n else:\\n assert 'Dataset not support!'\\n source_set = ReidDataset(source_image_dir, train_transform)\\n target_set = ReidDataset(target_image_dir, train_transform, config.expanding_cam)\\n test_set = ReidDataset(source_image_dir, test_transform)\\n\\n # Dataloader.\\n source_loader = data.DataLoader(dataset=source_set, batch_size=config.batch_size,\\n num_workers=config.num_workers, shuffle=True, pin_memory=True, drop_last=True)\\n\\n target_loader = data.DataLoader(dataset=target_set, batch_size=config.batch_size,\\n num_workers=config.num_workers, shuffle=True, pin_memory=True, drop_last=True)\\n\\n test_loader = data.DataLoader(dataset=test_set, batch_size=config.batch_size, num_workers=config.num_workers,\\n shuffle=False, pin_memory=True, drop_last=False)\\n\\n return {'source_loader': source_loader, 'target_loader': target_loader, 'test_loader': test_loader}\",\n \"def load_dataset(data_dir='flowers'):\\n train_dir = data_dir + '/train'\\n valid_dir = data_dir + '/valid'\\n test_dir = data_dir + '/test'\\n \\n # Apply transformations on training set, leave alone validation and testing sets:\\n data_transforms = {\\n \\\"training\\\" : transforms.Compose([transforms.RandomRotation(30),\\n transforms.RandomResizedCrop(224),\\n transforms.RandomHorizontalFlip(),\\n transforms.RandomVerticalFlip(),\\n transforms.ToTensor(),\\n transforms.Normalize([0.485, 0.456, 0.406],\\n [0.229, 0.224, 0.225])]),\\n # For validation and tesing sets, since they are the \\\"unseen\\\" data that used to measure the model performance, so they should not be applied by any transformations, however, resizing is stil needed.\\n \\\"validation\\\" : transforms.Compose([transforms.Resize(256),\\n transforms.CenterCrop(224),\\n transforms.ToTensor(),\\n transforms.Normalize([0.485, 0.456, 0.406],\\n [0.229, 0.224, 0.225])]),\\n \\\"testing\\\" : transforms.Compose([transforms.Resize(256),\\n transforms.CenterCrop(224),\\n transforms.ToTensor(),\\n transforms.Normalize([0.485, 0.456, 0.406],\\n [0.229, 0.224, 0.225])])\\n }\\n \\n # Load datasets with ImageFolder:\\n image_datasets = {\\n \\\"training\\\" : datasets.ImageFolder(train_dir, transform = data_transforms[\\\"training\\\"]),\\n \\\"validation\\\" : datasets.ImageFolder(valid_dir, transform = data_transforms[\\\"validation\\\"]),\\n \\\"testing\\\" : datasets.ImageFolder(test_dir, transform = data_transforms[\\\"testing\\\"])\\n }\\n \\n # Using the image datasets and the trainforms, define the dataloaders: \\n dataloaders = {\\n \\\"training\\\" : torch.utils.data.DataLoader(image_datasets[\\\"training\\\"], batch_size = 64, shuffle = True),\\n \\\"validation\\\" : torch.utils.data.DataLoader(image_datasets[\\\"validation\\\"], batch_size = 64),\\n \\\"testing\\\" : torch.utils.data.DataLoader(image_datasets[\\\"testing\\\"], batch_size = 64)\\n }\\n \\n return (dataloaders['training'],\\n dataloaders['validation'],\\n dataloaders['testing'],\\n image_datasets['training'],\\n image_datasets['validation'],\\n image_datasets['testing'])\",\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 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 val_dataloader(self) -> torch.utils.data.DataLoader: \\n return torch.utils.data.DataLoader(self.dataset_valid, **self.dl_kwargs)\",\n \"def get_driving_data_loaders(batch_size, train_dataset, valid_dataset, test_dataset, num_workers=0): \\n\\n valid_loader = DataLoader(dataset=valid_dataset,\\n batch_size=batch_size,\\n num_workers=num_workers,\\n shuffle=True)\\n\\n train_loader = DataLoader(dataset=train_dataset,\\n batch_size=batch_size,\\n num_workers=num_workers,\\n drop_last=True, \\n shuffle=True)\\n\\n test_loader = DataLoader(dataset=test_dataset,\\n batch_size=batch_size,\\n num_workers=num_workers,\\n shuffle=False)\\n\\n return train_loader, valid_loader, test_loader\",\n \"def get_faces_loaders(batch_size=128, test=True, data_path=\\\"./data/\\\"):\\n\\n dat = np.load(data_path + \\\"rotated_faces_data.npz\\\")\\n train_images = torch.FloatTensor(dat['train_images'])\\n train_targets = torch.FloatTensor(dat['train_angles'])\\n\\n traindata = torch.utils.data.TensorDataset(train_images, train_targets)\\n trainloader = torch.utils.data.DataLoader(traindata, batch_size=batch_size,\\n shuffle=True)\\n\\n if test:\\n test_images = torch.FloatTensor(dat['test_images'])\\n test_targets = torch.FloatTensor(dat['test_angles'])\\n\\n testdata = torch.utils.data.TensorDataset(test_images, test_targets)\\n testloader = torch.utils.data.DataLoader(testdata, batch_size=batch_size)\\n\\n return trainloader, testloader\\n\\n return trainloader\",\n \"def dataloader(self):\\n return DataLoader\",\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 load_data(dataset, root, batch_size, workers):\\n # Data transform\\n normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\\n std=[0.229, 0.224, 0.225])\\n train_transform = transforms.Compose([\\n transforms.RandomResizedCrop(224),\\n transforms.RandomHorizontalFlip(),\\n transforms.ToTensor(),\\n normalize,\\n ])\\n query_transform = transforms.Compose([\\n transforms.Resize(256),\\n transforms.CenterCrop(224),\\n transforms.ToTensor(),\\n normalize,\\n ])\\n\\n # Construct data loader\\n index = dataset.index(\\\"IF\\\")\\n sub = dataset[index:]\\n if sub == 'IF100':\\n train_dir = os.path.join(root, 'train-IF100')\\n elif sub == 'IF50':\\n train_dir = os.path.join(root, 'train-IF50')\\n elif sub == 'IF20':\\n train_dir = os.path.join(root, 'train-IF20')\\n elif sub == 'IF10':\\n train_dir = os.path.join(root, 'train-IF10')\\n elif sub == 'IF1':\\n train_dir = os.path.join(root, 'train-IF1')\\n else:\\n print('train path error')\\n return\\n # train_dir = os.path.join(root, 'train')\\n query_dir = os.path.join(root, 'query')\\n database_dir = os.path.join(root, 'database')\\n\\n train_dataset = ImagenetDataset(\\n train_dir,\\n transform=train_transform,\\n targets_transform=Onehot(100),\\n )\\n\\n train_dataloader = DataLoader(\\n train_dataset,\\n batch_size=batch_size,\\n shuffle=True,\\n num_workers=workers,\\n pin_memory=True,\\n )\\n\\n query_dataset = ImagenetDataset(\\n query_dir,\\n transform=query_transform,\\n targets_transform=Onehot(100),\\n )\\n\\n query_dataloader = DataLoader(\\n query_dataset,\\n batch_size=batch_size,\\n num_workers=workers,\\n pin_memory=True,\\n )\\n\\n database_dataset = ImagenetDataset(\\n database_dir,\\n transform=query_transform,\\n targets_transform=Onehot(100),\\n )\\n\\n database_dataloader = DataLoader(\\n database_dataset,\\n batch_size=batch_size,\\n num_workers=workers,\\n pin_memory=True,\\n )\\n\\n return train_dataloader, query_dataloader, database_dataloader\",\n \"def get_train_test_loaders(self, num_workers=2):\\n print('Loading the image data...')\\n \\n train_path_info, test_path_info = self.get_train_test_info()\\n\\n train_transform = transforms.Compose([transforms.Resize((self.image_width, self.image_height)),\\n transforms.RandomAffine(10,translate=(0.1,0.1)),\\n transforms.ToTensor()])\\n\\n test_transform = transforms.Compose([transforms.Resize((self.image_width, self.image_height)),\\n transforms.ToTensor()])\\n\\n trainset = PocovidDataset(train_path_info, transform = train_transform)\\n testset = PocovidDataset(test_path_info, transform = test_transform)\\n \\n self.class_map = trainset.get_class_map()\\n self.classes = [self.class_map[key] for key in sorted(self.class_map)]\\n\\n train_loader = torch.utils.data.DataLoader(trainset, num_workers=num_workers, shuffle=True,\\n batch_size=self.batch_size, drop_last=True)\\n\\n test_loader = torch.utils.data.DataLoader(testset, num_workers=num_workers, shuffle=True,\\n batch_size=self.batch_size)\\n \\n print('Image data is loaded with fold {} as the test data'.format(self.fold))\\n print('Number of training images:', len(trainset))\\n print('Number of testing images:', len(testset))\\n print('*'*100)\\n print('The classes are:', self.classes)\\n print('*'*100)\\n \\n return train_loader, test_loader\",\n \"def to_dataloader(texts, extras, ys,\\n tokenizer,\\n max_seq_length,\\n batch_size,\\n dataset_cls=TensorDataset,\\n sampler_cls=RandomSampler):\\n #train_y = train_df[labels].values\\n\\n # Labels\\n train_y_tensor = torch.tensor(ys).float()\\n\\n if texts is not None and extras is not None:\\n # All features\\n train_tokens_tensor, train_masks_tensor = text_to_train_tensors(texts, tokenizer, max_seq_length)\\n train_extras_tensor = torch.tensor(extras, dtype=torch.float)\\n\\n train_dataset = dataset_cls(train_tokens_tensor, train_masks_tensor, train_extras_tensor, train_y_tensor)\\n elif texts is not None and extras is None:\\n # Text only\\n train_tokens_tensor, train_masks_tensor = text_to_train_tensors(texts, tokenizer, max_seq_length)\\n train_dataset = dataset_cls(train_tokens_tensor, train_masks_tensor, train_y_tensor)\\n elif texts is None and extras is not None:\\n\\n train_extras_tensor = torch.tensor(extras, dtype=torch.float)\\n train_dataset = dataset_cls(train_extras_tensor, train_y_tensor)\\n else:\\n raise ValueError('Either texts or extra must be set.')\\n\\n train_sampler = sampler_cls(train_dataset)\\n \\n return DataLoader(train_dataset, sampler=train_sampler, batch_size=batch_size)\",\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 __init__(self, **kwargs):\\n DataLoader.__init__(self, **kwargs)\\n \\n self._results_ = None\",\n \"def train_test_loaders(dataset, validation_ratio=0.2, **kwargs):\\n dataset_size = len(dataset)\\n test_size = int(np.floor(validation_ratio * dataset_size))\\n train_size = dataset_size - test_size\\n print('TRAIN SIZE {}'.format(train_size))\\n print('TEST SIZE {}'.format(test_size))\\n train_dataset, test_dataset = random_split(dataset, (train_size, test_size),\\n generator=torch.Generator().manual_seed(RANDOM_SEED))\\n train_loader = torch.utils.data.DataLoader(train_dataset, **kwargs)\\n test_loader = torch.utils.data.DataLoader(test_dataset, **kwargs)\\n return train_loader, test_loader\",\n \"def get_data_loader(\\n name: str, **kwargs) -> data_loader.DataLoader:\\n\\n if name == \\\"synthetic_images\\\":\\n logging.info(\\\"Creating synthetic image data loader.\\\")\\n return synthetic_image.SyntheticImageDataLoader(**kwargs)\\n elif name == \\\"synthetic_bert\\\":\\n logging.info(\\\"Creating synthetic bert data loader.\\\")\\n return synthetic_bert.SyntheticBertLoader(**kwargs)\\n elif name == \\\"squad_bert\\\":\\n logging.info(\\\"Creating SQuAD 1.1 bert data loader.\\\")\\n return squad_bert.SquadBertLoader(**kwargs)\\n elif name == \\\"sentiment_bert\\\":\\n logging.info(\\\"Creating IMDB sentiment analysis data loader.\\\")\\n return generic_jsonl.GenericJsonlLoader(**kwargs)\\n elif name == \\\"criteo\\\":\\n logging.info(\\\"Creating Criteo data loader.\\\")\\n return criteo.CriteoLoader(**kwargs)\\n elif name == \\\"generic_jsonl\\\":\\n logging.info(\\\"Creating generic jsonl file data loader.\\\")\\n return generic_jsonl.GenericJsonlLoader(**kwargs)\\n else:\\n raise ValueError(\\\"Unsupported data loader type.\\\")\",\n \"def load_data(path):\\n # Training Images Details\\n IMG_SIZE = 224 # Size of images used for training\\n IMG_MEAN = [0.485, 0.456, 0.406] # image normalization mean\\n IMG_SDEV = [0.229, 0.224, 0.225] # image normalization standard deviation\\n\\n # Training phases\\n phases = ['train', 'valid', 'test']\\n\\n # Define data locations\\n data_dir = {n: path + n for n in phases}\\n\\n # Define transforms for the training, validation, and testing sets\\n data_transforms = {\\n 'train':\\n transforms.Compose([\\n transforms.RandomRotation(30),\\n transforms.RandomResizedCrop(IMG_SIZE),\\n transforms.RandomHorizontalFlip(p=0.5),\\n transforms.ToTensor(),\\n transforms.Normalize(IMG_MEAN, IMG_SDEV)]),\\n 'valid':\\n transforms.Compose([\\n transforms.Resize(256),\\n transforms.CenterCrop(IMG_SIZE),\\n transforms.ToTensor(),\\n transforms.Normalize(IMG_MEAN, IMG_SDEV)]),\\n 'test':\\n transforms.Compose([\\n transforms.Resize(256),\\n transforms.CenterCrop(IMG_SIZE),\\n transforms.ToTensor(),\\n transforms.Normalize(IMG_MEAN, IMG_SDEV)])\\n }\\n\\n # Load the datasets\\n image_datasets = {n: datasets.ImageFolder(\\n data_dir[n], transform=data_transforms[n])\\n for n in phases}\\n\\n # Create the PyTorch dataloaders\\n dataloaders = {n: torch.utils.data.DataLoader(\\n image_datasets[n], batch_size=64, shuffle=True)\\n for n in phases}\\n\\n # mapping of classes to training indices\\n class_to_idx = image_datasets['train'].class_to_idx\\n\\n return dataloaders, class_to_idx\",\n \"def _prepare_data(self, examples, labels):\\n\\n if self.to_tensor:\\n examples = torch.Tensor(examples)\\n labels = torch.Tensor(labels)\\n\\n if self.use_gpu:\\n examples = examples.cuda()\\n labels = labels.cuda()\\n\\n return (examples, labels)\",\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_batch_data(train_loader, device, unlabelled_data, batch_size):\\n labelled_data, labelled_target = next(iter(train_loader))\\n labelled_target = labelled_target[3]\\n unlabelled_data = unlabelled_data.to(device)\\n labelled_target = labelled_target.to(device=device, dtype=torch.int64)\\n labelled_data = labelled_data.to(device)\\n labelled_target = labelled_target.squeeze()\\n # print(\\\"labelled_target\\\", labelled_target.shape)\\n\\n labelled_data = labelled_data.view(batch_size, 1, 3750)\\n unlabelled_data = unlabelled_data.view(batch_size, 1, 3750)\\n\\n labelled_data = pp.Preprocessor().forward(labelled_data)\\n unlabelled_data = pp.Preprocessor().forward(unlabelled_data)\\n\\n labelled_data = labelled_data.view(batch_size, 1, 3750)\\n unlabelled_data = unlabelled_data.view(batch_size, 1, 3750)\\n\\n return labelled_data, labelled_target, unlabelled_data\",\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 get_data_loaders(img_dir, img_height, img_width, batch_size=8):\\n total_count = sum([len(files) for r, d, files in os.walk(img_dir)])\\n\\n data_transform = torchvision.transforms.Compose(\\n [\\n transforms.Resize((img_height, img_width)),\\n transforms.ToTensor(),\\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\\n ]\\n )\\n \\n # build a dataset of images from the img_dir directory\\n im_folder = torchvision.datasets.ImageFolder(img_dir, transform=data_transform)\\n model_dataset = td.datasets.WrapDataset(im_folder)\\n\\n dataset_loader = torch.utils.data.DataLoader(model_dataset, batch_size=batch_size)\\n\\n return dataset_loader, total_count\",\n \"def load_data(data_dir):\\n train_dir = data_dir + '/train'\\n valid_dir = data_dir + '/valid'\\n test_dir = data_dir + '/test'\\n \\n for directory in [train_dir, valid_dir, test_dir]:\\n if not os.path.isdir(directory):\\n raise IOError(\\\"Directory \\\" + directory + \\\" does not exist\\\")\\n \\n # Define transforms for the training, validation, and testing sets\\n train_transforms = transforms.Compose([transforms.RandomRotation(30),\\n transforms.RandomHorizontalFlip(),\\n transforms.Resize(255),\\n transforms.CenterCrop(224),\\n transforms.ToTensor(),\\n transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\\n data_transforms = transforms.Compose([transforms.Resize(255),\\n transforms.CenterCrop(224),\\n transforms.ToTensor()])\\n \\n # Load the datasets with ImageFolder\\n train_datasets = datasets.ImageFolder(train_dir, transform=train_transforms)\\n valid_datasets = datasets.ImageFolder(valid_dir, transform=data_transforms)\\n test_datasets = datasets.ImageFolder(test_dir, transform=data_transforms)\\n \\n # Using the image datasets and the trainforms, define the dataloaders\\n trainloader = torch.utils.data.DataLoader(train_datasets, batch_size=64, shuffle=True)\\n validloader = torch.utils.data.DataLoader(valid_datasets, batch_size=32, shuffle=True)\\n testloader = torch.utils.data.DataLoader(test_datasets, batch_size=32, shuffle=True)\\n \\n return {\\n 'datasets': {\\n 'train': train_datasets,\\n 'valid': valid_datasets,\\n 'test': test_datasets\\n },\\n 'loader': {\\n 'train': trainloader,\\n 'valid': validloader,\\n 'test': testloader\\n }\\n }\",\n \"def load_test_dataset(self):\\n test_data_path = \\\"testdata\\\"\\n root = Path(test_data_path)\\n classes = sorted([j.name.split('/')[-1] for j in root.iterdir()])\\n print(classes)\\n\\n transform = transforms.Compose([\\n transforms.Resize(300),\\n transforms.RandomHorizontalFlip(),\\n transforms.CenterCrop(250),\\n transforms.ToTensor(),\\n transforms.Normalize(mean=[0.6071, 0.4828, 0.3934], std=[0.2845, 0.3187, 0.3240])\\n ])\\n\\n dataset = datasets.ImageFolder(test_data_path, transform=transform)\\n testloader = DataLoader(dataset, batch_size=4, shuffle=True)\\n print(\\\"Loaded data\\\")\\n return testloader\",\n \"def load_data_and_labels(self):\\n gen = image.ImageDataGenerator()\\n target_size = (224,224)\\n if self.preprocess:\\n print('Preprocessing data...')\\n if not os.path.isdir(self.pproc_dir()):\\n os.mkdir(self.pproc_dir())\\n \\n batch_arr = []\\n for ld,segment in [(self.train_dir(), 'train'),\\n (self.valid_dir(), 'valid')]:\\n # TODO(ness): segment = os.basename(ld)\\n flowgen = gen.flow_from_directory(\\n ld,\\n target_size=target_size,\\n shuffle=False,\\n class_mode=None,\\n batch_size=1)\\n # Save the batches using method defined in utils.py\\n data = np.concatenate([flowgen.next() for i in range(flowgen.n)])\\n batches_dir = self.pproc_dir() + segment + '-bc'\\n save_array(batches_dir, data)\\n \\n # Save the classes.\\n cls_dir = self.pproc_dir() + segment + '-cl'\\n save_array(cls_dir, flowgen.classes)\\n \\n batch_arr.append((data, flowgen.classes, flowgen.class_indices))\\n \\n # Set the data.\\n self.training_data = batch_arr[0][0]\\n self.validation_data = batch_arr[1][0]\\n \\n # Classes are zero-indexed and represent a category in\\n # numerical form. So if the classes are 'dog' and 'cat',\\n # the possible class values will be 0 and 1.\\n self.trn_classes = batch_arr[0][1]\\n self.val_classes = batch_arr[1][1]\\n \\n # Labels are the one-hot encoded (i.e. categorical)\\n # version of the classes. In other words, if there are\\n # 5 classes and an element belongs to class 2,\\n # its label will be [0,0,1,0,0] (index 1).\\n self.training_labels = to_categorical(batch_arr[0][1])\\n self.validation_labels = to_categorical(batch_arr[1][1])\\n \\n # Class indices are dictionaries of the form\\n # {'category_name': 0, 'category_name_2: 1}. They\\n # make the mapping between numerical class indices and\\n # a human-readable category name. They are (should be...)\\n # the same for validation and training, so only load them\\n # once, after sanity checking.\\n self.cindices = batch_arr[0][2]\\n print('Done preprocessing.')\\n else:\\n print('Loading data...')\\n # Load the pre-saved data using methods defined in utils.py. See\\n # preprocessing branch for the meaning of the data.\\n self.training_data = load_array(self.pproc_dir() + 'train-bc')\\n self.validation_data = load_array(self.pproc_dir() + 'valid-bc')\\n self.trn_classes = load_array(self.pproc_dir() + 'train-cl')\\n self.val_classes = load_array(self.pproc_dir() + 'valid-cl')\\n self.training_labels = to_categorical(self.trn_classes)\\n self.validation_labels = to_categorical(self.val_classes)\\n \\n # To get the class indices, we create the generator. It's cheap to\\n # run since it doesn't actually load all the data.\\n flowgen = gen.flow_from_directory(\\n self.train_dir(),\\n target_size=target_size,\\n shuffle=False,\\n class_mode=None,\\n batch_size=1) \\n self.cindices = flowgen.class_indices\\n print('Done loading.')\",\n \"def 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 get_dataloader(\\n path='data/interim/data.json',\\n train_test_split=0.8,\\n batch_size_train=5,\\n batch_size_test=5,\\n shuffle_train=True,\\n perm_images=True,\\n transform_train=True,\\n transform_test=False,\\n class_names=None):\\n\\n # use our dataset and defined transformations\\n if class_names is None:\\n dataset = ProdigyDataReader(path, get_transforms(train=transform_train))\\n dataset_test = ProdigyDataReader(path, get_transforms(train=transform_test))\\n else:\\n dataset = ProdigyDataReader(path, get_transforms(train=transform_train),\\n object_categories=class_names)\\n dataset_test = ProdigyDataReader(path, get_transforms(train=transform_test),\\n object_categories=class_names)\\n\\n # split the dataset in train and test set\\n if perm_images:\\n indices = torch.randperm(len(dataset)).tolist()\\n else:\\n indices = list(range(len(dataset)))\\n\\n len_train = int(len(indices) * train_test_split)\\n dataset = torch.utils.data.Subset(dataset, indices[:len_train])\\n dataset_test = torch.utils.data.Subset(dataset_test, indices[len_train:])\\n\\n # define training and validation data loaders\\n data_loader = torch.utils.data.DataLoader(\\n dataset, batch_size=batch_size_train, shuffle=shuffle_train, num_workers=0,\\n collate_fn=collate_fn)\\n\\n data_loader_test = torch.utils.data.DataLoader(\\n dataset_test, batch_size=batch_size_test, shuffle=False, num_workers=0,\\n collate_fn=collate_fn)\\n\\n return [data_loader, data_loader_test]\",\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 get_dataloaders(logging, batch_size):\\n # Load Data\\n logging.info(\\\"Reading Train and Test data...\\\")\\n train_df = pd.read_csv(\\\"C:/tmp/avila_classification/data/avila-tr.txt\\\", header=None)\\n test_df = pd.read_csv(\\\"C:/tmp/avila_classification/data/avila-ts.txt\\\", header=None)\\n\\n # Fix column names\\n col_names = ['col_' + str(j + 1) for j in range(train_df.shape[1] - 1)]\\n indep_cols = col_names.copy()\\n col_names.append('y')\\n\\n logging.debug(\\\"Assigning columns\\\")\\n train_df.columns = col_names\\n test_df.columns = col_names\\n\\n # Encode dependent variable column\\n le = LabelEncoder()\\n le.fit(train_df['y'])\\n logging.debug(f\\\"Classes: {le.classes_}\\\")\\n logging.debug(f\\\"Transformed Classes: {le.transform(le.classes_)}\\\")\\n\\n train_df['y_enc'] = le.transform(train_df['y'])\\n test_df['y_enc'] = le.transform(test_df['y'])\\n\\n # train_df.head()\\n logging.debug(f\\\"Shape of train data: {train_df.shape}\\\")\\n logging.debug(f\\\"Shape of test data: {test_df.shape}\\\")\\n\\n # Create train and validation dataloaders\\n train_ds = AvilaDataset(data_frame=train_df, indep_cols=indep_cols, dep_col='y_enc')\\n valid_ds = AvilaDataset(data_frame=test_df, indep_cols=indep_cols, dep_col='y_enc')\\n\\n # Should be some exponent of 2 (128, 256)\\n # batch_size = 256\\n train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True)\\n valid_dl = DataLoader(valid_ds, batch_size=batch_size, shuffle=False)\\n\\n return train_dl, valid_dl, le\",\n \"def _loadTrain(self, features, labels):\\n\\t\\tself.trainX_, self.trainY_, self.trainLabel_ = self.__load(features, labels)\",\n \"def _get_data(\\n self, train_dataset: TensorDataset, validation_dataset: TensorDataset\\n ):\\n return (\\n DataLoader(train_dataset, batch_size=self.batch_size, shuffle=True),\\n DataLoader(validation_dataset, batch_size=self.batch_size * 2),\\n )\",\n \"def prepare_dataloaders(data,\\n seq_len,\\n batch_size=64,\\n validation_set=False,\\n validation_size=0.1,\\n random_seed=42):\\n vocab = set(data)\\n token2id = {k: v for v, k in enumerate(vocab)}\\n id2token = {k: v for v, k in token2id.items()}\\n data_range = range(0, len(data) - seq_len, seq_len)\\n\\n data = [token2id[t] for t in data]\\n data = np.array([data[i:i + seq_len] for i in data_range])\\n tensor_data = torch.from_numpy(data)\\n\\n if validation_set:\\n np.random.seed(random_seed)\\n idx = np.random.choice(\\n range(len(tensor_data)), size=len(tensor_data), replace=False)\\n split = int(len(idx) * (1 - validation_size))\\n train_idx = idx[:split]\\n valid_idx = idx[split:]\\n\\n train_data = TensorDataset(torch.LongTensor(tensor_data[train_idx]))\\n valid_data = TensorDataset(torch.LongTensor(tensor_data[valid_idx]))\\n\\n train_loader = DataLoader(\\n train_data, shuffle=True, batch_size=batch_size)\\n valid_loader = DataLoader(\\n valid_data, shuffle=True, batch_size=batch_size)\\n\\n return train_loader, valid_loader, vocab, token2id, id2token\\n else:\\n train_data = TensorDataset(torch.LongTensor(tensor_data))\\n train_loader = DataLoader(\\n train_data, shuffle=True, batch_size=batch_size)\\n return train_loader, vocab, token2id, id2token\",\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 get_train_loader(batch_size, train_set, train_sampler):\\n train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, sampler=train_sampler, num_workers=4)\\n\\n return train_loader\",\n \"def init_loaders_predict(self, data_dict, label_dict):\\n return self.init_loaders(data_dict, label_dict)\",\n \"def get_loader(data_list, config, train=True):\\n \\n with open(config[\\\"label_map\\\"], \\\"r\\\") as f:\\n label_map = json.load(f)\\n\\n dataset = GoogleSpeechDataset(\\n data_list=data_list,\\n label_map=label_map,\\n audio_settings=config[\\\"hparams\\\"][\\\"audio\\\"],\\n aug_settings=config[\\\"hparams\\\"][\\\"augment\\\"] if train else None,\\n cache=config[\\\"exp\\\"][\\\"cache\\\"]\\n )\\n\\n dataloader = DataLoader(\\n dataset,\\n batch_size=config[\\\"hparams\\\"][\\\"batch_size\\\"],\\n num_workers=config[\\\"exp\\\"][\\\"n_workers\\\"],\\n pin_memory=config[\\\"exp\\\"][\\\"pin_memory\\\"],\\n shuffle=True if train else False\\n )\\n\\n return dataloader\",\n \"def get_dataloaders(data_dir, hyp):\\n \\n # Grab data, targets\\n data_file_paths, targets = get_files_paths_and_labels(data_dir)\\n \\n # Split into train/validation\\n train_data, val_data, train_labels, val_labels = train_test_split(data_file_paths,\\n targets,\\n train_size=hyp['perc_train'],\\n shuffle=hyp['shuffle'],\\n stratify=targets)\\n\\n # Create train/validation augmentation handler\\n train_aug = get_training_augmentations(hyp)\\n val_aug = get_validation_augmentations(hyp)\\n \\n # Create datasets\\n train_dset = SETIDataset(train_data, train_labels, transform=train_aug)\\n val_dset = SETIDataset(val_data, val_labels, transform=val_aug)\\n \\n # Create dataloaders\\n train_loader = DataLoader(train_dset, shuffle=True, batch_size=hyp['batch_size'], \\n pin_memory=True, num_workers=8)\\n \\n val_loader = DataLoader(val_dset, batch_size=hyp['batch_size'], \\n pin_memory=True, num_workers=8)\\n \\n return train_loader, val_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_loader(self):\\n # load data to memory.\\n if self.is_cifar100:\\n (x_train, y_train), (x_test,\\n y_test) = tf.keras.datasets.cifar100.load_data()\\n else:\\n (x_train, y_train), (x_test,\\n y_test) = tf.keras.datasets.cifar10.load_data()\\n\\n y_train = y_train.astype(np.int32)\\n y_test = y_test.astype(np.int32)\\n\\n x_train, y_train = shuffle_dataset(x_train, y_train)\\n n_probe = int(math.floor(x_train.shape[0] * FLAGS.probe_dataset_hold_ratio))\\n\\n # TODO(zizhaoz): add other noise types.\\n if 'asymmetric' in self.dataset_name:\\n assert 'cifar100' not in self.dataset_name, 'Asymmetric only has CIFAR10'\\n (x_train, y_train, y_gold), (x_probe, y_probe) = load_asymmetric(\\n x_train,\\n y_train,\\n noise_ratio=self.noise_ratio,\\n n_val=n_probe,\\n random_seed=FLAGS.seed)\\n elif 'uniform' in self.dataset_name:\\n (x_train, y_train, y_gold), (x_probe,\\n y_probe) = load_train_val_uniform_noise(\\n x_train,\\n y_train,\\n n_classes=self.num_classes,\\n noise_ratio=self.noise_ratio,\\n n_val=n_probe)\\n else:\\n assert self.dataset_name in ['cifar10', 'cifar100']\\n\\n if not self.split_probe and x_probe is not None:\\n # Usually used for supervised comparison.\\n tf.logging.info('Merge train and probe')\\n x_train = np.concatenate([x_train, x_probe], axis=0)\\n y_train = np.concatenate([y_train, y_probe], axis=0)\\n y_gold = np.concatenate([y_gold, y_probe], axis=0)\\n\\n conf_mat = sklearn_metrics.confusion_matrix(y_gold, y_train)\\n conf_mat = conf_mat / np.sum(conf_mat, axis=1, keepdims=True)\\n tf.logging.info('Corrupted confusion matirx\\\\n {}'.format(conf_mat))\\n x_test, y_test = shuffle_dataset(x_test, y_test)\\n self.train_dataset_size = x_train.shape[0]\\n self.val_dataset_size = x_test.shape[0]\\n if self.split_probe:\\n self.probe_size = x_probe.shape[0]\\n\\n input_tuple = (x_train, y_train.squeeze())\\n self.train_dataflow = self.create_ds(input_tuple, is_train=True)\\n self.val_dataflow = self.create_ds((x_test, y_test.squeeze()),\\n is_train=False)\\n if self.split_probe:\\n self.probe_dataflow = self.create_ds((x_probe, y_probe.squeeze()),\\n is_train=True)\\n\\n tf.logging.info('Init [{}] dataset loader'.format(self.dataset_name))\\n verbose_data('train', x_train, y_train)\\n verbose_data('test', x_test, y_test)\\n if self.split_probe:\\n verbose_data('probe', x_probe, y_probe)\\n\\n return self\",\n \"def load_mnist(data_filename, batch_size):\\n\\n train_data, valid_data, test_data = unpickle_mnist(data_filename)\\n\\n train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)\\n valid_loader = DataLoader(valid_data, batch_size=batch_size, shuffle=True)\\n test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=True)\\n\\n return train_loader, valid_loader, test_loader\",\n \"def load_data(batch_size=batch_size):\\n trainset = LibriSpeechDataset(training_set, int(LIBRISPEECH_SAMPLING_RATE * n_seconds))\\n testset = LibriSpeechDataset(validation_set, int(LIBRISPEECH_SAMPLING_RATE * n_seconds), stochastic=False)\\n\\n train_loader = DataLoader(trainset, batch_size=batch_size, num_workers=1, shuffle=True, drop_last=True)\\n test_loader = DataLoader(testset, batch_size=1, num_workers=1, drop_last=True)\\n\\n return train_loader, test_loader\",\n \"def get_test_loader(id_list = './data/sample_submission.csv', root_dir = './data/test/'):\\n data = HumanProteinDataset(id_list, root_dir, transform = transforms.Compose([\\n Rescale((256, 256)), \\n ToTensor()\\n ]))\\n\\n indices = np.arange(len(data))\\n dataloader_test = DataLoader(data, batch_size=10, num_workers=5)\\n\\n return dataloader_test\",\n \"def test_dataloader(self) -> DataLoader:\\n return self._custom_data_loader()\",\n \"def get_data_loader(image_type, image_dir, \\n image_size=128, batch_size=16, num_workers=0):\\n \\n # resize and normalize the images\\n transform = transforms.Compose([transforms.Resize(image_size), # resize to 128x128\\n transforms.ToTensor()])\\n\\n # get training and test directories\\n image_path = './' + image_dir\\n train_path = os.path.join(image_path, image_type)\\n test_path = os.path.join(image_path, 'test_{}'.format(image_type))\\n\\n # define datasets using ImageFolder\\n train_dataset = datasets.ImageFolder(train_path, transform)\\n test_dataset = datasets.ImageFolder(test_path, transform)\\n\\n # create and return DataLoaders\\n train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers)\\n test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers)\\n\\n return train_loader, test_loader\",\n \"def make_loader(model, dataset, batch_size, workers, eval_proportion):\\n dataset_extra_args = dict(\\n num_frames=model['num_frames'],\\n channels=model['input_type'],\\n action_space=model['action_space'],\\n steps_action=model['steps_action'],\\n num_signals=model['num_signals'],\\n num_skills=model['num_skills'])\\n if model['mode'] == 'regression':\\n dataset_class = RegressionDataset\\n else:\\n dataset_class = ImitationDataset\\n\\n im_dataset = dataset_class(**dataset, **dataset_extra_args)\\n train_dataset, eval_dataset = split_dataset(im_dataset, eval_proportion)\\n train_loader = torch.utils.data.DataLoader(\\n train_dataset,\\n batch_size,\\n num_workers=workers,\\n shuffle=True,\\n drop_last=False)\\n if eval_dataset is not None:\\n eval_loader = torch.utils.data.DataLoader(\\n eval_dataset,\\n batch_size,\\n num_workers=workers,\\n shuffle=True,\\n drop_last=False)\\n else:\\n eval_loader = None\\n\\n env_name = im_dataset._frames.infos['env_name']\\n return (train_loader, eval_loader, env_name, im_dataset.get_statistics())\",\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_train_loaders(config):\\n assert 'loaders' in config, 'Could not find data loaders configuration'\\n loaders_config = config['loaders']\\n\\n logger.info('Creating training and validation set loaders...')\\n\\n # get dataset class\\n dataset_cls_str = loaders_config.get('dataset', None)\\n if dataset_cls_str is None:\\n dataset_cls_str = 'StandardHDF5Dataset'\\n logger.warning(f\\\"Cannot find dataset class in the config. Using default '{dataset_cls_str}'.\\\")\\n dataset_class = _loader_classes(dataset_cls_str)\\n\\n assert set(loaders_config['train']['file_paths']).isdisjoint(loaders_config['val']['file_paths']), \\\\\\n \\\"Train and validation 'file_paths' overlap. One cannot use validation data for training!\\\"\\n\\n train_datasets = dataset_class.create_datasets(loaders_config, phase='train')\\n\\n val_datasets = dataset_class.create_datasets(loaders_config, phase='val')\\n\\n num_workers = loaders_config.get('num_workers', 1)\\n logger.info(f'Number of workers for train/val dataloader: {num_workers}')\\n batch_size = loaders_config.get('batch_size', 1)\\n if torch.cuda.device_count() > 1 and not config['device'] == 'cpu':\\n logger.info(\\n f'{torch.cuda.device_count()} GPUs available. Using batch_size = {torch.cuda.device_count()} * {batch_size}')\\n batch_size = batch_size * torch.cuda.device_count()\\n\\n logger.info(f'Batch size for train/val loader: {batch_size}')\\n # when training with volumetric data use batch_size of 1 due to GPU memory constraints\\n return {\\n 'train': DataLoader(ConcatDataset(train_datasets), batch_size=batch_size, shuffle=True, pin_memory=True,\\n num_workers=num_workers),\\n # don't shuffle during validation: useful when showing how predictions for a given batch get better over time\\n 'val': DataLoader(ConcatDataset(val_datasets), batch_size=batch_size, shuffle=False, pin_memory=True,\\n num_workers=num_workers)\\n }\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74957144","0.74059236","0.73900753","0.73697627","0.7280223","0.7249118","0.7240241","0.71756315","0.70918363","0.7086592","0.7085246","0.7044244","0.7007126","0.6970048","0.69508225","0.6943519","0.69286335","0.6925529","0.6924148","0.6876771","0.68674177","0.6858872","0.68525","0.6832442","0.6828353","0.6785143","0.67645794","0.6752341","0.6713221","0.67077625","0.6707364","0.66986597","0.66945875","0.66915274","0.6691334","0.6678283","0.6669582","0.6662975","0.6650631","0.6646659","0.6619493","0.6618053","0.6595859","0.6587913","0.6580504","0.65800804","0.6574015","0.65682316","0.6534813","0.6523354","0.6514457","0.65101427","0.6502588","0.6489523","0.64841026","0.6480916","0.64660627","0.64496183","0.64484006","0.6440256","0.64293176","0.6426669","0.6426096","0.6423281","0.63998824","0.63977796","0.6395324","0.6394231","0.6387595","0.63782614","0.63700634","0.636686","0.6361537","0.63541543","0.6350069","0.6348746","0.6346864","0.63464224","0.6344744","0.6344275","0.633745","0.63273686","0.63024586","0.628849","0.6287377","0.6282651","0.6280401","0.6279624","0.627538","0.6273434","0.6262081","0.62565815","0.62482053","0.624289","0.62369233","0.62340593","0.6230942","0.6227968","0.6223248","0.6221454"],"string":"[\n \"0.74957144\",\n \"0.74059236\",\n \"0.73900753\",\n \"0.73697627\",\n \"0.7280223\",\n \"0.7249118\",\n \"0.7240241\",\n \"0.71756315\",\n \"0.70918363\",\n \"0.7086592\",\n \"0.7085246\",\n \"0.7044244\",\n \"0.7007126\",\n \"0.6970048\",\n \"0.69508225\",\n \"0.6943519\",\n \"0.69286335\",\n \"0.6925529\",\n \"0.6924148\",\n \"0.6876771\",\n \"0.68674177\",\n \"0.6858872\",\n \"0.68525\",\n \"0.6832442\",\n \"0.6828353\",\n \"0.6785143\",\n \"0.67645794\",\n \"0.6752341\",\n \"0.6713221\",\n \"0.67077625\",\n \"0.6707364\",\n \"0.66986597\",\n \"0.66945875\",\n \"0.66915274\",\n \"0.6691334\",\n \"0.6678283\",\n \"0.6669582\",\n \"0.6662975\",\n \"0.6650631\",\n \"0.6646659\",\n \"0.6619493\",\n \"0.6618053\",\n \"0.6595859\",\n \"0.6587913\",\n \"0.6580504\",\n \"0.65800804\",\n \"0.6574015\",\n \"0.65682316\",\n \"0.6534813\",\n \"0.6523354\",\n \"0.6514457\",\n \"0.65101427\",\n \"0.6502588\",\n \"0.6489523\",\n \"0.64841026\",\n \"0.6480916\",\n \"0.64660627\",\n \"0.64496183\",\n \"0.64484006\",\n \"0.6440256\",\n \"0.64293176\",\n \"0.6426669\",\n \"0.6426096\",\n \"0.6423281\",\n \"0.63998824\",\n \"0.63977796\",\n \"0.6395324\",\n \"0.6394231\",\n \"0.6387595\",\n \"0.63782614\",\n \"0.63700634\",\n \"0.636686\",\n \"0.6361537\",\n \"0.63541543\",\n \"0.6350069\",\n \"0.6348746\",\n \"0.6346864\",\n \"0.63464224\",\n \"0.6344744\",\n \"0.6344275\",\n \"0.633745\",\n \"0.63273686\",\n \"0.63024586\",\n \"0.628849\",\n \"0.6287377\",\n \"0.6282651\",\n \"0.6280401\",\n \"0.6279624\",\n \"0.627538\",\n \"0.6273434\",\n \"0.6262081\",\n \"0.62565815\",\n \"0.62482053\",\n \"0.624289\",\n \"0.62369233\",\n \"0.62340593\",\n \"0.6230942\",\n \"0.6227968\",\n \"0.6223248\",\n \"0.6221454\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6935648"},"document_rank":{"kind":"string","value":"16"}}},{"rowIdx":91495,"cells":{"query":{"kind":"string","value":"Creates data loaders from inputs for use at prediction time"},"document":{"kind":"string","value":"def init_loaders_predict(self, data_dict, label_dict):\n return self.init_loaders(data_dict, label_dict)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_data_loaders(args, tokenizer):\n personachat = get_dataset(tokenizer, args.dataset_path, args.dataset_cache, args.train_lang)\n _ = personachat.pop(\"test\", None)\n logger.info(\"Build inputs and labels\")\n datasets = {\"train\": [], \"valid\": []}\n\n if args.train_lang in [\"En\", \"Fr\", \"It\", \"Id\", \"Jp\", \"Ko\", \"Zh\"]: #monolingual data\n for dataset_name, dataset in personachat.items():\n for dial in dataset[args.train_lang]: #dial: {\"persona\":[], \"history\":[], \"response\":str}\n instance = build_input_from_segments(dial[\"persona\"], dial[\"history\"][-args.max_turns:], dial[\"response\"], tokenizer, lm_labels = True)\n datasets[dataset_name].append(instance) \n else: #multilingual data\n for dataset_name, dataset in personachat.items():\n for lang, dials in dataset.items():\n for dial in dials: #dial: {\"persona\":[], \"history\":[], \"response\":str}\n instance = build_input_from_segments(dial[\"persona\"], dial[\"history\"][-args.max_turns:], dial[\"response\"], tokenizer, lang_id=\"<{}>\".format(lang.lower()), lm_labels = True)\n datasets[dataset_name].append(instance) #all langs together\n\n\n logger.info(\"Build train and validation dataloaders\")\n train_dataset = DatasetTrain(datasets[\"train\"])\n valid_dataset = DatasetTrain(datasets[\"valid\"])\n\n #logger.info(\"Build train and validation dataloaders\")\n #train_dataset, valid_dataset = TensorDataset(*tensor_datasets[\"train\"]), TensorDataset(*tensor_datasets[\"valid\"])\n train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) if args.distributed else None\n valid_sampler = torch.utils.data.distributed.DistributedSampler(valid_dataset) if args.distributed else None\n train_loader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.train_batch_size, shuffle=(not args.distributed), collate_fn=collate_fn)\n valid_loader = DataLoader(valid_dataset, sampler=valid_sampler, batch_size=args.valid_batch_size, shuffle=False, collate_fn=collate_fn)\n\n # logger.info(\"Train dataset (Batch, Candidates, Seq length): {}\".format(train_dataset.tensors[0].shape))\n # #logger.info(\"Train dataset (Batch, Candidates, Seq length): {}\".format(train_dataset.tensors[1].shape))\n # logger.info(\"Valid dataset (Batch, Candidates, Seq length): {}\".format(valid_dataset.tensors[0].shape))\n logger.info(\"Train dataset length: {}\".format(len(train_dataset)))\n logger.info(\"Valid dataset length: {}\".format(len(valid_dataset)))\n return train_loader, valid_loader, train_sampler, valid_sampler","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 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 init_loaders(self, *args, **kwargs):\n\n # Convert the data to Dataset\n dataset_dict = self.init_datasets(*args, **kwargs)\n\n # If the Dataset implements collate_fn, that is used. Otherwise, default_collate is used\n if hasattr(dataset_dict[\"train\"], \"collate_fn\") and callable(\n getattr(dataset_dict[\"train\"], \"collate_fn\")\n ):\n collate_fn = dataset_dict[\"train\"].collate_fn\n else:\n collate_fn = default_collate\n\n # If 'iters_per_epoch' is defined, then a fixed number of random sample batches from the training set\n # are drawn per epoch.\n # Otherwise, an epoch is defined by a full run through all of the data in the dataloader.\n #\n if self.config_dict.get(\"iters_per_epoch\") is not None:\n num_samples = (\n self.config_dict[\"iters_per_epoch\"] * self.config_dict[\"batch_size\"]\n )\n loaders_dict = {}\n for key in dataset_dict.keys():\n if key == \"train\":\n loaders_dict[key] = DataLoader(\n dataset_dict[key],\n batch_sampler=BatchSampler(\n RandomSampler(\n dataset_dict[key],\n replacement=True,\n num_samples=num_samples,\n ),\n batch_size=self.config_dict[\"batch_size\"],\n drop_last=False,\n ),\n collate_fn=collate_fn,\n )\n else:\n loaders_dict[key] = DataLoader(\n dataset_dict[key],\n batch_size=self.config_dict[\"batch_size\"],\n collate_fn=collate_fn,\n )\n else:\n loaders_dict = {\n key: DataLoader(\n dataset_dict[key],\n batch_size=self.config_dict[\"batch_size\"],\n collate_fn=collate_fn,\n )\n for key in data_dict.keys()\n }\n\n return loaders_dict","def build_training_data_loader(self) -> DataLoader:\n pass","def get_loaders(train_dataset, val_dataset, test_dataset, batch_size=128):\n train_loader = DataLoader(train_dataset, batch_size=batch_size, num_workers=8,\n shuffle=True)\n\n val_loader = DataLoader(val_dataset, batch_size=batch_size, num_workers=8,\n shuffle=False)\n\n test_loader = DataLoader(test_dataset, batch_size=batch_size, num_workers=8,\n shuffle=False)\n\n return train_loader, val_loader, test_loader","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 get_data_loaders():\n dataset_path = \"\"\n dataset_cache = None\n personachat = get_dataset(dataset_path, dataset_cache)\n\n tokenizer_selected = OpenAIGPTTokenizer.from_pretrained('openai-gpt')\n logger.info(\"Build inputs and labels\")\n datasets = {\"train\": defaultdict(list), \"valid\": defaultdict(list)}\n personality = []\n history_complete = []\n count_persona = 0\n with open('data_faiss_pegasus_2sentences_finalgenerated.pkl', 'rb') as f:\n persona_selected_list = pickle.load(f)\n for dataset_name, dataset in personachat.items():\n num_candidates = len(dataset[0][\"utterances\"][0][\"candidates\"])\n if num_candidates > 0 and dataset_name == 'train':\n num_candidates = min(1, num_candidates)\n for dialog in dataset:\n persona = dialog[\"persona_info\"].copy()\n #datasets[personality].append(persona)\n count_history = 0\n for utterance in dialog[\"utterances\"]:\n count_history = count_history + 1\n history = utterance[\"history\"][-(2*2+5):]\n \n #history_complete.append(history)\n if len(persona) == 4:\n if len(history) > (len(persona)+3):\n history_chatbot = history[1::2]\n persona_selected = persona_selected_list[count_persona]\n instance = build_input_from_segments_faiss_2(persona, history_chatbot) \n for input_name, input_array in instance.items():\n datasets[dataset_name][input_name].append(input_array)\n count_persona = count_persona + 1\n return datasets","def create_loader(self):\n # load data to memory.\n if self.is_cifar100:\n (x_train, y_train), (x_test,\n y_test) = tf.keras.datasets.cifar100.load_data()\n else:\n (x_train, y_train), (x_test,\n y_test) = tf.keras.datasets.cifar10.load_data()\n\n y_train = y_train.astype(np.int32)\n y_test = y_test.astype(np.int32)\n\n x_train, y_train = shuffle_dataset(x_train, y_train)\n n_probe = int(math.floor(x_train.shape[0] * FLAGS.probe_dataset_hold_ratio))\n\n # TODO(zizhaoz): add other noise types.\n if 'asymmetric' in self.dataset_name:\n assert 'cifar100' not in self.dataset_name, 'Asymmetric only has CIFAR10'\n (x_train, y_train, y_gold), (x_probe, y_probe) = load_asymmetric(\n x_train,\n y_train,\n noise_ratio=self.noise_ratio,\n n_val=n_probe,\n random_seed=FLAGS.seed)\n elif 'uniform' in self.dataset_name:\n (x_train, y_train, y_gold), (x_probe,\n y_probe) = load_train_val_uniform_noise(\n x_train,\n y_train,\n n_classes=self.num_classes,\n noise_ratio=self.noise_ratio,\n n_val=n_probe)\n else:\n assert self.dataset_name in ['cifar10', 'cifar100']\n\n if not self.split_probe and x_probe is not None:\n # Usually used for supervised comparison.\n tf.logging.info('Merge train and probe')\n x_train = np.concatenate([x_train, x_probe], axis=0)\n y_train = np.concatenate([y_train, y_probe], axis=0)\n y_gold = np.concatenate([y_gold, y_probe], axis=0)\n\n conf_mat = sklearn_metrics.confusion_matrix(y_gold, y_train)\n conf_mat = conf_mat / np.sum(conf_mat, axis=1, keepdims=True)\n tf.logging.info('Corrupted confusion matirx\\n {}'.format(conf_mat))\n x_test, y_test = shuffle_dataset(x_test, y_test)\n self.train_dataset_size = x_train.shape[0]\n self.val_dataset_size = x_test.shape[0]\n if self.split_probe:\n self.probe_size = x_probe.shape[0]\n\n input_tuple = (x_train, y_train.squeeze())\n self.train_dataflow = self.create_ds(input_tuple, is_train=True)\n self.val_dataflow = self.create_ds((x_test, y_test.squeeze()),\n is_train=False)\n if self.split_probe:\n self.probe_dataflow = self.create_ds((x_probe, y_probe.squeeze()),\n is_train=True)\n\n tf.logging.info('Init [{}] dataset loader'.format(self.dataset_name))\n verbose_data('train', x_train, y_train)\n verbose_data('test', x_test, y_test)\n if self.split_probe:\n verbose_data('probe', x_probe, y_probe)\n\n return self","def __create_dataloaders(\n self, encoded_input: dict, batch_size\n ) -> Tuple[DataLoader, DataLoader, DataLoader]:\n input_ids = encoded_input[\"input_ids\"]\n token_type_ids = encoded_input[\"token_type_ids\"]\n attention_mask = encoded_input[\"attention_mask\"]\n\n input_ids_data_loader = torch.utils.data.DataLoader(\n input_ids, batch_size=batch_size, shuffle=False\n )\n token_type_ids_data_loader = torch.utils.data.DataLoader(\n token_type_ids, batch_size=batch_size, shuffle=False\n )\n attention_mask_data_loader = torch.utils.data.DataLoader(\n attention_mask, batch_size=batch_size, shuffle=False\n )\n\n return (\n input_ids_data_loader,\n token_type_ids_data_loader,\n attention_mask_data_loader,\n )","def _custom_data_loader(self) -> DataLoader:\n dataloaders = DataLoader(self.dataset, batch_size=1)\n return dataloaders","def train_dataloader(self) -> DataLoader:\n return self._custom_data_loader()","def prepare_data(self,d):\n train_loaders, train_iters = {}, {}\n unlabeled_loaders, unlabeled_iters = {}, {}\n for domain in opt.domains:\n #CONVERT TO FLOAT32\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape((-1,1))\n train = data_utils.TensorDataset(features,target)\n train_loaders[domain] = DataLoader(train, opt.batch_size, shuffle = True)\n train_iters[domain] = iter(train_loaders[domain])\n for domain in opt.unlabeled_domains:\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape(-1,1))\n uset = data_utils.TensorDataset(features,target)\n unlabeled_loaders[domain] = DataLoader(uset,opt.batch_size, shuffle = True)\n unlabeled_iters[domain] = iter(unlabeled_loaders[domain])\n \n return train_loaders, train_iters, unlabeled_loaders, unlabeled_iters","def get_data_loaders(data, batch_size, ratio=0.8, num_workers=1):\n train_size = int(len(data) * ratio)\n val_size = len(data) - train_size\n train_set, val_set = random_split(data, [train_size, val_size])\n data_train_loader = DataLoader(train_set, batch_size=batch_size, num_workers=num_workers, shuffle=True)\n data_val_loader = DataLoader(val_set, batch_size=batch_size, num_workers=num_workers, shuffle=True)\n return data_train_loader, data_val_loader","def get_each_loader(data_path, batch_size, trn_negnum, shuffle=True, num_workers=0):\n \n dataset = ML_Dataset(data_path, trn_negnum)\n \n if data_path.endswith('trn') == True:\n collate = dataset.train_collate\n else:\n collate = test_collate\n\n data_loader = data.DataLoader(dataset=dataset,\n batch_size=batch_size,\n shuffle=shuffle,\n num_workers=num_workers,\n collate_fn=collate)\n\n return data_loader","def get_loader(config):\n train_transform = [T.Resize((256, 128)), T.RandomHorizontalFlip(), T.ToTensor(),\n T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])]\n train_transform = T.Compose(train_transform)\n\n test_transform = [T.Resize((256, 128)), T.ToTensor(),\n T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])]\n test_transform = T.Compose(test_transform)\n\n # Datasets.\n if config.source_dataset in ['duke'] and config.target_dataset in ['market']:\n source_image_dir = config.duke_image_dir\n target_image_dir = config.market_image_dir\n elif config.source_dataset in ['market'] and config.target_dataset in ['duke']:\n source_image_dir = config.market_image_dir\n target_image_dir = config.duke_image_dir\n else:\n assert 'Dataset not support!'\n source_set = ReidDataset(source_image_dir, train_transform)\n target_set = ReidDataset(target_image_dir, train_transform, config.expanding_cam)\n test_set = ReidDataset(source_image_dir, test_transform)\n\n # Dataloader.\n source_loader = data.DataLoader(dataset=source_set, batch_size=config.batch_size,\n num_workers=config.num_workers, shuffle=True, pin_memory=True, drop_last=True)\n\n target_loader = data.DataLoader(dataset=target_set, batch_size=config.batch_size,\n num_workers=config.num_workers, shuffle=True, pin_memory=True, drop_last=True)\n\n test_loader = data.DataLoader(dataset=test_set, batch_size=config.batch_size, num_workers=config.num_workers,\n shuffle=False, pin_memory=True, drop_last=False)\n\n return {'source_loader': source_loader, 'target_loader': target_loader, 'test_loader': test_loader}","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 prepare_data_loaders(num_split, batch_size=32, hier=False, elmo=False, elmo_pre=None, use_elmo_pre=False, deepmoji=False, dev_with_label=False, include_test=False):\n train_data_loaders = []\n val_data_loaders = []\n test_data_loaders = []\n\n vocab = generate_vocab(deepmoji)\n for i in range(num_split):\n train, val, test, _ = prepare_data(batch_size=batch_size, hier=hier, elmo=elmo, elmo_pre=elmo_pre, use_elmo_pre=use_elmo_pre, deepmoji=deepmoji, is_shuffle=True, random_state=i, vocab=vocab, dev_with_label=dev_with_label, include_test=include_test)\n train_data_loaders.append(train)\n val_data_loaders.append(val)\n test_data_loaders.append(test)\n\n return train_data_loaders, val_data_loaders, test_data_loaders, vocab","def get_data_loader(\n name: str, **kwargs) -> data_loader.DataLoader:\n\n if name == \"synthetic_images\":\n logging.info(\"Creating synthetic image data loader.\")\n return synthetic_image.SyntheticImageDataLoader(**kwargs)\n elif name == \"synthetic_bert\":\n logging.info(\"Creating synthetic bert data loader.\")\n return synthetic_bert.SyntheticBertLoader(**kwargs)\n elif name == \"squad_bert\":\n logging.info(\"Creating SQuAD 1.1 bert data loader.\")\n return squad_bert.SquadBertLoader(**kwargs)\n elif name == \"sentiment_bert\":\n logging.info(\"Creating IMDB sentiment analysis data loader.\")\n return generic_jsonl.GenericJsonlLoader(**kwargs)\n elif name == \"criteo\":\n logging.info(\"Creating Criteo data loader.\")\n return criteo.CriteoLoader(**kwargs)\n elif name == \"generic_jsonl\":\n logging.info(\"Creating generic jsonl file data loader.\")\n return generic_jsonl.GenericJsonlLoader(**kwargs)\n else:\n raise ValueError(\"Unsupported data loader type.\")","def data_loaders(args):\n\n transform = transforms.Compose([\n transforms.Resize(64),\n transforms.ToTensor(),\n lambda image: (image - 0.5) * 2\n ])\n\n train_mnist = datasets.MNIST(\n root=args.database_root,\n train=True,\n download=True,\n transform=transform\n )\n train_loader = DataLoader(\n dataset=train_mnist,\n batch_size=args.train_batch_size,\n shuffle=True,\n num_workers=1,\n pin_memory=True\n )\n\n test_mnist = datasets.MNIST(\n root=args.database_root,\n train=False,\n download=True,\n transform=transform\n )\n test_loader = DataLoader(\n dataset=test_mnist,\n batch_size=args.test_batch_size,\n shuffle=True,\n num_workers=1,\n pin_memory=True\n )\n\n return train_loader, test_loader","def get_train_loaders(config):\n assert 'loaders' in config, 'Could not find data loaders configuration'\n loaders_config = config['loaders']\n\n logger.info('Creating training and validation set loaders...')\n\n # get dataset class\n dataset_cls_str = loaders_config.get('dataset', None)\n if dataset_cls_str is None:\n dataset_cls_str = 'StandardHDF5Dataset'\n logger.warning(f\"Cannot find dataset class in the config. Using default '{dataset_cls_str}'.\")\n dataset_class = _loader_classes(dataset_cls_str)\n\n assert set(loaders_config['train']['file_paths']).isdisjoint(loaders_config['val']['file_paths']), \\\n \"Train and validation 'file_paths' overlap. One cannot use validation data for training!\"\n\n train_datasets = dataset_class.create_datasets(loaders_config, phase='train')\n\n val_datasets = dataset_class.create_datasets(loaders_config, phase='val')\n\n num_workers = loaders_config.get('num_workers', 1)\n logger.info(f'Number of workers for train/val dataloader: {num_workers}')\n batch_size = loaders_config.get('batch_size', 1)\n if torch.cuda.device_count() > 1 and not config['device'] == 'cpu':\n logger.info(\n f'{torch.cuda.device_count()} GPUs available. Using batch_size = {torch.cuda.device_count()} * {batch_size}')\n batch_size = batch_size * torch.cuda.device_count()\n\n logger.info(f'Batch size for train/val loader: {batch_size}')\n # when training with volumetric data use batch_size of 1 due to GPU memory constraints\n return {\n 'train': DataLoader(ConcatDataset(train_datasets), batch_size=batch_size, shuffle=True, pin_memory=True,\n num_workers=num_workers),\n # don't shuffle during validation: useful when showing how predictions for a given batch get better over time\n 'val': DataLoader(ConcatDataset(val_datasets), batch_size=batch_size, shuffle=False, pin_memory=True,\n num_workers=num_workers)\n }","def get_loaders(img_size=CONFIG[\"matrix_size\"], batch_size=CONFIG[\"batch_size\"],\n used_keypoints=CONFIG[\"used_keypoints\"], interpolation_frames=CONFIG[\"interpolation_frames\"],\n noise_frames=CONFIG[\"noise_frames\"], all_data=None, all_labels=None):\n\n if all_data is None or all_labels is None:\n all_data, all_labels = load_video_data_labels(interpolation_frames, noise_frames, used_keypoints, img_size)\n\n p = np.random.permutation(len(all_data))\n train_len = int(len(p) / 80)\n others_len = int((len(p) - train_len) / 2)\n\n train_data, train_labels = all_data[p[:train_len]], all_labels[p[:train_len]]\n val_data = all_data[p[train_len:train_len + others_len]]\n val_labels = all_labels[p[train_len:train_len + others_len]]\n test_data, test_labels = all_data[p[-others_len:]], all_labels[p[-others_len:]]\n\n # Transform to tensor\n train_data_tensor, train_labels_tensor = torch.from_numpy(train_data), torch.from_numpy(train_labels)\n val_data_tensor, val_labels_tensor = torch.from_numpy(val_data), torch.from_numpy(val_labels)\n test_data_tensor, test_labels_tensor = torch.from_numpy(test_data), torch.from_numpy(test_labels)\n\n # Data Loader for easy mini-batch return in training, load the Dataset from the numpy arrays\n train_loader = DataLoader(TensorDataset(train_data_tensor, train_labels_tensor), batch_size=batch_size)\n val_loader = DataLoader(TensorDataset(val_data_tensor, val_labels_tensor), batch_size=batch_size)\n test_loader = DataLoader(TensorDataset(test_data_tensor, test_labels_tensor), batch_size=batch_size)\n\n data = {\"train_data\": train_data,\n \"train_labels\": train_labels,\n \"val_data\": val_data,\n \"val_labels\": val_labels,\n \"test_data\": test_data,\n \"test_labels\": test_labels,\n \"all_data\": all_data[p],\n \"all_labels\": all_labels[p]}\n\n return data, train_loader, val_loader, test_loader","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 prepare_data(self):\n data = self._get_dataset(self.hparams.dataset_path)\n label_encoder = data[\"label_encoder\"]\n del data[\"label_encoder\"]\n\n click.secho(\"Building inputs and labels.\", fg=\"yellow\")\n datasets = {\n \"train\": defaultdict(list),\n \"valid\": defaultdict(list),\n \"test\": defaultdict(list),\n }\n for dataset_name, dataset in data.items():\n for sample in dataset:\n instance = self.build_input(\n self.tokenizer, sample[\"text\"], label_encoder, sample[\"label\"]\n )\n for input_name, input_array in instance.items():\n datasets[dataset_name][input_name].append(input_array)\n\n click.secho(\"Padding inputs and building tensors.\", fg=\"yellow\")\n tensor_datasets = {\"train\": [], \"valid\": [], \"test\": []}\n for dataset_name, dataset in datasets.items():\n dataset = self.pad_dataset(dataset, padding=self.tokenizer.pad_index)\n for input_name in MODEL_INPUTS:\n if input_name == \"labels\":\n tensor = torch.tensor(dataset[input_name], dtype=torch.float32)\n else:\n tensor = torch.tensor(dataset[input_name])\n tensor_datasets[dataset_name].append(tensor)\n\n self.train_dataset = TensorDataset(*tensor_datasets[\"train\"])\n self.valid_dataset = TensorDataset(*tensor_datasets[\"valid\"])\n self.test_dataset = TensorDataset(*tensor_datasets[\"test\"])\n click.secho(\n \"Train dataset (Batch, Candidates, Seq length): {}\".format(\n self.train_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )\n click.secho(\n \"Valid dataset (Batch, Candidates, Seq length): {}\".format(\n self.valid_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )\n click.secho(\n \"Test dataset (Batch, Candidates, Seq length): {}\".format(\n self.test_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )","def data_loaders(dataset_path):\n dataset_path = dataset_path\n news_stock_dataset = NewsStockDataLoader(dataset_path)\n \n dataset_size = len(news_stock_dataset)\n indices = list(range(dataset_size))\n training_split = int(0.8 * dataset_size)\n validation_split = int(0.9 * dataset_size)\n\n np.random.seed(96)\n np.random.shuffle(indices)\n\n train_indices = indices[:training_split]\n valid_indices = indices[training_split:validation_split]\n test_indices = indices[validation_split:]\n\n train_sampler = SubsetRandomSampler(train_indices)\n valid_sampler = SubsetRandomSampler(valid_indices)\n test_sampler = SubsetRandomSampler(test_indices)\n \n collate = PadSequence()\n\n training_loader = DataLoader(news_stock_dataset,\n num_workers = 1,\n batch_size = Config.get(\"training_batch_size\"),\n sampler = train_sampler,\n collate_fn = collate)\n\n validation_loader = DataLoader(news_stock_dataset,\n num_workers = 1,\n batch_size = Config.get(\"validation_batch_size\"),\n sampler = valid_sampler,\n collate_fn = collate)\n\n testing_loader = DataLoader(news_stock_dataset,\n num_workers = 1,\n batch_size = Config.get(\"testing_batch_size\"),\n sampler= test_sampler,\n collate_fn = collate)\n \n return training_loader, validation_loader, testing_loader","def get_loaders(opt):\n train_samples, val_samples = get_train_val_metadata(opt.dataset_dir,\n opt.validation_cities,\n opt.patch_size,\n opt.stride)\n print('train samples : ', len(train_samples))\n print('val samples : ', len(val_samples))\n\n logging.info('STARTING Dataset Creation')\n\n full_load = full_onera_loader(opt.dataset_dir, opt)\n\n train_dataset = OneraPreloader(opt.dataset_dir,\n train_samples,\n full_load,\n opt.patch_size,\n opt.augmentation)\n val_dataset = OneraPreloader(opt.dataset_dir,\n val_samples,\n full_load,\n opt.patch_size,\n False)\n\n logging.info('STARTING Dataloading')\n\n train_loader = torch.utils.data.DataLoader(train_dataset,\n batch_size=opt.batch_size,\n shuffle=True,\n num_workers=opt.num_workers)\n val_loader = torch.utils.data.DataLoader(val_dataset,\n batch_size=opt.batch_size,\n shuffle=False,\n num_workers=opt.num_workers)\n return train_loader, val_loader","def get_driving_data_loaders(batch_size, train_dataset, valid_dataset, test_dataset, num_workers=0): \n\n valid_loader = DataLoader(dataset=valid_dataset,\n batch_size=batch_size,\n num_workers=num_workers,\n shuffle=True)\n\n train_loader = DataLoader(dataset=train_dataset,\n batch_size=batch_size,\n num_workers=num_workers,\n drop_last=True, \n shuffle=True)\n\n test_loader = DataLoader(dataset=test_dataset,\n batch_size=batch_size,\n num_workers=num_workers,\n shuffle=False)\n\n return train_loader, valid_loader, test_loader","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 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 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_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 get_dataloaders(datasets, split, args, is_eval=False):\n dataloaders = []\n for task, dataset in datasets.items():\n if is_eval:\n num_rows = dataset.num_rows if args.eval_rows == -1 else args.eval_rows\n else:\n num_rows = dataset.num_rows if args.train_rows == -1 else args.train_rows\n all_input_ids = np.zeros([num_rows, args.max_length])\n all_attention_mask = np.zeros([num_rows, args.max_length])\n all_token_type_ids = np.zeros([num_rows, args.max_length])\n for i in range(num_rows):\n features = dataset[i]\n curr_len = len(features[\"attention_mask\"])\n all_input_ids[i,:curr_len] = features[\"input_ids\"]\n all_attention_mask[i,:curr_len] = features[\"attention_mask\"]\n all_token_type_ids[i,:curr_len] = features[\"token_type_ids\"]\n all_input_ids = torch.tensor(all_input_ids, dtype=torch.long)\n all_attention_mask = torch.tensor(all_attention_mask, dtype=torch.long)\n all_token_type_ids = torch.tensor(all_token_type_ids, dtype=torch.long)\n all_label = torch.tensor(dataset[:num_rows][\"label\"], dtype=torch.long)\n if task == \"stsb\":\n all_label = all_label.float()\n \n data = TensorDataset(all_input_ids, all_attention_mask, all_token_type_ids, all_label)\n if split in [\"train\", \"support\"]:\n sampler = RandomSampler(data)\n dataloader = DataLoader(data, sampler=sampler, batch_size=args.train_batch_size)\n else:\n sampler = SequentialSampler(data)\n dataloader = DataLoader(data, sampler=sampler, batch_size=args.eval_batch_size)\n dataloaders.append(dataloader)\n return dataloaders","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 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 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 create_trainval_dataloaders(params):\n # ----------------Create Dataset objects and Dataloaders----------------\n mr_dataset_train, tokenizer = get_dataset(params, run_mode=\"train\")\n params.vocab_size = tokenizer.get_vocab_size()\n print(\"SystemLog: Vocab size used for training is %d\" % (params.vocab_size))\n print(\"SystemLog: Number of items in the train dataset=%d\" % len(mr_dataset_train))\n sys.stdout.flush()\n # Collate Function pads the sequences to have a uniform length for the entire batch\n mr_dataloader_train = DataLoader(mr_dataset_train, batch_size=params.batch_size,\n shuffle=True, num_workers=params.num_workers, collate_fn=CollateMRSequence(params.architecture))\n\n mr_dataset_valid, _ = get_dataset(params, run_mode=\"valid\")\n print(\"SystemLog: Number of items in the valid dataset=%d\" % len(mr_dataset_valid))\n mr_dataloader_valid = DataLoader(mr_dataset_valid, batch_size=params.batch_size_validation,\n shuffle=False, num_workers=0, collate_fn=CollateMRSequence(params.architecture))\n\n return mr_dataset_train, mr_dataloader_train, mr_dataset_valid, mr_dataloader_valid","def get_feature_loader(rxspecifiers, feature_loader, batch_size, num_workers):\n dataset = _Kaldi_Dataset(rxspecifiers, feature_loader, batch_size)\n return data.DataLoader(dataset, batch_size=1, shuffle=False, num_workers=num_workers, collate_fn=_collater)","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 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_test_loader(id_list = './data/sample_submission.csv', root_dir = './data/test/'):\n data = HumanProteinDataset(id_list, root_dir, transform = transforms.Compose([\n Rescale((256, 256)), \n ToTensor()\n ]))\n\n indices = np.arange(len(data))\n dataloader_test = DataLoader(data, batch_size=10, num_workers=5)\n\n return dataloader_test","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 dataloaders():\n # train data path\n data_train = '../dataset/train/'\n # set transformations\n train_transforms = transforms.Compose([\n transforms.Resize((224, 224)),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406],\n [0.229, 0.224, 0.225])])\n \n train_data = datasets.ImageFolder(data_train, transform = train_transforms)\n trainloader = torch.utils.data.DataLoader(train_data, batch_size = 16, shuffle = True)\n \n return trainloader","def dataio_prepare(hparams):\n data_folder = hparams[\"data_folder\"]\n\n train_data = dataset.DynamicItemDataset.from_csv(\n csv_path=hparams[\"train_data\"],\n replacements={\"data_root\": data_folder}, )\n\n if hparams[\"sorting\"] == \"ascending\":\n # we sort training data to speed up training and get better results.\n train_data = train_data.filtered_sorted(sort_key=\"duration\")\n # when sorting do not shuffle in dataloader ! otherwise is pointless\n hparams[\"train_dataloader_opts\"][\"shuffle\"] = False\n\n elif hparams[\"sorting\"] == \"descending\":\n train_data = train_data.filtered_sorted(\n sort_key=\"duration\", reverse=True)\n # when sorting do not shuffle in dataloader ! otherwise is pointless\n hparams[\"train_dataloader_opts\"][\"shuffle\"] = False\n\n elif hparams[\"sorting\"] == \"random\":\n pass\n\n else:\n raise NotImplementedError(\n \"sorting must be random, ascending or descending\")\n\n valid_data = dataset.DynamicItemDataset.from_csv(\n csv_path=hparams[\"valid_data\"],\n replacements={\"data_root\": data_folder}, )\n valid_data = valid_data.filtered_sorted(sort_key=\"duration\")\n\n test_data = dataset.DynamicItemDataset.from_csv(\n csv_path=hparams[\"test_data\"],\n replacements={\"data_root\": data_folder}, )\n test_data = test_data.filtered_sorted(sort_key=\"duration\")\n\n datasets = [train_data, valid_data, test_data]\n\n # Defining tokenizer and loading it\n tokenizer = transformers.BertTokenizer.from_pretrained('bert-base-chinese')\n\n # 2. Define audio pipeline:\n @data_pipeline.takes(\"wav\")\n @data_pipeline.provides(\"sig\")\n def audio_pipeline(wav):\n sig = dataio.read_audio(wav)\n return sig\n\n dataset.add_dynamic_item(datasets, audio_pipeline)\n\n # 3. Define text pipeline:\n @data_pipeline.takes(\"transcript\")\n @data_pipeline.provides(\"wrd\", \"tokens_list\", \"tokens\")\n def text_pipeline(wrd):\n wrd = \"\".join(wrd.split(\" \"))\n yield wrd\n tokens_list = tokenizer(wrd)[\"input_ids\"]\n yield tokens_list\n tokens = numpy.array(tokens_list, dtype=\"int64\")\n yield tokens\n\n dataset.add_dynamic_item(datasets, text_pipeline)\n\n # 4. Set output:\n dataset.set_output_keys(\n datasets,\n [\"id\", \"sig\", \"wrd\", \"tokens\"], )\n\n # 5. If Dynamic Batching is used, we instantiate the needed samplers.\n train_batch_sampler = None\n valid_batch_sampler = None\n if hparams[\"dynamic_batching\"]:\n from sampler import DynamicBatchSampler # noqa\n\n dynamic_hparams = hparams[\"dynamic_batch_sampler\"]\n num_buckets = dynamic_hparams[\"num_buckets\"]\n\n train_batch_sampler = DynamicBatchSampler(\n train_data,\n dynamic_hparams[\"max_batch_len\"],\n num_buckets=num_buckets,\n length_func=lambda x: x[\"duration\"],\n shuffle=dynamic_hparams[\"shuffle_ex\"],\n batch_ordering=dynamic_hparams[\"batch_ordering\"], )\n\n valid_batch_sampler = DynamicBatchSampler(\n valid_data,\n dynamic_hparams[\"max_batch_len\"],\n num_buckets=num_buckets,\n length_func=lambda x: x[\"duration\"],\n shuffle=dynamic_hparams[\"shuffle_ex\"],\n batch_ordering=dynamic_hparams[\"batch_ordering\"], )\n\n return (train_data, valid_data, test_data, tokenizer, train_batch_sampler,\n valid_batch_sampler, )","def initialize_dataloaders(\n self, X: Union[np.ndarray, pd.DataFrame], y: Union[np.ndarray, np.array]\n ):\n training_design_matrix, training_targets_array, validation_design_matrix, validation_targets_array = self.generate_training_validation_split(\n X, y\n )\n training_dataloader_kwargs = {\n \"design_matrix\": training_design_matrix,\n \"targets_array\": training_targets_array,\n \"data_type\": self.data_type,\n \"batch_size\": self.batch_size,\n \"shuffle\": self.shuffle_training_examples,\n }\n validation_dataloader_kwargs = {\n \"design_matrix\": validation_design_matrix,\n \"targets_array\": validation_targets_array,\n \"data_type\": self.data_type,\n \"batch_size\": self.batch_size,\n \"shuffle\": False,\n }\n self.training_dataloader = self.generate_dataloader(**training_dataloader_kwargs)\n self.validation_dataloader = self.generate_dataloader(**validation_dataloader_kwargs)","def train_dataloader(self) -> torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_train, **self.dl_kwargs)","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 create_split_loaders(root_dir, batch_size, seed=0, transform=transforms.ToTensor(),\n p_val=0.1, p_test=0.2, shuffle=True, \n show_sample=False, extras={}):\n \n\n # once all single json datasets are created you can concat them into a single one:\n quickdraw_dataset = CharacterDataset(root_dir=root_dir, transform=transform)\n \n # Dimensions and indices of training set\n dataset_size = len(quickdraw_dataset)\n all_indices = list(range(dataset_size))\n\n # Shuffle dataset before dividing into training & test sets\n if shuffle:\n np.random.seed(seed)\n np.random.shuffle(all_indices)\n \n # Create the validation split from the full dataset\n val_split = int(np.floor(p_val * dataset_size))\n train_ind, val_ind = all_indices[val_split :], all_indices[: val_split]\n \n # Separate a test split from the training dataset\n test_split = int(np.floor(p_test * len(train_ind)))\n train_ind, test_ind = train_ind[test_split :], train_ind[: test_split]\n print(len(train_ind), len(val_ind), len(test_ind))\n # Use the SubsetRandomSampler as the iterator for each subset\n sample_train = SubsetRandomSampler(train_ind)\n sample_test = SubsetRandomSampler(test_ind)\n sample_val = SubsetRandomSampler(val_ind)\n\n num_workers = 0\n pin_memory = False\n # If CUDA is available\n if extras:\n num_workers = extras[\"num_workers\"]\n pin_memory = extras[\"pin_memory\"]\n \n # Define the training, test, & validation DataLoaders\n train_loader = DataLoader(quickdraw_dataset, batch_size=batch_size, \n sampler=sample_train, num_workers=num_workers, \n pin_memory=pin_memory)\n\n test_loader = DataLoader(quickdraw_dataset, batch_size=batch_size, \n sampler=sample_test, num_workers=num_workers, \n pin_memory=pin_memory)\n\n val_loader = DataLoader(quickdraw_dataset, batch_size=batch_size,\n sampler=sample_val, num_workers=num_workers, \n pin_memory=pin_memory)\n\n \n # Return the training, validation, test DataLoader objects\n return (train_loader, val_loader, test_loader)","def get_dataloaders(data_dir, hyp):\n \n # Grab data, targets\n data_file_paths, targets = get_files_paths_and_labels(data_dir)\n \n # Split into train/validation\n train_data, val_data, train_labels, val_labels = train_test_split(data_file_paths,\n targets,\n train_size=hyp['perc_train'],\n shuffle=hyp['shuffle'],\n stratify=targets)\n\n # Create train/validation augmentation handler\n train_aug = get_training_augmentations(hyp)\n val_aug = get_validation_augmentations(hyp)\n \n # Create datasets\n train_dset = SETIDataset(train_data, train_labels, transform=train_aug)\n val_dset = SETIDataset(val_data, val_labels, transform=val_aug)\n \n # Create dataloaders\n train_loader = DataLoader(train_dset, shuffle=True, batch_size=hyp['batch_size'], \n pin_memory=True, num_workers=8)\n \n val_loader = DataLoader(val_dset, batch_size=hyp['batch_size'], \n pin_memory=True, num_workers=8)\n \n return train_loader, val_loader","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_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 get_loaders(\n data_dir,\n train_transforms=None,\n val_transforms=None,\n train_test_split=0.85,\n train_val_split=0.15,\n batch_size=16,\n shuffle=True):\n np.random.seed(24)\n train_ds = ImageFolder(root=data_dir, transform=train_transforms)\n val_ds = ImageFolder(root=data_dir, transform=val_transforms)\n test_ds = ImageFolder(root=data_dir, transform=val_transforms)\n img_count = len(train_ds)\n indices = list(range(img_count))\n test_split = int(img_count * train_test_split)\n if shuffle:\n np.random.shuffle(indices)\n train_idx, test_idx = indices[:test_split], indices[test_split:]\n train_count = len(train_idx)\n val_split = int(train_count * (1 - train_val_split))\n train_idx, val_idx = train_idx[:val_split], train_idx[val_split:]\n train_sample = SubsetRandomSampler(train_idx)\n val_sample = SubsetRandomSampler(val_idx)\n test_sample = SubsetRandomSampler(test_idx)\n train_loader = DataLoader(train_ds, batch_size=batch_size, sampler=train_sample)\n val_loader = DataLoader(val_ds, batch_size=batch_size, sampler=val_sample)\n test_loader = DataLoader(test_ds, batch_size=batch_size, sampler=test_sample)\n\n return train_loader, val_loader, test_loader","def prepare_data_loaders_without_shuffle(batch_size=32, hier=False, elmo=False, elmo_pre=None, use_elmo_pre=False, deepmoji=False, dev_with_label=False, include_test=False):\n train_data_loaders = []\n val_data_loaders = []\n test_data_loaders = []\n\n vocab = generate_vocab(deepmoji)\n train, val, test, _ = prepare_data(batch_size=batch_size, hier=hier, elmo=elmo, elmo_pre=elmo_pre, use_elmo_pre=use_elmo_pre, deepmoji=deepmoji, is_shuffle=False, vocab=vocab, dev_with_label=dev_with_label, include_test=include_test)\n\n return train, val, test, vocab","def _init_loaders(self):\n @self.loaders_wrapper(\"nx2nx\")\n def get_nx2nx_loader(extractor, stream, transformers, graph):\n \"\"\"\n :param tranformers: List of dicts.\n :extractor: function.\n :param graph: networkx.Graph\n :returns: projx.nx_loader\n \"\"\"\n return loaders.nx2nx_loader(extractor, stream, transformers,\n self.loader_json[self.loader_name],\n graph)\n\n @self.loaders_wrapper(\"neo4j2nx\")\n def get_neo4j2nx_loader(extractor, stream, transformers, graph):\n \"\"\"\n :param tranformers: List of dicts.\n :extractor: function.\n :param graph: networkx.Graph\n :returns: projx.nx_loader\n \"\"\"\n return loaders.neo4j2nx_loader(extractor, stream, transformers,\n self.loader_json[self.loader_name],\n graph)\n\n\n @self.loaders_wrapper(\"neo4j2edgelist\")\n def get_neo4j2edgelist_loader(extractor, stream, transformers, graph):\n \"\"\"\n :param tranformers: List of dicts.\n :extractor: function.\n :param graph: networkx.Graph\n :returns: projx.nx_loader\n \"\"\"\n return loaders.neo4j2edgelist_loader(\n extractor,\n stream,\n transformers,\n self.loader_json[self.loader_name],\n graph\n )\n\n\n @self.loaders_wrapper(\"edgelist2neo4j\")\n def get_edgelist2neo4j_loader(extractor, stream, transformers, graph):\n \"\"\"\n :param tranformers: List of dicts.\n :extractor: function.\n :param graph: networkx.Graph\n :returns: projx.nx_loader\n \"\"\"\n return loaders.edgelist2neo4j_loader(\n extractor,\n stream,\n transformers,\n self.loader_json[self.loader_name],\n graph\n )","def build_dataloaders(dataset, batch_size, train_test_split=0.1, train_shuffle=True, eval_shuffle=True):\n # 데이터셋 길이\n dataset_len = len(dataset)\n\n # 학습, 평가 데이터 나누기\n eval_len = int(dataset_len * train_test_split)\n train_len = dataset_len - eval_len\n\n train_dataset, eval_dataset = random_split(dataset, (train_len, eval_len))\n\n train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=train_shuffle)\n eval_loader = DataLoader(eval_dataset, batch_size=batch_size, shuffle=eval_shuffle)\n\n\n logging.info(f'''train_dataloader size: {len(train_loader.dataset)} | shuffle: {train_shuffle}\n eval_dataloader size: {len(eval_loader.dataset)} | shuffle: {eval_shuffle}''')\n\n return train_loader, eval_loader","def get_loader(mode):\n\tglobal train_loader, valid_loader\n\tconfig = Config\n\ttransform_list_train = []\n\ttransform_list_test = []\n\tis_train = mode == \"train\"\n\tif config.train.use_augmentation:\n\t\ttransform_list_train.extend([transforms.Resize((config.data.image_size, config.data.image_size)), ImageNetPolicy()])\n\ttransform_list_train.extend([transforms.Resize((config.data.image_size, config.data.image_size)), transforms.ToTensor(),\n\t transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\n\t\n\ttransform_train = transforms.Compose(transform_list_train)\n\t\n\tif config.predict.use_augmentation:\n\t\ttransform_list_test.extend([transforms.Resize((config.data.image_size, config.data.image_size)), ImageNetPolicy()])\n\ttransform_list_test.extend([transforms.Resize((config.data.image_size, config.data.image_size)), transforms.ToTensor(),\n\t transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\n\t\n\ttransform_test = transforms.Compose(transform_list_test)\n\tif config.model.dataset == \"mnist\":\n\t\tmnist = datasets.MNIST(root=config.data.mnist_path, download=True, transform=transform_train, train=is_train)\n\t\t# train-validation split\n\t\ttrain_mnist, valid_mnist = train_valid_split(mnist)\n\t\ttrain_loader = DataLoader(dataset=train_mnist, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\n\t\tvalid_loader = DataLoader(dataset=valid_mnist, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\n\tif config.model.dataset == \"svhn\":\n\t\tsvhn = datasets.SVHN(root=config.data.svhn_path, download=True, transform=transform_train, split=mode)\n\t\ttrain_svhn, valid_svhn = train_valid_split(svhn)\n\t\ttrain_loader = DataLoader(dataset=train_svhn, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\n\t\tvalid_loader = DataLoader(dataset=valid_svhn, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\n\tif config.model.dataset == \"cifar10\":\n\t\tcifar10 = datasets.CIFAR10(root=config.data.cifar10_path, download=True, transform=transform_train, train=is_train)\n\t\ttrain_cifar, valid_cifar = train_valid_split(cifar10)\n\t\ttrain_loader = DataLoader(dataset=train_cifar, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\n\t\tvalid_loader = DataLoader(dataset=valid_cifar, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\n\tif config.model.dataset == \"moons\":\n\t\ttrain_moons, valid_moons = train_valid_split(moons_dataset())\n\t\ttrain_loader = DataLoader(dataset=train_moons, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\n\t\tvalid_loader = DataLoader(dataset=valid_moons, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\n\tif config.model.dataset == \"miniimagenet\":\n\t\ttrain_loader, valid_loader = read_dataset(Config.data.miniimagenet_path, transform_train, transform_test) # transform_train(train_loader)\n\tif config.model.dataset == \"miniimagenet_all\":\n\t\ttrain_loader = datasets.ImageFolder(root=config.data.miniimagenet_path_train, transform=transform_train)\n\t\tvalid_loader = datasets.ImageFolder(root=config.data.miniimagenet_path_valid, transform=transform_list_test)\n\t\t# \t# test_imagenet = datasets.ImageFolder(root=config.data.miniimagenet_path_test)\n\t\ttrain_loader = DataLoader(dataset=train_loader, batch_size=Config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\n\t\tvalid_loader = DataLoader(dataset=valid_loader, batch_size=Config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\n\t# \t# test_loader = DataLoader(dataset=test_imagenet, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\n\tif config.model.dataset == \"miniimagenet_concat\":\n\t\tconcat_dataset = ConcatDataset([datasets.ImageFolder(config.data.miniimagenet_path_train, transform=transform_train),\n\t\t datasets.ImageFolder(config.data.miniimagenet_path_valid, transform=transform_train)])\n\t\ttrain_, valid_ = train_valid_split(concat_dataset)\n\t\ttrain_loader = torch.utils.data.DataLoader(train_, batch_size=config.train.batch_size, shuffle=True, num_workers=config.data.num_workers, pin_memory=True)\n\t\tvalid_loader = torch.utils.data.DataLoader(valid_, batch_size=config.train.batch_size, shuffle=True, num_workers=config.data.num_workers, pin_memory=True)\n\t\n\tif config.model.dataset == \"imagenet\":\n\t\ttrain_loader = datasets.ImageFolder(root=config.data.imagenet_path_train, transform=transform_train)\n\t\tvalid_loader = datasets.ImageFolder(root=config.data.imagenet_path_val, transform=transform_list_test)\n\t\t# \t# test_imagenet = datasets.ImageFolder(root=config.data.miniimagenet_path_test)\n\t\ttrain_loader = DataLoader(dataset=train_loader, batch_size=Config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\n\t\tvalid_loader = DataLoader(dataset=valid_loader, batch_size=Config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\n\treturn train_loader, valid_loader","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 _init_train_loader(self):\n # Choose the right dataset type\n if self.config_args[\"num_members\"] > 1:\n class_dataset_wrapper = dataset_wrapper.MixMoDataset\n else:\n class_dataset_wrapper = dataset_wrapper.MSDADataset\n\n # Load augmentations\n self.traindatasetwrapper = class_dataset_wrapper(\n dataset=self.train_dataset,\n num_classes=int(self.config_args[\"data\"][\"num_classes\"]),\n num_members=self.config_args[\"num_members\"],\n dict_config=self.config_args[\"training\"][\"dataset_wrapper\"],\n properties=self.properties\n )\n\n # Build standard sampler\n _train_sampler = torch.utils.data.sampler.RandomSampler(\n data_source=self.traindatasetwrapper, ## only needed for its length\n num_samples=None,\n replacement=False,\n )\n\n # Wrap it with the repeating sampler used for multi-input models\n batch_sampler = batch_repetition_sampler.BatchRepetitionSampler(\n sampler=_train_sampler,\n batch_size=self.batch_size,\n num_members=self.config_args[\"num_members\"],\n drop_last=True,\n config_batch_sampler=self.config_args[\"training\"][\"batch_sampler\"]\n )\n\n self.train_loader = torch.utils.data.DataLoader(\n self.traindatasetwrapper,\n batch_sampler=batch_sampler,\n num_workers=self.num_workers,\n batch_size=1,\n shuffle=False,\n sampler=None,\n drop_last=False,\n pin_memory=True,\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)","def get_loader(data_list, config, train=True):\n \n with open(config[\"label_map\"], \"r\") as f:\n label_map = json.load(f)\n\n dataset = GoogleSpeechDataset(\n data_list=data_list,\n label_map=label_map,\n audio_settings=config[\"hparams\"][\"audio\"],\n aug_settings=config[\"hparams\"][\"augment\"] if train else None,\n cache=config[\"exp\"][\"cache\"]\n )\n\n dataloader = DataLoader(\n dataset,\n batch_size=config[\"hparams\"][\"batch_size\"],\n num_workers=config[\"exp\"][\"n_workers\"],\n pin_memory=config[\"exp\"][\"pin_memory\"],\n shuffle=True if train else False\n )\n\n return dataloader","def create_pretraining_dataloader(\n hdf5_fpath: str,\n max_masked_tokens_per_input: int,\n batch_size: int\n ):\n pretraining_data = PretrainingDataset(\n hdf5_fpath=hdf5_fpath,\n max_masked_tokens_per_input=max_masked_tokens_per_input\n )\n train_sampler = RandomSampler(pretraining_data)\n train_dataloader = DataLoader(\n pretraining_data,\n sampler=train_sampler,\n batch_size=batch_size,\n num_workers=4,\n pin_memory=True\n )\n return train_dataloader, hdf5_fpath","def __init__(self, dataset_name, split, *args, data_dir=None, **kwargs):\n super(TfdsInput, self).__init__(*args, **kwargs)\n self.dataset_name = dataset_name\n self.split = split\n self.data_dir = data_dir","def to_DataLoader(self, **kwargs):\r\n return DataLoader(self, **kwargs)","def make_loader(model, dataset, batch_size, workers, eval_proportion):\n dataset_extra_args = dict(\n num_frames=model['num_frames'],\n channels=model['input_type'],\n action_space=model['action_space'],\n steps_action=model['steps_action'],\n num_signals=model['num_signals'],\n num_skills=model['num_skills'])\n if model['mode'] == 'regression':\n dataset_class = RegressionDataset\n else:\n dataset_class = ImitationDataset\n\n im_dataset = dataset_class(**dataset, **dataset_extra_args)\n train_dataset, eval_dataset = split_dataset(im_dataset, eval_proportion)\n train_loader = torch.utils.data.DataLoader(\n train_dataset,\n batch_size,\n num_workers=workers,\n shuffle=True,\n drop_last=False)\n if eval_dataset is not None:\n eval_loader = torch.utils.data.DataLoader(\n eval_dataset,\n batch_size,\n num_workers=workers,\n shuffle=True,\n drop_last=False)\n else:\n eval_loader = None\n\n env_name = im_dataset._frames.infos['env_name']\n return (train_loader, eval_loader, env_name, im_dataset.get_statistics())","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 load_dataloaders(args):\n logger.info(\"Loading dataloaders...\")\n p_path = os.path.join(\"./data/\", \"df_unencoded.pkl\")\n train_path = os.path.join(\"./data/\", \"df_encoded.pkl\")\n if (not os.path.isfile(p_path)) and (not os.path.isfile(train_path)):\n df = get_data(args, load_extracted=False)\n elif os.path.isfile(p_path) and (not os.path.isfile(train_path)):\n df = get_data(args, load_extracted=True)\n elif os.path.isfile(train_path):\n df = load_pickle(\"df_encoded.pkl\")\n \n # Train-Test split\n msk = np.random.rand(len(df)) < args.train_test_ratio\n trainset = df[msk]\n testset = df[~msk]\n \n trainset = text_dataset(trainset, args)\n max_features_length = trainset.max_x_len\n max_seq_len = trainset.max_y_len\n train_length = len(trainset)\n train_loader = DataLoader(trainset, batch_size=args.batch_size, shuffle=True,\\\n num_workers=0, collate_fn=Pad_Sequence(), pin_memory=False)\n \n testset = text_dataset(testset, args)\n test_length = len(testset)\n test_loader = DataLoader(testset, batch_size=args.batch_size, shuffle=True,\\\n num_workers=0, collate_fn=Pad_Sequence(), pin_memory=False)\n return train_loader, train_length, max_features_length, max_seq_len, test_loader, test_length","def make_loader(dataset, train_batch_size, validation_split=0.2):\n # number of samples in train and test set\n train_len = int(len(dataset) * (1 - validation_split))\n test_len = len(dataset) - train_len\n train_set, test_set = torch.utils.data.random_split(dataset, [train_len, test_len])\n # create train_loader\n train_loader = torch.utils.data.DataLoader(\n train_set, batch_size=train_batch_size, shuffle=True,\n )\n # create test_loader\n test_loader = torch.utils.data.DataLoader(test_set, batch_size=1, shuffle=False,)\n return train_loader, test_loader","def fetch_dataloader(types, dataset_dir, params):\n\n dataloaders = {}\n samplers = {}\n\n for split in ['train', 'val', 'test']:\n if split in types:\n path = os.path.join(dataset_dir, \"{}\".format(split))\n\n # Use the train_transformer if training data, else use eval_transformer without random flip\n # take care of 'pin_memory' and 'num_workers'\n if split == 'train':\n train_set = BaseDataset(path, train_transformer)\n sampler = None\n if params.distributed:\n sampler = torch.utils.data.distributed.DistributedSampler(\n train_set)\n dataloader = DataLoader(\n train_set,\n batch_size=params.batch_size_pre_gpu,\n shuffle=(sampler is None),\n num_workers=params.num_workers,\n pin_memory=params.cuda,\n sampler=sampler)\n\n else:\n val_set = BaseDataset(path, eval_transformer)\n sampler = None\n if params.distributed:\n sampler = torch.utils.data.distributed.DistributedSampler(\n val_set)\n dataloader = DataLoader(\n val_set,\n batch_size=params.batch_size_pre_gpu,\n shuffle=False,\n pin_memory=params.cuda,\n num_workers=params.num_workers,\n sampler=sampler)\n\n dataloaders[split] = dataloader\n samplers[split] = sampler\n\n return dataloaders, samplers","def get_dataset_loader(self, batch_size, workers, is_gpu):\n\n train_loader = torch.utils.data.DataLoader(\n self.trainset,\n batch_size=batch_size, shuffle=True,\n num_workers=workers, pin_memory=is_gpu, sampler=None)\n\n val_loader = torch.utils.data.DataLoader(\n self.valset,\n batch_size=batch_size, shuffle=False,\n num_workers=workers, pin_memory=is_gpu)\n\n return train_loader, val_loader","def get_dataset_loader(self, batch_size, workers, is_gpu):\n\n train_loader = torch.utils.data.DataLoader(\n self.trainset,\n batch_size=batch_size, shuffle=True,\n num_workers=workers, pin_memory=is_gpu, sampler=None)\n\n val_loader = torch.utils.data.DataLoader(\n self.valset,\n batch_size=batch_size, shuffle=False,\n num_workers=workers, pin_memory=is_gpu)\n\n return train_loader, val_loader","def get_dataset_loader(self, batch_size, workers, is_gpu):\n\n train_loader = torch.utils.data.DataLoader(\n self.trainset,\n batch_size=batch_size, shuffle=True,\n num_workers=workers, pin_memory=is_gpu, sampler=None)\n\n val_loader = torch.utils.data.DataLoader(\n self.valset,\n batch_size=batch_size, shuffle=False,\n num_workers=workers, pin_memory=is_gpu)\n\n return train_loader, val_loader","def get_dataset_loader(self, batch_size, workers, is_gpu):\n\n train_loader = torch.utils.data.DataLoader(\n self.trainset,\n batch_size=batch_size, shuffle=True,\n num_workers=workers, pin_memory=is_gpu, sampler=None)\n\n val_loader = torch.utils.data.DataLoader(\n self.valset,\n batch_size=batch_size, shuffle=False,\n num_workers=workers, pin_memory=is_gpu)\n\n return train_loader, val_loader","def get_dataset_loader(self, batch_size, workers, is_gpu):\n\n train_loader = torch.utils.data.DataLoader(\n self.trainset,\n batch_size=batch_size, shuffle=True,\n num_workers=workers, pin_memory=is_gpu, sampler=None)\n\n val_loader = torch.utils.data.DataLoader(\n self.valset,\n batch_size=batch_size, shuffle=False,\n num_workers=workers, pin_memory=is_gpu)\n\n return train_loader, val_loader","def get_dataset_loader(self, batch_size, workers, is_gpu):\n\n train_loader = torch.utils.data.DataLoader(\n self.trainset,\n batch_size=batch_size, shuffle=True,\n num_workers=workers, pin_memory=is_gpu, sampler=None)\n\n val_loader = torch.utils.data.DataLoader(\n self.valset,\n batch_size=batch_size, shuffle=False,\n num_workers=workers, pin_memory=is_gpu)\n\n return train_loader, val_loader","def get_dataset_loader(self, batch_size, workers, is_gpu):\n\n train_loader = torch.utils.data.DataLoader(\n self.trainset,\n batch_size=batch_size, shuffle=True,\n num_workers=workers, pin_memory=is_gpu, sampler=None)\n\n val_loader = torch.utils.data.DataLoader(\n self.valset,\n batch_size=batch_size, shuffle=False,\n num_workers=workers, pin_memory=is_gpu)\n\n return train_loader, val_loader","def get_dataset_loader(self, batch_size, workers, is_gpu):\n\n train_loader = torch.utils.data.DataLoader(\n self.trainset,\n batch_size=batch_size, shuffle=True,\n num_workers=workers, pin_memory=is_gpu, sampler=None)\n\n val_loader = torch.utils.data.DataLoader(\n self.valset,\n batch_size=batch_size, shuffle=False,\n num_workers=workers, pin_memory=is_gpu)\n\n return train_loader, val_loader","def get_dataset_loader(self, batch_size, workers, is_gpu):\n\n train_loader = torch.utils.data.DataLoader(\n self.trainset,\n batch_size=batch_size, shuffle=True,\n num_workers=workers, pin_memory=is_gpu, sampler=None)\n\n val_loader = torch.utils.data.DataLoader(\n self.valset,\n batch_size=batch_size, shuffle=False,\n num_workers=workers, pin_memory=is_gpu)\n\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 train_input(config, params):\n\n def _grouping(rim, rla, pim, pla, imp, lap):\n # group dataset elements as required by estimator\n features = {\n 'rawimages': rim,\n 'proimages': pim,\n 'rawimagespaths': imp,\n 'rawlabelspaths': lap,\n }\n labels = {\n 'rawlabels': rla,\n 'prolabels': pla,\n }\n\n # next line for distributed debugging\n # tf.string tensors is not supported for DMA read/write to GPUs (TF bug)\n if params.distribute:\n del features['rawimagespaths']\n del features['rawlabelspaths']\n\n return (features, labels)\n\n with tf.variable_scope('input_pipeline'):\n dataset = prebatch_dataset(config, params)\n dataset = dataset.batch(get_temp_Nb(config, params.Nb))\n dataset = postbatch_dataset(dataset, config, params)\n dataset = dataset.map(_grouping, num_parallel_calls=NUM_PARALLEL_CALLS)\n dataset = dataset.prefetch(None)\n\n return dataset","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 get_precomp_loader(data_path, data_split, opt, batch_size=100,\n shuffle=True, num_workers=16):\n dset = PrecompDataset(data_path, data_split, opt)\n\n data_loader = torch.utils.data.DataLoader(dataset=dset,\n batch_size=batch_size,\n shuffle=shuffle,\n pin_memory=True,\n collate_fn=collate_fn,num_workers = num_workers)\n return data_loader","def get_data_loaders_4sentence():\n dataset_path = \"\"\n dataset_cache = None\n personachat = get_dataset(dataset_path, dataset_cache)\n\n tokenizer_selected = OpenAIGPTTokenizer.from_pretrained('openai-gpt')\n logger.info(\"Build inputs and labels\")\n datasets = {\"train\": defaultdict(list), \"valid\": defaultdict(list)}\n personality = []\n history_complete = []\n count_persona = 0\n with open('data_faiss_pegasus_1generated.pkl', 'rb') as f:\n persona_selected_list = pickle.load(f)\n for dataset_name, dataset in personachat.items():\n num_candidates = len(dataset[0][\"utterances\"][0][\"candidates\"])\n if num_candidates > 0 and dataset_name == 'train':\n num_candidates = min(1, num_candidates)\n for dialog in dataset:\n persona = dialog[\"persona_info\"].copy()\n #datasets[personality].append(persona)\n count_history = 0\n for utterance in dialog[\"utterances\"]:\n count_history = count_history + 1\n history = utterance[\"history\"]\n #history_complete.append(history)\n if len(history_splitted) > (len(persona)-1):\n history_chatbot = history[1::2]\n persona_selected = persona_selected_list[count_persona]\n instance = build_input_from_segments_faiss(persona_selected, history_chatbot) \n for input_name, input_array in instance.items():\n datasets[dataset_name][input_name].append(input_array)\n count_persona = count_persona + 1\n return datasets","def get_data_loaders(opt):\n return find_dataloader_using_name(opt.dataloader)(opt).load_data()","def fetch_dataloader(splits, params):\n # train_transforms, val_transforms = get_transforms_initial()\n train_transforms, val_transforms = get_transforms_stanford()\n\n dataloaders = {}\n\n for split in splits:\n\n if split == args.TRAIN:\n dl = DataLoader(ISBI2012Dataset(path_img=args.path_img_train,\n path_target=args.path_target_train,\n transforms=train_transforms,\n split=args.TRAIN),\n batch_size=params.batch_size,\n shuffle=True,\n num_workers=0,\n pin_memory=params.cuda)\n elif split == args.VAL:\n dl = DataLoader(ISBI2012Dataset(path_img=args.path_img_train,\n path_target=args.path_target_train,\n transforms=val_transforms,\n split=args.VAL),\n batch_size=params.batch_size,\n shuffle=True,\n num_workers=0,\n pin_memory=params.cuda)\n elif split == args.TEST:\n dl = DataLoader(ISBI2012Dataset(path_img=args.path_img_test,\n path_target=None,\n transforms=val_transforms,\n split=args.TEST),\n batch_size=params.batch_size,\n shuffle=False,\n num_workers=0,\n pin_memory=params.cuda)\n else:\n raise IndexError('incorrect split')\n\n dataloaders[split] = dl\n\n return dataloaders","def get_precomp_loader(data_path, data_split, vocab, opt, batch_size=100,\r\n shuffle=True, num_workers=2):\r\n\r\n dset = PrecompDataset(data_path, data_split, vocab)\r\n # train_sampler = torch.utils.data.distributed.DistributedSampler(dset)\r\n # if data_split == 'train':\r\n # data_loader = DataLoader(dataset=dset, batch_size=batch_size, shuffle=False, num_workers=num_workers, pin_memory=True, collate_fn=collate_fn, sampler=train_sampler)\r\n # else:\r\n data_loader = DataLoaderX(dataset=dset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers, pin_memory=True, collate_fn=collate_fn)\r\n\r\n return data_loader","def dataio_prepare(hparams, tokenizer):\n\n # 1. Define datasets\n data_folder = hparams[\"data_folder\"]\n\n train_data = sb.dataio.dataset.DynamicItemDataset.from_csv(\n csv_path=hparams[\"train_csv\"], replacements={\"data_root\": data_folder},\n )\n\n if hparams[\"sorting\"] == \"ascending\":\n # we sort training data to speed up training and get better results.\n train_data = train_data.filtered_sorted(\n sort_key=\"duration\",\n key_max_value={\"duration\": hparams[\"avoid_if_longer_than\"]},\n )\n # when sorting do not shuffle in dataloader ! otherwise is pointless\n hparams[\"dataloader_options\"][\"shuffle\"] = False\n\n elif hparams[\"sorting\"] == \"descending\":\n train_data = train_data.filtered_sorted(\n sort_key=\"duration\",\n reverse=True,\n key_max_value={\"duration\": hparams[\"avoid_if_longer_than\"]},\n )\n # when sorting do not shuffle in dataloader ! otherwise is pointless\n hparams[\"dataloader_options\"][\"shuffle\"] = False\n\n elif hparams[\"sorting\"] == \"random\":\n pass\n\n else:\n raise NotImplementedError(\n \"sorting must be random, ascending or descending\"\n )\n\n valid_data = sb.dataio.dataset.DynamicItemDataset.from_csv(\n csv_path=hparams[\"valid_csv\"], replacements={\"data_root\": data_folder},\n )\n # We also sort the validation data so it is faster to validate\n valid_data = valid_data.filtered_sorted(sort_key=\"duration\")\n\n test_data = sb.dataio.dataset.DynamicItemDataset.from_csv(\n csv_path=hparams[\"test_csv\"], replacements={\"data_root\": data_folder},\n )\n\n # We also sort the validation data so it is faster to validate\n test_data = test_data.filtered_sorted(sort_key=\"duration\")\n\n datasets = [train_data, valid_data, test_data]\n\n # 2. Define audio pipeline:\n @sb.utils.data_pipeline.takes(\"wav\")\n @sb.utils.data_pipeline.provides(\"sig\")\n def audio_pipeline(wav):\n info = torchaudio.info(wav)\n sig = sb.dataio.dataio.read_audio(wav)\n resampled = torchaudio.transforms.Resample(\n info.sample_rate, hparams[\"sample_rate\"],\n )(sig)\n return resampled\n\n sb.dataio.dataset.add_dynamic_item(datasets, audio_pipeline)\n\n # 3. Define text pipeline:\n @sb.utils.data_pipeline.takes(\"wrd\")\n @sb.utils.data_pipeline.provides(\n \"tokens_list\", \"tokens_bos\", \"tokens_eos\", \"tokens\"\n )\n def text_pipeline(wrd):\n tokens_list = tokenizer.sp.encode_as_ids(wrd)\n yield tokens_list\n tokens_bos = torch.LongTensor([hparams[\"bos_index\"]] + (tokens_list))\n yield tokens_bos\n tokens_eos = torch.LongTensor(tokens_list + [hparams[\"eos_index\"]])\n yield tokens_eos\n tokens = torch.LongTensor(tokens_list)\n yield tokens\n\n sb.dataio.dataset.add_dynamic_item(datasets, text_pipeline)\n\n # 4. Set output:\n sb.dataio.dataset.set_output_keys(\n datasets, [\"id\", \"sig\", \"tokens_bos\", \"tokens_eos\", \"tokens\"],\n )\n return train_data, valid_data, test_data","def make_data_loader(condition, root='data', base_path='ut-zap50k-images',\n files_json_path='filenames.json',\n batch_size=64, shuffle=False, **kwargs):\n dataset = make_dataset(condition, root, base_path, files_json_path)\n loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,\n shuffle=shuffle, **kwargs)\n return loader","def get_dataloader(sets, root_dir, manifest_path, task, batch_size=1, return_pid = False):\n data_loaders = {}\n\n for set in ['train', 'valid', 'test', 'all_images']: # test doesn't apply to MRNet but will keep in\n if set in sets:\n if set == 'train':\n ds = Dataset(set='train', task = task, root_dir=root_dir, manifest_path = manifest_path, return_pid = return_pid,\n transform=transforms.Compose([transforms.ToPILImage(),\n #transforms.RandomHorizontalFlip(), # default is 50%\n #transforms.RandomAffine(25, # rotation\n # translate=(0.1, 0.1),\n # shear = (-15, 15)),\n transforms.ToTensor(),\n ]))\n loader = DataLoader(ds, batch_size=batch_size, shuffle=True)\n elif set == 'valid':\n ds = Dataset(set='valid', task = task, root_dir=root_dir,manifest_path = manifest_path, return_pid = return_pid,\n transform=transforms.Compose([transforms.ToPILImage(),\n transforms.ToTensor(),\n ]))\n\n loader = DataLoader(ds, batch_size=batch_size, shuffle=False)\n elif set == 'all_images':\n ds = Dataset(set='all_images', task = task, root_dir=root_dir,manifest_path = manifest_path, return_pid = return_pid,\n transform=transforms.Compose([transforms.ToPILImage(),\n transforms.ToTensor(),\n ]))\n loader = DataLoader(ds, batch_size=batch_size, shuffle=False)\n data_loaders[set] = loader\n return (data_loaders)","def get_dataloaders(logging, batch_size):\n # Load Data\n logging.info(\"Reading Train and Test data...\")\n train_df = pd.read_csv(\"C:/tmp/avila_classification/data/avila-tr.txt\", header=None)\n test_df = pd.read_csv(\"C:/tmp/avila_classification/data/avila-ts.txt\", header=None)\n\n # Fix column names\n col_names = ['col_' + str(j + 1) for j in range(train_df.shape[1] - 1)]\n indep_cols = col_names.copy()\n col_names.append('y')\n\n logging.debug(\"Assigning columns\")\n train_df.columns = col_names\n test_df.columns = col_names\n\n # Encode dependent variable column\n le = LabelEncoder()\n le.fit(train_df['y'])\n logging.debug(f\"Classes: {le.classes_}\")\n logging.debug(f\"Transformed Classes: {le.transform(le.classes_)}\")\n\n train_df['y_enc'] = le.transform(train_df['y'])\n test_df['y_enc'] = le.transform(test_df['y'])\n\n # train_df.head()\n logging.debug(f\"Shape of train data: {train_df.shape}\")\n logging.debug(f\"Shape of test data: {test_df.shape}\")\n\n # Create train and validation dataloaders\n train_ds = AvilaDataset(data_frame=train_df, indep_cols=indep_cols, dep_col='y_enc')\n valid_ds = AvilaDataset(data_frame=test_df, indep_cols=indep_cols, dep_col='y_enc')\n\n # Should be some exponent of 2 (128, 256)\n # batch_size = 256\n train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True)\n valid_dl = DataLoader(valid_ds, batch_size=batch_size, shuffle=False)\n\n return train_dl, valid_dl, le","def get_dataloaders(data_dir,train_batch_size,val_batch_size,aug_flag):\n # Create the dataset object.\n transformed_dataset = PersonDataset(data_dir,False)\n # dataloader for train and validation\n validation_split = 0.2\n shuffle_dataset = True\n #random seed to keep the train-val split constant for inference purpose\n random_seed= 42\n # create indices for training and validation splits.\n dataset_size = len(transformed_dataset)\n # we create the indices using python range function and store it into a list\n indices = list(range(dataset_size))\n split = int(np.floor(validation_split*dataset_size))\n if shuffle_dataset:\n np.random.seed(random_seed)\n np.random.shuffle(indices)\n train_indices,val_indices = indices[split:],indices[:split]\n # create dataloaders...\n train_sampler = SubsetRandomSampler(train_indices)\n val_sampler = SubsetRandomSampler(val_indices)\n train_aug,val_aug = aug_flag,False\n train_loader = DataLoader(PersonDataset(data_dir,train_aug), batch_size=train_batch_size, shuffle=False, num_workers=0,sampler = train_sampler)\n val_loader = DataLoader(PersonDataset(data_dir,val_aug), batch_size=val_batch_size, shuffle=False, num_workers=0,sampler = val_sampler)\n\n # dictionary for data loaders..\n dataloaders = {\"train\" :train_loader,\n \"val\":val_loader\n }\n return dataloaders","def prepare(self):\n\n inp = self.config.get('predict.input', 'X:0')\n out = self.config.get('predict.output', 'output:0')\n\n # set input placeholder\n self.input = self.graph.get_tensor_by_name(inp)\n\n # set output operation\n if isinstance(out, str) or isinstance(out, unicode):\n self.output = {out: self.graph.get_tensor_by_name(out)}\n self.output_alone = True\n elif isinstance(out, list):\n self.output = {o: self.graph.get_tensor_by_name(o) for o in out}\n self.output_alone = False\n else:\n raise LoaderException('incorrect predict.output type')","def fetch_dataloader(types, params, CViters):\n\tdataloaders = {}\n\tassert CViters[0] != CViters[1], 'ERROR! Test set and validation set cannot be the same!'\n\t\n\tif len(types)>0:\n\t\tfor split in types:\n\t\t\tif split in ['train', 'val', 'test']:\n\t\t\t\tdl = DataLoader(imageDataset(split, params, CViters), batch_size=params.batch_size, shuffle=True,\n\t\t\t\t\tnum_workers=params.num_workers,\n\t\t\t\t\tpin_memory=params.cuda)\n\n\t\t\t\tdataloaders[split] = dl\n\telse:\n\t\tdl = DataLoader(imageDataset('', params, CViters), batch_size=params.batch_size, shuffle=True,\n\t\t\tnum_workers=params.num_workers,\n\t\t\tpin_memory=params.cuda)\n\n\t\treturn dl\n\n\treturn dataloaders","def create_dataloaders(data_dir, input_size, batch_size):\n # Get dataset mean and std\n dataset_mean, dataset_std = estimate_dataset_mean_and_std(expand_subdir(data_dir), input_size)\n\n # Data augmentation and normalization for training\n # Just normalization for validation\n data_transforms = {\n 'train': transforms.Compose([\n opencv_transforms.RandomRotation(45),\n opencv_transforms.RandomResizedCrop(input_size),\n opencv_transforms.RandomHorizontalFlip(),\n opencv_transforms.RandomVerticalFlip(),\n opencv_transforms.ToTensor(),\n transforms.Normalize(dataset_mean, dataset_std)\n ]),\n 'val': transforms.Compose([\n opencv_transforms.Resize(input_size),\n opencv_transforms.ToTensor(),\n transforms.Normalize(dataset_mean, dataset_std)\n ]),\n 'test': transforms.Compose([\n opencv_transforms.Resize(input_size),\n opencv_transforms.ToTensor(),\n transforms.Normalize(dataset_mean, dataset_std)\n ])\n }\n\n # Create training and validation datasets\n image_datasets = {\n x: datasets.DatasetFolder(\n os.path.join(data_dir, x),\n opencv_loader,\n ['jpg', 'tif'],\n transform=data_transforms[x]\n )\n for x in ['train', 'val', 'test']\n }\n\n # Create training and validation dataloaders\n dataloaders = {\n x: torch.utils.data.DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True, num_workers=1)\n for x in ['train', 'val', 'test']\n }\n\n return dataloaders, dataset_mean, dataset_std","def __init__(self, **kwargs):\n DataLoader.__init__(self, **kwargs)","def fetch_dataloader(types, data_dir, hyper_params, train_idx=None, val_idx=None):\n dataloaders = {}\n \n # TODO: write this to hyper_params, make hyper_params an out variable? then save? yes, AND: when ONLY test is requested, load from hyperparams!\n # TODO: also, add 3rd variation of types: for testing, only read it from hyper_params (DO I NEED TO READ HYPER_PARAMS FOR JUST TESTING?)\n if train_idx is not None:\n mean, std = mean_std_calc(DataLoader(Subset(Heart2DSegmentationDataset(str(Path(data_dir) / \"train_heart_scans\"), hyper_params.endo_or_epi), train_idx)))\n hyper_params.mean = mean.item()\n hyper_params.std = std.item()\n else:\n if 'train' in types:\n mean, std = mean_std_calc(DataLoader(Heart2DSegmentationDataset(str(Path(data_dir) / \"train_heart_scans\"), hyper_params.endo_or_epi)))\n hyper_params.mean = mean.item()\n hyper_params.std = std.item()\n else:\n mean, std = torch.tensor(hyper_params.mean), torch.tensor(hyper_params.std)\n \n print(\"Mean: {}, Std: {}\".format(mean.item(), std.item()))\n # borrowed from http://pytorch.org/tutorials/advanced/neural_style_tutorial.html\n # and http://pytorch.org/tutorials/beginner/data_loading_tutorial.html\n train_transformer = transforms.Compose([\n transforms.Normalize(mean=[mean.item()], std=[std.item()])\n ])\n \n eval_transformer = transforms.Compose([\n transforms.Normalize(mean=[mean.item()], std=[std.item()])\n ])\n\n for split in ['train', 'val', 'test']:\n if split in types:\n path = str(Path(data_dir) / \"{}_heart_scans\".format(split if split != 'val' else 'train'))\n\n if split == 'train':\n if train_idx is not None:\n dl = DataLoader(Subset(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, train_transformer), train_idx), \n batch_size=hyper_params.batch_size, \n shuffle=True,\n num_workers=hyper_params.num_workers,\n pin_memory=hyper_params.cuda)\n else:\n dl = DataLoader(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, train_transformer), \n batch_size=hyper_params.batch_size, \n shuffle=True,\n num_workers=hyper_params.num_workers,\n pin_memory=hyper_params.cuda)\n else:\n if (split == 'val') and (val_idx is not None): \n dl = DataLoader(Subset(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, eval_transformer), val_idx), \n batch_size=hyper_params.batch_size, \n shuffle=False,\n num_workers=hyper_params.num_workers,\n pin_memory=hyper_params.cuda) \n else:\n dl = DataLoader(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, eval_transformer), \n batch_size=hyper_params.batch_size, \n shuffle=False,\n num_workers=hyper_params.num_workers,\n pin_memory=hyper_params.cuda)\n\n dataloaders[split] = dl\n\n return dataloaders","def get_data_loader(target_classes, batch_size):\n classes = ('plane', 'car', 'bird', 'cat',\n 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n ########################################################################\n # The output of torchvision datasets are PILImage images of range [0, 1].\n # We transform them to Tensors of normalized range [-1, 1].\n transform = transforms.Compose(\n [transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n trainset = torchvision.datasets.CIFAR10(root='./data', train=True,\n download=True, transform=transform)\n # Get the list of indices to sample from\n relevant_train_indices = get_relevant_indices(\n trainset,\n classes,\n target_classes)\n # Split into train and validation\n np.random.seed(1000) # Fixed numpy random seed for reproducible shuffling\n np.random.shuffle(relevant_train_indices)\n split = int(len(relevant_train_indices) * 0.8)\n relevant_train_indices, relevant_val_indices = relevant_train_indices[:split], relevant_train_indices[split:]\n train_sampler = SubsetRandomSampler(relevant_train_indices)\n train_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n num_workers=0, sampler=train_sampler)\n val_sampler = SubsetRandomSampler(relevant_val_indices)\n val_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n num_workers=0, sampler=val_sampler)\n testset = torchvision.datasets.CIFAR10(root='./data', train=False,\n download=True, transform=transform)\n relevant_test_indices = get_relevant_indices(testset, classes, target_classes)\n test_sampler = SubsetRandomSampler(relevant_test_indices)\n test_loader = torch.utils.data.DataLoader(testset, batch_size=batch_size,\n num_workers=0, sampler=test_sampler)\n return train_loader, val_loader, test_loader, classes","def instantiate_batch(self, inputs):\n return inputs","def eval_loader(self, loader):\r\n\t\treturn predict(model=self.model,\r\n\t\t\tpipeline=self.pipeline,\r\n\t\t\tdataloader=loader,\r\n\t\t\ttask=self.task,\r\n\t\t\tmode=\"eval\")","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 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_precomp_loader(data_path, data_split, vocab, opt, batch_size=100,\n shuffle=True, num_workers=2):\n dset = PrecompDataset(data_path, data_split, vocab)\n\n data_loader = torch.utils.data.DataLoader(dataset=dset,\n batch_size=batch_size,\n shuffle=shuffle,\n pin_memory=True,\n collate_fn=collate_fn)\n return data_loader"],"string":"[\n \"def get_data_loaders(args, tokenizer):\\n personachat = get_dataset(tokenizer, args.dataset_path, args.dataset_cache, args.train_lang)\\n _ = personachat.pop(\\\"test\\\", None)\\n logger.info(\\\"Build inputs and labels\\\")\\n datasets = {\\\"train\\\": [], \\\"valid\\\": []}\\n\\n if args.train_lang in [\\\"En\\\", \\\"Fr\\\", \\\"It\\\", \\\"Id\\\", \\\"Jp\\\", \\\"Ko\\\", \\\"Zh\\\"]: #monolingual data\\n for dataset_name, dataset in personachat.items():\\n for dial in dataset[args.train_lang]: #dial: {\\\"persona\\\":[], \\\"history\\\":[], \\\"response\\\":str}\\n instance = build_input_from_segments(dial[\\\"persona\\\"], dial[\\\"history\\\"][-args.max_turns:], dial[\\\"response\\\"], tokenizer, lm_labels = True)\\n datasets[dataset_name].append(instance) \\n else: #multilingual data\\n for dataset_name, dataset in personachat.items():\\n for lang, dials in dataset.items():\\n for dial in dials: #dial: {\\\"persona\\\":[], \\\"history\\\":[], \\\"response\\\":str}\\n instance = build_input_from_segments(dial[\\\"persona\\\"], dial[\\\"history\\\"][-args.max_turns:], dial[\\\"response\\\"], tokenizer, lang_id=\\\"<{}>\\\".format(lang.lower()), lm_labels = True)\\n datasets[dataset_name].append(instance) #all langs together\\n\\n\\n logger.info(\\\"Build train and validation dataloaders\\\")\\n train_dataset = DatasetTrain(datasets[\\\"train\\\"])\\n valid_dataset = DatasetTrain(datasets[\\\"valid\\\"])\\n\\n #logger.info(\\\"Build train and validation dataloaders\\\")\\n #train_dataset, valid_dataset = TensorDataset(*tensor_datasets[\\\"train\\\"]), TensorDataset(*tensor_datasets[\\\"valid\\\"])\\n train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) if args.distributed else None\\n valid_sampler = torch.utils.data.distributed.DistributedSampler(valid_dataset) if args.distributed else None\\n train_loader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.train_batch_size, shuffle=(not args.distributed), collate_fn=collate_fn)\\n valid_loader = DataLoader(valid_dataset, sampler=valid_sampler, batch_size=args.valid_batch_size, shuffle=False, collate_fn=collate_fn)\\n\\n # logger.info(\\\"Train dataset (Batch, Candidates, Seq length): {}\\\".format(train_dataset.tensors[0].shape))\\n # #logger.info(\\\"Train dataset (Batch, Candidates, Seq length): {}\\\".format(train_dataset.tensors[1].shape))\\n # logger.info(\\\"Valid dataset (Batch, Candidates, Seq length): {}\\\".format(valid_dataset.tensors[0].shape))\\n logger.info(\\\"Train dataset length: {}\\\".format(len(train_dataset)))\\n logger.info(\\\"Valid dataset length: {}\\\".format(len(valid_dataset)))\\n return train_loader, valid_loader, train_sampler, valid_sampler\",\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 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 init_loaders(self, *args, **kwargs):\\n\\n # Convert the data to Dataset\\n dataset_dict = self.init_datasets(*args, **kwargs)\\n\\n # If the Dataset implements collate_fn, that is used. Otherwise, default_collate is used\\n if hasattr(dataset_dict[\\\"train\\\"], \\\"collate_fn\\\") and callable(\\n getattr(dataset_dict[\\\"train\\\"], \\\"collate_fn\\\")\\n ):\\n collate_fn = dataset_dict[\\\"train\\\"].collate_fn\\n else:\\n collate_fn = default_collate\\n\\n # If 'iters_per_epoch' is defined, then a fixed number of random sample batches from the training set\\n # are drawn per epoch.\\n # Otherwise, an epoch is defined by a full run through all of the data in the dataloader.\\n #\\n if self.config_dict.get(\\\"iters_per_epoch\\\") is not None:\\n num_samples = (\\n self.config_dict[\\\"iters_per_epoch\\\"] * self.config_dict[\\\"batch_size\\\"]\\n )\\n loaders_dict = {}\\n for key in dataset_dict.keys():\\n if key == \\\"train\\\":\\n loaders_dict[key] = DataLoader(\\n dataset_dict[key],\\n batch_sampler=BatchSampler(\\n RandomSampler(\\n dataset_dict[key],\\n replacement=True,\\n num_samples=num_samples,\\n ),\\n batch_size=self.config_dict[\\\"batch_size\\\"],\\n drop_last=False,\\n ),\\n collate_fn=collate_fn,\\n )\\n else:\\n loaders_dict[key] = DataLoader(\\n dataset_dict[key],\\n batch_size=self.config_dict[\\\"batch_size\\\"],\\n collate_fn=collate_fn,\\n )\\n else:\\n loaders_dict = {\\n key: DataLoader(\\n dataset_dict[key],\\n batch_size=self.config_dict[\\\"batch_size\\\"],\\n collate_fn=collate_fn,\\n )\\n for key in data_dict.keys()\\n }\\n\\n return loaders_dict\",\n \"def build_training_data_loader(self) -> DataLoader:\\n pass\",\n \"def get_loaders(train_dataset, val_dataset, test_dataset, batch_size=128):\\n train_loader = DataLoader(train_dataset, batch_size=batch_size, num_workers=8,\\n shuffle=True)\\n\\n val_loader = DataLoader(val_dataset, batch_size=batch_size, num_workers=8,\\n shuffle=False)\\n\\n test_loader = DataLoader(test_dataset, batch_size=batch_size, num_workers=8,\\n shuffle=False)\\n\\n return train_loader, val_loader, test_loader\",\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 get_data_loaders():\\n dataset_path = \\\"\\\"\\n dataset_cache = None\\n personachat = get_dataset(dataset_path, dataset_cache)\\n\\n tokenizer_selected = OpenAIGPTTokenizer.from_pretrained('openai-gpt')\\n logger.info(\\\"Build inputs and labels\\\")\\n datasets = {\\\"train\\\": defaultdict(list), \\\"valid\\\": defaultdict(list)}\\n personality = []\\n history_complete = []\\n count_persona = 0\\n with open('data_faiss_pegasus_2sentences_finalgenerated.pkl', 'rb') as f:\\n persona_selected_list = pickle.load(f)\\n for dataset_name, dataset in personachat.items():\\n num_candidates = len(dataset[0][\\\"utterances\\\"][0][\\\"candidates\\\"])\\n if num_candidates > 0 and dataset_name == 'train':\\n num_candidates = min(1, num_candidates)\\n for dialog in dataset:\\n persona = dialog[\\\"persona_info\\\"].copy()\\n #datasets[personality].append(persona)\\n count_history = 0\\n for utterance in dialog[\\\"utterances\\\"]:\\n count_history = count_history + 1\\n history = utterance[\\\"history\\\"][-(2*2+5):]\\n \\n #history_complete.append(history)\\n if len(persona) == 4:\\n if len(history) > (len(persona)+3):\\n history_chatbot = history[1::2]\\n persona_selected = persona_selected_list[count_persona]\\n instance = build_input_from_segments_faiss_2(persona, history_chatbot) \\n for input_name, input_array in instance.items():\\n datasets[dataset_name][input_name].append(input_array)\\n count_persona = count_persona + 1\\n return datasets\",\n \"def create_loader(self):\\n # load data to memory.\\n if self.is_cifar100:\\n (x_train, y_train), (x_test,\\n y_test) = tf.keras.datasets.cifar100.load_data()\\n else:\\n (x_train, y_train), (x_test,\\n y_test) = tf.keras.datasets.cifar10.load_data()\\n\\n y_train = y_train.astype(np.int32)\\n y_test = y_test.astype(np.int32)\\n\\n x_train, y_train = shuffle_dataset(x_train, y_train)\\n n_probe = int(math.floor(x_train.shape[0] * FLAGS.probe_dataset_hold_ratio))\\n\\n # TODO(zizhaoz): add other noise types.\\n if 'asymmetric' in self.dataset_name:\\n assert 'cifar100' not in self.dataset_name, 'Asymmetric only has CIFAR10'\\n (x_train, y_train, y_gold), (x_probe, y_probe) = load_asymmetric(\\n x_train,\\n y_train,\\n noise_ratio=self.noise_ratio,\\n n_val=n_probe,\\n random_seed=FLAGS.seed)\\n elif 'uniform' in self.dataset_name:\\n (x_train, y_train, y_gold), (x_probe,\\n y_probe) = load_train_val_uniform_noise(\\n x_train,\\n y_train,\\n n_classes=self.num_classes,\\n noise_ratio=self.noise_ratio,\\n n_val=n_probe)\\n else:\\n assert self.dataset_name in ['cifar10', 'cifar100']\\n\\n if not self.split_probe and x_probe is not None:\\n # Usually used for supervised comparison.\\n tf.logging.info('Merge train and probe')\\n x_train = np.concatenate([x_train, x_probe], axis=0)\\n y_train = np.concatenate([y_train, y_probe], axis=0)\\n y_gold = np.concatenate([y_gold, y_probe], axis=0)\\n\\n conf_mat = sklearn_metrics.confusion_matrix(y_gold, y_train)\\n conf_mat = conf_mat / np.sum(conf_mat, axis=1, keepdims=True)\\n tf.logging.info('Corrupted confusion matirx\\\\n {}'.format(conf_mat))\\n x_test, y_test = shuffle_dataset(x_test, y_test)\\n self.train_dataset_size = x_train.shape[0]\\n self.val_dataset_size = x_test.shape[0]\\n if self.split_probe:\\n self.probe_size = x_probe.shape[0]\\n\\n input_tuple = (x_train, y_train.squeeze())\\n self.train_dataflow = self.create_ds(input_tuple, is_train=True)\\n self.val_dataflow = self.create_ds((x_test, y_test.squeeze()),\\n is_train=False)\\n if self.split_probe:\\n self.probe_dataflow = self.create_ds((x_probe, y_probe.squeeze()),\\n is_train=True)\\n\\n tf.logging.info('Init [{}] dataset loader'.format(self.dataset_name))\\n verbose_data('train', x_train, y_train)\\n verbose_data('test', x_test, y_test)\\n if self.split_probe:\\n verbose_data('probe', x_probe, y_probe)\\n\\n return self\",\n \"def __create_dataloaders(\\n self, encoded_input: dict, batch_size\\n ) -> Tuple[DataLoader, DataLoader, DataLoader]:\\n input_ids = encoded_input[\\\"input_ids\\\"]\\n token_type_ids = encoded_input[\\\"token_type_ids\\\"]\\n attention_mask = encoded_input[\\\"attention_mask\\\"]\\n\\n input_ids_data_loader = torch.utils.data.DataLoader(\\n input_ids, batch_size=batch_size, shuffle=False\\n )\\n token_type_ids_data_loader = torch.utils.data.DataLoader(\\n token_type_ids, batch_size=batch_size, shuffle=False\\n )\\n attention_mask_data_loader = torch.utils.data.DataLoader(\\n attention_mask, batch_size=batch_size, shuffle=False\\n )\\n\\n return (\\n input_ids_data_loader,\\n token_type_ids_data_loader,\\n attention_mask_data_loader,\\n )\",\n \"def _custom_data_loader(self) -> DataLoader:\\n dataloaders = DataLoader(self.dataset, batch_size=1)\\n return dataloaders\",\n \"def train_dataloader(self) -> DataLoader:\\n return self._custom_data_loader()\",\n \"def prepare_data(self,d):\\n train_loaders, train_iters = {}, {}\\n unlabeled_loaders, unlabeled_iters = {}, {}\\n for domain in opt.domains:\\n #CONVERT TO FLOAT32\\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape((-1,1))\\n train = data_utils.TensorDataset(features,target)\\n train_loaders[domain] = DataLoader(train, opt.batch_size, shuffle = True)\\n train_iters[domain] = iter(train_loaders[domain])\\n for domain in opt.unlabeled_domains:\\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape(-1,1))\\n uset = data_utils.TensorDataset(features,target)\\n unlabeled_loaders[domain] = DataLoader(uset,opt.batch_size, shuffle = True)\\n unlabeled_iters[domain] = iter(unlabeled_loaders[domain])\\n \\n return train_loaders, train_iters, unlabeled_loaders, unlabeled_iters\",\n \"def get_data_loaders(data, batch_size, ratio=0.8, num_workers=1):\\n train_size = int(len(data) * ratio)\\n val_size = len(data) - train_size\\n train_set, val_set = random_split(data, [train_size, val_size])\\n data_train_loader = DataLoader(train_set, batch_size=batch_size, num_workers=num_workers, shuffle=True)\\n data_val_loader = DataLoader(val_set, batch_size=batch_size, num_workers=num_workers, shuffle=True)\\n return data_train_loader, data_val_loader\",\n \"def get_each_loader(data_path, batch_size, trn_negnum, shuffle=True, num_workers=0):\\n \\n dataset = ML_Dataset(data_path, trn_negnum)\\n \\n if data_path.endswith('trn') == True:\\n collate = dataset.train_collate\\n else:\\n collate = test_collate\\n\\n data_loader = data.DataLoader(dataset=dataset,\\n batch_size=batch_size,\\n shuffle=shuffle,\\n num_workers=num_workers,\\n collate_fn=collate)\\n\\n return data_loader\",\n \"def get_loader(config):\\n train_transform = [T.Resize((256, 128)), T.RandomHorizontalFlip(), T.ToTensor(),\\n T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])]\\n train_transform = T.Compose(train_transform)\\n\\n test_transform = [T.Resize((256, 128)), T.ToTensor(),\\n T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])]\\n test_transform = T.Compose(test_transform)\\n\\n # Datasets.\\n if config.source_dataset in ['duke'] and config.target_dataset in ['market']:\\n source_image_dir = config.duke_image_dir\\n target_image_dir = config.market_image_dir\\n elif config.source_dataset in ['market'] and config.target_dataset in ['duke']:\\n source_image_dir = config.market_image_dir\\n target_image_dir = config.duke_image_dir\\n else:\\n assert 'Dataset not support!'\\n source_set = ReidDataset(source_image_dir, train_transform)\\n target_set = ReidDataset(target_image_dir, train_transform, config.expanding_cam)\\n test_set = ReidDataset(source_image_dir, test_transform)\\n\\n # Dataloader.\\n source_loader = data.DataLoader(dataset=source_set, batch_size=config.batch_size,\\n num_workers=config.num_workers, shuffle=True, pin_memory=True, drop_last=True)\\n\\n target_loader = data.DataLoader(dataset=target_set, batch_size=config.batch_size,\\n num_workers=config.num_workers, shuffle=True, pin_memory=True, drop_last=True)\\n\\n test_loader = data.DataLoader(dataset=test_set, batch_size=config.batch_size, num_workers=config.num_workers,\\n shuffle=False, pin_memory=True, drop_last=False)\\n\\n return {'source_loader': source_loader, 'target_loader': target_loader, 'test_loader': test_loader}\",\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 prepare_data_loaders(num_split, batch_size=32, hier=False, elmo=False, elmo_pre=None, use_elmo_pre=False, deepmoji=False, dev_with_label=False, include_test=False):\\n train_data_loaders = []\\n val_data_loaders = []\\n test_data_loaders = []\\n\\n vocab = generate_vocab(deepmoji)\\n for i in range(num_split):\\n train, val, test, _ = prepare_data(batch_size=batch_size, hier=hier, elmo=elmo, elmo_pre=elmo_pre, use_elmo_pre=use_elmo_pre, deepmoji=deepmoji, is_shuffle=True, random_state=i, vocab=vocab, dev_with_label=dev_with_label, include_test=include_test)\\n train_data_loaders.append(train)\\n val_data_loaders.append(val)\\n test_data_loaders.append(test)\\n\\n return train_data_loaders, val_data_loaders, test_data_loaders, vocab\",\n \"def get_data_loader(\\n name: str, **kwargs) -> data_loader.DataLoader:\\n\\n if name == \\\"synthetic_images\\\":\\n logging.info(\\\"Creating synthetic image data loader.\\\")\\n return synthetic_image.SyntheticImageDataLoader(**kwargs)\\n elif name == \\\"synthetic_bert\\\":\\n logging.info(\\\"Creating synthetic bert data loader.\\\")\\n return synthetic_bert.SyntheticBertLoader(**kwargs)\\n elif name == \\\"squad_bert\\\":\\n logging.info(\\\"Creating SQuAD 1.1 bert data loader.\\\")\\n return squad_bert.SquadBertLoader(**kwargs)\\n elif name == \\\"sentiment_bert\\\":\\n logging.info(\\\"Creating IMDB sentiment analysis data loader.\\\")\\n return generic_jsonl.GenericJsonlLoader(**kwargs)\\n elif name == \\\"criteo\\\":\\n logging.info(\\\"Creating Criteo data loader.\\\")\\n return criteo.CriteoLoader(**kwargs)\\n elif name == \\\"generic_jsonl\\\":\\n logging.info(\\\"Creating generic jsonl file data loader.\\\")\\n return generic_jsonl.GenericJsonlLoader(**kwargs)\\n else:\\n raise ValueError(\\\"Unsupported data loader type.\\\")\",\n \"def data_loaders(args):\\n\\n transform = transforms.Compose([\\n transforms.Resize(64),\\n transforms.ToTensor(),\\n lambda image: (image - 0.5) * 2\\n ])\\n\\n train_mnist = datasets.MNIST(\\n root=args.database_root,\\n train=True,\\n download=True,\\n transform=transform\\n )\\n train_loader = DataLoader(\\n dataset=train_mnist,\\n batch_size=args.train_batch_size,\\n shuffle=True,\\n num_workers=1,\\n pin_memory=True\\n )\\n\\n test_mnist = datasets.MNIST(\\n root=args.database_root,\\n train=False,\\n download=True,\\n transform=transform\\n )\\n test_loader = DataLoader(\\n dataset=test_mnist,\\n batch_size=args.test_batch_size,\\n shuffle=True,\\n num_workers=1,\\n pin_memory=True\\n )\\n\\n return train_loader, test_loader\",\n \"def get_train_loaders(config):\\n assert 'loaders' in config, 'Could not find data loaders configuration'\\n loaders_config = config['loaders']\\n\\n logger.info('Creating training and validation set loaders...')\\n\\n # get dataset class\\n dataset_cls_str = loaders_config.get('dataset', None)\\n if dataset_cls_str is None:\\n dataset_cls_str = 'StandardHDF5Dataset'\\n logger.warning(f\\\"Cannot find dataset class in the config. Using default '{dataset_cls_str}'.\\\")\\n dataset_class = _loader_classes(dataset_cls_str)\\n\\n assert set(loaders_config['train']['file_paths']).isdisjoint(loaders_config['val']['file_paths']), \\\\\\n \\\"Train and validation 'file_paths' overlap. One cannot use validation data for training!\\\"\\n\\n train_datasets = dataset_class.create_datasets(loaders_config, phase='train')\\n\\n val_datasets = dataset_class.create_datasets(loaders_config, phase='val')\\n\\n num_workers = loaders_config.get('num_workers', 1)\\n logger.info(f'Number of workers for train/val dataloader: {num_workers}')\\n batch_size = loaders_config.get('batch_size', 1)\\n if torch.cuda.device_count() > 1 and not config['device'] == 'cpu':\\n logger.info(\\n f'{torch.cuda.device_count()} GPUs available. Using batch_size = {torch.cuda.device_count()} * {batch_size}')\\n batch_size = batch_size * torch.cuda.device_count()\\n\\n logger.info(f'Batch size for train/val loader: {batch_size}')\\n # when training with volumetric data use batch_size of 1 due to GPU memory constraints\\n return {\\n 'train': DataLoader(ConcatDataset(train_datasets), batch_size=batch_size, shuffle=True, pin_memory=True,\\n num_workers=num_workers),\\n # don't shuffle during validation: useful when showing how predictions for a given batch get better over time\\n 'val': DataLoader(ConcatDataset(val_datasets), batch_size=batch_size, shuffle=False, pin_memory=True,\\n num_workers=num_workers)\\n }\",\n \"def get_loaders(img_size=CONFIG[\\\"matrix_size\\\"], batch_size=CONFIG[\\\"batch_size\\\"],\\n used_keypoints=CONFIG[\\\"used_keypoints\\\"], interpolation_frames=CONFIG[\\\"interpolation_frames\\\"],\\n noise_frames=CONFIG[\\\"noise_frames\\\"], all_data=None, all_labels=None):\\n\\n if all_data is None or all_labels is None:\\n all_data, all_labels = load_video_data_labels(interpolation_frames, noise_frames, used_keypoints, img_size)\\n\\n p = np.random.permutation(len(all_data))\\n train_len = int(len(p) / 80)\\n others_len = int((len(p) - train_len) / 2)\\n\\n train_data, train_labels = all_data[p[:train_len]], all_labels[p[:train_len]]\\n val_data = all_data[p[train_len:train_len + others_len]]\\n val_labels = all_labels[p[train_len:train_len + others_len]]\\n test_data, test_labels = all_data[p[-others_len:]], all_labels[p[-others_len:]]\\n\\n # Transform to tensor\\n train_data_tensor, train_labels_tensor = torch.from_numpy(train_data), torch.from_numpy(train_labels)\\n val_data_tensor, val_labels_tensor = torch.from_numpy(val_data), torch.from_numpy(val_labels)\\n test_data_tensor, test_labels_tensor = torch.from_numpy(test_data), torch.from_numpy(test_labels)\\n\\n # Data Loader for easy mini-batch return in training, load the Dataset from the numpy arrays\\n train_loader = DataLoader(TensorDataset(train_data_tensor, train_labels_tensor), batch_size=batch_size)\\n val_loader = DataLoader(TensorDataset(val_data_tensor, val_labels_tensor), batch_size=batch_size)\\n test_loader = DataLoader(TensorDataset(test_data_tensor, test_labels_tensor), batch_size=batch_size)\\n\\n data = {\\\"train_data\\\": train_data,\\n \\\"train_labels\\\": train_labels,\\n \\\"val_data\\\": val_data,\\n \\\"val_labels\\\": val_labels,\\n \\\"test_data\\\": test_data,\\n \\\"test_labels\\\": test_labels,\\n \\\"all_data\\\": all_data[p],\\n \\\"all_labels\\\": all_labels[p]}\\n\\n return data, train_loader, val_loader, test_loader\",\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 prepare_data(self):\\n data = self._get_dataset(self.hparams.dataset_path)\\n label_encoder = data[\\\"label_encoder\\\"]\\n del data[\\\"label_encoder\\\"]\\n\\n click.secho(\\\"Building inputs and labels.\\\", fg=\\\"yellow\\\")\\n datasets = {\\n \\\"train\\\": defaultdict(list),\\n \\\"valid\\\": defaultdict(list),\\n \\\"test\\\": defaultdict(list),\\n }\\n for dataset_name, dataset in data.items():\\n for sample in dataset:\\n instance = self.build_input(\\n self.tokenizer, sample[\\\"text\\\"], label_encoder, sample[\\\"label\\\"]\\n )\\n for input_name, input_array in instance.items():\\n datasets[dataset_name][input_name].append(input_array)\\n\\n click.secho(\\\"Padding inputs and building tensors.\\\", fg=\\\"yellow\\\")\\n tensor_datasets = {\\\"train\\\": [], \\\"valid\\\": [], \\\"test\\\": []}\\n for dataset_name, dataset in datasets.items():\\n dataset = self.pad_dataset(dataset, padding=self.tokenizer.pad_index)\\n for input_name in MODEL_INPUTS:\\n if input_name == \\\"labels\\\":\\n tensor = torch.tensor(dataset[input_name], dtype=torch.float32)\\n else:\\n tensor = torch.tensor(dataset[input_name])\\n tensor_datasets[dataset_name].append(tensor)\\n\\n self.train_dataset = TensorDataset(*tensor_datasets[\\\"train\\\"])\\n self.valid_dataset = TensorDataset(*tensor_datasets[\\\"valid\\\"])\\n self.test_dataset = TensorDataset(*tensor_datasets[\\\"test\\\"])\\n click.secho(\\n \\\"Train dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.train_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n \\\"Valid dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.valid_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n \\\"Test dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.test_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\",\n \"def data_loaders(dataset_path):\\n dataset_path = dataset_path\\n news_stock_dataset = NewsStockDataLoader(dataset_path)\\n \\n dataset_size = len(news_stock_dataset)\\n indices = list(range(dataset_size))\\n training_split = int(0.8 * dataset_size)\\n validation_split = int(0.9 * dataset_size)\\n\\n np.random.seed(96)\\n np.random.shuffle(indices)\\n\\n train_indices = indices[:training_split]\\n valid_indices = indices[training_split:validation_split]\\n test_indices = indices[validation_split:]\\n\\n train_sampler = SubsetRandomSampler(train_indices)\\n valid_sampler = SubsetRandomSampler(valid_indices)\\n test_sampler = SubsetRandomSampler(test_indices)\\n \\n collate = PadSequence()\\n\\n training_loader = DataLoader(news_stock_dataset,\\n num_workers = 1,\\n batch_size = Config.get(\\\"training_batch_size\\\"),\\n sampler = train_sampler,\\n collate_fn = collate)\\n\\n validation_loader = DataLoader(news_stock_dataset,\\n num_workers = 1,\\n batch_size = Config.get(\\\"validation_batch_size\\\"),\\n sampler = valid_sampler,\\n collate_fn = collate)\\n\\n testing_loader = DataLoader(news_stock_dataset,\\n num_workers = 1,\\n batch_size = Config.get(\\\"testing_batch_size\\\"),\\n sampler= test_sampler,\\n collate_fn = collate)\\n \\n return training_loader, validation_loader, testing_loader\",\n \"def get_loaders(opt):\\n train_samples, val_samples = get_train_val_metadata(opt.dataset_dir,\\n opt.validation_cities,\\n opt.patch_size,\\n opt.stride)\\n print('train samples : ', len(train_samples))\\n print('val samples : ', len(val_samples))\\n\\n logging.info('STARTING Dataset Creation')\\n\\n full_load = full_onera_loader(opt.dataset_dir, opt)\\n\\n train_dataset = OneraPreloader(opt.dataset_dir,\\n train_samples,\\n full_load,\\n opt.patch_size,\\n opt.augmentation)\\n val_dataset = OneraPreloader(opt.dataset_dir,\\n val_samples,\\n full_load,\\n opt.patch_size,\\n False)\\n\\n logging.info('STARTING Dataloading')\\n\\n train_loader = torch.utils.data.DataLoader(train_dataset,\\n batch_size=opt.batch_size,\\n shuffle=True,\\n num_workers=opt.num_workers)\\n val_loader = torch.utils.data.DataLoader(val_dataset,\\n batch_size=opt.batch_size,\\n shuffle=False,\\n num_workers=opt.num_workers)\\n return train_loader, val_loader\",\n \"def get_driving_data_loaders(batch_size, train_dataset, valid_dataset, test_dataset, num_workers=0): \\n\\n valid_loader = DataLoader(dataset=valid_dataset,\\n batch_size=batch_size,\\n num_workers=num_workers,\\n shuffle=True)\\n\\n train_loader = DataLoader(dataset=train_dataset,\\n batch_size=batch_size,\\n num_workers=num_workers,\\n drop_last=True, \\n shuffle=True)\\n\\n test_loader = DataLoader(dataset=test_dataset,\\n batch_size=batch_size,\\n num_workers=num_workers,\\n shuffle=False)\\n\\n return train_loader, valid_loader, test_loader\",\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 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 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_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 get_dataloaders(datasets, split, args, is_eval=False):\\n dataloaders = []\\n for task, dataset in datasets.items():\\n if is_eval:\\n num_rows = dataset.num_rows if args.eval_rows == -1 else args.eval_rows\\n else:\\n num_rows = dataset.num_rows if args.train_rows == -1 else args.train_rows\\n all_input_ids = np.zeros([num_rows, args.max_length])\\n all_attention_mask = np.zeros([num_rows, args.max_length])\\n all_token_type_ids = np.zeros([num_rows, args.max_length])\\n for i in range(num_rows):\\n features = dataset[i]\\n curr_len = len(features[\\\"attention_mask\\\"])\\n all_input_ids[i,:curr_len] = features[\\\"input_ids\\\"]\\n all_attention_mask[i,:curr_len] = features[\\\"attention_mask\\\"]\\n all_token_type_ids[i,:curr_len] = features[\\\"token_type_ids\\\"]\\n all_input_ids = torch.tensor(all_input_ids, dtype=torch.long)\\n all_attention_mask = torch.tensor(all_attention_mask, dtype=torch.long)\\n all_token_type_ids = torch.tensor(all_token_type_ids, dtype=torch.long)\\n all_label = torch.tensor(dataset[:num_rows][\\\"label\\\"], dtype=torch.long)\\n if task == \\\"stsb\\\":\\n all_label = all_label.float()\\n \\n data = TensorDataset(all_input_ids, all_attention_mask, all_token_type_ids, all_label)\\n if split in [\\\"train\\\", \\\"support\\\"]:\\n sampler = RandomSampler(data)\\n dataloader = DataLoader(data, sampler=sampler, batch_size=args.train_batch_size)\\n else:\\n sampler = SequentialSampler(data)\\n dataloader = DataLoader(data, sampler=sampler, batch_size=args.eval_batch_size)\\n dataloaders.append(dataloader)\\n return dataloaders\",\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 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 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 create_trainval_dataloaders(params):\\n # ----------------Create Dataset objects and Dataloaders----------------\\n mr_dataset_train, tokenizer = get_dataset(params, run_mode=\\\"train\\\")\\n params.vocab_size = tokenizer.get_vocab_size()\\n print(\\\"SystemLog: Vocab size used for training is %d\\\" % (params.vocab_size))\\n print(\\\"SystemLog: Number of items in the train dataset=%d\\\" % len(mr_dataset_train))\\n sys.stdout.flush()\\n # Collate Function pads the sequences to have a uniform length for the entire batch\\n mr_dataloader_train = DataLoader(mr_dataset_train, batch_size=params.batch_size,\\n shuffle=True, num_workers=params.num_workers, collate_fn=CollateMRSequence(params.architecture))\\n\\n mr_dataset_valid, _ = get_dataset(params, run_mode=\\\"valid\\\")\\n print(\\\"SystemLog: Number of items in the valid dataset=%d\\\" % len(mr_dataset_valid))\\n mr_dataloader_valid = DataLoader(mr_dataset_valid, batch_size=params.batch_size_validation,\\n shuffle=False, num_workers=0, collate_fn=CollateMRSequence(params.architecture))\\n\\n return mr_dataset_train, mr_dataloader_train, mr_dataset_valid, mr_dataloader_valid\",\n \"def get_feature_loader(rxspecifiers, feature_loader, batch_size, num_workers):\\n dataset = _Kaldi_Dataset(rxspecifiers, feature_loader, batch_size)\\n return data.DataLoader(dataset, batch_size=1, shuffle=False, num_workers=num_workers, collate_fn=_collater)\",\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 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_test_loader(id_list = './data/sample_submission.csv', root_dir = './data/test/'):\\n data = HumanProteinDataset(id_list, root_dir, transform = transforms.Compose([\\n Rescale((256, 256)), \\n ToTensor()\\n ]))\\n\\n indices = np.arange(len(data))\\n dataloader_test = DataLoader(data, batch_size=10, num_workers=5)\\n\\n return dataloader_test\",\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 dataloaders():\\n # train data path\\n data_train = '../dataset/train/'\\n # set transformations\\n train_transforms = transforms.Compose([\\n transforms.Resize((224, 224)),\\n transforms.ToTensor(),\\n transforms.Normalize([0.485, 0.456, 0.406],\\n [0.229, 0.224, 0.225])])\\n \\n train_data = datasets.ImageFolder(data_train, transform = train_transforms)\\n trainloader = torch.utils.data.DataLoader(train_data, batch_size = 16, shuffle = True)\\n \\n return trainloader\",\n \"def dataio_prepare(hparams):\\n data_folder = hparams[\\\"data_folder\\\"]\\n\\n train_data = dataset.DynamicItemDataset.from_csv(\\n csv_path=hparams[\\\"train_data\\\"],\\n replacements={\\\"data_root\\\": data_folder}, )\\n\\n if hparams[\\\"sorting\\\"] == \\\"ascending\\\":\\n # we sort training data to speed up training and get better results.\\n train_data = train_data.filtered_sorted(sort_key=\\\"duration\\\")\\n # when sorting do not shuffle in dataloader ! otherwise is pointless\\n hparams[\\\"train_dataloader_opts\\\"][\\\"shuffle\\\"] = False\\n\\n elif hparams[\\\"sorting\\\"] == \\\"descending\\\":\\n train_data = train_data.filtered_sorted(\\n sort_key=\\\"duration\\\", reverse=True)\\n # when sorting do not shuffle in dataloader ! otherwise is pointless\\n hparams[\\\"train_dataloader_opts\\\"][\\\"shuffle\\\"] = False\\n\\n elif hparams[\\\"sorting\\\"] == \\\"random\\\":\\n pass\\n\\n else:\\n raise NotImplementedError(\\n \\\"sorting must be random, ascending or descending\\\")\\n\\n valid_data = dataset.DynamicItemDataset.from_csv(\\n csv_path=hparams[\\\"valid_data\\\"],\\n replacements={\\\"data_root\\\": data_folder}, )\\n valid_data = valid_data.filtered_sorted(sort_key=\\\"duration\\\")\\n\\n test_data = dataset.DynamicItemDataset.from_csv(\\n csv_path=hparams[\\\"test_data\\\"],\\n replacements={\\\"data_root\\\": data_folder}, )\\n test_data = test_data.filtered_sorted(sort_key=\\\"duration\\\")\\n\\n datasets = [train_data, valid_data, test_data]\\n\\n # Defining tokenizer and loading it\\n tokenizer = transformers.BertTokenizer.from_pretrained('bert-base-chinese')\\n\\n # 2. Define audio pipeline:\\n @data_pipeline.takes(\\\"wav\\\")\\n @data_pipeline.provides(\\\"sig\\\")\\n def audio_pipeline(wav):\\n sig = dataio.read_audio(wav)\\n return sig\\n\\n dataset.add_dynamic_item(datasets, audio_pipeline)\\n\\n # 3. Define text pipeline:\\n @data_pipeline.takes(\\\"transcript\\\")\\n @data_pipeline.provides(\\\"wrd\\\", \\\"tokens_list\\\", \\\"tokens\\\")\\n def text_pipeline(wrd):\\n wrd = \\\"\\\".join(wrd.split(\\\" \\\"))\\n yield wrd\\n tokens_list = tokenizer(wrd)[\\\"input_ids\\\"]\\n yield tokens_list\\n tokens = numpy.array(tokens_list, dtype=\\\"int64\\\")\\n yield tokens\\n\\n dataset.add_dynamic_item(datasets, text_pipeline)\\n\\n # 4. Set output:\\n dataset.set_output_keys(\\n datasets,\\n [\\\"id\\\", \\\"sig\\\", \\\"wrd\\\", \\\"tokens\\\"], )\\n\\n # 5. If Dynamic Batching is used, we instantiate the needed samplers.\\n train_batch_sampler = None\\n valid_batch_sampler = None\\n if hparams[\\\"dynamic_batching\\\"]:\\n from sampler import DynamicBatchSampler # noqa\\n\\n dynamic_hparams = hparams[\\\"dynamic_batch_sampler\\\"]\\n num_buckets = dynamic_hparams[\\\"num_buckets\\\"]\\n\\n train_batch_sampler = DynamicBatchSampler(\\n train_data,\\n dynamic_hparams[\\\"max_batch_len\\\"],\\n num_buckets=num_buckets,\\n length_func=lambda x: x[\\\"duration\\\"],\\n shuffle=dynamic_hparams[\\\"shuffle_ex\\\"],\\n batch_ordering=dynamic_hparams[\\\"batch_ordering\\\"], )\\n\\n valid_batch_sampler = DynamicBatchSampler(\\n valid_data,\\n dynamic_hparams[\\\"max_batch_len\\\"],\\n num_buckets=num_buckets,\\n length_func=lambda x: x[\\\"duration\\\"],\\n shuffle=dynamic_hparams[\\\"shuffle_ex\\\"],\\n batch_ordering=dynamic_hparams[\\\"batch_ordering\\\"], )\\n\\n return (train_data, valid_data, test_data, tokenizer, train_batch_sampler,\\n valid_batch_sampler, )\",\n \"def initialize_dataloaders(\\n self, X: Union[np.ndarray, pd.DataFrame], y: Union[np.ndarray, np.array]\\n ):\\n training_design_matrix, training_targets_array, validation_design_matrix, validation_targets_array = self.generate_training_validation_split(\\n X, y\\n )\\n training_dataloader_kwargs = {\\n \\\"design_matrix\\\": training_design_matrix,\\n \\\"targets_array\\\": training_targets_array,\\n \\\"data_type\\\": self.data_type,\\n \\\"batch_size\\\": self.batch_size,\\n \\\"shuffle\\\": self.shuffle_training_examples,\\n }\\n validation_dataloader_kwargs = {\\n \\\"design_matrix\\\": validation_design_matrix,\\n \\\"targets_array\\\": validation_targets_array,\\n \\\"data_type\\\": self.data_type,\\n \\\"batch_size\\\": self.batch_size,\\n \\\"shuffle\\\": False,\\n }\\n self.training_dataloader = self.generate_dataloader(**training_dataloader_kwargs)\\n self.validation_dataloader = self.generate_dataloader(**validation_dataloader_kwargs)\",\n \"def train_dataloader(self) -> torch.utils.data.DataLoader: \\n return torch.utils.data.DataLoader(self.dataset_train, **self.dl_kwargs)\",\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 create_split_loaders(root_dir, batch_size, seed=0, transform=transforms.ToTensor(),\\n p_val=0.1, p_test=0.2, shuffle=True, \\n show_sample=False, extras={}):\\n \\n\\n # once all single json datasets are created you can concat them into a single one:\\n quickdraw_dataset = CharacterDataset(root_dir=root_dir, transform=transform)\\n \\n # Dimensions and indices of training set\\n dataset_size = len(quickdraw_dataset)\\n all_indices = list(range(dataset_size))\\n\\n # Shuffle dataset before dividing into training & test sets\\n if shuffle:\\n np.random.seed(seed)\\n np.random.shuffle(all_indices)\\n \\n # Create the validation split from the full dataset\\n val_split = int(np.floor(p_val * dataset_size))\\n train_ind, val_ind = all_indices[val_split :], all_indices[: val_split]\\n \\n # Separate a test split from the training dataset\\n test_split = int(np.floor(p_test * len(train_ind)))\\n train_ind, test_ind = train_ind[test_split :], train_ind[: test_split]\\n print(len(train_ind), len(val_ind), len(test_ind))\\n # Use the SubsetRandomSampler as the iterator for each subset\\n sample_train = SubsetRandomSampler(train_ind)\\n sample_test = SubsetRandomSampler(test_ind)\\n sample_val = SubsetRandomSampler(val_ind)\\n\\n num_workers = 0\\n pin_memory = False\\n # If CUDA is available\\n if extras:\\n num_workers = extras[\\\"num_workers\\\"]\\n pin_memory = extras[\\\"pin_memory\\\"]\\n \\n # Define the training, test, & validation DataLoaders\\n train_loader = DataLoader(quickdraw_dataset, batch_size=batch_size, \\n sampler=sample_train, num_workers=num_workers, \\n pin_memory=pin_memory)\\n\\n test_loader = DataLoader(quickdraw_dataset, batch_size=batch_size, \\n sampler=sample_test, num_workers=num_workers, \\n pin_memory=pin_memory)\\n\\n val_loader = DataLoader(quickdraw_dataset, batch_size=batch_size,\\n sampler=sample_val, num_workers=num_workers, \\n pin_memory=pin_memory)\\n\\n \\n # Return the training, validation, test DataLoader objects\\n return (train_loader, val_loader, test_loader)\",\n \"def get_dataloaders(data_dir, hyp):\\n \\n # Grab data, targets\\n data_file_paths, targets = get_files_paths_and_labels(data_dir)\\n \\n # Split into train/validation\\n train_data, val_data, train_labels, val_labels = train_test_split(data_file_paths,\\n targets,\\n train_size=hyp['perc_train'],\\n shuffle=hyp['shuffle'],\\n stratify=targets)\\n\\n # Create train/validation augmentation handler\\n train_aug = get_training_augmentations(hyp)\\n val_aug = get_validation_augmentations(hyp)\\n \\n # Create datasets\\n train_dset = SETIDataset(train_data, train_labels, transform=train_aug)\\n val_dset = SETIDataset(val_data, val_labels, transform=val_aug)\\n \\n # Create dataloaders\\n train_loader = DataLoader(train_dset, shuffle=True, batch_size=hyp['batch_size'], \\n pin_memory=True, num_workers=8)\\n \\n val_loader = DataLoader(val_dset, batch_size=hyp['batch_size'], \\n pin_memory=True, num_workers=8)\\n \\n return train_loader, val_loader\",\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_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 get_loaders(\\n data_dir,\\n train_transforms=None,\\n val_transforms=None,\\n train_test_split=0.85,\\n train_val_split=0.15,\\n batch_size=16,\\n shuffle=True):\\n np.random.seed(24)\\n train_ds = ImageFolder(root=data_dir, transform=train_transforms)\\n val_ds = ImageFolder(root=data_dir, transform=val_transforms)\\n test_ds = ImageFolder(root=data_dir, transform=val_transforms)\\n img_count = len(train_ds)\\n indices = list(range(img_count))\\n test_split = int(img_count * train_test_split)\\n if shuffle:\\n np.random.shuffle(indices)\\n train_idx, test_idx = indices[:test_split], indices[test_split:]\\n train_count = len(train_idx)\\n val_split = int(train_count * (1 - train_val_split))\\n train_idx, val_idx = train_idx[:val_split], train_idx[val_split:]\\n train_sample = SubsetRandomSampler(train_idx)\\n val_sample = SubsetRandomSampler(val_idx)\\n test_sample = SubsetRandomSampler(test_idx)\\n train_loader = DataLoader(train_ds, batch_size=batch_size, sampler=train_sample)\\n val_loader = DataLoader(val_ds, batch_size=batch_size, sampler=val_sample)\\n test_loader = DataLoader(test_ds, batch_size=batch_size, sampler=test_sample)\\n\\n return train_loader, val_loader, test_loader\",\n \"def prepare_data_loaders_without_shuffle(batch_size=32, hier=False, elmo=False, elmo_pre=None, use_elmo_pre=False, deepmoji=False, dev_with_label=False, include_test=False):\\n train_data_loaders = []\\n val_data_loaders = []\\n test_data_loaders = []\\n\\n vocab = generate_vocab(deepmoji)\\n train, val, test, _ = prepare_data(batch_size=batch_size, hier=hier, elmo=elmo, elmo_pre=elmo_pre, use_elmo_pre=use_elmo_pre, deepmoji=deepmoji, is_shuffle=False, vocab=vocab, dev_with_label=dev_with_label, include_test=include_test)\\n\\n return train, val, test, vocab\",\n \"def _init_loaders(self):\\n @self.loaders_wrapper(\\\"nx2nx\\\")\\n def get_nx2nx_loader(extractor, stream, transformers, graph):\\n \\\"\\\"\\\"\\n :param tranformers: List of dicts.\\n :extractor: function.\\n :param graph: networkx.Graph\\n :returns: projx.nx_loader\\n \\\"\\\"\\\"\\n return loaders.nx2nx_loader(extractor, stream, transformers,\\n self.loader_json[self.loader_name],\\n graph)\\n\\n @self.loaders_wrapper(\\\"neo4j2nx\\\")\\n def get_neo4j2nx_loader(extractor, stream, transformers, graph):\\n \\\"\\\"\\\"\\n :param tranformers: List of dicts.\\n :extractor: function.\\n :param graph: networkx.Graph\\n :returns: projx.nx_loader\\n \\\"\\\"\\\"\\n return loaders.neo4j2nx_loader(extractor, stream, transformers,\\n self.loader_json[self.loader_name],\\n graph)\\n\\n\\n @self.loaders_wrapper(\\\"neo4j2edgelist\\\")\\n def get_neo4j2edgelist_loader(extractor, stream, transformers, graph):\\n \\\"\\\"\\\"\\n :param tranformers: List of dicts.\\n :extractor: function.\\n :param graph: networkx.Graph\\n :returns: projx.nx_loader\\n \\\"\\\"\\\"\\n return loaders.neo4j2edgelist_loader(\\n extractor,\\n stream,\\n transformers,\\n self.loader_json[self.loader_name],\\n graph\\n )\\n\\n\\n @self.loaders_wrapper(\\\"edgelist2neo4j\\\")\\n def get_edgelist2neo4j_loader(extractor, stream, transformers, graph):\\n \\\"\\\"\\\"\\n :param tranformers: List of dicts.\\n :extractor: function.\\n :param graph: networkx.Graph\\n :returns: projx.nx_loader\\n \\\"\\\"\\\"\\n return loaders.edgelist2neo4j_loader(\\n extractor,\\n stream,\\n transformers,\\n self.loader_json[self.loader_name],\\n graph\\n )\",\n \"def build_dataloaders(dataset, batch_size, train_test_split=0.1, train_shuffle=True, eval_shuffle=True):\\n # 데이터셋 길이\\n dataset_len = len(dataset)\\n\\n # 학습, 평가 데이터 나누기\\n eval_len = int(dataset_len * train_test_split)\\n train_len = dataset_len - eval_len\\n\\n train_dataset, eval_dataset = random_split(dataset, (train_len, eval_len))\\n\\n train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=train_shuffle)\\n eval_loader = DataLoader(eval_dataset, batch_size=batch_size, shuffle=eval_shuffle)\\n\\n\\n logging.info(f'''train_dataloader size: {len(train_loader.dataset)} | shuffle: {train_shuffle}\\n eval_dataloader size: {len(eval_loader.dataset)} | shuffle: {eval_shuffle}''')\\n\\n return train_loader, eval_loader\",\n \"def get_loader(mode):\\n\\tglobal train_loader, valid_loader\\n\\tconfig = Config\\n\\ttransform_list_train = []\\n\\ttransform_list_test = []\\n\\tis_train = mode == \\\"train\\\"\\n\\tif config.train.use_augmentation:\\n\\t\\ttransform_list_train.extend([transforms.Resize((config.data.image_size, config.data.image_size)), ImageNetPolicy()])\\n\\ttransform_list_train.extend([transforms.Resize((config.data.image_size, config.data.image_size)), transforms.ToTensor(),\\n\\t transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\\n\\t\\n\\ttransform_train = transforms.Compose(transform_list_train)\\n\\t\\n\\tif config.predict.use_augmentation:\\n\\t\\ttransform_list_test.extend([transforms.Resize((config.data.image_size, config.data.image_size)), ImageNetPolicy()])\\n\\ttransform_list_test.extend([transforms.Resize((config.data.image_size, config.data.image_size)), transforms.ToTensor(),\\n\\t transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\\n\\t\\n\\ttransform_test = transforms.Compose(transform_list_test)\\n\\tif config.model.dataset == \\\"mnist\\\":\\n\\t\\tmnist = datasets.MNIST(root=config.data.mnist_path, download=True, transform=transform_train, train=is_train)\\n\\t\\t# train-validation split\\n\\t\\ttrain_mnist, valid_mnist = train_valid_split(mnist)\\n\\t\\ttrain_loader = DataLoader(dataset=train_mnist, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\\n\\t\\tvalid_loader = DataLoader(dataset=valid_mnist, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\\n\\tif config.model.dataset == \\\"svhn\\\":\\n\\t\\tsvhn = datasets.SVHN(root=config.data.svhn_path, download=True, transform=transform_train, split=mode)\\n\\t\\ttrain_svhn, valid_svhn = train_valid_split(svhn)\\n\\t\\ttrain_loader = DataLoader(dataset=train_svhn, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\\n\\t\\tvalid_loader = DataLoader(dataset=valid_svhn, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\\n\\tif config.model.dataset == \\\"cifar10\\\":\\n\\t\\tcifar10 = datasets.CIFAR10(root=config.data.cifar10_path, download=True, transform=transform_train, train=is_train)\\n\\t\\ttrain_cifar, valid_cifar = train_valid_split(cifar10)\\n\\t\\ttrain_loader = DataLoader(dataset=train_cifar, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\\n\\t\\tvalid_loader = DataLoader(dataset=valid_cifar, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\\n\\tif config.model.dataset == \\\"moons\\\":\\n\\t\\ttrain_moons, valid_moons = train_valid_split(moons_dataset())\\n\\t\\ttrain_loader = DataLoader(dataset=train_moons, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\\n\\t\\tvalid_loader = DataLoader(dataset=valid_moons, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\\n\\tif config.model.dataset == \\\"miniimagenet\\\":\\n\\t\\ttrain_loader, valid_loader = read_dataset(Config.data.miniimagenet_path, transform_train, transform_test) # transform_train(train_loader)\\n\\tif config.model.dataset == \\\"miniimagenet_all\\\":\\n\\t\\ttrain_loader = datasets.ImageFolder(root=config.data.miniimagenet_path_train, transform=transform_train)\\n\\t\\tvalid_loader = datasets.ImageFolder(root=config.data.miniimagenet_path_valid, transform=transform_list_test)\\n\\t\\t# \\t# test_imagenet = datasets.ImageFolder(root=config.data.miniimagenet_path_test)\\n\\t\\ttrain_loader = DataLoader(dataset=train_loader, batch_size=Config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\\n\\t\\tvalid_loader = DataLoader(dataset=valid_loader, batch_size=Config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\\n\\t# \\t# test_loader = DataLoader(dataset=test_imagenet, batch_size=config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\\n\\tif config.model.dataset == \\\"miniimagenet_concat\\\":\\n\\t\\tconcat_dataset = ConcatDataset([datasets.ImageFolder(config.data.miniimagenet_path_train, transform=transform_train),\\n\\t\\t datasets.ImageFolder(config.data.miniimagenet_path_valid, transform=transform_train)])\\n\\t\\ttrain_, valid_ = train_valid_split(concat_dataset)\\n\\t\\ttrain_loader = torch.utils.data.DataLoader(train_, batch_size=config.train.batch_size, shuffle=True, num_workers=config.data.num_workers, pin_memory=True)\\n\\t\\tvalid_loader = torch.utils.data.DataLoader(valid_, batch_size=config.train.batch_size, shuffle=True, num_workers=config.data.num_workers, pin_memory=True)\\n\\t\\n\\tif config.model.dataset == \\\"imagenet\\\":\\n\\t\\ttrain_loader = datasets.ImageFolder(root=config.data.imagenet_path_train, transform=transform_train)\\n\\t\\tvalid_loader = datasets.ImageFolder(root=config.data.imagenet_path_val, transform=transform_list_test)\\n\\t\\t# \\t# test_imagenet = datasets.ImageFolder(root=config.data.miniimagenet_path_test)\\n\\t\\ttrain_loader = DataLoader(dataset=train_loader, batch_size=Config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\\n\\t\\tvalid_loader = DataLoader(dataset=valid_loader, batch_size=Config.train.batch_size, shuffle=config.train.shuffle, num_workers=config.data.num_workers)\\n\\treturn train_loader, valid_loader\",\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 _init_train_loader(self):\\n # Choose the right dataset type\\n if self.config_args[\\\"num_members\\\"] > 1:\\n class_dataset_wrapper = dataset_wrapper.MixMoDataset\\n else:\\n class_dataset_wrapper = dataset_wrapper.MSDADataset\\n\\n # Load augmentations\\n self.traindatasetwrapper = class_dataset_wrapper(\\n dataset=self.train_dataset,\\n num_classes=int(self.config_args[\\\"data\\\"][\\\"num_classes\\\"]),\\n num_members=self.config_args[\\\"num_members\\\"],\\n dict_config=self.config_args[\\\"training\\\"][\\\"dataset_wrapper\\\"],\\n properties=self.properties\\n )\\n\\n # Build standard sampler\\n _train_sampler = torch.utils.data.sampler.RandomSampler(\\n data_source=self.traindatasetwrapper, ## only needed for its length\\n num_samples=None,\\n replacement=False,\\n )\\n\\n # Wrap it with the repeating sampler used for multi-input models\\n batch_sampler = batch_repetition_sampler.BatchRepetitionSampler(\\n sampler=_train_sampler,\\n batch_size=self.batch_size,\\n num_members=self.config_args[\\\"num_members\\\"],\\n drop_last=True,\\n config_batch_sampler=self.config_args[\\\"training\\\"][\\\"batch_sampler\\\"]\\n )\\n\\n self.train_loader = torch.utils.data.DataLoader(\\n self.traindatasetwrapper,\\n batch_sampler=batch_sampler,\\n num_workers=self.num_workers,\\n batch_size=1,\\n shuffle=False,\\n sampler=None,\\n drop_last=False,\\n pin_memory=True,\\n )\",\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 get_loader(data_list, config, train=True):\\n \\n with open(config[\\\"label_map\\\"], \\\"r\\\") as f:\\n label_map = json.load(f)\\n\\n dataset = GoogleSpeechDataset(\\n data_list=data_list,\\n label_map=label_map,\\n audio_settings=config[\\\"hparams\\\"][\\\"audio\\\"],\\n aug_settings=config[\\\"hparams\\\"][\\\"augment\\\"] if train else None,\\n cache=config[\\\"exp\\\"][\\\"cache\\\"]\\n )\\n\\n dataloader = DataLoader(\\n dataset,\\n batch_size=config[\\\"hparams\\\"][\\\"batch_size\\\"],\\n num_workers=config[\\\"exp\\\"][\\\"n_workers\\\"],\\n pin_memory=config[\\\"exp\\\"][\\\"pin_memory\\\"],\\n shuffle=True if train else False\\n )\\n\\n return dataloader\",\n \"def create_pretraining_dataloader(\\n hdf5_fpath: str,\\n max_masked_tokens_per_input: int,\\n batch_size: int\\n ):\\n pretraining_data = PretrainingDataset(\\n hdf5_fpath=hdf5_fpath,\\n max_masked_tokens_per_input=max_masked_tokens_per_input\\n )\\n train_sampler = RandomSampler(pretraining_data)\\n train_dataloader = DataLoader(\\n pretraining_data,\\n sampler=train_sampler,\\n batch_size=batch_size,\\n num_workers=4,\\n pin_memory=True\\n )\\n return train_dataloader, hdf5_fpath\",\n \"def __init__(self, dataset_name, split, *args, data_dir=None, **kwargs):\\n super(TfdsInput, self).__init__(*args, **kwargs)\\n self.dataset_name = dataset_name\\n self.split = split\\n self.data_dir = data_dir\",\n \"def to_DataLoader(self, **kwargs):\\r\\n return DataLoader(self, **kwargs)\",\n \"def make_loader(model, dataset, batch_size, workers, eval_proportion):\\n dataset_extra_args = dict(\\n num_frames=model['num_frames'],\\n channels=model['input_type'],\\n action_space=model['action_space'],\\n steps_action=model['steps_action'],\\n num_signals=model['num_signals'],\\n num_skills=model['num_skills'])\\n if model['mode'] == 'regression':\\n dataset_class = RegressionDataset\\n else:\\n dataset_class = ImitationDataset\\n\\n im_dataset = dataset_class(**dataset, **dataset_extra_args)\\n train_dataset, eval_dataset = split_dataset(im_dataset, eval_proportion)\\n train_loader = torch.utils.data.DataLoader(\\n train_dataset,\\n batch_size,\\n num_workers=workers,\\n shuffle=True,\\n drop_last=False)\\n if eval_dataset is not None:\\n eval_loader = torch.utils.data.DataLoader(\\n eval_dataset,\\n batch_size,\\n num_workers=workers,\\n shuffle=True,\\n drop_last=False)\\n else:\\n eval_loader = None\\n\\n env_name = im_dataset._frames.infos['env_name']\\n return (train_loader, eval_loader, env_name, im_dataset.get_statistics())\",\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 load_dataloaders(args):\\n logger.info(\\\"Loading dataloaders...\\\")\\n p_path = os.path.join(\\\"./data/\\\", \\\"df_unencoded.pkl\\\")\\n train_path = os.path.join(\\\"./data/\\\", \\\"df_encoded.pkl\\\")\\n if (not os.path.isfile(p_path)) and (not os.path.isfile(train_path)):\\n df = get_data(args, load_extracted=False)\\n elif os.path.isfile(p_path) and (not os.path.isfile(train_path)):\\n df = get_data(args, load_extracted=True)\\n elif os.path.isfile(train_path):\\n df = load_pickle(\\\"df_encoded.pkl\\\")\\n \\n # Train-Test split\\n msk = np.random.rand(len(df)) < args.train_test_ratio\\n trainset = df[msk]\\n testset = df[~msk]\\n \\n trainset = text_dataset(trainset, args)\\n max_features_length = trainset.max_x_len\\n max_seq_len = trainset.max_y_len\\n train_length = len(trainset)\\n train_loader = DataLoader(trainset, batch_size=args.batch_size, shuffle=True,\\\\\\n num_workers=0, collate_fn=Pad_Sequence(), pin_memory=False)\\n \\n testset = text_dataset(testset, args)\\n test_length = len(testset)\\n test_loader = DataLoader(testset, batch_size=args.batch_size, shuffle=True,\\\\\\n num_workers=0, collate_fn=Pad_Sequence(), pin_memory=False)\\n return train_loader, train_length, max_features_length, max_seq_len, test_loader, test_length\",\n \"def make_loader(dataset, train_batch_size, validation_split=0.2):\\n # number of samples in train and test set\\n train_len = int(len(dataset) * (1 - validation_split))\\n test_len = len(dataset) - train_len\\n train_set, test_set = torch.utils.data.random_split(dataset, [train_len, test_len])\\n # create train_loader\\n train_loader = torch.utils.data.DataLoader(\\n train_set, batch_size=train_batch_size, shuffle=True,\\n )\\n # create test_loader\\n test_loader = torch.utils.data.DataLoader(test_set, batch_size=1, shuffle=False,)\\n return train_loader, test_loader\",\n \"def fetch_dataloader(types, dataset_dir, params):\\n\\n dataloaders = {}\\n samplers = {}\\n\\n for split in ['train', 'val', 'test']:\\n if split in types:\\n path = os.path.join(dataset_dir, \\\"{}\\\".format(split))\\n\\n # Use the train_transformer if training data, else use eval_transformer without random flip\\n # take care of 'pin_memory' and 'num_workers'\\n if split == 'train':\\n train_set = BaseDataset(path, train_transformer)\\n sampler = None\\n if params.distributed:\\n sampler = torch.utils.data.distributed.DistributedSampler(\\n train_set)\\n dataloader = DataLoader(\\n train_set,\\n batch_size=params.batch_size_pre_gpu,\\n shuffle=(sampler is None),\\n num_workers=params.num_workers,\\n pin_memory=params.cuda,\\n sampler=sampler)\\n\\n else:\\n val_set = BaseDataset(path, eval_transformer)\\n sampler = None\\n if params.distributed:\\n sampler = torch.utils.data.distributed.DistributedSampler(\\n val_set)\\n dataloader = DataLoader(\\n val_set,\\n batch_size=params.batch_size_pre_gpu,\\n shuffle=False,\\n pin_memory=params.cuda,\\n num_workers=params.num_workers,\\n sampler=sampler)\\n\\n dataloaders[split] = dataloader\\n samplers[split] = sampler\\n\\n return dataloaders, samplers\",\n \"def get_dataset_loader(self, batch_size, workers, is_gpu):\\n\\n train_loader = torch.utils.data.DataLoader(\\n self.trainset,\\n batch_size=batch_size, shuffle=True,\\n num_workers=workers, pin_memory=is_gpu, sampler=None)\\n\\n val_loader = torch.utils.data.DataLoader(\\n self.valset,\\n batch_size=batch_size, shuffle=False,\\n num_workers=workers, pin_memory=is_gpu)\\n\\n return train_loader, val_loader\",\n \"def get_dataset_loader(self, batch_size, workers, is_gpu):\\n\\n train_loader = torch.utils.data.DataLoader(\\n self.trainset,\\n batch_size=batch_size, shuffle=True,\\n num_workers=workers, pin_memory=is_gpu, sampler=None)\\n\\n val_loader = torch.utils.data.DataLoader(\\n self.valset,\\n batch_size=batch_size, shuffle=False,\\n num_workers=workers, pin_memory=is_gpu)\\n\\n return train_loader, val_loader\",\n \"def get_dataset_loader(self, batch_size, workers, is_gpu):\\n\\n train_loader = torch.utils.data.DataLoader(\\n self.trainset,\\n batch_size=batch_size, shuffle=True,\\n num_workers=workers, pin_memory=is_gpu, sampler=None)\\n\\n val_loader = torch.utils.data.DataLoader(\\n self.valset,\\n batch_size=batch_size, shuffle=False,\\n num_workers=workers, pin_memory=is_gpu)\\n\\n return train_loader, val_loader\",\n \"def get_dataset_loader(self, batch_size, workers, is_gpu):\\n\\n train_loader = torch.utils.data.DataLoader(\\n self.trainset,\\n batch_size=batch_size, shuffle=True,\\n num_workers=workers, pin_memory=is_gpu, sampler=None)\\n\\n val_loader = torch.utils.data.DataLoader(\\n self.valset,\\n batch_size=batch_size, shuffle=False,\\n num_workers=workers, pin_memory=is_gpu)\\n\\n return train_loader, val_loader\",\n \"def get_dataset_loader(self, batch_size, workers, is_gpu):\\n\\n train_loader = torch.utils.data.DataLoader(\\n self.trainset,\\n batch_size=batch_size, shuffle=True,\\n num_workers=workers, pin_memory=is_gpu, sampler=None)\\n\\n val_loader = torch.utils.data.DataLoader(\\n self.valset,\\n batch_size=batch_size, shuffle=False,\\n num_workers=workers, pin_memory=is_gpu)\\n\\n return train_loader, val_loader\",\n \"def get_dataset_loader(self, batch_size, workers, is_gpu):\\n\\n train_loader = torch.utils.data.DataLoader(\\n self.trainset,\\n batch_size=batch_size, shuffle=True,\\n num_workers=workers, pin_memory=is_gpu, sampler=None)\\n\\n val_loader = torch.utils.data.DataLoader(\\n self.valset,\\n batch_size=batch_size, shuffle=False,\\n num_workers=workers, pin_memory=is_gpu)\\n\\n return train_loader, val_loader\",\n \"def get_dataset_loader(self, batch_size, workers, is_gpu):\\n\\n train_loader = torch.utils.data.DataLoader(\\n self.trainset,\\n batch_size=batch_size, shuffle=True,\\n num_workers=workers, pin_memory=is_gpu, sampler=None)\\n\\n val_loader = torch.utils.data.DataLoader(\\n self.valset,\\n batch_size=batch_size, shuffle=False,\\n num_workers=workers, pin_memory=is_gpu)\\n\\n return train_loader, val_loader\",\n \"def get_dataset_loader(self, batch_size, workers, is_gpu):\\n\\n train_loader = torch.utils.data.DataLoader(\\n self.trainset,\\n batch_size=batch_size, shuffle=True,\\n num_workers=workers, pin_memory=is_gpu, sampler=None)\\n\\n val_loader = torch.utils.data.DataLoader(\\n self.valset,\\n batch_size=batch_size, shuffle=False,\\n num_workers=workers, pin_memory=is_gpu)\\n\\n return train_loader, val_loader\",\n \"def get_dataset_loader(self, batch_size, workers, is_gpu):\\n\\n train_loader = torch.utils.data.DataLoader(\\n self.trainset,\\n batch_size=batch_size, shuffle=True,\\n num_workers=workers, pin_memory=is_gpu, sampler=None)\\n\\n val_loader = torch.utils.data.DataLoader(\\n self.valset,\\n batch_size=batch_size, shuffle=False,\\n num_workers=workers, pin_memory=is_gpu)\\n\\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 train_input(config, params):\\n\\n def _grouping(rim, rla, pim, pla, imp, lap):\\n # group dataset elements as required by estimator\\n features = {\\n 'rawimages': rim,\\n 'proimages': pim,\\n 'rawimagespaths': imp,\\n 'rawlabelspaths': lap,\\n }\\n labels = {\\n 'rawlabels': rla,\\n 'prolabels': pla,\\n }\\n\\n # next line for distributed debugging\\n # tf.string tensors is not supported for DMA read/write to GPUs (TF bug)\\n if params.distribute:\\n del features['rawimagespaths']\\n del features['rawlabelspaths']\\n\\n return (features, labels)\\n\\n with tf.variable_scope('input_pipeline'):\\n dataset = prebatch_dataset(config, params)\\n dataset = dataset.batch(get_temp_Nb(config, params.Nb))\\n dataset = postbatch_dataset(dataset, config, params)\\n dataset = dataset.map(_grouping, num_parallel_calls=NUM_PARALLEL_CALLS)\\n dataset = dataset.prefetch(None)\\n\\n return dataset\",\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 get_precomp_loader(data_path, data_split, opt, batch_size=100,\\n shuffle=True, num_workers=16):\\n dset = PrecompDataset(data_path, data_split, opt)\\n\\n data_loader = torch.utils.data.DataLoader(dataset=dset,\\n batch_size=batch_size,\\n shuffle=shuffle,\\n pin_memory=True,\\n collate_fn=collate_fn,num_workers = num_workers)\\n return data_loader\",\n \"def get_data_loaders_4sentence():\\n dataset_path = \\\"\\\"\\n dataset_cache = None\\n personachat = get_dataset(dataset_path, dataset_cache)\\n\\n tokenizer_selected = OpenAIGPTTokenizer.from_pretrained('openai-gpt')\\n logger.info(\\\"Build inputs and labels\\\")\\n datasets = {\\\"train\\\": defaultdict(list), \\\"valid\\\": defaultdict(list)}\\n personality = []\\n history_complete = []\\n count_persona = 0\\n with open('data_faiss_pegasus_1generated.pkl', 'rb') as f:\\n persona_selected_list = pickle.load(f)\\n for dataset_name, dataset in personachat.items():\\n num_candidates = len(dataset[0][\\\"utterances\\\"][0][\\\"candidates\\\"])\\n if num_candidates > 0 and dataset_name == 'train':\\n num_candidates = min(1, num_candidates)\\n for dialog in dataset:\\n persona = dialog[\\\"persona_info\\\"].copy()\\n #datasets[personality].append(persona)\\n count_history = 0\\n for utterance in dialog[\\\"utterances\\\"]:\\n count_history = count_history + 1\\n history = utterance[\\\"history\\\"]\\n #history_complete.append(history)\\n if len(history_splitted) > (len(persona)-1):\\n history_chatbot = history[1::2]\\n persona_selected = persona_selected_list[count_persona]\\n instance = build_input_from_segments_faiss(persona_selected, history_chatbot) \\n for input_name, input_array in instance.items():\\n datasets[dataset_name][input_name].append(input_array)\\n count_persona = count_persona + 1\\n return datasets\",\n \"def get_data_loaders(opt):\\n return find_dataloader_using_name(opt.dataloader)(opt).load_data()\",\n \"def fetch_dataloader(splits, params):\\n # train_transforms, val_transforms = get_transforms_initial()\\n train_transforms, val_transforms = get_transforms_stanford()\\n\\n dataloaders = {}\\n\\n for split in splits:\\n\\n if split == args.TRAIN:\\n dl = DataLoader(ISBI2012Dataset(path_img=args.path_img_train,\\n path_target=args.path_target_train,\\n transforms=train_transforms,\\n split=args.TRAIN),\\n batch_size=params.batch_size,\\n shuffle=True,\\n num_workers=0,\\n pin_memory=params.cuda)\\n elif split == args.VAL:\\n dl = DataLoader(ISBI2012Dataset(path_img=args.path_img_train,\\n path_target=args.path_target_train,\\n transforms=val_transforms,\\n split=args.VAL),\\n batch_size=params.batch_size,\\n shuffle=True,\\n num_workers=0,\\n pin_memory=params.cuda)\\n elif split == args.TEST:\\n dl = DataLoader(ISBI2012Dataset(path_img=args.path_img_test,\\n path_target=None,\\n transforms=val_transforms,\\n split=args.TEST),\\n batch_size=params.batch_size,\\n shuffle=False,\\n num_workers=0,\\n pin_memory=params.cuda)\\n else:\\n raise IndexError('incorrect split')\\n\\n dataloaders[split] = dl\\n\\n return dataloaders\",\n \"def get_precomp_loader(data_path, data_split, vocab, opt, batch_size=100,\\r\\n shuffle=True, num_workers=2):\\r\\n\\r\\n dset = PrecompDataset(data_path, data_split, vocab)\\r\\n # train_sampler = torch.utils.data.distributed.DistributedSampler(dset)\\r\\n # if data_split == 'train':\\r\\n # data_loader = DataLoader(dataset=dset, batch_size=batch_size, shuffle=False, num_workers=num_workers, pin_memory=True, collate_fn=collate_fn, sampler=train_sampler)\\r\\n # else:\\r\\n data_loader = DataLoaderX(dataset=dset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers, pin_memory=True, collate_fn=collate_fn)\\r\\n\\r\\n return data_loader\",\n \"def dataio_prepare(hparams, tokenizer):\\n\\n # 1. Define datasets\\n data_folder = hparams[\\\"data_folder\\\"]\\n\\n train_data = sb.dataio.dataset.DynamicItemDataset.from_csv(\\n csv_path=hparams[\\\"train_csv\\\"], replacements={\\\"data_root\\\": data_folder},\\n )\\n\\n if hparams[\\\"sorting\\\"] == \\\"ascending\\\":\\n # we sort training data to speed up training and get better results.\\n train_data = train_data.filtered_sorted(\\n sort_key=\\\"duration\\\",\\n key_max_value={\\\"duration\\\": hparams[\\\"avoid_if_longer_than\\\"]},\\n )\\n # when sorting do not shuffle in dataloader ! otherwise is pointless\\n hparams[\\\"dataloader_options\\\"][\\\"shuffle\\\"] = False\\n\\n elif hparams[\\\"sorting\\\"] == \\\"descending\\\":\\n train_data = train_data.filtered_sorted(\\n sort_key=\\\"duration\\\",\\n reverse=True,\\n key_max_value={\\\"duration\\\": hparams[\\\"avoid_if_longer_than\\\"]},\\n )\\n # when sorting do not shuffle in dataloader ! otherwise is pointless\\n hparams[\\\"dataloader_options\\\"][\\\"shuffle\\\"] = False\\n\\n elif hparams[\\\"sorting\\\"] == \\\"random\\\":\\n pass\\n\\n else:\\n raise NotImplementedError(\\n \\\"sorting must be random, ascending or descending\\\"\\n )\\n\\n valid_data = sb.dataio.dataset.DynamicItemDataset.from_csv(\\n csv_path=hparams[\\\"valid_csv\\\"], replacements={\\\"data_root\\\": data_folder},\\n )\\n # We also sort the validation data so it is faster to validate\\n valid_data = valid_data.filtered_sorted(sort_key=\\\"duration\\\")\\n\\n test_data = sb.dataio.dataset.DynamicItemDataset.from_csv(\\n csv_path=hparams[\\\"test_csv\\\"], replacements={\\\"data_root\\\": data_folder},\\n )\\n\\n # We also sort the validation data so it is faster to validate\\n test_data = test_data.filtered_sorted(sort_key=\\\"duration\\\")\\n\\n datasets = [train_data, valid_data, test_data]\\n\\n # 2. Define audio pipeline:\\n @sb.utils.data_pipeline.takes(\\\"wav\\\")\\n @sb.utils.data_pipeline.provides(\\\"sig\\\")\\n def audio_pipeline(wav):\\n info = torchaudio.info(wav)\\n sig = sb.dataio.dataio.read_audio(wav)\\n resampled = torchaudio.transforms.Resample(\\n info.sample_rate, hparams[\\\"sample_rate\\\"],\\n )(sig)\\n return resampled\\n\\n sb.dataio.dataset.add_dynamic_item(datasets, audio_pipeline)\\n\\n # 3. Define text pipeline:\\n @sb.utils.data_pipeline.takes(\\\"wrd\\\")\\n @sb.utils.data_pipeline.provides(\\n \\\"tokens_list\\\", \\\"tokens_bos\\\", \\\"tokens_eos\\\", \\\"tokens\\\"\\n )\\n def text_pipeline(wrd):\\n tokens_list = tokenizer.sp.encode_as_ids(wrd)\\n yield tokens_list\\n tokens_bos = torch.LongTensor([hparams[\\\"bos_index\\\"]] + (tokens_list))\\n yield tokens_bos\\n tokens_eos = torch.LongTensor(tokens_list + [hparams[\\\"eos_index\\\"]])\\n yield tokens_eos\\n tokens = torch.LongTensor(tokens_list)\\n yield tokens\\n\\n sb.dataio.dataset.add_dynamic_item(datasets, text_pipeline)\\n\\n # 4. Set output:\\n sb.dataio.dataset.set_output_keys(\\n datasets, [\\\"id\\\", \\\"sig\\\", \\\"tokens_bos\\\", \\\"tokens_eos\\\", \\\"tokens\\\"],\\n )\\n return train_data, valid_data, test_data\",\n \"def make_data_loader(condition, root='data', base_path='ut-zap50k-images',\\n files_json_path='filenames.json',\\n batch_size=64, shuffle=False, **kwargs):\\n dataset = make_dataset(condition, root, base_path, files_json_path)\\n loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,\\n shuffle=shuffle, **kwargs)\\n return loader\",\n \"def get_dataloader(sets, root_dir, manifest_path, task, batch_size=1, return_pid = False):\\n data_loaders = {}\\n\\n for set in ['train', 'valid', 'test', 'all_images']: # test doesn't apply to MRNet but will keep in\\n if set in sets:\\n if set == 'train':\\n ds = Dataset(set='train', task = task, root_dir=root_dir, manifest_path = manifest_path, return_pid = return_pid,\\n transform=transforms.Compose([transforms.ToPILImage(),\\n #transforms.RandomHorizontalFlip(), # default is 50%\\n #transforms.RandomAffine(25, # rotation\\n # translate=(0.1, 0.1),\\n # shear = (-15, 15)),\\n transforms.ToTensor(),\\n ]))\\n loader = DataLoader(ds, batch_size=batch_size, shuffle=True)\\n elif set == 'valid':\\n ds = Dataset(set='valid', task = task, root_dir=root_dir,manifest_path = manifest_path, return_pid = return_pid,\\n transform=transforms.Compose([transforms.ToPILImage(),\\n transforms.ToTensor(),\\n ]))\\n\\n loader = DataLoader(ds, batch_size=batch_size, shuffle=False)\\n elif set == 'all_images':\\n ds = Dataset(set='all_images', task = task, root_dir=root_dir,manifest_path = manifest_path, return_pid = return_pid,\\n transform=transforms.Compose([transforms.ToPILImage(),\\n transforms.ToTensor(),\\n ]))\\n loader = DataLoader(ds, batch_size=batch_size, shuffle=False)\\n data_loaders[set] = loader\\n return (data_loaders)\",\n \"def get_dataloaders(logging, batch_size):\\n # Load Data\\n logging.info(\\\"Reading Train and Test data...\\\")\\n train_df = pd.read_csv(\\\"C:/tmp/avila_classification/data/avila-tr.txt\\\", header=None)\\n test_df = pd.read_csv(\\\"C:/tmp/avila_classification/data/avila-ts.txt\\\", header=None)\\n\\n # Fix column names\\n col_names = ['col_' + str(j + 1) for j in range(train_df.shape[1] - 1)]\\n indep_cols = col_names.copy()\\n col_names.append('y')\\n\\n logging.debug(\\\"Assigning columns\\\")\\n train_df.columns = col_names\\n test_df.columns = col_names\\n\\n # Encode dependent variable column\\n le = LabelEncoder()\\n le.fit(train_df['y'])\\n logging.debug(f\\\"Classes: {le.classes_}\\\")\\n logging.debug(f\\\"Transformed Classes: {le.transform(le.classes_)}\\\")\\n\\n train_df['y_enc'] = le.transform(train_df['y'])\\n test_df['y_enc'] = le.transform(test_df['y'])\\n\\n # train_df.head()\\n logging.debug(f\\\"Shape of train data: {train_df.shape}\\\")\\n logging.debug(f\\\"Shape of test data: {test_df.shape}\\\")\\n\\n # Create train and validation dataloaders\\n train_ds = AvilaDataset(data_frame=train_df, indep_cols=indep_cols, dep_col='y_enc')\\n valid_ds = AvilaDataset(data_frame=test_df, indep_cols=indep_cols, dep_col='y_enc')\\n\\n # Should be some exponent of 2 (128, 256)\\n # batch_size = 256\\n train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True)\\n valid_dl = DataLoader(valid_ds, batch_size=batch_size, shuffle=False)\\n\\n return train_dl, valid_dl, le\",\n \"def get_dataloaders(data_dir,train_batch_size,val_batch_size,aug_flag):\\n # Create the dataset object.\\n transformed_dataset = PersonDataset(data_dir,False)\\n # dataloader for train and validation\\n validation_split = 0.2\\n shuffle_dataset = True\\n #random seed to keep the train-val split constant for inference purpose\\n random_seed= 42\\n # create indices for training and validation splits.\\n dataset_size = len(transformed_dataset)\\n # we create the indices using python range function and store it into a list\\n indices = list(range(dataset_size))\\n split = int(np.floor(validation_split*dataset_size))\\n if shuffle_dataset:\\n np.random.seed(random_seed)\\n np.random.shuffle(indices)\\n train_indices,val_indices = indices[split:],indices[:split]\\n # create dataloaders...\\n train_sampler = SubsetRandomSampler(train_indices)\\n val_sampler = SubsetRandomSampler(val_indices)\\n train_aug,val_aug = aug_flag,False\\n train_loader = DataLoader(PersonDataset(data_dir,train_aug), batch_size=train_batch_size, shuffle=False, num_workers=0,sampler = train_sampler)\\n val_loader = DataLoader(PersonDataset(data_dir,val_aug), batch_size=val_batch_size, shuffle=False, num_workers=0,sampler = val_sampler)\\n\\n # dictionary for data loaders..\\n dataloaders = {\\\"train\\\" :train_loader,\\n \\\"val\\\":val_loader\\n }\\n return dataloaders\",\n \"def prepare(self):\\n\\n inp = self.config.get('predict.input', 'X:0')\\n out = self.config.get('predict.output', 'output:0')\\n\\n # set input placeholder\\n self.input = self.graph.get_tensor_by_name(inp)\\n\\n # set output operation\\n if isinstance(out, str) or isinstance(out, unicode):\\n self.output = {out: self.graph.get_tensor_by_name(out)}\\n self.output_alone = True\\n elif isinstance(out, list):\\n self.output = {o: self.graph.get_tensor_by_name(o) for o in out}\\n self.output_alone = False\\n else:\\n raise LoaderException('incorrect predict.output type')\",\n \"def fetch_dataloader(types, params, CViters):\\n\\tdataloaders = {}\\n\\tassert CViters[0] != CViters[1], 'ERROR! Test set and validation set cannot be the same!'\\n\\t\\n\\tif len(types)>0:\\n\\t\\tfor split in types:\\n\\t\\t\\tif split in ['train', 'val', 'test']:\\n\\t\\t\\t\\tdl = DataLoader(imageDataset(split, params, CViters), batch_size=params.batch_size, shuffle=True,\\n\\t\\t\\t\\t\\tnum_workers=params.num_workers,\\n\\t\\t\\t\\t\\tpin_memory=params.cuda)\\n\\n\\t\\t\\t\\tdataloaders[split] = dl\\n\\telse:\\n\\t\\tdl = DataLoader(imageDataset('', params, CViters), batch_size=params.batch_size, shuffle=True,\\n\\t\\t\\tnum_workers=params.num_workers,\\n\\t\\t\\tpin_memory=params.cuda)\\n\\n\\t\\treturn dl\\n\\n\\treturn dataloaders\",\n \"def create_dataloaders(data_dir, input_size, batch_size):\\n # Get dataset mean and std\\n dataset_mean, dataset_std = estimate_dataset_mean_and_std(expand_subdir(data_dir), input_size)\\n\\n # Data augmentation and normalization for training\\n # Just normalization for validation\\n data_transforms = {\\n 'train': transforms.Compose([\\n opencv_transforms.RandomRotation(45),\\n opencv_transforms.RandomResizedCrop(input_size),\\n opencv_transforms.RandomHorizontalFlip(),\\n opencv_transforms.RandomVerticalFlip(),\\n opencv_transforms.ToTensor(),\\n transforms.Normalize(dataset_mean, dataset_std)\\n ]),\\n 'val': transforms.Compose([\\n opencv_transforms.Resize(input_size),\\n opencv_transforms.ToTensor(),\\n transforms.Normalize(dataset_mean, dataset_std)\\n ]),\\n 'test': transforms.Compose([\\n opencv_transforms.Resize(input_size),\\n opencv_transforms.ToTensor(),\\n transforms.Normalize(dataset_mean, dataset_std)\\n ])\\n }\\n\\n # Create training and validation datasets\\n image_datasets = {\\n x: datasets.DatasetFolder(\\n os.path.join(data_dir, x),\\n opencv_loader,\\n ['jpg', 'tif'],\\n transform=data_transforms[x]\\n )\\n for x in ['train', 'val', 'test']\\n }\\n\\n # Create training and validation dataloaders\\n dataloaders = {\\n x: torch.utils.data.DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True, num_workers=1)\\n for x in ['train', 'val', 'test']\\n }\\n\\n return dataloaders, dataset_mean, dataset_std\",\n \"def __init__(self, **kwargs):\\n DataLoader.__init__(self, **kwargs)\",\n \"def fetch_dataloader(types, data_dir, hyper_params, train_idx=None, val_idx=None):\\n dataloaders = {}\\n \\n # TODO: write this to hyper_params, make hyper_params an out variable? then save? yes, AND: when ONLY test is requested, load from hyperparams!\\n # TODO: also, add 3rd variation of types: for testing, only read it from hyper_params (DO I NEED TO READ HYPER_PARAMS FOR JUST TESTING?)\\n if train_idx is not None:\\n mean, std = mean_std_calc(DataLoader(Subset(Heart2DSegmentationDataset(str(Path(data_dir) / \\\"train_heart_scans\\\"), hyper_params.endo_or_epi), train_idx)))\\n hyper_params.mean = mean.item()\\n hyper_params.std = std.item()\\n else:\\n if 'train' in types:\\n mean, std = mean_std_calc(DataLoader(Heart2DSegmentationDataset(str(Path(data_dir) / \\\"train_heart_scans\\\"), hyper_params.endo_or_epi)))\\n hyper_params.mean = mean.item()\\n hyper_params.std = std.item()\\n else:\\n mean, std = torch.tensor(hyper_params.mean), torch.tensor(hyper_params.std)\\n \\n print(\\\"Mean: {}, Std: {}\\\".format(mean.item(), std.item()))\\n # borrowed from http://pytorch.org/tutorials/advanced/neural_style_tutorial.html\\n # and http://pytorch.org/tutorials/beginner/data_loading_tutorial.html\\n train_transformer = transforms.Compose([\\n transforms.Normalize(mean=[mean.item()], std=[std.item()])\\n ])\\n \\n eval_transformer = transforms.Compose([\\n transforms.Normalize(mean=[mean.item()], std=[std.item()])\\n ])\\n\\n for split in ['train', 'val', 'test']:\\n if split in types:\\n path = str(Path(data_dir) / \\\"{}_heart_scans\\\".format(split if split != 'val' else 'train'))\\n\\n if split == 'train':\\n if train_idx is not None:\\n dl = DataLoader(Subset(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, train_transformer), train_idx), \\n batch_size=hyper_params.batch_size, \\n shuffle=True,\\n num_workers=hyper_params.num_workers,\\n pin_memory=hyper_params.cuda)\\n else:\\n dl = DataLoader(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, train_transformer), \\n batch_size=hyper_params.batch_size, \\n shuffle=True,\\n num_workers=hyper_params.num_workers,\\n pin_memory=hyper_params.cuda)\\n else:\\n if (split == 'val') and (val_idx is not None): \\n dl = DataLoader(Subset(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, eval_transformer), val_idx), \\n batch_size=hyper_params.batch_size, \\n shuffle=False,\\n num_workers=hyper_params.num_workers,\\n pin_memory=hyper_params.cuda) \\n else:\\n dl = DataLoader(Heart2DSegmentationDataset(path, hyper_params.endo_or_epi, eval_transformer), \\n batch_size=hyper_params.batch_size, \\n shuffle=False,\\n num_workers=hyper_params.num_workers,\\n pin_memory=hyper_params.cuda)\\n\\n dataloaders[split] = dl\\n\\n return dataloaders\",\n \"def get_data_loader(target_classes, batch_size):\\n classes = ('plane', 'car', 'bird', 'cat',\\n 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\\n ########################################################################\\n # The output of torchvision datasets are PILImage images of range [0, 1].\\n # We transform them to Tensors of normalized range [-1, 1].\\n transform = transforms.Compose(\\n [transforms.ToTensor(),\\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\\n trainset = torchvision.datasets.CIFAR10(root='./data', train=True,\\n download=True, transform=transform)\\n # Get the list of indices to sample from\\n relevant_train_indices = get_relevant_indices(\\n trainset,\\n classes,\\n target_classes)\\n # Split into train and validation\\n np.random.seed(1000) # Fixed numpy random seed for reproducible shuffling\\n np.random.shuffle(relevant_train_indices)\\n split = int(len(relevant_train_indices) * 0.8)\\n relevant_train_indices, relevant_val_indices = relevant_train_indices[:split], relevant_train_indices[split:]\\n train_sampler = SubsetRandomSampler(relevant_train_indices)\\n train_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\\n num_workers=0, sampler=train_sampler)\\n val_sampler = SubsetRandomSampler(relevant_val_indices)\\n val_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\\n num_workers=0, sampler=val_sampler)\\n testset = torchvision.datasets.CIFAR10(root='./data', train=False,\\n download=True, transform=transform)\\n relevant_test_indices = get_relevant_indices(testset, classes, target_classes)\\n test_sampler = SubsetRandomSampler(relevant_test_indices)\\n test_loader = torch.utils.data.DataLoader(testset, batch_size=batch_size,\\n num_workers=0, sampler=test_sampler)\\n return train_loader, val_loader, test_loader, classes\",\n \"def instantiate_batch(self, inputs):\\n return inputs\",\n \"def eval_loader(self, loader):\\r\\n\\t\\treturn predict(model=self.model,\\r\\n\\t\\t\\tpipeline=self.pipeline,\\r\\n\\t\\t\\tdataloader=loader,\\r\\n\\t\\t\\ttask=self.task,\\r\\n\\t\\t\\tmode=\\\"eval\\\")\",\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 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_precomp_loader(data_path, data_split, vocab, opt, batch_size=100,\\n shuffle=True, num_workers=2):\\n dset = PrecompDataset(data_path, data_split, vocab)\\n\\n data_loader = torch.utils.data.DataLoader(dataset=dset,\\n batch_size=batch_size,\\n shuffle=shuffle,\\n pin_memory=True,\\n collate_fn=collate_fn)\\n return data_loader\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74005574","0.7197881","0.7158881","0.6972034","0.6917558","0.68405676","0.6837874","0.678532","0.6781111","0.6738349","0.67170435","0.67128015","0.66842","0.6673706","0.6673443","0.6654735","0.6637798","0.659848","0.65955985","0.6593302","0.6554777","0.6549994","0.65466017","0.6526682","0.6514791","0.6512869","0.6499863","0.6499662","0.6486111","0.6476474","0.6462255","0.6462189","0.645473","0.6433944","0.6425803","0.6416145","0.6414726","0.6412251","0.64062846","0.64006746","0.638786","0.63849115","0.6382319","0.6366457","0.6354456","0.6354144","0.6351114","0.63454235","0.6333896","0.63285124","0.6324406","0.63233143","0.6323016","0.6318405","0.63050264","0.6271817","0.6251987","0.6251472","0.6238807","0.6238041","0.6229634","0.62187105","0.6217668","0.6216396","0.62156963","0.6213398","0.6198799","0.61972785","0.61972785","0.61972785","0.61972785","0.61972785","0.61972785","0.61972785","0.61972785","0.61972785","0.6182779","0.61822087","0.61582214","0.61515176","0.61473477","0.6144385","0.6136519","0.6136173","0.6135644","0.60987365","0.60920215","0.6088752","0.6083866","0.60698545","0.6067298","0.6063142","0.6056642","0.6049097","0.60403657","0.6028773","0.6026345","0.6024697","0.6023978","0.6021439"],"string":"[\n \"0.74005574\",\n \"0.7197881\",\n \"0.7158881\",\n \"0.6972034\",\n \"0.6917558\",\n \"0.68405676\",\n \"0.6837874\",\n \"0.678532\",\n \"0.6781111\",\n \"0.6738349\",\n \"0.67170435\",\n \"0.67128015\",\n \"0.66842\",\n \"0.6673706\",\n \"0.6673443\",\n \"0.6654735\",\n \"0.6637798\",\n \"0.659848\",\n \"0.65955985\",\n \"0.6593302\",\n \"0.6554777\",\n \"0.6549994\",\n \"0.65466017\",\n \"0.6526682\",\n \"0.6514791\",\n \"0.6512869\",\n \"0.6499863\",\n \"0.6499662\",\n \"0.6486111\",\n \"0.6476474\",\n \"0.6462255\",\n \"0.6462189\",\n \"0.645473\",\n \"0.6433944\",\n \"0.6425803\",\n \"0.6416145\",\n \"0.6414726\",\n \"0.6412251\",\n \"0.64062846\",\n \"0.64006746\",\n \"0.638786\",\n \"0.63849115\",\n \"0.6382319\",\n \"0.6366457\",\n \"0.6354456\",\n \"0.6354144\",\n \"0.6351114\",\n \"0.63454235\",\n \"0.6333896\",\n \"0.63285124\",\n \"0.6324406\",\n \"0.63233143\",\n \"0.6323016\",\n \"0.6318405\",\n \"0.63050264\",\n \"0.6271817\",\n \"0.6251987\",\n \"0.6251472\",\n \"0.6238807\",\n \"0.6238041\",\n \"0.6229634\",\n \"0.62187105\",\n \"0.6217668\",\n \"0.6216396\",\n \"0.62156963\",\n \"0.6213398\",\n \"0.6198799\",\n \"0.61972785\",\n \"0.61972785\",\n \"0.61972785\",\n \"0.61972785\",\n \"0.61972785\",\n \"0.61972785\",\n \"0.61972785\",\n \"0.61972785\",\n \"0.61972785\",\n \"0.6182779\",\n \"0.61822087\",\n \"0.61582214\",\n \"0.61515176\",\n \"0.61473477\",\n \"0.6144385\",\n \"0.6136519\",\n \"0.6136173\",\n \"0.6135644\",\n \"0.60987365\",\n \"0.60920215\",\n \"0.6088752\",\n \"0.6083866\",\n \"0.60698545\",\n \"0.6067298\",\n \"0.6063142\",\n \"0.6056642\",\n \"0.6049097\",\n \"0.60403657\",\n \"0.6028773\",\n \"0.6026345\",\n \"0.6024697\",\n \"0.6023978\",\n \"0.6021439\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6874065"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":91496,"cells":{"query":{"kind":"string","value":"Initialize a dict of metrics"},"document":{"kind":"string","value":"def init_metric_dict(self, metrics=[\"\"], phases=[\"train\", \"val\"]):\n metric_dict = {phase: {metric: [] for metric in metrics} for phase in phases}\n return metric_dict"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def initialize_metrics():\n metrics = {\n 'cd_losses': [],\n 'cd_corrects': [],\n 'cd_precisions': [],\n 'cd_recalls': [],\n 'cd_f1scores': [],\n }\n\n return metrics","def init_metrics():\n metrics = defaultdict(list)\n metrics['best_acc'] = 0.0\n metrics['best_loss'] = float('inf')\n metrics['best_epoch'] = 0\n return metrics","def init_metric_dict(self, metrics=None, init_value=None):\n if metrics is None:\n metrics = [\"\"]\n\n if init_value is None:\n init_value = 0.0\n\n self.metric_dict = {metric: init_value for metric in metrics}","def init_metrics(self):\n\n self.metrics = {}\n\n self.metrics['train_loss'] = np.zeros(0)\n self.metrics['test_loss'] = np.zeros(0)\n\n # self.orth_clf = LinearDecoder(self, self.q_, MeanClassifier)\n # self.metrics['train_orthogonality'] = np.zeros(0)\n # self.metrics['test_orthogonality'] = np.zeros(0)\n\n self.metrics['train_parallelism'] = np.zeros((0,self.q_)) \n self.metrics['test_parallelism'] = np.zeros((0,self.q_))","def __init__(self, metrics_to_record):\n self.tape = {}\n\n for metric_name in metrics_to_record:\n self.tape[metric_name] = []","def __init__(self, metrics, gt, pred):\n self.dict_metrics = self.compute_metrics(metrics, gt, pred)","def initialize(self, runInfo, inputs, initDict) :\n super().initialize(runInfo, inputs, initDict)\n for metricIn in self.assemblerDict['Metric']:\n self.metricsDict[metricIn[2]] = metricIn[3]","def init_meters(*metrics):\n return {m: util.AverageMeter() for m in metrics}","def __init__(self, metrics_map, include_val_metrics=False):\n self.metrics_map = metrics_map\n self.include_val_metrics = include_val_metrics\n self.metrics_history = self.__createMetricsHistory()","def init_metrics(losses):\n metrics = {'train': {}, 'valid': {}}\n for mode, d in metrics.items():\n metrics[mode] = dict([(k, 0) for k in losses])\n\n return metrics","def __init_metrics(self):\n\n batch = {}\n # split data into batches of size batch_size or less\n for metric_name, metric_pattern in self.metrics.items():\n # get the batch list for that metric\n batch_list = []\n for s in range(1, self.schema + 1):\n for t in range(1, self.table + 1):\n k = '/metrics/type=IndexTable/keyspace={}/scope={}/name={}/mean'.format(s, t, metric_name)\n # from Python 3.6 onwards, the standard dict type maintains insertion order by default\n batch[k] = 0\n # if the batch has batch_size items or at the end of iteration,\n # append the batch to list of that metric and create a new empty batch\n if len(batch) == self.batch_size or (s == self.schema and t == self.table):\n batch_list.append(batch)\n batch = {}\n\n # parse metric patterns\n l = metric_pattern.split()\n if l[0] == '(>':\n self.metrics[metric_name] = IncMetricStruct(float(int(l[1])), float(l[2][1:]), float(l[4][:-2]),\n batch_list)\n else:\n self.metrics[metric_name] = RandMetricStruct(float(l[0][1:]), float(l[-1][:-1]), batch_list)","def get_metrics(self) -> dict:\n return self.metric_dict","def __init__(self, metrics, test=True, valid_keys=None):\n self.i = {'train': 0}\n self.log_auc, self.log_acc = False, False\n self.log_p_r = False\n self.metrics = {'train': {}}\n self.key = 'train'\n if test:\n self.metrics['test'] = {}\n self.i['test'] = 0\n self.valid_keys = valid_keys\n if valid_keys is not None:\n for valid_key in valid_keys:\n self.metrics[valid_key] = {}\n self.i[valid_key] = 0\n if 'acc' in metrics:\n self.log_acc = True\n for key in self.metrics:\n self.metrics[key].update({'acc': []})\n if 'AUC' in metrics:\n self.log_auc = True\n for key in self.metrics:\n self.metrics[key].update({'auc': []})\n if 'P-R' in metrics:\n self.log_p_r = True\n for key in self.metrics:\n self.metrics[key].update({'p-r': []})\n for key in self.metrics:\n self.metrics[key].update({'loss': [0]})","def metrics(self):\n return {**self.prepend_name_dict(self._prefixes[0], self._train_metrics),\n **self.prepend_name_dict(self._prefixes[1], self.validator.metrics)}","def __init__(self) -> None:\n self.metrics = {}\n self.current = None\n self.run = None","def set_metrics(self):","def set_metrics(metric_dict, cd_loss, cd_corrects, cd_report):\n metric_dict['cd_losses'].append(cd_loss.item())\n metric_dict['cd_corrects'].append(cd_corrects.item())\n metric_dict['cd_precisions'].append(cd_report[0])\n metric_dict['cd_recalls'].append(cd_report[1])\n metric_dict['cd_f1scores'].append(cd_report[2])\n\n return metric_dict","def get_metrics(self) -> Dict[str, base.Number]:\n return self._metrics","def __init__(self, included_metrics: List[str]):\n self.included_metrics = included_metrics\n self.metrics = self._initialize_metrics()","def metrics(self) -> dict:\n if not self.exp_metadata.metrics:\n self.exp_metadata.metrics = {}\n return self.exp_metadata.metrics","def __init__(self, metrics_cache):\n self._metrics_cache = metrics_cache","def metrics(self):\n\n data = requests.get(\n f\"http://{self.prometheus_host}:{self.prometheus_port}/metrics\"\n ).content.decode()\n lines = [line for line in data.split(\"\\n\") if not line.startswith(\"#\")]\n metrics = {}\n for line in lines:\n if not line:\n continue\n\n name, value = line.split(\" \")\n\n try:\n value = int(value) # type: ignore\n except ValueError:\n value = float(value) # type: ignore\n\n if \"{\" in name and \"}\" in name:\n base = name[: name.index(\"{\")]\n tags = name[name.index(\"{\") + 1 : -1]\n tags = [tag.split(\"=\") for tag in tags.split(\",\")]\n tags = [(key, val.replace('\"', \"\")) for key, val in tags]\n\n name = base + \"#\" + \",\".join(f\"{k}:{v}\" for k, v in sorted(tags))\n\n metrics[name] = value\n\n return metrics","def __init__(\n self, config: Config, metrics: Union[Metric, Iterable[Metric]]\n ) -> None:\n self._metrics: Dict[Metric, Optional[float]] = {}\n\n if isinstance(metrics, Metric):\n self._metrics[metrics] = None\n else:\n for key in metrics:\n self._metrics[key] = None\n self._metric_funcs = {\n Metric.ACCURACY: accuracy,\n Metric.RECALL: recall,\n Metric.PRECISION: precision,\n Metric.F1: f_1,\n Metric.CONSISTENCY: consistency,\n }\n self._config = config\n self._ids: List[str] = []\n self._preds: List[str] = []\n self._targets: List[str] = []","def metrics(self):\n raise NotImplementedError(\"metrics\")","def metrics_group():","def configure_metrics(self):\n allowed = list(METRIC_LOOKUP.keys()) + [None]\n metrics = nn.ModuleDict()\n for k, m in self.branch_metrics.items():\n for metric_name in m:\n if metric_name not in allowed:\n raise ValueError(\n f\"Illegal metric given. Got: {metric_name}. Allowed: {allowed}.\"\n )\n\n if metric_name is not None:\n metric = METRIC_LOOKUP[metric_name]()\n else:\n metric = None\n\n metrics[f\"{k}_{metric_name}\"] = metric\n\n return metrics","def test_metrics_empty(self):\n skill_map = SkillMap.load(self.course)\n sm_metrics = SkillMapMetrics(skill_map)\n self.assertEqual(sm_metrics.simple_cycles(), [])\n self.assertEqual(sm_metrics.singletons(), [])\n self.assertEqual(sm_metrics.long_chains(), [])\n expected = {'cycles': [], 'singletons': [], 'long_chains': []}\n self.assertEqual(sm_metrics.diagnose(), expected)","def build_metrics_dict(node):\n\n # Initialize tensors\n n = 0\n n = _recv(n,node)\n keys = [[0 for j in range(8)] for i in range(n)] # max_seq_len for metric name is 8\n values = [0.0 for i in range(n)]\n higher_is_better = [0 for i in range(n)]\n\n # Read data\n keys = _recv(keys,node)\n values = _recv(values,node)\n higher_is_better = _recv(higher_is_better,node)\n\n # Reorganize output + decode dict keys\n orig_keys = [encode_string(key, string_to_int=False) for key in keys]\n values_dict = [{'value': float(v), 'higher_is_better': bool(higher_is_better[i])} for i, v in enumerate(values)]\n metrics = dict(zip(orig_keys,values_dict))\n num_instances = int(metrics.pop('num')['value'])\n\n result = None, metrics, num_instances\n \n return result","def test_create_metrics_dict(self):\n # binary tasks have 1 class at class definition.\n num_classes = 1\n metrics_dict = create_metrics_dict(num_classes)\n assert 'iou_1' in metrics_dict.keys()\n assert 'iou_2' not in metrics_dict.keys()\n\n num_classes = 3\n metrics_dict = create_metrics_dict(num_classes)\n assert 'iou_1' in metrics_dict.keys()\n assert 'iou_2' in metrics_dict.keys()\n assert 'iou_3' not in metrics_dict.keys()\n del metrics_dict","def _make_metric_dict(self, metrics):\n exon = None\n hgvs_c = None\n\n slen = len(metrics.split(':'))\n if slen == 1:\n if \"(dist=\" not in metrics:\n tx = metrics\n else:\n tx = None\n elif slen == 2:\n tx = metrics.split('(')[0]\n hgvs_c = metrics.split(':')[1].rstrip(')')\n elif slen == 3:\n tx = metrics.split('(')[0]\n exon = metrics.split(':')[1][4:]\n hgvs_c = metrics.split(':')[2].rstrip(')')\n else:\n raise UserWarning(\"There are an incorrect number of fields listed in: \" + str(self.info))\n\n if hgvs_c:\n full_c = ':'.join([tx, hgvs_c])\n hgvs_parser = Hgvs(full_c)\n hgvs_basep = hgvs_parser.start\n else:\n hgvs_basep = None\n\n return {\n 'AAP': None,\n 'BASEP': hgvs_basep,\n 'EXON': exon,\n 'HGNC': None,\n 'HGVSC': hgvs_c,\n 'HGVSP1': None,\n 'HGVSP3': None,\n 'SOURCE': self.tfx_type,\n 'SPLICE': self.splicing,\n 'TXC': tx,\n 'PVT': self.vtype,\n 'VFX': None\n }","def metrics(self):\r\n return Metrics(self)","def compute_metrics(self):\n self.finalize_output_dict()\n self.metric_dict = {\n key: value(self.output_dict[\"labels\"], self.output_dict[\"pred_probs\"])\n for key, value in self.metric_fns.items()\n }","def _calculate_metrics(self):\n metrics = {}\n precision, recall = self.calc_precision_recall()\n metrics[\"precision\"] = precision\n metrics[\"recall\"] = recall\n metrics[\"entropy\"] = self.calc_entropy()\n metrics[\"component_entropy\"] = self.calc_component_entropy()\n metrics[\"num_comps\"] = len(self.get_components())\n metrics[\"num_diagnoses\"] = len(self.diagnoses)\n metrics[\"distinct_diagnoses_scores\"] = len(Counter(list(map(lambda x: x.probability, self.diagnoses))))\n metrics[\"num_tests\"] = len(self.get_tests())\n metrics[\"num_distinct_traces\"] = len(self.get_distinct_traces())\n metrics[\"num_failed_tests\"] = len(self._get_tests_by_error(1))\n metrics[\"num_passed_tests\"] = len(self._get_tests_by_error(0))\n passed_comps = set(self._get_components_by_error(0))\n failed_comps = set(self.get_components_in_failed_tests())\n metrics[\"num_failed_comps\"] = len(failed_comps)\n metrics[\"only_failed_comps\"] = len(failed_comps - passed_comps)\n metrics[\"only_passed_comps\"] = len(passed_comps - failed_comps)\n metrics[\"num_bugs\"] = len(self.get_bugs())\n metrics[\"wasted\"] = self.calc_wasted_components()\n metrics[\"top_k\"] = self.calc_top_k()\n metrics[\"num_comps_in_diagnoses\"] = len(self._get_comps_in_diagnoses())\n metrics[\"bugs_cover_ratio\"] = self._get_bugs_cover_ratio()\n metrics[\"average_trace_size\"] = self._get_average_trace_size()\n metrics[\"average_component_activity\"] = self._get_average_component_activity()\n metrics[\"average_diagnosis_size\"] = self._get_average_diagnosis_size()\n metrics[\"bugs_scores_average\"], metrics[\"bugs_scores_std\"], metrics[\"bugs_scores_entropy\"] = self._get_bugs_scores()\n metrics[\"non_bugs_scores_average\"], metrics[\"non_bugs_scores_std\"], metrics[\"non_bugs_scores_entropy\"] = self._get_non_bugs_scores()\n metrics.update(self.cardinality())\n # metrics[\"ochiai\"] = self.calc_ochiai_values()\n return metrics","def __init__(self, count_metrics=None, time_metrics=None, gauge_metrics=None, max_call_count=-1,\n max_time_between_calls=-1):\n super(InMemoryMetrics, self).__init__()\n self._count_metrics = count_metrics if count_metrics is not None else defaultdict(int)\n self._time_metrics = time_metrics if time_metrics is not None \\\n else defaultdict(LatencyTracker)\n self._gauge_metrics = gauge_metrics if gauge_metrics is not None else defaultdict(float)\n self._max_call_count = max_call_count\n self._max_time_between_calls = max_time_between_calls\n\n utcnow_timestamp = arrow.utcnow().timestamp\n\n self._count_call_count = 0\n self._count_last_call_time = utcnow_timestamp\n self._time_call_count = 0\n self._time_last_call_time = utcnow_timestamp\n self._gauge_call_count = 0\n self._gauge_last_call_time = utcnow_timestamp\n self._count_rlock = RLock()\n self._time_rlock = RLock()\n self._gauge_rlock = RLock()\n self._ignore_metrics = False","def _default_metrics(self):\n loss_key = _summary_key(self.head_name, metric_key.MetricKey.LOSS)\n accuracy_key = _summary_key(self.head_name, metric_key.MetricKey.ACCURACY)\n auc_key = _summary_key(self.head_name, metric_key.MetricKey.AUC)\n\n metrics = {\n loss_key:\n _weighted_average_loss_metric_spec(\n self._loss_fn, prediction_key.PredictionKey.LOGITS,\n self._label_name, self._weight_column_name),\n # TODO(b/29366811): This currently results in both an \"accuracy\" and an\n # \"accuracy/threshold_0.500000_mean\" metric for binary classification.\n accuracy_key:\n self._metric_spec(metrics_lib.streaming_accuracy,\n prediction_key.PredictionKey.CLASSES),\n auc_key:\n self._metric_spec(_streaming_auc,\n prediction_key.PredictionKey.PROBABILITIES),\n }\n\n for class_id in self._metric_class_ids:\n\n # TODO(ptucker): Add per-class accuracy, precision, recall.\n\n prediction_mean_key = _summary_key(\n self.head_name, metric_key.MetricKey.CLASS_PREDICTION_MEAN % class_id)\n label_mean_key = _summary_key(self.head_name,\n metric_key.MetricKey.CLASS_LABEL_MEAN %\n class_id)\n probability_mean_key = _summary_key(\n self.head_name,\n metric_key.MetricKey.CLASS_PROBABILITY_MEAN % class_id)\n logits_mean_key = _summary_key(self.head_name,\n metric_key.MetricKey.CLASS_LOGITS_MEAN %\n class_id)\n auc_key = _summary_key(self.head_name,\n metric_key.MetricKey.CLASS_AUC % class_id)\n\n metrics[prediction_mean_key] = self._metric_spec(\n functools.partial(\n _predictions_streaming_mean, class_id=class_id),\n prediction_key.PredictionKey.CLASSES)\n metrics[label_mean_key] = self._metric_spec(\n functools.partial(\n _indicator_labels_streaming_mean, class_id=class_id),\n prediction_key.PredictionKey.CLASSES)\n metrics[probability_mean_key] = self._metric_spec(\n functools.partial(\n _predictions_streaming_mean, class_id=class_id),\n prediction_key.PredictionKey.PROBABILITIES)\n metrics[logits_mean_key] = self._metric_spec(\n functools.partial(\n _predictions_streaming_mean, class_id=class_id),\n prediction_key.PredictionKey.LOGITS)\n metrics[auc_key] = self._metric_spec(\n functools.partial(\n _streaming_auc, class_id=class_id),\n prediction_key.PredictionKey.LOGITS)\n\n return metrics","def __init__(self):\n self.stats = {}\n self.stats['hits'] = 0\n self.stats['operations'] = {}\n self.stats['operations']['GetCapabilities'] = {}\n self.stats['operations']['GetCapabilities']['hits'] = 0\n self.stats['operations']['POST'] = {}\n self.stats['operations']['POST']['hits'] = 0","def _getMetrics(self):\n metric = None\n if self.metrics is not None:\n metric = self.metrics(self._currentRecordIndex+1)\n elif self.metricValue is not None:\n metric = self.metricValue\n else:\n raise RuntimeError('No metrics or metric value specified for dummy model')\n\n return {self._optimizeKeyPattern:metric}","def metrics(self, metrics):\n\n self._metrics = metrics","def dictionary_of_metrics(items):\n\n 'Initialize dict'\n d = {}\n\n # Add 'mean' key to the dict with the value of the mean calculate by using\n # np.mean rounded to 2 decimal places\n d['mean'] = round(np.mean(items), 2)\n\n # Add 'median' key to the dict with the value of the median calculate by\n # using np.median rounded to 2 decimal places\n d['median'] = round(np.median(items), 2)\n\n # Add 'var' key to the dict with the value of the varience calculate by\n # using np.var rounded to 2 decimal places\n d['var'] = round(np.var(items, ddof=1), 2)\n\n # Add 'std' key to the dict with the value of the standard deviation\n # calculate by using np.std to 2 decimal places\n d['std'] = round(np.std(items, ddof=1), 2)\n\n # Add 'min' key to the dict with the value of the minimum calculate by\n # using np.min to 2 decimal places\n d['min'] = round(np.min(items), 2)\n\n # Add 'max' key to the dict with the value of the maximum calculate by\n # using np.max to 2 decimal places\n d['max'] = round(np.max(items), 2)\n\n # returns dictionary, d\n return d","def compute_metrics(self, results: list) -> dict:","def build_metrics_counter_data(count_metrics):\n return [{'name': name, 'delta': delta} for name, delta in iteritems(count_metrics)]","def get_all_metrics(self):\n metrics = {}\n for item in self.list_metrics():\n metric_name = item[2]\n metric = self.get_metric(\n item,\n existing_dict=metrics.get(metric_name, None))\n metrics[metric_name] = metric\n return metrics","def __init__(self, replication_num, metric_name_array, metric_collection_types = None, detailed_metric_assembly = False):\n self.replication_num = replication_num\n self.metrics = metric_name_array\n self.metric_collection_types = metric_collection_types # can be a string array elements of which can be one of ('STRING_LIST', 'COUNT_MAX', 'MEAN_STD','MIN','MAX', 'MIN_MAX') \n self.detailed_metric_assembly = detailed_metric_assembly\n self.replication_counter = 0\n self.metric_final_results = {}\n # initialize results array for each metric\n for metric in metric_name_array:\n self.metric_final_results[metric] = []","def add_metrics(_dict):\n for key, itr in _dict.items():\n if key not in self.metric_cols:\n self.metric_cols.append(key)","def __init__(self, metrics, recompute_real=True, **kwargs):\n super().__init__(recompute_real=recompute_real, **kwargs)\n self._metrics = metrics\n\n for metric in self._metrics:\n metric._recompute_real = recompute_real","def add_metrics(self, metric_dict: dict):\n self.metric_dict.update(metric_dict)","def _make_metric_dict(self, metrics):\n exon = None\n hgvs_c = None\n hgvs_p = None\n hgvs_three = None\n hgvs_basep = None\n hgvs_aap = None\n\n tx = metrics.split(':')[1]\n hgnc = metrics.split(':')[0]\n raw_exon = metrics.split(':')[2]\n if raw_exon != 'wholegene':\n exon = metrics.split(':')[2][4:]\n hgvs_c = metrics.split(':')[3]\n full_c = ':'.join([tx, hgvs_c])\n hgvs_parser = Hgvs(full_c)\n\n hgvs_basep = hgvs_parser.start\n try:\n hgvs_p = metrics.split(':')[4]\n full_p = ':'.join([tx, hgvs_p])\n hgvs_parser = Hgvs(full_p)\n hgvs_three = hgvs_parser.threep\n hgvs_aap = hgvs_parser.start[3:]\n except IndexError:\n hgvs_p = None\n full_p = None\n hgvs_three = None\n hgvs_aap = None\n\n return {\n 'AAP': hgvs_aap,\n 'BASEP': hgvs_basep,\n 'EXON': exon,\n 'HGNC': hgnc,\n 'HGVSC': hgvs_c,\n 'HGVSP1': hgvs_p,\n 'HGVSP3': hgvs_three,\n 'SOURCE': self.tfx_type,\n 'SPLICE': None,\n 'TXC': tx,\n 'VFX': self.veff,\n 'PVT': None\n }","def __init__(self):\n self.num_counts = {}","def get_metrics(self, reset: bool = False) -> Dict[str, float]:\n return {'accuracy' : self.accuracy.get_metric(reset)}","def dictionary_of_metrics(items):\n \n n = len(items)\n average = round(np.mean(items), 2)\n median = round(np.median(items), 2)\n variance = round((sum((items-np.mean(items))**2))/(n-1), 2)\n standard_dev = round(((sum((items-np.mean(items))**2))/(n-1))**(1/2), 2)\n minimum = round(min(items), 2)\n maximum = round(max(items), 2)\n \n return {'mean':average,'median':median,'var':variance,'std':standard_dev,'min':minimum,'max':maximum}\n pass","def _build_eval_metrics(self, results, features, labels):\n metrics = {}\n for metric in self.metrics:\n metrics[metric.IDENTIFIER] = getters.get_metric(\n metric.IDENTIFIER, results, labels, **metric.to_dict())\n return metrics","def compute_metrics(self):\n pass","def _init_metrics(self, mp_type, namespace, unreachable=False):\n kind = ResourceKind.METRIC if namespace else ResourceKind.GLOBALMETRIC\n metrics_info = (\n self._METRICS_PROVIDER_INFO.get(mp_type, {})\n .get(namespace, {})\n .get(\"metrics\", [])\n )\n\n # We will collect metrics from all metrics providers of the correct type\n # and in the correct namespace in the metrics list.\n metrics = []\n\n # all metrics providers of the correct type in the correct namespace\n if unreachable:\n mps_list = self.unreachable_metrics_providers\n else:\n mps_list = self.metrics_providers\n mps = mps_list.get(mp_type, {}).get(namespace, {})\n\n # Mapping from metrics provider resource definition to its metrics.\n # Initially empty.\n metrics_for_mp = dict.fromkeys([mp for mp in mps], [])\n for metric_info in metrics_info:\n # check if metric has the correct reachability. Skip if not.\n mp_name = metric_info[\"mp_name\"]\n reachability_matches = True if mp_name in [mp.name for mp in mps] else False\n if reachability_matches:\n # Create and collect the metric\n metric_name = metric_info[\"name\"]\n mp_metric_name = metric_info.get(\"mp_metric_name\", None)\n metric = BaseMetricDefinition(\n metric_name,\n kind,\n namespace,\n metric_info[\"allowed_values\"],\n metric_info[\"min\"],\n metric_info[\"max\"],\n mp_name,\n mp_metric_name=mp_metric_name,\n )\n metrics.append(metric)\n\n # remember its metrics provider for performance reasons\n mps_w_correct_name = [mp for mp in mps if mp.name == mp_name]\n if len(mps_w_correct_name) != 1:\n msg = (\n f\"Expected 1 metrics provider with the name {mp_name}. \"\n f\"Found {len(mps_w_correct_name)}.\"\n )\n raise ValueError(msg)\n mp = mps_w_correct_name[0]\n self._metric_to_metrics_provider[metric] = mp\n\n # save this metric to the metrics provider so it can be added later.\n metrics_for_mp[mp].append(metric)\n\n # The metrics providers need their metrics, so we add them here - also for\n # non-static metrics providers, since information about the metrics they\n # provide is needed in the tests.\n sanity_check_number_of_metrics = 0\n for mp, mp_metrics in metrics_for_mp.items():\n sanity_check_number_of_metrics += len(mp_metrics)\n self._add_metrics_to_metrics_provider(mp, mp_metrics)\n if len(metrics) != sanity_check_number_of_metrics:\n msg = (\n f\"Expected {len(metrics)} and {sanity_check_number_of_metrics} \"\n f\"to be equal.\"\n )\n raise ValueError(msg)\n\n return metrics","def get_metrics(self):\n return None","def initialize_metrics_json(metrics_filename):\n json_structure = ['dataset','region','metric','statistic']\n metrics = {\n 'SCHEMA': {\n 'name': 'CMEC',\n 'version': 'v1',\n 'package': 'ASoP'},\n 'DIMENSIONS':{\n 'json_structure': json_structure,\n 'dimensions': {\n 'dataset': {},\n 'region': {},\n 'metric': {\n 'Temporal intermittency': {},\n 'Spatial intermittency': {}},\n 'statistic': {\n 'p(upper|upper)': \"Probability of upper quartile precipitation followed by upper quartile precipitation\",\n 'p(lower|lower)': \"Probability of lower quartile precipitation followed by lower quartile precipitation\",\n 'p(upper|lower)': \"Probability of upper quartile precipitation followed by lower quartile precipitation\",\n 'p(lower|upper)': \"Probability of lower quartile precipitation followed by upper quartile precipitation\",\n 'combined': 'Metric of coherence (combined probabilities)'\n }}},\n 'RESULTS': {},\n 'REFERENCE': 'Klingaman et al. (2017, GMD, doi:10.5194/gmd-10-57-2017)'}\n with open(metrics_filename,'w') as fname:\n json.dump(metrics,fname,indent=2)\n\n return","def make_metric(name):\n return {\n \"type\": \"Metric\",\n \"name\": name,\n \"value\": \"\",\n \"units\": \"\",\n \"rating\": \"\",\n \"notes\": \"\",\n \"comment\": \"\",\n }","def dictionary_of_metrics(items):\n \n np_list = np.array(items) #create an array of list to use numpy functions on list\n metric_dict = {'mean': np.mean(np_list).round(2),\n 'median': np.median(np_list).round(2),\n 'var': np.var(np_list, ddof=1).round(2),\n 'std': np.std(np_list, ddof=1).round(2),\n 'min': np.min(np_list).round(2),\n 'max': np.max(np_list).round(2),} #create a dictionary that calculates the five metrics\n \n return metric_dict #return result as a dictionary","def prepare_multiple_perf_metrics(run_dict):\n multiple_perf_metrics = {}\n for run_label, run_name in run_dict.items():\n output_parser = OutputParser(run_name, use_most_recent=False)\n perf_metrics = performance_calculations.performance_metrics(output_parser)\n multiple_perf_metrics[run_label] = perf_metrics\n return multiple_perf_metrics","def _default_metrics(self):\n return {\n _summary_key(self.head_name, metric_key.MetricKey.LOSS):\n _weighted_average_loss_metric_spec(\n self._loss_fn, prediction_key.PredictionKey.SCORES,\n self._label_name, self._weight_column_name)\n }","def __init__(self, metricName, timeResolutions = (86400,)):\n self.metric = metricName\n self.timeResolutions = timeResolutions","def measure_dict():\n out = base_dict()\n out['mro']['current'] = ['Measure']\n out['name']['current'] = 'Measure'\n ao(out, 'nSamples', 'Integer', 1, readLevel=3)\n ao(out, 'id', 'String', 'Conversion source ID', readLevel=3)\n ao(out, 'uid', 'String', 'Unique ID', readLevel=5)\n ao(out, 'date', 'Date', '00:00:00 01/01/2000', name='Test date')\n ao(out, 'zerotime', 'Float', name='Acquisition starting time', readLevel=4)\n ao(out, 'elapsed', 'Float', name='Test duration', unit='second')\n ao(out, 'operator', 'String', name='Operator')\n return out","def _default_metrics(self):\n\n def _streaming_auc_with_class_id_label(predictions, labels, weights=None):\n indicator_labels = _class_id_labels_to_indicator(\n labels, num_classes=self.logits_dimension)\n return _streaming_auc(predictions, indicator_labels, weights)\n\n loss_key = _summary_key(self.head_name, metric_key.MetricKey.LOSS)\n accuracy_key = _summary_key(self.head_name, metric_key.MetricKey.ACCURACY)\n auc_key = _summary_key(self.head_name, metric_key.MetricKey.AUC)\n metrics = {\n loss_key:\n _weighted_average_loss_metric_spec(\n self._loss_fn, prediction_key.PredictionKey.LOGITS,\n self._label_name, self._weight_column_name),\n # TODO(b/29366811): This currently results in both an \"accuracy\" and an\n # \"accuracy/threshold_0.500000_mean\" metric for binary classification.\n accuracy_key:\n self._metric_spec(metrics_lib.streaming_accuracy,\n prediction_key.PredictionKey.CLASSES),\n auc_key:\n self._metric_spec(_streaming_auc_with_class_id_label,\n prediction_key.PredictionKey.PROBABILITIES)\n }\n\n def _class_predictions_streaming_mean(predictions,\n labels,\n weights=None,\n class_id=None):\n del labels\n return metrics_lib.streaming_mean(\n array_ops.where(\n math_ops.equal(\n math_ops.to_int32(class_id), math_ops.to_int32(predictions)),\n array_ops.ones_like(predictions),\n array_ops.zeros_like(predictions)),\n weights=weights)\n\n def _class_labels_streaming_mean(predictions,\n labels,\n weights=None,\n class_id=None):\n del predictions\n assert class_id is not None\n return metrics_lib.streaming_mean(\n array_ops.where(\n math_ops.equal(\n math_ops.to_int32(class_id), math_ops.to_int32(labels)),\n array_ops.ones_like(labels), array_ops.zeros_like(labels)),\n weights=weights)\n\n def _class_streaming_auc(predictions, labels, weights=None, class_id=None):\n assert class_id is not None\n indicator_labels = _class_id_labels_to_indicator(\n labels, num_classes=self.logits_dimension)\n return _streaming_auc(\n predictions, indicator_labels, weights=weights, class_id=class_id)\n\n for class_id in self._metric_class_ids:\n\n # TODO(ptucker): Add per-class accuracy, precision, recall.\n\n prediction_mean_key = _summary_key(\n self.head_name, metric_key.MetricKey.CLASS_PREDICTION_MEAN % class_id)\n label_mean_key = _summary_key(self.head_name,\n metric_key.MetricKey.CLASS_LABEL_MEAN %\n class_id)\n probability_mean_key = _summary_key(\n self.head_name,\n metric_key.MetricKey.CLASS_PROBABILITY_MEAN % class_id)\n logits_mean_key = _summary_key(self.head_name,\n metric_key.MetricKey.CLASS_LOGITS_MEAN %\n class_id)\n auc_key = _summary_key(self.head_name,\n metric_key.MetricKey.CLASS_AUC % class_id)\n\n metrics[prediction_mean_key] = self._metric_spec(\n functools.partial(\n _class_predictions_streaming_mean, class_id=class_id),\n prediction_key.PredictionKey.CLASSES)\n metrics[label_mean_key] = self._metric_spec(\n functools.partial(\n _class_labels_streaming_mean, class_id=class_id),\n prediction_key.PredictionKey.PROBABILITIES)\n metrics[probability_mean_key] = self._metric_spec(\n functools.partial(\n _predictions_streaming_mean, class_id=class_id),\n prediction_key.PredictionKey.PROBABILITIES)\n metrics[logits_mean_key] = self._metric_spec(\n functools.partial(\n _predictions_streaming_mean, class_id=class_id),\n prediction_key.PredictionKey.LOGITS)\n metrics[auc_key] = self._metric_spec(\n functools.partial(\n _class_streaming_auc, class_id=class_id),\n prediction_key.PredictionKey.LOGITS)\n\n return metrics","def static_metrics(self) -> dict[str, float | int]:\n return self.performance[\"meta\"]","def metrics(self):\r\n url = '{0}/{1}'.format(self.get_url(), 'metrics')\r\n\r\n return http.Request('GET', url), parsers.parse_json","def __init__(self, metrics_params):\n self.met_obs_start_dt = metrics_params['met_obs_start_dt']\n self.met_obs_end_dt = metrics_params['met_obs_end_dt']\n self.num_sats = metrics_params['num_sats']\n self.num_targ = metrics_params['num_targ']\n self.all_targ_IDs = metrics_params['all_targ_IDs']\n self.min_obs_dv_dlnk_req = metrics_params['min_obs_dv_dlnk_req']\n self.latency_calculation_params = metrics_params['latency_calculation_params']\n self.targ_id_ignore_list = metrics_params['targ_id_ignore_list']\n self.aoi_units = metrics_params['aoi_units']\n self.sats_emin_Wh = metrics_params['sats_emin_Wh']\n self.sats_emax_Wh = metrics_params['sats_emax_Wh']\n self.sats_dmin_Gb = metrics_params.get('sats_dmin_Gb',None)\n self.sats_dmax_Gb = metrics_params.get('sats_dmax_Gb',None)\n\n # the amount by which the minimum data volume is allowed to be lower than self.min_obs_dv_dlnk_req\n self.min_obs_dv_dlnk_req_slop = self.min_obs_dv_dlnk_req*0.01\n\n # if two downlink times are within this number of seconds, then they are counted as being at the same time for the purposes of AoI calculation\n self.dlnk_same_time_slop_s = metrics_params['timestep_s'] - 1","def get_metrics(cm, list_metrics):\n dic_metrics = {}\n total = np.sum(cm)\n\n if 'accuracy' in list_metrics:\n out = np.sum(np.diag(cm))\n dic_metrics['accuracy'] = out/total\n\n if 'pres_0' in list_metrics:\n num = cm[0, 0]\n den = cm[:, 0].sum()\n dic_metrics['pres_0'] = num/den if den > 0 else 0\n\n if 'pres_1' in list_metrics:\n num = cm[1, 1]\n den = cm[:, 1].sum()\n dic_metrics['pres_1'] = num/den if den > 0 else 0\n\n if 'recall_0' in list_metrics:\n num = cm[0, 0]\n den = cm[0, :].sum()\n dic_metrics['recall_0'] = num/den if den > 0 else 0\n\n if 'recall_1' in list_metrics:\n num = cm[1, 1]\n den = cm[1, :].sum()\n dic_metrics['recall_1'] = num/den if den > 0 else 0\n\n return dic_metrics","def __init__ (self):\n self.lengths = {}\n self.lower_counts = {}\n self.upper_counts = {}\n self.digit_counts = {}\n self.symbol_counts = {}\n self.class_counts = {}\n self.word_counts = {}","def _get_metrics(one_hot: bool) -> Mapping[Text, Any]:\n if one_hot:\n return {\n # (name, metric_fn)\n 'acc': tf.keras.metrics.CategoricalAccuracy(),\n 'accuracy': tf.keras.metrics.CategoricalAccuracy(),\n 'top_1': tf.keras.metrics.CategoricalAccuracy(),\n 'top_5': tf.keras.metrics.TopKCategoricalAccuracy(\n k=5, name='top_5_accuracy'),\n }\n else:\n return {\n # (name, metric_fn)\n 'acc': tf.keras.metrics.SparseCategoricalAccuracy(),\n 'accuracy': tf.keras.metrics.SparseCategoricalAccuracy(),\n 'top_1': tf.keras.metrics.SparseCategoricalAccuracy(),\n 'top_5': tf.keras.metrics.SparseTopKCategoricalAccuracy(\n k=5, name='top_5_accuracy'),\n }","def __init__(self):\n self.counts = {}","def __init__(self, collectd):\n self.collectd = collectd\n self.conf = self.default_config()\n self.types = {}\n\n collectd.info('Initialized MetricsConfig with default config %s' % self.conf)","def __init__(self, group_key=None, sort_key=None):\n super(Metric, self).__init__()\n self.group_key = group_key\n self.sort_key = sort_key","def create_metric(self) -> EvalMetric:\n pass","def _section_metrics(course_key, access):\r\n section_data = {\r\n 'section_key': 'metrics',\r\n 'section_display_name': ('Metrics'),\r\n 'access': access,\r\n 'course_id': course_key.to_deprecated_string(),\r\n 'sub_section_display_name': get_section_display_name(course_key),\r\n 'section_has_problem': get_array_section_has_problem(course_key),\r\n 'get_students_opened_subsection_url': reverse('get_students_opened_subsection'),\r\n 'get_students_problem_grades_url': reverse('get_students_problem_grades'),\r\n 'post_metrics_data_csv_url': reverse('post_metrics_data_csv'),\r\n }\r\n return section_data","def report_metrics(metrics, label_matches=None):\n metrics_map = {}\n\n for metric in metrics.values():\n samples = []\n for sample in metric.samples:\n if not label_matches or label_matches.items() <= sample.labels.items():\n sample_map = {'labels': sample.labels, 'value': sample.value}\n samples.append(sample_map)\n metrics_map[metric.name] = {'samples': samples}\n\n return metrics_map","def metric_tests(self, metric_tests: Dict[str, FAIRResultEvaluationCriterium]):\n\n self._metric_tests = metric_tests","def __init__(self, instresult, number):\n self.instresult = instresult\n self.number = number\n self.measures = {}","def _default_metrics(self):\n metrics = {\n _summary_key(self.head_name, metric_key.MetricKey.LOSS):\n _weighted_average_loss_metric_spec(\n self._loss_fn, prediction_key.PredictionKey.LOGITS,\n self._label_name, self._weight_column_name)\n }\n\n # TODO(b/29366811): This currently results in both an \"accuracy\" and an\n # \"accuracy/threshold_0.500000_mean\" metric for binary classification.\n metrics[_summary_key(self.head_name, metric_key.MetricKey.ACCURACY)] = (\n metric_spec.MetricSpec(metrics_lib.streaming_accuracy,\n prediction_key.PredictionKey.CLASSES,\n self._label_name, self._weight_column_name))\n\n def _add_binary_metric(key, metric_fn):\n metrics[_summary_key(self.head_name, key)] = metric_spec.MetricSpec(\n metric_fn, prediction_key.PredictionKey.LOGISTIC, self._label_name,\n self._weight_column_name)\n\n _add_binary_metric(metric_key.MetricKey.PREDICTION_MEAN,\n _predictions_streaming_mean)\n _add_binary_metric(metric_key.MetricKey.LABEL_MEAN,\n _indicator_labels_streaming_mean)\n\n # Also include the streaming mean of the label as an accuracy baseline, as\n # a reminder to users.\n _add_binary_metric(metric_key.MetricKey.ACCURACY_BASELINE,\n _indicator_labels_streaming_mean)\n\n _add_binary_metric(metric_key.MetricKey.AUC, _streaming_auc)\n\n for threshold in self._thresholds:\n _add_binary_metric(metric_key.MetricKey.ACCURACY_MEAN % threshold,\n _accuracy_at_threshold(threshold))\n # Precision for positive examples.\n _add_binary_metric(\n metric_key.MetricKey.PRECISION_MEAN % threshold,\n _streaming_at_threshold(metrics_lib.streaming_precision_at_thresholds,\n threshold),)\n # Recall for positive examples.\n _add_binary_metric(metric_key.MetricKey.RECALL_MEAN % threshold,\n _streaming_at_threshold(\n metrics_lib.streaming_recall_at_thresholds,\n threshold))\n return metrics","def create_system_metrics(system):\n pass","def __init__(self):\r\n # sample ID -> (ref individual count,\r\n # {size -> (estimate, std err, ci_low, ci_high)})\r\n self._data = {}","def __init__(self):\n super().__init__()\n self.metric = 'ACURCY'","def get_km_test_metrics(metrics_obj):\n metrics_dict = dict()\n metrics_dict['betweenss'] = metrics_obj.betweenss()\n metrics_dict['tot_withinss'] = metrics_obj.tot_withinss()\n metrics_dict['totss'] = metrics_obj.totss()\n metrics_dict['centroid_stats'] = twodim_table_2_frame(metrics_obj._metric_json['centroid_stats'])[1]\n\n return metrics_dict","def initialize_case_metrics(self) -> None:\n for case in self.cases:\n graph_distance, time_distance = extract_case_distances(self.process_model_graph, case)\n case.graph_distance = graph_distance\n case.time_distance = time_distance","def get_metrics(self, x, y):\n metrics = dict()\n y_predicted = self.predict(x)\n metrics['Accuracy'] = accuracy_score(y, y_predicted)\n metrics['F1'] = f1_score(y, y_predicted)\n metrics['Precision'] = precision_score(y, y_predicted)\n\n return metrics","def build_metrics_gauge_data(gauge_metrics):\n return [{'name': name, 'value': value} for name, value in iteritems(gauge_metrics)]","def list_metrics(self):\n pass","def __init__(self, metrics=[\n Hamming(),\n Levenshtein(),\n Osa(),\n DamerauLevenshtein(),\n Jaccard(),\n Dice(),\n Jaro(),\n JaroWinkler() ]):\n self.metrics = metrics","def create_stats(measures: \"List of function timings.\",\n col: \"Current Column.\", row: \"Current Row\",\n scenario: \"Current Scenario.\") -> dict:\n return {\"scenario\": scenario,\n \"no_column\": col,\n \"data_length\": row,\n \"min\": np.min(measures),\n \"max\": np.max(measures),\n \"avg\": np.mean(measures),\n \"q50\": np.median(measures)}","def add_stats(self):\n units = self.get_unit_map()\n for metric in self.raw_metrics:\n unit, metric_type = units.get(metric, (DEFAULT_UNIT, DEFAULT_TYPE))\n if metric_type == \"counter\":\n # Unit/Second\n unit = \"/\".join((unit, \"Second\"))\n self.add_derive_value(metric, unit, self.raw_metrics[metric], rate=True)\n else:\n self.add_gauge_value(metric, unit, self.raw_metrics[metric])","def metrics(self):\n \n if self.mse.shape[0]>1:\n raise ValueError('Metrics can only handle single observations.')\n \n if self.N==1:\n pred = float('nan')\n err = float('nan')\n y_true = float('nan')\n else:\n pred = int(self._predictions[-1])\n err = self._mse[-1]\n y_true = int(self.label[0])\n \n is_outlier = {\"type\":\"GAUGE\",\"key\":\"is_outlier\",\"value\":pred}\n mse = {\"type\":\"GAUGE\",\"key\":\"mse\",\"value\":err}\n obs = {\"type\":\"GAUGE\",\"key\":\"observation\",\"value\":self.N - 1}\n threshold = {\"type\":\"GAUGE\",\"key\":\"threshold\",\"value\":self.threshold}\n \n label = {\"type\":\"GAUGE\",\"key\":\"label\",\"value\":y_true}\n \n accuracy_tot = {\"type\":\"GAUGE\",\"key\":\"accuracy_tot\",\"value\":self.metric[4]}\n precision_tot = {\"type\":\"GAUGE\",\"key\":\"precision_tot\",\"value\":self.metric[5]}\n recall_tot = {\"type\":\"GAUGE\",\"key\":\"recall_tot\",\"value\":self.metric[6]}\n f1_score_tot = {\"type\":\"GAUGE\",\"key\":\"f1_tot\",\"value\":self.metric[7]}\n f2_score_tot = {\"type\":\"GAUGE\",\"key\":\"f2_tot\",\"value\":self.metric[8]}\n \n accuracy_roll = {\"type\":\"GAUGE\",\"key\":\"accuracy_roll\",\"value\":self.metric[9]}\n precision_roll = {\"type\":\"GAUGE\",\"key\":\"precision_roll\",\"value\":self.metric[10]}\n recall_roll = {\"type\":\"GAUGE\",\"key\":\"recall_roll\",\"value\":self.metric[11]}\n f1_score_roll = {\"type\":\"GAUGE\",\"key\":\"f1_roll\",\"value\":self.metric[12]}\n f2_score_roll = {\"type\":\"GAUGE\",\"key\":\"f2_roll\",\"value\":self.metric[13]}\n \n true_negative = {\"type\":\"GAUGE\",\"key\":\"true_negative\",\"value\":self.metric[0]}\n false_positive = {\"type\":\"GAUGE\",\"key\":\"false_positive\",\"value\":self.metric[1]}\n false_negative = {\"type\":\"GAUGE\",\"key\":\"false_negative\",\"value\":self.metric[2]}\n true_positive = {\"type\":\"GAUGE\",\"key\":\"true_positive\",\"value\":self.metric[3]}\n \n nb_outliers_roll = {\"type\":\"GAUGE\",\"key\":\"nb_outliers_roll\",\"value\":self.metric[14]}\n nb_labels_roll = {\"type\":\"GAUGE\",\"key\":\"nb_labels_roll\",\"value\":self.metric[15]}\n nb_outliers_tot = {\"type\":\"GAUGE\",\"key\":\"nb_outliers_tot\",\"value\":self.metric[16]}\n nb_labels_tot = {\"type\":\"GAUGE\",\"key\":\"nb_labels_tot\",\"value\":self.metric[17]}\n \n return [is_outlier,mse,obs,threshold,label,\n accuracy_tot,precision_tot,recall_tot,f1_score_tot,f2_score_tot,\n accuracy_roll,precision_roll,recall_roll,f1_score_roll,f2_score_roll,\n true_negative,false_positive,false_negative,true_positive,\n nb_outliers_roll,nb_labels_roll,nb_outliers_tot,nb_labels_tot]","def compute_metrics(self, x, extra=None):\n if self.__metrics is None and extra is None:\n return None\n\n ret = {}\n if self.__metrics is not None:\n for m in self.__metrics:\n ret[m.name] = self._mdmetric(x, m)\n\n if extra is not None and extra.name not in ret:\n ret[extra.name] = self._mdmetric(x, extra)\n\n return ret","def metrics(self):\n return self.__metrics","def __init__(__self__, *,\n metrics: Optional[pulumi.Input['ManagedClusterAzureMonitorProfileMetricsArgs']] = None):\n if metrics is not None:\n pulumi.set(__self__, \"metrics\", metrics)","def __init__(self):\n self.cnt = {}","def __init__(self):\n super().__init__()\n self.metric = 'FALLOUT'","def metrics(self):\r\n if not hasattr(self, '_observable_metrics'):\r\n self._observable_metrics = Metrics()\r\n return self._observable_metrics","def __init__(self, *args, **kwargs):\n self.metric_type = kwargs['acc_metric'] \n\n if self.metric_type == 'Accuracy':\n self.metric_object = Accuracy(*args, **kwargs) \n elif self.metric_type == 'AveragePrecision':\n self.metric_object = AveragePrecision(*args, **kwargs)\n elif self.metric_type == 'mAP':\n self.metric_object = MAP(*args, **kwargs)\n elif self.metric_type == 'SSD_AP':\n self.metric_object = SSD_AP(*args, **kwargs)\n else:\n self.metric_type = None","def get_config_metrics():\n\n metrics = {'disk_usage': 'YES',\n 'cpu_percent': 'YES',\n 'memory_info': 'YES',\n 'cpu_stats': 'YES'}\n\n return metrics","def __init__(self):\n super().__init__()\n self.metric = 'FMEASR'","def metrics(self):\n self.metrics = []\n \n self.clients()\n\n if len(self.metrics) > 0:\n return self.metrics\n else:\n return []","def __init__(self, *args, **opts):\n \n madloop_statistics = {\n 'unknown_stability' : 0,\n 'stable_points' : 0,\n 'unstable_points' : 0,\n 'exceptional_points' : 0,\n 'DP_usage' : 0,\n 'QP_usage' : 0,\n 'DP_init_usage' : 0,\n 'QP_init_usage' : 0,\n 'CutTools_DP_usage' : 0,\n 'CutTools_QP_usage' : 0, \n 'PJFry_usage' : 0,\n 'Golem_usage' : 0,\n 'IREGI_usage' : 0,\n 'Samurai_usage' : 0,\n 'Ninja_usage' : 0,\n 'Ninja_QP_usage' : 0,\n 'COLLIER_usage' : 0,\n 'max_precision' : 1.0e99,\n 'min_precision' : 0.0,\n 'averaged_timing' : 0.0,\n 'n_madloop_calls' : 0,\n 'cumulative_timing' : 0.0,\n 'skipped_subchannel' : 0 # number of times that a computation have been \n # discarded due to abnormal weight.\n }\n \n for key, value in madloop_statistics.items():\n self[key] = value\n\n super(dict,self).__init__(*args, **opts)"],"string":"[\n \"def initialize_metrics():\\n metrics = {\\n 'cd_losses': [],\\n 'cd_corrects': [],\\n 'cd_precisions': [],\\n 'cd_recalls': [],\\n 'cd_f1scores': [],\\n }\\n\\n return metrics\",\n \"def init_metrics():\\n metrics = defaultdict(list)\\n metrics['best_acc'] = 0.0\\n metrics['best_loss'] = float('inf')\\n metrics['best_epoch'] = 0\\n return metrics\",\n \"def init_metric_dict(self, metrics=None, init_value=None):\\n if metrics is None:\\n metrics = [\\\"\\\"]\\n\\n if init_value is None:\\n init_value = 0.0\\n\\n self.metric_dict = {metric: init_value for metric in metrics}\",\n \"def init_metrics(self):\\n\\n self.metrics = {}\\n\\n self.metrics['train_loss'] = np.zeros(0)\\n self.metrics['test_loss'] = np.zeros(0)\\n\\n # self.orth_clf = LinearDecoder(self, self.q_, MeanClassifier)\\n # self.metrics['train_orthogonality'] = np.zeros(0)\\n # self.metrics['test_orthogonality'] = np.zeros(0)\\n\\n self.metrics['train_parallelism'] = np.zeros((0,self.q_)) \\n self.metrics['test_parallelism'] = np.zeros((0,self.q_))\",\n \"def __init__(self, metrics_to_record):\\n self.tape = {}\\n\\n for metric_name in metrics_to_record:\\n self.tape[metric_name] = []\",\n \"def __init__(self, metrics, gt, pred):\\n self.dict_metrics = self.compute_metrics(metrics, gt, pred)\",\n \"def initialize(self, runInfo, inputs, initDict) :\\n super().initialize(runInfo, inputs, initDict)\\n for metricIn in self.assemblerDict['Metric']:\\n self.metricsDict[metricIn[2]] = metricIn[3]\",\n \"def init_meters(*metrics):\\n return {m: util.AverageMeter() for m in metrics}\",\n \"def __init__(self, metrics_map, include_val_metrics=False):\\n self.metrics_map = metrics_map\\n self.include_val_metrics = include_val_metrics\\n self.metrics_history = self.__createMetricsHistory()\",\n \"def init_metrics(losses):\\n metrics = {'train': {}, 'valid': {}}\\n for mode, d in metrics.items():\\n metrics[mode] = dict([(k, 0) for k in losses])\\n\\n return metrics\",\n \"def __init_metrics(self):\\n\\n batch = {}\\n # split data into batches of size batch_size or less\\n for metric_name, metric_pattern in self.metrics.items():\\n # get the batch list for that metric\\n batch_list = []\\n for s in range(1, self.schema + 1):\\n for t in range(1, self.table + 1):\\n k = '/metrics/type=IndexTable/keyspace={}/scope={}/name={}/mean'.format(s, t, metric_name)\\n # from Python 3.6 onwards, the standard dict type maintains insertion order by default\\n batch[k] = 0\\n # if the batch has batch_size items or at the end of iteration,\\n # append the batch to list of that metric and create a new empty batch\\n if len(batch) == self.batch_size or (s == self.schema and t == self.table):\\n batch_list.append(batch)\\n batch = {}\\n\\n # parse metric patterns\\n l = metric_pattern.split()\\n if l[0] == '(>':\\n self.metrics[metric_name] = IncMetricStruct(float(int(l[1])), float(l[2][1:]), float(l[4][:-2]),\\n batch_list)\\n else:\\n self.metrics[metric_name] = RandMetricStruct(float(l[0][1:]), float(l[-1][:-1]), batch_list)\",\n \"def get_metrics(self) -> dict:\\n return self.metric_dict\",\n \"def __init__(self, metrics, test=True, valid_keys=None):\\n self.i = {'train': 0}\\n self.log_auc, self.log_acc = False, False\\n self.log_p_r = False\\n self.metrics = {'train': {}}\\n self.key = 'train'\\n if test:\\n self.metrics['test'] = {}\\n self.i['test'] = 0\\n self.valid_keys = valid_keys\\n if valid_keys is not None:\\n for valid_key in valid_keys:\\n self.metrics[valid_key] = {}\\n self.i[valid_key] = 0\\n if 'acc' in metrics:\\n self.log_acc = True\\n for key in self.metrics:\\n self.metrics[key].update({'acc': []})\\n if 'AUC' in metrics:\\n self.log_auc = True\\n for key in self.metrics:\\n self.metrics[key].update({'auc': []})\\n if 'P-R' in metrics:\\n self.log_p_r = True\\n for key in self.metrics:\\n self.metrics[key].update({'p-r': []})\\n for key in self.metrics:\\n self.metrics[key].update({'loss': [0]})\",\n \"def metrics(self):\\n return {**self.prepend_name_dict(self._prefixes[0], self._train_metrics),\\n **self.prepend_name_dict(self._prefixes[1], self.validator.metrics)}\",\n \"def __init__(self) -> None:\\n self.metrics = {}\\n self.current = None\\n self.run = None\",\n \"def set_metrics(self):\",\n \"def set_metrics(metric_dict, cd_loss, cd_corrects, cd_report):\\n metric_dict['cd_losses'].append(cd_loss.item())\\n metric_dict['cd_corrects'].append(cd_corrects.item())\\n metric_dict['cd_precisions'].append(cd_report[0])\\n metric_dict['cd_recalls'].append(cd_report[1])\\n metric_dict['cd_f1scores'].append(cd_report[2])\\n\\n return metric_dict\",\n \"def get_metrics(self) -> Dict[str, base.Number]:\\n return self._metrics\",\n \"def __init__(self, included_metrics: List[str]):\\n self.included_metrics = included_metrics\\n self.metrics = self._initialize_metrics()\",\n \"def metrics(self) -> dict:\\n if not self.exp_metadata.metrics:\\n self.exp_metadata.metrics = {}\\n return self.exp_metadata.metrics\",\n \"def __init__(self, metrics_cache):\\n self._metrics_cache = metrics_cache\",\n \"def metrics(self):\\n\\n data = requests.get(\\n f\\\"http://{self.prometheus_host}:{self.prometheus_port}/metrics\\\"\\n ).content.decode()\\n lines = [line for line in data.split(\\\"\\\\n\\\") if not line.startswith(\\\"#\\\")]\\n metrics = {}\\n for line in lines:\\n if not line:\\n continue\\n\\n name, value = line.split(\\\" \\\")\\n\\n try:\\n value = int(value) # type: ignore\\n except ValueError:\\n value = float(value) # type: ignore\\n\\n if \\\"{\\\" in name and \\\"}\\\" in name:\\n base = name[: name.index(\\\"{\\\")]\\n tags = name[name.index(\\\"{\\\") + 1 : -1]\\n tags = [tag.split(\\\"=\\\") for tag in tags.split(\\\",\\\")]\\n tags = [(key, val.replace('\\\"', \\\"\\\")) for key, val in tags]\\n\\n name = base + \\\"#\\\" + \\\",\\\".join(f\\\"{k}:{v}\\\" for k, v in sorted(tags))\\n\\n metrics[name] = value\\n\\n return metrics\",\n \"def __init__(\\n self, config: Config, metrics: Union[Metric, Iterable[Metric]]\\n ) -> None:\\n self._metrics: Dict[Metric, Optional[float]] = {}\\n\\n if isinstance(metrics, Metric):\\n self._metrics[metrics] = None\\n else:\\n for key in metrics:\\n self._metrics[key] = None\\n self._metric_funcs = {\\n Metric.ACCURACY: accuracy,\\n Metric.RECALL: recall,\\n Metric.PRECISION: precision,\\n Metric.F1: f_1,\\n Metric.CONSISTENCY: consistency,\\n }\\n self._config = config\\n self._ids: List[str] = []\\n self._preds: List[str] = []\\n self._targets: List[str] = []\",\n \"def metrics(self):\\n raise NotImplementedError(\\\"metrics\\\")\",\n \"def metrics_group():\",\n \"def configure_metrics(self):\\n allowed = list(METRIC_LOOKUP.keys()) + [None]\\n metrics = nn.ModuleDict()\\n for k, m in self.branch_metrics.items():\\n for metric_name in m:\\n if metric_name not in allowed:\\n raise ValueError(\\n f\\\"Illegal metric given. Got: {metric_name}. Allowed: {allowed}.\\\"\\n )\\n\\n if metric_name is not None:\\n metric = METRIC_LOOKUP[metric_name]()\\n else:\\n metric = None\\n\\n metrics[f\\\"{k}_{metric_name}\\\"] = metric\\n\\n return metrics\",\n \"def test_metrics_empty(self):\\n skill_map = SkillMap.load(self.course)\\n sm_metrics = SkillMapMetrics(skill_map)\\n self.assertEqual(sm_metrics.simple_cycles(), [])\\n self.assertEqual(sm_metrics.singletons(), [])\\n self.assertEqual(sm_metrics.long_chains(), [])\\n expected = {'cycles': [], 'singletons': [], 'long_chains': []}\\n self.assertEqual(sm_metrics.diagnose(), expected)\",\n \"def build_metrics_dict(node):\\n\\n # Initialize tensors\\n n = 0\\n n = _recv(n,node)\\n keys = [[0 for j in range(8)] for i in range(n)] # max_seq_len for metric name is 8\\n values = [0.0 for i in range(n)]\\n higher_is_better = [0 for i in range(n)]\\n\\n # Read data\\n keys = _recv(keys,node)\\n values = _recv(values,node)\\n higher_is_better = _recv(higher_is_better,node)\\n\\n # Reorganize output + decode dict keys\\n orig_keys = [encode_string(key, string_to_int=False) for key in keys]\\n values_dict = [{'value': float(v), 'higher_is_better': bool(higher_is_better[i])} for i, v in enumerate(values)]\\n metrics = dict(zip(orig_keys,values_dict))\\n num_instances = int(metrics.pop('num')['value'])\\n\\n result = None, metrics, num_instances\\n \\n return result\",\n \"def test_create_metrics_dict(self):\\n # binary tasks have 1 class at class definition.\\n num_classes = 1\\n metrics_dict = create_metrics_dict(num_classes)\\n assert 'iou_1' in metrics_dict.keys()\\n assert 'iou_2' not in metrics_dict.keys()\\n\\n num_classes = 3\\n metrics_dict = create_metrics_dict(num_classes)\\n assert 'iou_1' in metrics_dict.keys()\\n assert 'iou_2' in metrics_dict.keys()\\n assert 'iou_3' not in metrics_dict.keys()\\n del metrics_dict\",\n \"def _make_metric_dict(self, metrics):\\n exon = None\\n hgvs_c = None\\n\\n slen = len(metrics.split(':'))\\n if slen == 1:\\n if \\\"(dist=\\\" not in metrics:\\n tx = metrics\\n else:\\n tx = None\\n elif slen == 2:\\n tx = metrics.split('(')[0]\\n hgvs_c = metrics.split(':')[1].rstrip(')')\\n elif slen == 3:\\n tx = metrics.split('(')[0]\\n exon = metrics.split(':')[1][4:]\\n hgvs_c = metrics.split(':')[2].rstrip(')')\\n else:\\n raise UserWarning(\\\"There are an incorrect number of fields listed in: \\\" + str(self.info))\\n\\n if hgvs_c:\\n full_c = ':'.join([tx, hgvs_c])\\n hgvs_parser = Hgvs(full_c)\\n hgvs_basep = hgvs_parser.start\\n else:\\n hgvs_basep = None\\n\\n return {\\n 'AAP': None,\\n 'BASEP': hgvs_basep,\\n 'EXON': exon,\\n 'HGNC': None,\\n 'HGVSC': hgvs_c,\\n 'HGVSP1': None,\\n 'HGVSP3': None,\\n 'SOURCE': self.tfx_type,\\n 'SPLICE': self.splicing,\\n 'TXC': tx,\\n 'PVT': self.vtype,\\n 'VFX': None\\n }\",\n \"def metrics(self):\\r\\n return Metrics(self)\",\n \"def compute_metrics(self):\\n self.finalize_output_dict()\\n self.metric_dict = {\\n key: value(self.output_dict[\\\"labels\\\"], self.output_dict[\\\"pred_probs\\\"])\\n for key, value in self.metric_fns.items()\\n }\",\n \"def _calculate_metrics(self):\\n metrics = {}\\n precision, recall = self.calc_precision_recall()\\n metrics[\\\"precision\\\"] = precision\\n metrics[\\\"recall\\\"] = recall\\n metrics[\\\"entropy\\\"] = self.calc_entropy()\\n metrics[\\\"component_entropy\\\"] = self.calc_component_entropy()\\n metrics[\\\"num_comps\\\"] = len(self.get_components())\\n metrics[\\\"num_diagnoses\\\"] = len(self.diagnoses)\\n metrics[\\\"distinct_diagnoses_scores\\\"] = len(Counter(list(map(lambda x: x.probability, self.diagnoses))))\\n metrics[\\\"num_tests\\\"] = len(self.get_tests())\\n metrics[\\\"num_distinct_traces\\\"] = len(self.get_distinct_traces())\\n metrics[\\\"num_failed_tests\\\"] = len(self._get_tests_by_error(1))\\n metrics[\\\"num_passed_tests\\\"] = len(self._get_tests_by_error(0))\\n passed_comps = set(self._get_components_by_error(0))\\n failed_comps = set(self.get_components_in_failed_tests())\\n metrics[\\\"num_failed_comps\\\"] = len(failed_comps)\\n metrics[\\\"only_failed_comps\\\"] = len(failed_comps - passed_comps)\\n metrics[\\\"only_passed_comps\\\"] = len(passed_comps - failed_comps)\\n metrics[\\\"num_bugs\\\"] = len(self.get_bugs())\\n metrics[\\\"wasted\\\"] = self.calc_wasted_components()\\n metrics[\\\"top_k\\\"] = self.calc_top_k()\\n metrics[\\\"num_comps_in_diagnoses\\\"] = len(self._get_comps_in_diagnoses())\\n metrics[\\\"bugs_cover_ratio\\\"] = self._get_bugs_cover_ratio()\\n metrics[\\\"average_trace_size\\\"] = self._get_average_trace_size()\\n metrics[\\\"average_component_activity\\\"] = self._get_average_component_activity()\\n metrics[\\\"average_diagnosis_size\\\"] = self._get_average_diagnosis_size()\\n metrics[\\\"bugs_scores_average\\\"], metrics[\\\"bugs_scores_std\\\"], metrics[\\\"bugs_scores_entropy\\\"] = self._get_bugs_scores()\\n metrics[\\\"non_bugs_scores_average\\\"], metrics[\\\"non_bugs_scores_std\\\"], metrics[\\\"non_bugs_scores_entropy\\\"] = self._get_non_bugs_scores()\\n metrics.update(self.cardinality())\\n # metrics[\\\"ochiai\\\"] = self.calc_ochiai_values()\\n return metrics\",\n \"def __init__(self, count_metrics=None, time_metrics=None, gauge_metrics=None, max_call_count=-1,\\n max_time_between_calls=-1):\\n super(InMemoryMetrics, self).__init__()\\n self._count_metrics = count_metrics if count_metrics is not None else defaultdict(int)\\n self._time_metrics = time_metrics if time_metrics is not None \\\\\\n else defaultdict(LatencyTracker)\\n self._gauge_metrics = gauge_metrics if gauge_metrics is not None else defaultdict(float)\\n self._max_call_count = max_call_count\\n self._max_time_between_calls = max_time_between_calls\\n\\n utcnow_timestamp = arrow.utcnow().timestamp\\n\\n self._count_call_count = 0\\n self._count_last_call_time = utcnow_timestamp\\n self._time_call_count = 0\\n self._time_last_call_time = utcnow_timestamp\\n self._gauge_call_count = 0\\n self._gauge_last_call_time = utcnow_timestamp\\n self._count_rlock = RLock()\\n self._time_rlock = RLock()\\n self._gauge_rlock = RLock()\\n self._ignore_metrics = False\",\n \"def _default_metrics(self):\\n loss_key = _summary_key(self.head_name, metric_key.MetricKey.LOSS)\\n accuracy_key = _summary_key(self.head_name, metric_key.MetricKey.ACCURACY)\\n auc_key = _summary_key(self.head_name, metric_key.MetricKey.AUC)\\n\\n metrics = {\\n loss_key:\\n _weighted_average_loss_metric_spec(\\n self._loss_fn, prediction_key.PredictionKey.LOGITS,\\n self._label_name, self._weight_column_name),\\n # TODO(b/29366811): This currently results in both an \\\"accuracy\\\" and an\\n # \\\"accuracy/threshold_0.500000_mean\\\" metric for binary classification.\\n accuracy_key:\\n self._metric_spec(metrics_lib.streaming_accuracy,\\n prediction_key.PredictionKey.CLASSES),\\n auc_key:\\n self._metric_spec(_streaming_auc,\\n prediction_key.PredictionKey.PROBABILITIES),\\n }\\n\\n for class_id in self._metric_class_ids:\\n\\n # TODO(ptucker): Add per-class accuracy, precision, recall.\\n\\n prediction_mean_key = _summary_key(\\n self.head_name, metric_key.MetricKey.CLASS_PREDICTION_MEAN % class_id)\\n label_mean_key = _summary_key(self.head_name,\\n metric_key.MetricKey.CLASS_LABEL_MEAN %\\n class_id)\\n probability_mean_key = _summary_key(\\n self.head_name,\\n metric_key.MetricKey.CLASS_PROBABILITY_MEAN % class_id)\\n logits_mean_key = _summary_key(self.head_name,\\n metric_key.MetricKey.CLASS_LOGITS_MEAN %\\n class_id)\\n auc_key = _summary_key(self.head_name,\\n metric_key.MetricKey.CLASS_AUC % class_id)\\n\\n metrics[prediction_mean_key] = self._metric_spec(\\n functools.partial(\\n _predictions_streaming_mean, class_id=class_id),\\n prediction_key.PredictionKey.CLASSES)\\n metrics[label_mean_key] = self._metric_spec(\\n functools.partial(\\n _indicator_labels_streaming_mean, class_id=class_id),\\n prediction_key.PredictionKey.CLASSES)\\n metrics[probability_mean_key] = self._metric_spec(\\n functools.partial(\\n _predictions_streaming_mean, class_id=class_id),\\n prediction_key.PredictionKey.PROBABILITIES)\\n metrics[logits_mean_key] = self._metric_spec(\\n functools.partial(\\n _predictions_streaming_mean, class_id=class_id),\\n prediction_key.PredictionKey.LOGITS)\\n metrics[auc_key] = self._metric_spec(\\n functools.partial(\\n _streaming_auc, class_id=class_id),\\n prediction_key.PredictionKey.LOGITS)\\n\\n return metrics\",\n \"def __init__(self):\\n self.stats = {}\\n self.stats['hits'] = 0\\n self.stats['operations'] = {}\\n self.stats['operations']['GetCapabilities'] = {}\\n self.stats['operations']['GetCapabilities']['hits'] = 0\\n self.stats['operations']['POST'] = {}\\n self.stats['operations']['POST']['hits'] = 0\",\n \"def _getMetrics(self):\\n metric = None\\n if self.metrics is not None:\\n metric = self.metrics(self._currentRecordIndex+1)\\n elif self.metricValue is not None:\\n metric = self.metricValue\\n else:\\n raise RuntimeError('No metrics or metric value specified for dummy model')\\n\\n return {self._optimizeKeyPattern:metric}\",\n \"def metrics(self, metrics):\\n\\n self._metrics = metrics\",\n \"def dictionary_of_metrics(items):\\n\\n 'Initialize dict'\\n d = {}\\n\\n # Add 'mean' key to the dict with the value of the mean calculate by using\\n # np.mean rounded to 2 decimal places\\n d['mean'] = round(np.mean(items), 2)\\n\\n # Add 'median' key to the dict with the value of the median calculate by\\n # using np.median rounded to 2 decimal places\\n d['median'] = round(np.median(items), 2)\\n\\n # Add 'var' key to the dict with the value of the varience calculate by\\n # using np.var rounded to 2 decimal places\\n d['var'] = round(np.var(items, ddof=1), 2)\\n\\n # Add 'std' key to the dict with the value of the standard deviation\\n # calculate by using np.std to 2 decimal places\\n d['std'] = round(np.std(items, ddof=1), 2)\\n\\n # Add 'min' key to the dict with the value of the minimum calculate by\\n # using np.min to 2 decimal places\\n d['min'] = round(np.min(items), 2)\\n\\n # Add 'max' key to the dict with the value of the maximum calculate by\\n # using np.max to 2 decimal places\\n d['max'] = round(np.max(items), 2)\\n\\n # returns dictionary, d\\n return d\",\n \"def compute_metrics(self, results: list) -> dict:\",\n \"def build_metrics_counter_data(count_metrics):\\n return [{'name': name, 'delta': delta} for name, delta in iteritems(count_metrics)]\",\n \"def get_all_metrics(self):\\n metrics = {}\\n for item in self.list_metrics():\\n metric_name = item[2]\\n metric = self.get_metric(\\n item,\\n existing_dict=metrics.get(metric_name, None))\\n metrics[metric_name] = metric\\n return metrics\",\n \"def __init__(self, replication_num, metric_name_array, metric_collection_types = None, detailed_metric_assembly = False):\\n self.replication_num = replication_num\\n self.metrics = metric_name_array\\n self.metric_collection_types = metric_collection_types # can be a string array elements of which can be one of ('STRING_LIST', 'COUNT_MAX', 'MEAN_STD','MIN','MAX', 'MIN_MAX') \\n self.detailed_metric_assembly = detailed_metric_assembly\\n self.replication_counter = 0\\n self.metric_final_results = {}\\n # initialize results array for each metric\\n for metric in metric_name_array:\\n self.metric_final_results[metric] = []\",\n \"def add_metrics(_dict):\\n for key, itr in _dict.items():\\n if key not in self.metric_cols:\\n self.metric_cols.append(key)\",\n \"def __init__(self, metrics, recompute_real=True, **kwargs):\\n super().__init__(recompute_real=recompute_real, **kwargs)\\n self._metrics = metrics\\n\\n for metric in self._metrics:\\n metric._recompute_real = recompute_real\",\n \"def add_metrics(self, metric_dict: dict):\\n self.metric_dict.update(metric_dict)\",\n \"def _make_metric_dict(self, metrics):\\n exon = None\\n hgvs_c = None\\n hgvs_p = None\\n hgvs_three = None\\n hgvs_basep = None\\n hgvs_aap = None\\n\\n tx = metrics.split(':')[1]\\n hgnc = metrics.split(':')[0]\\n raw_exon = metrics.split(':')[2]\\n if raw_exon != 'wholegene':\\n exon = metrics.split(':')[2][4:]\\n hgvs_c = metrics.split(':')[3]\\n full_c = ':'.join([tx, hgvs_c])\\n hgvs_parser = Hgvs(full_c)\\n\\n hgvs_basep = hgvs_parser.start\\n try:\\n hgvs_p = metrics.split(':')[4]\\n full_p = ':'.join([tx, hgvs_p])\\n hgvs_parser = Hgvs(full_p)\\n hgvs_three = hgvs_parser.threep\\n hgvs_aap = hgvs_parser.start[3:]\\n except IndexError:\\n hgvs_p = None\\n full_p = None\\n hgvs_three = None\\n hgvs_aap = None\\n\\n return {\\n 'AAP': hgvs_aap,\\n 'BASEP': hgvs_basep,\\n 'EXON': exon,\\n 'HGNC': hgnc,\\n 'HGVSC': hgvs_c,\\n 'HGVSP1': hgvs_p,\\n 'HGVSP3': hgvs_three,\\n 'SOURCE': self.tfx_type,\\n 'SPLICE': None,\\n 'TXC': tx,\\n 'VFX': self.veff,\\n 'PVT': None\\n }\",\n \"def __init__(self):\\n self.num_counts = {}\",\n \"def get_metrics(self, reset: bool = False) -> Dict[str, float]:\\n return {'accuracy' : self.accuracy.get_metric(reset)}\",\n \"def dictionary_of_metrics(items):\\n \\n n = len(items)\\n average = round(np.mean(items), 2)\\n median = round(np.median(items), 2)\\n variance = round((sum((items-np.mean(items))**2))/(n-1), 2)\\n standard_dev = round(((sum((items-np.mean(items))**2))/(n-1))**(1/2), 2)\\n minimum = round(min(items), 2)\\n maximum = round(max(items), 2)\\n \\n return {'mean':average,'median':median,'var':variance,'std':standard_dev,'min':minimum,'max':maximum}\\n pass\",\n \"def _build_eval_metrics(self, results, features, labels):\\n metrics = {}\\n for metric in self.metrics:\\n metrics[metric.IDENTIFIER] = getters.get_metric(\\n metric.IDENTIFIER, results, labels, **metric.to_dict())\\n return metrics\",\n \"def compute_metrics(self):\\n pass\",\n \"def _init_metrics(self, mp_type, namespace, unreachable=False):\\n kind = ResourceKind.METRIC if namespace else ResourceKind.GLOBALMETRIC\\n metrics_info = (\\n self._METRICS_PROVIDER_INFO.get(mp_type, {})\\n .get(namespace, {})\\n .get(\\\"metrics\\\", [])\\n )\\n\\n # We will collect metrics from all metrics providers of the correct type\\n # and in the correct namespace in the metrics list.\\n metrics = []\\n\\n # all metrics providers of the correct type in the correct namespace\\n if unreachable:\\n mps_list = self.unreachable_metrics_providers\\n else:\\n mps_list = self.metrics_providers\\n mps = mps_list.get(mp_type, {}).get(namespace, {})\\n\\n # Mapping from metrics provider resource definition to its metrics.\\n # Initially empty.\\n metrics_for_mp = dict.fromkeys([mp for mp in mps], [])\\n for metric_info in metrics_info:\\n # check if metric has the correct reachability. Skip if not.\\n mp_name = metric_info[\\\"mp_name\\\"]\\n reachability_matches = True if mp_name in [mp.name for mp in mps] else False\\n if reachability_matches:\\n # Create and collect the metric\\n metric_name = metric_info[\\\"name\\\"]\\n mp_metric_name = metric_info.get(\\\"mp_metric_name\\\", None)\\n metric = BaseMetricDefinition(\\n metric_name,\\n kind,\\n namespace,\\n metric_info[\\\"allowed_values\\\"],\\n metric_info[\\\"min\\\"],\\n metric_info[\\\"max\\\"],\\n mp_name,\\n mp_metric_name=mp_metric_name,\\n )\\n metrics.append(metric)\\n\\n # remember its metrics provider for performance reasons\\n mps_w_correct_name = [mp for mp in mps if mp.name == mp_name]\\n if len(mps_w_correct_name) != 1:\\n msg = (\\n f\\\"Expected 1 metrics provider with the name {mp_name}. \\\"\\n f\\\"Found {len(mps_w_correct_name)}.\\\"\\n )\\n raise ValueError(msg)\\n mp = mps_w_correct_name[0]\\n self._metric_to_metrics_provider[metric] = mp\\n\\n # save this metric to the metrics provider so it can be added later.\\n metrics_for_mp[mp].append(metric)\\n\\n # The metrics providers need their metrics, so we add them here - also for\\n # non-static metrics providers, since information about the metrics they\\n # provide is needed in the tests.\\n sanity_check_number_of_metrics = 0\\n for mp, mp_metrics in metrics_for_mp.items():\\n sanity_check_number_of_metrics += len(mp_metrics)\\n self._add_metrics_to_metrics_provider(mp, mp_metrics)\\n if len(metrics) != sanity_check_number_of_metrics:\\n msg = (\\n f\\\"Expected {len(metrics)} and {sanity_check_number_of_metrics} \\\"\\n f\\\"to be equal.\\\"\\n )\\n raise ValueError(msg)\\n\\n return metrics\",\n \"def get_metrics(self):\\n return None\",\n \"def initialize_metrics_json(metrics_filename):\\n json_structure = ['dataset','region','metric','statistic']\\n metrics = {\\n 'SCHEMA': {\\n 'name': 'CMEC',\\n 'version': 'v1',\\n 'package': 'ASoP'},\\n 'DIMENSIONS':{\\n 'json_structure': json_structure,\\n 'dimensions': {\\n 'dataset': {},\\n 'region': {},\\n 'metric': {\\n 'Temporal intermittency': {},\\n 'Spatial intermittency': {}},\\n 'statistic': {\\n 'p(upper|upper)': \\\"Probability of upper quartile precipitation followed by upper quartile precipitation\\\",\\n 'p(lower|lower)': \\\"Probability of lower quartile precipitation followed by lower quartile precipitation\\\",\\n 'p(upper|lower)': \\\"Probability of upper quartile precipitation followed by lower quartile precipitation\\\",\\n 'p(lower|upper)': \\\"Probability of lower quartile precipitation followed by upper quartile precipitation\\\",\\n 'combined': 'Metric of coherence (combined probabilities)'\\n }}},\\n 'RESULTS': {},\\n 'REFERENCE': 'Klingaman et al. (2017, GMD, doi:10.5194/gmd-10-57-2017)'}\\n with open(metrics_filename,'w') as fname:\\n json.dump(metrics,fname,indent=2)\\n\\n return\",\n \"def make_metric(name):\\n return {\\n \\\"type\\\": \\\"Metric\\\",\\n \\\"name\\\": name,\\n \\\"value\\\": \\\"\\\",\\n \\\"units\\\": \\\"\\\",\\n \\\"rating\\\": \\\"\\\",\\n \\\"notes\\\": \\\"\\\",\\n \\\"comment\\\": \\\"\\\",\\n }\",\n \"def dictionary_of_metrics(items):\\n \\n np_list = np.array(items) #create an array of list to use numpy functions on list\\n metric_dict = {'mean': np.mean(np_list).round(2),\\n 'median': np.median(np_list).round(2),\\n 'var': np.var(np_list, ddof=1).round(2),\\n 'std': np.std(np_list, ddof=1).round(2),\\n 'min': np.min(np_list).round(2),\\n 'max': np.max(np_list).round(2),} #create a dictionary that calculates the five metrics\\n \\n return metric_dict #return result as a dictionary\",\n \"def prepare_multiple_perf_metrics(run_dict):\\n multiple_perf_metrics = {}\\n for run_label, run_name in run_dict.items():\\n output_parser = OutputParser(run_name, use_most_recent=False)\\n perf_metrics = performance_calculations.performance_metrics(output_parser)\\n multiple_perf_metrics[run_label] = perf_metrics\\n return multiple_perf_metrics\",\n \"def _default_metrics(self):\\n return {\\n _summary_key(self.head_name, metric_key.MetricKey.LOSS):\\n _weighted_average_loss_metric_spec(\\n self._loss_fn, prediction_key.PredictionKey.SCORES,\\n self._label_name, self._weight_column_name)\\n }\",\n \"def __init__(self, metricName, timeResolutions = (86400,)):\\n self.metric = metricName\\n self.timeResolutions = timeResolutions\",\n \"def measure_dict():\\n out = base_dict()\\n out['mro']['current'] = ['Measure']\\n out['name']['current'] = 'Measure'\\n ao(out, 'nSamples', 'Integer', 1, readLevel=3)\\n ao(out, 'id', 'String', 'Conversion source ID', readLevel=3)\\n ao(out, 'uid', 'String', 'Unique ID', readLevel=5)\\n ao(out, 'date', 'Date', '00:00:00 01/01/2000', name='Test date')\\n ao(out, 'zerotime', 'Float', name='Acquisition starting time', readLevel=4)\\n ao(out, 'elapsed', 'Float', name='Test duration', unit='second')\\n ao(out, 'operator', 'String', name='Operator')\\n return out\",\n \"def _default_metrics(self):\\n\\n def _streaming_auc_with_class_id_label(predictions, labels, weights=None):\\n indicator_labels = _class_id_labels_to_indicator(\\n labels, num_classes=self.logits_dimension)\\n return _streaming_auc(predictions, indicator_labels, weights)\\n\\n loss_key = _summary_key(self.head_name, metric_key.MetricKey.LOSS)\\n accuracy_key = _summary_key(self.head_name, metric_key.MetricKey.ACCURACY)\\n auc_key = _summary_key(self.head_name, metric_key.MetricKey.AUC)\\n metrics = {\\n loss_key:\\n _weighted_average_loss_metric_spec(\\n self._loss_fn, prediction_key.PredictionKey.LOGITS,\\n self._label_name, self._weight_column_name),\\n # TODO(b/29366811): This currently results in both an \\\"accuracy\\\" and an\\n # \\\"accuracy/threshold_0.500000_mean\\\" metric for binary classification.\\n accuracy_key:\\n self._metric_spec(metrics_lib.streaming_accuracy,\\n prediction_key.PredictionKey.CLASSES),\\n auc_key:\\n self._metric_spec(_streaming_auc_with_class_id_label,\\n prediction_key.PredictionKey.PROBABILITIES)\\n }\\n\\n def _class_predictions_streaming_mean(predictions,\\n labels,\\n weights=None,\\n class_id=None):\\n del labels\\n return metrics_lib.streaming_mean(\\n array_ops.where(\\n math_ops.equal(\\n math_ops.to_int32(class_id), math_ops.to_int32(predictions)),\\n array_ops.ones_like(predictions),\\n array_ops.zeros_like(predictions)),\\n weights=weights)\\n\\n def _class_labels_streaming_mean(predictions,\\n labels,\\n weights=None,\\n class_id=None):\\n del predictions\\n assert class_id is not None\\n return metrics_lib.streaming_mean(\\n array_ops.where(\\n math_ops.equal(\\n math_ops.to_int32(class_id), math_ops.to_int32(labels)),\\n array_ops.ones_like(labels), array_ops.zeros_like(labels)),\\n weights=weights)\\n\\n def _class_streaming_auc(predictions, labels, weights=None, class_id=None):\\n assert class_id is not None\\n indicator_labels = _class_id_labels_to_indicator(\\n labels, num_classes=self.logits_dimension)\\n return _streaming_auc(\\n predictions, indicator_labels, weights=weights, class_id=class_id)\\n\\n for class_id in self._metric_class_ids:\\n\\n # TODO(ptucker): Add per-class accuracy, precision, recall.\\n\\n prediction_mean_key = _summary_key(\\n self.head_name, metric_key.MetricKey.CLASS_PREDICTION_MEAN % class_id)\\n label_mean_key = _summary_key(self.head_name,\\n metric_key.MetricKey.CLASS_LABEL_MEAN %\\n class_id)\\n probability_mean_key = _summary_key(\\n self.head_name,\\n metric_key.MetricKey.CLASS_PROBABILITY_MEAN % class_id)\\n logits_mean_key = _summary_key(self.head_name,\\n metric_key.MetricKey.CLASS_LOGITS_MEAN %\\n class_id)\\n auc_key = _summary_key(self.head_name,\\n metric_key.MetricKey.CLASS_AUC % class_id)\\n\\n metrics[prediction_mean_key] = self._metric_spec(\\n functools.partial(\\n _class_predictions_streaming_mean, class_id=class_id),\\n prediction_key.PredictionKey.CLASSES)\\n metrics[label_mean_key] = self._metric_spec(\\n functools.partial(\\n _class_labels_streaming_mean, class_id=class_id),\\n prediction_key.PredictionKey.PROBABILITIES)\\n metrics[probability_mean_key] = self._metric_spec(\\n functools.partial(\\n _predictions_streaming_mean, class_id=class_id),\\n prediction_key.PredictionKey.PROBABILITIES)\\n metrics[logits_mean_key] = self._metric_spec(\\n functools.partial(\\n _predictions_streaming_mean, class_id=class_id),\\n prediction_key.PredictionKey.LOGITS)\\n metrics[auc_key] = self._metric_spec(\\n functools.partial(\\n _class_streaming_auc, class_id=class_id),\\n prediction_key.PredictionKey.LOGITS)\\n\\n return metrics\",\n \"def static_metrics(self) -> dict[str, float | int]:\\n return self.performance[\\\"meta\\\"]\",\n \"def metrics(self):\\r\\n url = '{0}/{1}'.format(self.get_url(), 'metrics')\\r\\n\\r\\n return http.Request('GET', url), parsers.parse_json\",\n \"def __init__(self, metrics_params):\\n self.met_obs_start_dt = metrics_params['met_obs_start_dt']\\n self.met_obs_end_dt = metrics_params['met_obs_end_dt']\\n self.num_sats = metrics_params['num_sats']\\n self.num_targ = metrics_params['num_targ']\\n self.all_targ_IDs = metrics_params['all_targ_IDs']\\n self.min_obs_dv_dlnk_req = metrics_params['min_obs_dv_dlnk_req']\\n self.latency_calculation_params = metrics_params['latency_calculation_params']\\n self.targ_id_ignore_list = metrics_params['targ_id_ignore_list']\\n self.aoi_units = metrics_params['aoi_units']\\n self.sats_emin_Wh = metrics_params['sats_emin_Wh']\\n self.sats_emax_Wh = metrics_params['sats_emax_Wh']\\n self.sats_dmin_Gb = metrics_params.get('sats_dmin_Gb',None)\\n self.sats_dmax_Gb = metrics_params.get('sats_dmax_Gb',None)\\n\\n # the amount by which the minimum data volume is allowed to be lower than self.min_obs_dv_dlnk_req\\n self.min_obs_dv_dlnk_req_slop = self.min_obs_dv_dlnk_req*0.01\\n\\n # if two downlink times are within this number of seconds, then they are counted as being at the same time for the purposes of AoI calculation\\n self.dlnk_same_time_slop_s = metrics_params['timestep_s'] - 1\",\n \"def get_metrics(cm, list_metrics):\\n dic_metrics = {}\\n total = np.sum(cm)\\n\\n if 'accuracy' in list_metrics:\\n out = np.sum(np.diag(cm))\\n dic_metrics['accuracy'] = out/total\\n\\n if 'pres_0' in list_metrics:\\n num = cm[0, 0]\\n den = cm[:, 0].sum()\\n dic_metrics['pres_0'] = num/den if den > 0 else 0\\n\\n if 'pres_1' in list_metrics:\\n num = cm[1, 1]\\n den = cm[:, 1].sum()\\n dic_metrics['pres_1'] = num/den if den > 0 else 0\\n\\n if 'recall_0' in list_metrics:\\n num = cm[0, 0]\\n den = cm[0, :].sum()\\n dic_metrics['recall_0'] = num/den if den > 0 else 0\\n\\n if 'recall_1' in list_metrics:\\n num = cm[1, 1]\\n den = cm[1, :].sum()\\n dic_metrics['recall_1'] = num/den if den > 0 else 0\\n\\n return dic_metrics\",\n \"def __init__ (self):\\n self.lengths = {}\\n self.lower_counts = {}\\n self.upper_counts = {}\\n self.digit_counts = {}\\n self.symbol_counts = {}\\n self.class_counts = {}\\n self.word_counts = {}\",\n \"def _get_metrics(one_hot: bool) -> Mapping[Text, Any]:\\n if one_hot:\\n return {\\n # (name, metric_fn)\\n 'acc': tf.keras.metrics.CategoricalAccuracy(),\\n 'accuracy': tf.keras.metrics.CategoricalAccuracy(),\\n 'top_1': tf.keras.metrics.CategoricalAccuracy(),\\n 'top_5': tf.keras.metrics.TopKCategoricalAccuracy(\\n k=5, name='top_5_accuracy'),\\n }\\n else:\\n return {\\n # (name, metric_fn)\\n 'acc': tf.keras.metrics.SparseCategoricalAccuracy(),\\n 'accuracy': tf.keras.metrics.SparseCategoricalAccuracy(),\\n 'top_1': tf.keras.metrics.SparseCategoricalAccuracy(),\\n 'top_5': tf.keras.metrics.SparseTopKCategoricalAccuracy(\\n k=5, name='top_5_accuracy'),\\n }\",\n \"def __init__(self):\\n self.counts = {}\",\n \"def __init__(self, collectd):\\n self.collectd = collectd\\n self.conf = self.default_config()\\n self.types = {}\\n\\n collectd.info('Initialized MetricsConfig with default config %s' % self.conf)\",\n \"def __init__(self, group_key=None, sort_key=None):\\n super(Metric, self).__init__()\\n self.group_key = group_key\\n self.sort_key = sort_key\",\n \"def create_metric(self) -> EvalMetric:\\n pass\",\n \"def _section_metrics(course_key, access):\\r\\n section_data = {\\r\\n 'section_key': 'metrics',\\r\\n 'section_display_name': ('Metrics'),\\r\\n 'access': access,\\r\\n 'course_id': course_key.to_deprecated_string(),\\r\\n 'sub_section_display_name': get_section_display_name(course_key),\\r\\n 'section_has_problem': get_array_section_has_problem(course_key),\\r\\n 'get_students_opened_subsection_url': reverse('get_students_opened_subsection'),\\r\\n 'get_students_problem_grades_url': reverse('get_students_problem_grades'),\\r\\n 'post_metrics_data_csv_url': reverse('post_metrics_data_csv'),\\r\\n }\\r\\n return section_data\",\n \"def report_metrics(metrics, label_matches=None):\\n metrics_map = {}\\n\\n for metric in metrics.values():\\n samples = []\\n for sample in metric.samples:\\n if not label_matches or label_matches.items() <= sample.labels.items():\\n sample_map = {'labels': sample.labels, 'value': sample.value}\\n samples.append(sample_map)\\n metrics_map[metric.name] = {'samples': samples}\\n\\n return metrics_map\",\n \"def metric_tests(self, metric_tests: Dict[str, FAIRResultEvaluationCriterium]):\\n\\n self._metric_tests = metric_tests\",\n \"def __init__(self, instresult, number):\\n self.instresult = instresult\\n self.number = number\\n self.measures = {}\",\n \"def _default_metrics(self):\\n metrics = {\\n _summary_key(self.head_name, metric_key.MetricKey.LOSS):\\n _weighted_average_loss_metric_spec(\\n self._loss_fn, prediction_key.PredictionKey.LOGITS,\\n self._label_name, self._weight_column_name)\\n }\\n\\n # TODO(b/29366811): This currently results in both an \\\"accuracy\\\" and an\\n # \\\"accuracy/threshold_0.500000_mean\\\" metric for binary classification.\\n metrics[_summary_key(self.head_name, metric_key.MetricKey.ACCURACY)] = (\\n metric_spec.MetricSpec(metrics_lib.streaming_accuracy,\\n prediction_key.PredictionKey.CLASSES,\\n self._label_name, self._weight_column_name))\\n\\n def _add_binary_metric(key, metric_fn):\\n metrics[_summary_key(self.head_name, key)] = metric_spec.MetricSpec(\\n metric_fn, prediction_key.PredictionKey.LOGISTIC, self._label_name,\\n self._weight_column_name)\\n\\n _add_binary_metric(metric_key.MetricKey.PREDICTION_MEAN,\\n _predictions_streaming_mean)\\n _add_binary_metric(metric_key.MetricKey.LABEL_MEAN,\\n _indicator_labels_streaming_mean)\\n\\n # Also include the streaming mean of the label as an accuracy baseline, as\\n # a reminder to users.\\n _add_binary_metric(metric_key.MetricKey.ACCURACY_BASELINE,\\n _indicator_labels_streaming_mean)\\n\\n _add_binary_metric(metric_key.MetricKey.AUC, _streaming_auc)\\n\\n for threshold in self._thresholds:\\n _add_binary_metric(metric_key.MetricKey.ACCURACY_MEAN % threshold,\\n _accuracy_at_threshold(threshold))\\n # Precision for positive examples.\\n _add_binary_metric(\\n metric_key.MetricKey.PRECISION_MEAN % threshold,\\n _streaming_at_threshold(metrics_lib.streaming_precision_at_thresholds,\\n threshold),)\\n # Recall for positive examples.\\n _add_binary_metric(metric_key.MetricKey.RECALL_MEAN % threshold,\\n _streaming_at_threshold(\\n metrics_lib.streaming_recall_at_thresholds,\\n threshold))\\n return metrics\",\n \"def create_system_metrics(system):\\n pass\",\n \"def __init__(self):\\r\\n # sample ID -> (ref individual count,\\r\\n # {size -> (estimate, std err, ci_low, ci_high)})\\r\\n self._data = {}\",\n \"def __init__(self):\\n super().__init__()\\n self.metric = 'ACURCY'\",\n \"def get_km_test_metrics(metrics_obj):\\n metrics_dict = dict()\\n metrics_dict['betweenss'] = metrics_obj.betweenss()\\n metrics_dict['tot_withinss'] = metrics_obj.tot_withinss()\\n metrics_dict['totss'] = metrics_obj.totss()\\n metrics_dict['centroid_stats'] = twodim_table_2_frame(metrics_obj._metric_json['centroid_stats'])[1]\\n\\n return metrics_dict\",\n \"def initialize_case_metrics(self) -> None:\\n for case in self.cases:\\n graph_distance, time_distance = extract_case_distances(self.process_model_graph, case)\\n case.graph_distance = graph_distance\\n case.time_distance = time_distance\",\n \"def get_metrics(self, x, y):\\n metrics = dict()\\n y_predicted = self.predict(x)\\n metrics['Accuracy'] = accuracy_score(y, y_predicted)\\n metrics['F1'] = f1_score(y, y_predicted)\\n metrics['Precision'] = precision_score(y, y_predicted)\\n\\n return metrics\",\n \"def build_metrics_gauge_data(gauge_metrics):\\n return [{'name': name, 'value': value} for name, value in iteritems(gauge_metrics)]\",\n \"def list_metrics(self):\\n pass\",\n \"def __init__(self, metrics=[\\n Hamming(),\\n Levenshtein(),\\n Osa(),\\n DamerauLevenshtein(),\\n Jaccard(),\\n Dice(),\\n Jaro(),\\n JaroWinkler() ]):\\n self.metrics = metrics\",\n \"def create_stats(measures: \\\"List of function timings.\\\",\\n col: \\\"Current Column.\\\", row: \\\"Current Row\\\",\\n scenario: \\\"Current Scenario.\\\") -> dict:\\n return {\\\"scenario\\\": scenario,\\n \\\"no_column\\\": col,\\n \\\"data_length\\\": row,\\n \\\"min\\\": np.min(measures),\\n \\\"max\\\": np.max(measures),\\n \\\"avg\\\": np.mean(measures),\\n \\\"q50\\\": np.median(measures)}\",\n \"def add_stats(self):\\n units = self.get_unit_map()\\n for metric in self.raw_metrics:\\n unit, metric_type = units.get(metric, (DEFAULT_UNIT, DEFAULT_TYPE))\\n if metric_type == \\\"counter\\\":\\n # Unit/Second\\n unit = \\\"/\\\".join((unit, \\\"Second\\\"))\\n self.add_derive_value(metric, unit, self.raw_metrics[metric], rate=True)\\n else:\\n self.add_gauge_value(metric, unit, self.raw_metrics[metric])\",\n \"def metrics(self):\\n \\n if self.mse.shape[0]>1:\\n raise ValueError('Metrics can only handle single observations.')\\n \\n if self.N==1:\\n pred = float('nan')\\n err = float('nan')\\n y_true = float('nan')\\n else:\\n pred = int(self._predictions[-1])\\n err = self._mse[-1]\\n y_true = int(self.label[0])\\n \\n is_outlier = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"is_outlier\\\",\\\"value\\\":pred}\\n mse = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"mse\\\",\\\"value\\\":err}\\n obs = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"observation\\\",\\\"value\\\":self.N - 1}\\n threshold = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"threshold\\\",\\\"value\\\":self.threshold}\\n \\n label = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"label\\\",\\\"value\\\":y_true}\\n \\n accuracy_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"accuracy_tot\\\",\\\"value\\\":self.metric[4]}\\n precision_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"precision_tot\\\",\\\"value\\\":self.metric[5]}\\n recall_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"recall_tot\\\",\\\"value\\\":self.metric[6]}\\n f1_score_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f1_tot\\\",\\\"value\\\":self.metric[7]}\\n f2_score_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f2_tot\\\",\\\"value\\\":self.metric[8]}\\n \\n accuracy_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"accuracy_roll\\\",\\\"value\\\":self.metric[9]}\\n precision_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"precision_roll\\\",\\\"value\\\":self.metric[10]}\\n recall_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"recall_roll\\\",\\\"value\\\":self.metric[11]}\\n f1_score_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f1_roll\\\",\\\"value\\\":self.metric[12]}\\n f2_score_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f2_roll\\\",\\\"value\\\":self.metric[13]}\\n \\n true_negative = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"true_negative\\\",\\\"value\\\":self.metric[0]}\\n false_positive = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"false_positive\\\",\\\"value\\\":self.metric[1]}\\n false_negative = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"false_negative\\\",\\\"value\\\":self.metric[2]}\\n true_positive = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"true_positive\\\",\\\"value\\\":self.metric[3]}\\n \\n nb_outliers_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_outliers_roll\\\",\\\"value\\\":self.metric[14]}\\n nb_labels_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_labels_roll\\\",\\\"value\\\":self.metric[15]}\\n nb_outliers_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_outliers_tot\\\",\\\"value\\\":self.metric[16]}\\n nb_labels_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_labels_tot\\\",\\\"value\\\":self.metric[17]}\\n \\n return [is_outlier,mse,obs,threshold,label,\\n accuracy_tot,precision_tot,recall_tot,f1_score_tot,f2_score_tot,\\n accuracy_roll,precision_roll,recall_roll,f1_score_roll,f2_score_roll,\\n true_negative,false_positive,false_negative,true_positive,\\n nb_outliers_roll,nb_labels_roll,nb_outliers_tot,nb_labels_tot]\",\n \"def compute_metrics(self, x, extra=None):\\n if self.__metrics is None and extra is None:\\n return None\\n\\n ret = {}\\n if self.__metrics is not None:\\n for m in self.__metrics:\\n ret[m.name] = self._mdmetric(x, m)\\n\\n if extra is not None and extra.name not in ret:\\n ret[extra.name] = self._mdmetric(x, extra)\\n\\n return ret\",\n \"def metrics(self):\\n return self.__metrics\",\n \"def __init__(__self__, *,\\n metrics: Optional[pulumi.Input['ManagedClusterAzureMonitorProfileMetricsArgs']] = None):\\n if metrics is not None:\\n pulumi.set(__self__, \\\"metrics\\\", metrics)\",\n \"def __init__(self):\\n self.cnt = {}\",\n \"def __init__(self):\\n super().__init__()\\n self.metric = 'FALLOUT'\",\n \"def metrics(self):\\r\\n if not hasattr(self, '_observable_metrics'):\\r\\n self._observable_metrics = Metrics()\\r\\n return self._observable_metrics\",\n \"def __init__(self, *args, **kwargs):\\n self.metric_type = kwargs['acc_metric'] \\n\\n if self.metric_type == 'Accuracy':\\n self.metric_object = Accuracy(*args, **kwargs) \\n elif self.metric_type == 'AveragePrecision':\\n self.metric_object = AveragePrecision(*args, **kwargs)\\n elif self.metric_type == 'mAP':\\n self.metric_object = MAP(*args, **kwargs)\\n elif self.metric_type == 'SSD_AP':\\n self.metric_object = SSD_AP(*args, **kwargs)\\n else:\\n self.metric_type = None\",\n \"def get_config_metrics():\\n\\n metrics = {'disk_usage': 'YES',\\n 'cpu_percent': 'YES',\\n 'memory_info': 'YES',\\n 'cpu_stats': 'YES'}\\n\\n return metrics\",\n \"def __init__(self):\\n super().__init__()\\n self.metric = 'FMEASR'\",\n \"def metrics(self):\\n self.metrics = []\\n \\n self.clients()\\n\\n if len(self.metrics) > 0:\\n return self.metrics\\n else:\\n return []\",\n \"def __init__(self, *args, **opts):\\n \\n madloop_statistics = {\\n 'unknown_stability' : 0,\\n 'stable_points' : 0,\\n 'unstable_points' : 0,\\n 'exceptional_points' : 0,\\n 'DP_usage' : 0,\\n 'QP_usage' : 0,\\n 'DP_init_usage' : 0,\\n 'QP_init_usage' : 0,\\n 'CutTools_DP_usage' : 0,\\n 'CutTools_QP_usage' : 0, \\n 'PJFry_usage' : 0,\\n 'Golem_usage' : 0,\\n 'IREGI_usage' : 0,\\n 'Samurai_usage' : 0,\\n 'Ninja_usage' : 0,\\n 'Ninja_QP_usage' : 0,\\n 'COLLIER_usage' : 0,\\n 'max_precision' : 1.0e99,\\n 'min_precision' : 0.0,\\n 'averaged_timing' : 0.0,\\n 'n_madloop_calls' : 0,\\n 'cumulative_timing' : 0.0,\\n 'skipped_subchannel' : 0 # number of times that a computation have been \\n # discarded due to abnormal weight.\\n }\\n \\n for key, value in madloop_statistics.items():\\n self[key] = value\\n\\n super(dict,self).__init__(*args, **opts)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8447349","0.8055454","0.7887387","0.7674845","0.7393849","0.7364651","0.7242206","0.7189611","0.7178743","0.7161504","0.71576923","0.6911986","0.68280876","0.6823303","0.6809899","0.6747972","0.67374635","0.6736809","0.67120516","0.66915673","0.6668668","0.666477","0.6657806","0.6644522","0.6633594","0.660553","0.660337","0.6574958","0.65592074","0.6537359","0.65288466","0.6508536","0.6482407","0.64759344","0.6446942","0.64326715","0.6398682","0.6394735","0.6374451","0.6364773","0.63622093","0.6358896","0.63555425","0.6348245","0.63187695","0.6276419","0.6273664","0.6269546","0.6257298","0.62501854","0.6248468","0.62134475","0.62019825","0.6179505","0.6150164","0.6143115","0.61145943","0.60835814","0.6082399","0.606552","0.60584325","0.6053091","0.605006","0.6043616","0.6042353","0.60342234","0.60316175","0.6028416","0.60132575","0.600205","0.59944135","0.5993709","0.5973518","0.5959812","0.5959262","0.5939327","0.59390974","0.5937878","0.59311694","0.59296757","0.5917344","0.59140253","0.5912844","0.5900124","0.58997977","0.589168","0.587981","0.5873965","0.5867164","0.58657175","0.58642405","0.5864158","0.5858018","0.5846861","0.58439434","0.5840378","0.5838027","0.583649","0.5836351","0.5826469"],"string":"[\n \"0.8447349\",\n \"0.8055454\",\n \"0.7887387\",\n \"0.7674845\",\n \"0.7393849\",\n \"0.7364651\",\n \"0.7242206\",\n \"0.7189611\",\n \"0.7178743\",\n \"0.7161504\",\n \"0.71576923\",\n \"0.6911986\",\n \"0.68280876\",\n \"0.6823303\",\n \"0.6809899\",\n \"0.6747972\",\n \"0.67374635\",\n \"0.6736809\",\n \"0.67120516\",\n \"0.66915673\",\n \"0.6668668\",\n \"0.666477\",\n \"0.6657806\",\n \"0.6644522\",\n \"0.6633594\",\n \"0.660553\",\n \"0.660337\",\n \"0.6574958\",\n \"0.65592074\",\n \"0.6537359\",\n \"0.65288466\",\n \"0.6508536\",\n \"0.6482407\",\n \"0.64759344\",\n \"0.6446942\",\n \"0.64326715\",\n \"0.6398682\",\n \"0.6394735\",\n \"0.6374451\",\n \"0.6364773\",\n \"0.63622093\",\n \"0.6358896\",\n \"0.63555425\",\n \"0.6348245\",\n \"0.63187695\",\n \"0.6276419\",\n \"0.6273664\",\n \"0.6269546\",\n \"0.6257298\",\n \"0.62501854\",\n \"0.6248468\",\n \"0.62134475\",\n \"0.62019825\",\n \"0.6179505\",\n \"0.6150164\",\n \"0.6143115\",\n \"0.61145943\",\n \"0.60835814\",\n \"0.6082399\",\n \"0.606552\",\n \"0.60584325\",\n \"0.6053091\",\n \"0.605006\",\n \"0.6043616\",\n \"0.6042353\",\n \"0.60342234\",\n \"0.60316175\",\n \"0.6028416\",\n \"0.60132575\",\n \"0.600205\",\n \"0.59944135\",\n \"0.5993709\",\n \"0.5973518\",\n \"0.5959812\",\n \"0.5959262\",\n \"0.5939327\",\n \"0.59390974\",\n \"0.5937878\",\n \"0.59311694\",\n \"0.59296757\",\n \"0.5917344\",\n \"0.59140253\",\n \"0.5912844\",\n \"0.5900124\",\n \"0.58997977\",\n \"0.589168\",\n \"0.587981\",\n \"0.5873965\",\n \"0.5867164\",\n \"0.58657175\",\n \"0.58642405\",\n \"0.5864158\",\n \"0.5858018\",\n \"0.5846861\",\n \"0.58439434\",\n \"0.5840378\",\n \"0.5838027\",\n \"0.583649\",\n \"0.5836351\",\n \"0.5826469\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78341216"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":91497,"cells":{"query":{"kind":"string","value":"Updates a metric dict with metrics from an epoch"},"document":{"kind":"string","value":"def update_metric_dict(self, metric_dict, update_dict):\n for key in update_dict.keys():\n metric_dict[key].append(update_dict[key])\n return metric_dict"},"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 calculate_epoch_metrics(self, val_metrics=False):\n metric_names = self.tracked_metrics()\n\n for metric in metric_names:\n if val_metrics:\n mean_val = np.array(self.metrics_history[f\"val_{metric}\"][\"batch_vals\"]).mean()\n self.metrics_history[f\"val_{metric}\"][\"epoch_vals\"].append(mean_val)\n else:\n mean_val = np.array(self.metrics_history[metric][\"batch_vals\"]).mean()\n self.metrics_history[metric][\"epoch_vals\"].append(mean_val)","def on_epoch_end(self):\n self.current_metric = self.model.metric(self.metric_fn, self.data)\n self.current_epoch += 1\n self.metrics += [self.current_metric]\n self.epochs += [self.current_epoch]\n if self.verbose:\n print('Epoch {} \\t{}: {}'.format(\n self.current_epoch,\n self.metric_name,\n self.current_metric))","def before_training_epoch(self, epoch, **kw):\n self.current_row = {MetricName(\"epoch\"): epoch}","def update_epoch(self):\n raise NotImplementedError","def update_metrics(self, metrics, predictions, labels):\n return","def add_epoch(self, ckpt_path, hyperparameters, metric_val):\n epoch = {\n 'ckpt_path': ckpt_path,\n 'hyperparameters': hyperparameters,\n 'metric_val': metric_val\n }\n self._history.append(epoch)","def add_entry(self, epoch: int, loss: float, accuracy: float, run: int = 1) -> None:\n self.run = run\n self.current = epoch\n self.metrics[f\"R{run}E{epoch}\"] = \\\n dict(epoch=epoch, loss=loss, accuracy=accuracy, run=run)","def update_metrics(self, state: TrainState, step: int, train_metrics: List[MetricsDict], t0):\n if not self.logflag:\n return\n\n eval_metrics: List[Any] = []\n\n # Build summary dictionary for logging\n # Include training stats\n train_metrics = common_utils.get_metrics(train_metrics)\n summary = {\n f\"train_{k}\": v\n for k, v in jax.tree_util.tree_map(lambda x: x.mean(), train_metrics).items()\n }\n epoch = step // self.steps_per_epoch\n summary[\"epoch\"] = epoch\n summary[\"time\"] = time.time() - t0\n\n # Eval over testing set\n for _ in range(self.steps_per_eval):\n eval_batch = next(self.eval_dt_iter)\n metrics = self.p_eval_step(state, eval_batch)\n eval_metrics.append(metrics)\n # Compute testing metrics\n eval_metrics = common_utils.get_metrics(eval_metrics)\n\n # Add testing stats to summary\n summary_eval = jax.tree_util.tree_map(lambda x: x.mean(), eval_metrics)\n summary.update(summary_eval)\n\n # Update iteration stats object\n assert isinstance(self.itstat_object, IterationStats) # for mypy\n self.itstat_object.insert(self.itstat_insert_func(ArgumentStruct(**summary)))","def _valid_epoch(self, epoch):\n self.model.eval()\n total_val_loss = 0\n total_val_metrics = np.zeros(len(self.metrics))\n length = len(self.valid_loader)\n total_pm25_loss = 0\n total_pm10_loss = 0\n pm25_loss = 0\n pm10_loss = 0\n\n with torch.no_grad():\n\n for batch_idx, (data, target) in enumerate(self.valid_loader):\n data, target = data.to(self.device), target.to(self.device)\n target = target.squeeze()\n output = self.model(data)\n # print(output)\n loss = self.loss(output, target)\n\n # pm25_predict, pm10_predict = torch.chunk(output, 2, dim=1)\n # pm25_target, pm10_target = torch.chunk(target, 2, dim=1)\n # pm25_loss = self.loss(pm25_predict, pm25_target)\n # pm10_loss = self.loss(pm10_predict, pm10_target)\n # total_pm25_loss += pm25_loss.item()\n # total_pm10_loss += pm10_loss.item()\n\n self.writer.set_step((epoch - 1) * len(self.valid_loader) + batch_idx, 'valid')\n self.writer.add_scalar('loss', loss.item())\n total_val_loss += loss.item()\n total_val_metrics += self._eval_metrics(output, target)\n\n return {\n 'val_loss': total_val_loss / length,\n 'val_rmse_loss':np.sqrt(total_val_loss / length),\n 'val_pm25_loss': np.sqrt(total_pm25_loss / length),\n 'val_pm10_loss': np.sqrt(total_pm10_loss / length)\n }","def _compute_running_metrics(self,\n model_output: torch.Tensor,\n batch: Tuple[torch.Tensor, torch.Tensor],\n running_metrics: dict) -> None:\n for metric in self.metrics:\n if metric.__name__ == 'word_error_rate' or metric.__name__ == 'character_error_rate':\n metric_result = metric(model_output, batch, self.decoder)\n else:\n metric_result = metric(model_output, batch)\n if type(metric_result) == torch.Tensor:\n metric_result = metric_result.item()\n\n running_metrics[metric.__name__].append(metric_result)","def run_epoch(self, train, dev, epoch):\n # iterate over dataset\n for i, (words, labels) in enumerate(minibatches(train, self.config.batch_size)):\n fd, _ = self.get_feed_dict(words, labels, self.config.lr,\n self.config.dropout)\n\n _, train_loss= self.sess.run(\n [self.train_op, self.loss], feed_dict=fd)\n\n# =============================================================================\n# # tensorboard\n# if i % 10 == 0:\n# self.file_writer.add_summary(summary, epoch*nbatches + i)\n# =============================================================================\n\n metrics = self.run_evaluate(dev)\n msg = \" - \".join([\"{} {:04.2f}\".format(k, v)\n for k, v in metrics.items()])\n print(msg)\n\n return metrics[\"f1\"]","def __init_metrics(self):\n\n batch = {}\n # split data into batches of size batch_size or less\n for metric_name, metric_pattern in self.metrics.items():\n # get the batch list for that metric\n batch_list = []\n for s in range(1, self.schema + 1):\n for t in range(1, self.table + 1):\n k = '/metrics/type=IndexTable/keyspace={}/scope={}/name={}/mean'.format(s, t, metric_name)\n # from Python 3.6 onwards, the standard dict type maintains insertion order by default\n batch[k] = 0\n # if the batch has batch_size items or at the end of iteration,\n # append the batch to list of that metric and create a new empty batch\n if len(batch) == self.batch_size or (s == self.schema and t == self.table):\n batch_list.append(batch)\n batch = {}\n\n # parse metric patterns\n l = metric_pattern.split()\n if l[0] == '(>':\n self.metrics[metric_name] = IncMetricStruct(float(int(l[1])), float(l[2][1:]), float(l[4][:-2]),\n batch_list)\n else:\n self.metrics[metric_name] = RandMetricStruct(float(l[0][1:]), float(l[-1][:-1]), batch_list)","def set_epoch(self, epoch):\r\n pass","def reset_epoch_cache(self):\n self.epoch_cache = {\"train\":PerformanceBatch(), \n \"val\":PerformanceBatch(), \n \"test\":PerformanceBatch()}","def update(self, current_iter, *metrics, **named_metrics):\n\n # Same order as __init__() in python>=3.6\n if len(metrics) > 0:\n for key, metric in zip(self.metrics.keys(), metrics):\n self.metrics[key].append((current_iter, metric))\n \n # Random order with names\n elif len(named_metrics) > 0:\n for name, metric in named_metrics.item():\n self.metrics[name].append((metric))\n\n else:\n raise ValueError(\"No valid value to update losses\")","def on_train_epoch_end(self) -> None:\n self.log_dict(self.train_metrics.compute())\n self.train_metrics.reset()","def compute_metrics(self):\n self.finalize_output_dict()\n self.metric_dict = {\n key: value(self.output_dict[\"labels\"], self.output_dict[\"pred_probs\"])\n for key, value in self.metric_fns.items()\n }","def _update_metric(\n metrics: List[mlflow.entities.Metric], dataset: MetricsDict = {}\n ) -> MetricsDict:\n for metric in metrics:\n metric_dict = {\"step\": metric.step, \"value\": metric.value}\n if metric.key in dataset:\n if isinstance(dataset[metric.key], list):\n dataset[metric.key].append(metric_dict)\n else:\n dataset[metric.key] = [dataset[metric.key], metric_dict]\n else:\n dataset[metric.key] = metric_dict\n return dataset","def add_metrics(self, metric_dict: dict):\n self.metric_dict.update(metric_dict)","def test_compute_metrics(self):\n with self.test_session() as sess:\n tf.set_random_seed(1234)\n dut = _setup_trainer(self.tmpdir)\n\n sess.run(tf.global_variables_initializer())\n sess.run((dut.train_iterator.initializer,\n dut.train_metric_reset_op))\n\n train_mloss = sess.run(dut.train_mean_loss)\n\n # Without update, it should be zero.\n self.assertEqual(train_mloss, 0.)\n\n sess.run((dut.train_op, dut.train_mean_loss_update_op))\n\n train_mloss = sess.run(dut.train_mean_loss)\n\n # After update.\n self.assertAlmostEqual(train_mloss, 5.2298584)","def before_epoch(self):\n if self.trainer._mode == 'train':\n with open(os.path.join(self.root_path, 'metrics.txt'), 'a+') as fout:\n if hasattr(self.trainer, '_metrics'):\n fout.write(\n str(self.trainer._epoch - 1) + '\\t' +\n str(self.trainer._metrics) + '\\n')","def epoch(self, learning_rate=None, metrics=None):\n # Calculate statistics from epoch\n train_loss = self.train_loss / self.train_samples\n train_losses = {k: v / self.train_samples for k, v in self.train_losses.items()}\n\n if self.val_samples > 0:\n val_loss = self.val_loss / self.val_samples\n val_losses = {k: v / self.val_samples for k, v in self.val_losses.items()}\n else:\n val_loss = None\n val_losses = None\n\n self.n_batches_last = self.i_train_batch\n self.i_epoch += 1\n self.i_train_batch = 0\n self.i_val_batch = 0\n\n metric_values = {}\n if metrics is not None:\n for m in metrics:\n try:\n metric_values[m.name] = m.get_values()\n except AttributeError as e:\n pass\n\n # Combine stats in dataset\n data = {}\n data[\"training_loss\"] = ((\"epochs\",), [train_loss])\n if len(train_losses) > 1:\n for t in train_losses:\n k = \"training_loss_\" + t\n data[k] = ((\"epochs\",), [train_losses[t]])\n\n if val_loss is not None:\n data[\"validation_loss\"] = ((\"epochs\",), [val_loss])\n if len(val_losses) > 1:\n for t in val_losses:\n k = \"validation_loss_\" + t\n data[k] = ((\"epochs\",), [val_losses[t]])\n\n for name, values in metric_values.items():\n if isinstance(values, dict):\n for target, value in values.items():\n k = name + \"_\" + target\n data[k] = ((\"epochs\",), [value])\n else:\n data[name] = ((\"epochs\"), [values])\n data[\"epochs\"] = [self.i_epoch]\n dataset = xr.Dataset(data)\n if self.history is None:\n self.history = xr.Dataset(dataset)\n else:\n self.history = xr.concat([self.history, dataset], dim=\"epochs\")\n\n # Write output\n self.progress.update_table(\n self.i_epoch,\n total_loss_training=train_loss,\n total_loss_validation=val_loss,\n losses_training=train_losses,\n losses_validation=val_losses,\n learning_rate=learning_rate,\n metrics=metric_values,\n )","def on_epoch_begin(self, epoch, logs=None):","def on_epoch_begin(self, epoch, logs=None):","def next_epoch(self):\n update_table = [None for _ in range(2 ** self.bit_count)]\n for w in self.frequency_map:\n frequency = self.frequency_map[w]\n for h in self.hash_functions:\n c = get_hash(h(), repr(w)) % 2 ** self.bit_count\n if not update_table[c] or frequency > update_table[c]:\n update_table[c] = frequency\n # Update statistics table\n debug_hit_something = False\n for c in range(len(update_table)):\n if update_table[c] is not None:\n debug_hit_something = True\n freq = update_table[c] / self.tweet_count\n self._update_bucket(freq, self.buckets[c])\n else:\n pass\n assert debug_hit_something is True\n self.epoch += 1\n self.index[self.epoch] = dict()\n self.trending_topics = []","def on_validation_epoch_end(self) -> None:\n self.log_dict(self.val_metrics.compute())\n self.val_metrics.reset()","def update_ema(metrics, metric, mode, iteration):\n decay = 0.99 if mode == 'train' else 0.9\n d = decay if iteration > 10 else 0.5\n\n for key, value in metric.items():\n metrics[mode][key] = metrics[mode][key] * d + value * (1 - d)\n\n return metrics","def on_epoch_begin(self, epoch, logs={}):\n self.current_progress = 0\n self.loss = 0\n self.accuracy = 0","def _train_epoch(self, epoch: int) -> Dict[str, float]:\n logger.info(\"Epoch %d/%d\", epoch, self._num_epochs - 1)\n peak_cpu_usage = peak_memory_mb()\n logger.info(f\"Peak CPU memory usage MB: {peak_cpu_usage}\")\n gpu_usage = []\n for gpu, memory in gpu_memory_mb().items():\n gpu_usage.append((gpu, memory))\n logger.info(f\"GPU {gpu} memory usage MB: {memory}\")\n\n train_loss = 0.0\n # Set the model to \"train\" mode.\n self.model.train()\n\n num_gpus = len(self._cuda_devices)\n\n # Get tqdm for the training batches\n raw_train_generator = self.iterator(self.train_data,\n num_epochs=1,\n shuffle=self.shuffle)\n train_generator = lazy_groups_of(raw_train_generator, num_gpus)\n num_training_batches = math.ceil(self.iterator.get_num_batches(self.train_data)/num_gpus)\n self._last_log = time.time()\n last_save_time = time.time()\n\n batches_this_epoch = 0\n if self._batch_num_total is None:\n self._batch_num_total = 0\n\n histogram_parameters = set(self.model.get_parameters_for_histogram_tensorboard_logging())\n\n logger.info(\"Training\")\n train_generator_tqdm = Tqdm.tqdm(train_generator,\n total=num_training_batches)\n cumulative_batch_size = 0\n for batch_group in train_generator_tqdm:\n batches_this_epoch += 1\n self._batch_num_total += 1\n batch_num_total = self._batch_num_total\n\n self.optimizer.zero_grad()\n\n output_dict = self.get_output_dict(batch_group, for_training=True)\n loss = self.get_batch_loss(output_dict, for_training=True)\n\n if torch.isnan(loss):\n raise ValueError(\"nan loss encountered\")\n\n loss.backward()\n\n train_loss += loss.item()\n\n batch_grad_norm = self.rescale_gradients()\n\n # This does nothing if batch_num_total is None or you are using a\n # scheduler which doesn't update per batch.\n if self._learning_rate_scheduler:\n self._learning_rate_scheduler.step_batch(batch_num_total)\n if self._momentum_scheduler:\n self._momentum_scheduler.step_batch(batch_num_total)\n\n if self._tensorboard.should_log_histograms_this_batch():\n # get the magnitude of parameter updates for logging\n # We need a copy of current parameters to compute magnitude of updates,\n # and copy them to CPU so large models won't go OOM on the GPU.\n param_updates = {name: param.detach().cpu().clone()\n for name, param in self.model.named_parameters()}\n self.optimizer.step()\n for name, param in self.model.named_parameters():\n param_updates[name].sub_(param.detach().cpu())\n update_norm = torch.norm(param_updates[name].view(-1, ))\n param_norm = torch.norm(param.view(-1, )).cpu()\n self._tensorboard.add_train_scalar(\"gradient_update/\" + name,\n update_norm / (param_norm + 1e-7))\n else:\n self.optimizer.step()\n\n # Update moving averages\n if self._moving_average is not None:\n self._moving_average.apply(batch_num_total)\n\n # Update the description with the latest metrics\n metrics = training_util.get_metrics(self.model, train_loss, batches_this_epoch)\n description = training_util.description_from_metrics(metrics)\n\n train_generator_tqdm.set_description(description, refresh=False)\n\n # Log parameter values to Tensorboard\n if self._tensorboard.should_log_this_batch():\n self._tensorboard.log_parameter_and_gradient_statistics(self.model, batch_grad_norm)\n self._tensorboard.log_learning_rates(self.model, self.optimizer)\n\n self._tensorboard.add_train_scalar(\"loss/loss_train\", metrics[\"loss\"])\n self._tensorboard.log_metrics({\"epoch_metrics/\" + k: v for k, v in metrics.items()})\n\n if self.tensorboard_log_batch_callback:\n self.tensorboard_log_batch_callback(output_dict, self._tensorboard)\n\n if self._tensorboard.should_log_histograms_this_batch():\n self._tensorboard.log_histograms(self.model, histogram_parameters)\n\n if self._log_batch_size_period:\n cur_batch = sum([training_util.get_batch_size(batch) for batch in batch_group])\n cumulative_batch_size += cur_batch\n if (batches_this_epoch - 1) % self._log_batch_size_period == 0:\n average = cumulative_batch_size/batches_this_epoch\n logger.info(f\"current batch size: {cur_batch} mean batch size: {average}\")\n self._tensorboard.add_train_scalar(\"current_batch_size\", cur_batch)\n self._tensorboard.add_train_scalar(\"mean_batch_size\", average)\n\n # Save model if needed.\n if self._model_save_interval is not None and (\n time.time() - last_save_time > self._model_save_interval\n ):\n last_save_time = time.time()\n self._save_checkpoint(\n '{0}.{1}'.format(epoch, training_util.time_to_str(int(last_save_time)))\n )\n metrics = training_util.get_metrics(self.model, train_loss, batches_this_epoch, reset=True)\n metrics['cpu_memory_MB'] = peak_cpu_usage\n for (gpu_num, memory) in gpu_usage:\n metrics['gpu_'+str(gpu_num)+'_memory_MB'] = memory\n return metrics","def test_epoch_monitor():\n dim = 1\n batch_size = 3\n n_batches = 10\n m = n_batches * batch_size\n\n dataset = ArangeDataset(m)\n model = SoftmaxModel(dim)\n monitor = Monitor.get_monitor(model)\n learning_rate = 1e-3\n data_specs = (model.get_input_space(), model.get_input_source())\n cost = DummyCost()\n termination_criterion = EpochCounter(1)\n\n monitor_rate = 3\n em = EpochMonitor(model=model,\n tick_rate=None,\n monitor_rate=monitor_rate)\n\n algorithm = SGD(learning_rate,\n cost,\n batch_size=batch_size,\n train_iteration_mode='sequential',\n monitoring_dataset=dataset,\n termination_criterion=termination_criterion,\n update_callbacks=[em],\n set_batch_size=False)\n\n algorithm.setup(dataset=dataset, model=model)\n algorithm.train(dataset)\n\n for key, val in monitor.channels.items():\n assert len(val.val_record) == n_batches//monitor_rate","def init_metrics():\n metrics = defaultdict(list)\n metrics['best_acc'] = 0.0\n metrics['best_loss'] = float('inf')\n metrics['best_epoch'] = 0\n return metrics","def set_metrics(metric_dict, cd_loss, cd_corrects, cd_report):\n metric_dict['cd_losses'].append(cd_loss.item())\n metric_dict['cd_corrects'].append(cd_corrects.item())\n metric_dict['cd_precisions'].append(cd_report[0])\n metric_dict['cd_recalls'].append(cd_report[1])\n metric_dict['cd_f1scores'].append(cd_report[2])\n\n return metric_dict","def set_epoch(self, epoch):\n self.epoch = epoch","def _train_epoch(self, epoch):\n self.model.train()\n\n\n total_loss = 0\n total_metrics = np.zeros(len(self.metrics))\n length = len(self.data_loader)\n total_pm25_loss = 0\n total_pm10_loss = 0\n pm25_loss = 0\n pm10_loss = 0\n\n for batch_idx, (data, target) in enumerate(self.data_loader):\n data, target = data.to(self.device), target.to(self.device)\n\n self.optimizer.zero_grad()\n output = self.model(data)\n # print(output.shape, target.shape)\n target = target.squeeze()\n model_loss = self.loss(output, target)\n\n # print(output.shape, target.shape)\n # pm25_predict, pm10_predict = torch.chunk(output, 2, dim=1)\n # pm25_target, pm10_target = torch.chunk(target, 2, dim=1)\n # pm25_loss = self.loss(pm25_predict, pm25_target)\n # pm10_loss = self.loss(pm10_predict, pm10_target)\n # total_pm25_loss += pm25_loss.item()\n # total_pm10_loss += pm10_loss.item()\n\n l2_reg = torch.tensor(0.0).to(self.device)\n if self.config['trainer']['l2_regularization']:\n for param in self.model.parameters():\n l2_reg += torch.norm(param, p=2)\n loss = model_loss + self.config['trainer']['l2_lambda'] * l2_reg\n else:\n loss = model_loss\n\n loss.backward()\n # torch.nn.utils.clip_grad_norm(self.model.parameters(), 1)\n self.optimizer.step()\n\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\n self.writer.add_scalar('loss', loss.item())\n total_loss += loss.item()\n # total_metrics += self._eval_metrics(output, target)\n\n if batch_idx % self.log_step == 0:\n self.logger.debug('Train Epoch: {} {} Loss: {:.6f} model_loss: {:.6f} pm25_loss {:.6f} pm10_loss {:.6f} l2_loss: {:.6f}'.format(\n epoch,\n self._progress(batch_idx),\n loss.item(),\n model_loss.item(),\n pm25_loss,\n pm10_loss,\n l2_reg.item()))\n\n if batch_idx == self.len_epoch:\n break\n\n log = {\n 'loss': total_loss / length,\n 'rmse_pm25_loss': np.sqrt(total_pm25_loss / length),\n 'rmse_pm10_loss': np.sqrt(total_pm10_loss / length)\n }\n\n\n val_log = self._valid_epoch(epoch)\n log.update(val_log)\n\n if self.lr_scheduler is not None:\n self.lr_scheduler.step(val_log['val_loss'])\n\n return log","def on_epoch_end(self, epoch, logs=None):","def on_epoch_end(self, epoch, logs=None):","def build_metrics_dict(node):\n\n # Initialize tensors\n n = 0\n n = _recv(n,node)\n keys = [[0 for j in range(8)] for i in range(n)] # max_seq_len for metric name is 8\n values = [0.0 for i in range(n)]\n higher_is_better = [0 for i in range(n)]\n\n # Read data\n keys = _recv(keys,node)\n values = _recv(values,node)\n higher_is_better = _recv(higher_is_better,node)\n\n # Reorganize output + decode dict keys\n orig_keys = [encode_string(key, string_to_int=False) for key in keys]\n values_dict = [{'value': float(v), 'higher_is_better': bool(higher_is_better[i])} for i, v in enumerate(values)]\n metrics = dict(zip(orig_keys,values_dict))\n num_instances = int(metrics.pop('num')['value'])\n\n result = None, metrics, num_instances\n \n return result","def get(self):\n if self.num_examples <= 0:\n raise ValueError(\"total_sample must be positive.\")\n avg_hit_at_one = self.sum_hit_at_one / self.num_examples\n avg_perr = self.sum_perr / self.num_examples\n avg_loss = self.sum_loss / self.num_examples\n\n epoch_info_dict = {\"avg_hit_at_one\": avg_hit_at_one, \n \"avg_perr\": avg_perr,\n \"avg_f1score\": avg_f1score,\n \"avg_f2score\": avg_f2score,\n \"avg_loss\": avg_loss}\n return epoch_info_dict","def on_epoch_end(self, epoch: int, logs: dict):\n # Metric calculated once per \"n\" epochs\n metric = logs.get(self.metric, 0.0)\n\n if self.mode == \"max\":\n if metric > self.thresh:\n self.model.model.save(\n f\"{self.path}/model_{epoch+1:04d}_{metric:.4f}.h5\"\n )\n K.set_value(self.thresh, metric)\n\n elif self.mode == \"min\":\n if metric < self.thresh:\n self.model.model.save(\n f\"{self.path}/model_{epoch+1:04d}_{metric:.4f}.h5\"\n )\n K.set_value(self.thresh, metric)\n else:\n raise NotImplementedError(\n f\"{self.mode} mode has not been implemented for this callback\"\n )\n\n return super().on_epoch_end(epoch, logs=logs)","def after_evaluation(self, epoch, **kw):\n if self.loss_txt is not None:\n self.current_row[MetricName(\"timestamp\")] = f\"{datetime.now():%H:%M:%S}\"\n\n # output log file\n with open(self.loss_txt, \"a\") as f:\n # remove columns where no value was found on the first epoch (could be != 1 if training was resumed)\n if epoch == self.first_epoch:\n for k in list(self.headers.keys()):\n if k not in self.current_row:\n del self.headers[k]\n\n # make headers on epoch 1\n if epoch == 1:\n # write header\n f.write(\"\\t\".join(self.headers.values()) + \"\\n\")\n\n for col in self.headers:\n assert col in self.current_row, str(col) + \" \" + str(self.current_row.keys())\n\n assert all(col in self.current_row for col in self.headers)\n\n f.write(\"\\t\".join([str(self.current_row[col]) for col in self.headers]) + \"\\n\")\n\n self.current_row = {}","def refresh_stats(self) -> None:\n try:\n self._mallctl(\"epoch\", read=False, write=1)\n except Exception as e:\n logger.warning(\"Failed to reload jemalloc stats: %s\", e)","def _valid_epoch(self, epoch):\n self.model.eval()\n self.valid_metrics.reset()\n with torch.no_grad():\n for batch_idx, (data, target) in enumerate(self.valid_data_loader):\n data, target = data.to(self.device), target.to(self.device)\n\n output = self.model(data)\n loss = self.criterion(output, target)\n\n self.writer.set_step(\n (epoch - 1) * len(self.valid_data_loader) + batch_idx, \"valid\"\n )\n self.valid_metrics.update(\"loss\", loss.item())\n for met in self.metric_ftns:\n self.valid_metrics.update(met.__name__, met(output, target))\n self.writer.add_image(\n \"input\", make_grid(data.cpu(), nrow=8, normalize=True)\n )\n\n # add histogram of model parameters to the tensorboard\n for name, p in self.model.named_parameters():\n self.writer.add_histogram(name, p, bins=\"auto\")\n return self.valid_metrics.result()","def update(self, feed_dict=None):\n if feed_dict is None:\n feed_dict = {}\n\n for key, value in six.iteritems(self.data):\n if isinstance(key, tf.Tensor) and \"Placeholder\" in key.op.type:\n feed_dict[key] = value\n\n sess = get_session()\n t = sess.run(self.increment_t)\n\n if self.debug:\n sess.run(self.op_check)\n\n if self.logging and self.n_print != 0:\n if t == 1 or t % self.n_print == 0:\n summary = sess.run(self.summarize, feed_dict)\n self.train_writer.add_summary(summary, t)\n\n return {'t': t}","def _evaluate_during_fit(self, test_loader, epoch):","def after_val_epoch(self,\n runner,\n metrics: Optional[Dict[str, float]] = None) -> None:\n tag, log_str = runner.log_processor.get_log_after_epoch(\n runner, len(runner.val_dataloader), 'val')\n runner.logger.info(log_str)\n if self.log_metric_by_epoch:\n # Accessing the epoch attribute of the runner will trigger\n # the construction of the train_loop. Therefore, to avoid\n # triggering the construction of the train_loop during\n # validation, check before accessing the epoch.\n if (isinstance(runner._train_loop, dict)\n or runner._train_loop is None):\n epoch = 0\n else:\n epoch = runner.epoch\n runner.visualizer.add_scalars(\n tag, step=epoch, file_path=self.json_log_path)\n else:\n if (isinstance(runner._train_loop, dict)\n or runner._train_loop is None):\n iter = 0\n else:\n iter = runner.iter\n runner.visualizer.add_scalars(\n tag, step=iter, file_path=self.json_log_path)","def on_epoch_end(self):\n self.epoch += 1\n metric = self.metric_fn()\n if metric < self.best:\n self.best = metric\n self.count = 0\n else:\n self.count += 1\n if self.count > self.patience:\n self.model.stop_training()\n if self.verbose:\n print(self.name+' after '+str(self.epoch)+' epochs')","def compute_epoch_statistics(self, output_dict):\n epoch_statistics = {\n \"auc\": roc_auc_score(\n output_dict[\"labels\"].cpu().numpy(),\n output_dict[\"pred_probs\"][:, 1].cpu().numpy(),\n ),\n \"auprc\": average_precision_score(\n output_dict[\"labels\"].cpu().numpy(),\n output_dict[\"pred_probs\"][:, 1].cpu().numpy(),\n ),\n \"brier\": brier_score_loss(\n output_dict[\"labels\"].cpu().numpy(),\n output_dict[\"pred_probs\"][:, 1].cpu().numpy(),\n ),\n }\n\n return epoch_statistics","def update(self, data: Mapping[str, np.ndarray]) -> Self:\n\n for metric in self.metrics:\n metric.update(data)\n\n return self","def init_metrics(self):\n\n self.metrics = {}\n\n self.metrics['train_loss'] = np.zeros(0)\n self.metrics['test_loss'] = np.zeros(0)\n\n # self.orth_clf = LinearDecoder(self, self.q_, MeanClassifier)\n # self.metrics['train_orthogonality'] = np.zeros(0)\n # self.metrics['test_orthogonality'] = np.zeros(0)\n\n self.metrics['train_parallelism'] = np.zeros((0,self.q_)) \n self.metrics['test_parallelism'] = np.zeros((0,self.q_))","def _train_epoch(self, epoch):\n raise NotImplementedError","def _train_epoch(self, epoch):\n raise NotImplementedError","def _train_epoch(self, epoch):\n raise NotImplementedError","def _train_epoch(self, epoch):\n raise NotImplementedError","def train_epoch(self, epoch, evaluator, optimizer, perf_path, perf_trace, state_fpath, writer_tensorboard):\n\n # Train an epoch\n self.model.train()\n print('Start epoch', epoch)\n train_itr = iter(self.loader_train)\n total_err = 0\n total_acc = 0\n\n for index, (data_pixel, data_labels) in enumerate(train_itr):\n\n # compute\n input_data = data_pixel.float().cuda()\n data_labels = data_labels.cuda()\n\n # Use the model the produce the classification\n grapheme_logits, vowel_logits, consonant_logits = self.model(input_data)\n\n # produce evaluator results\n eval_result = evaluator(grapheme_logits, vowel_logits, consonant_logits, data_labels)\n\n # set optimizer to zero.\n optimizer.zero_grad()\n\n # back propogate the evaluation results.\n eval_result['loss'].backward()\n\n # optimizer take step forward.\n optimizer.step()\n\n # tabulate the steps from the evaluation\n eval_result = {k: eval_result[k].item() for k in eval_result}\n\n # update every hundreds' of\n if index % 100 == 0:\n print(index, eval_result['loss'], eval_result['acc'])\n train_result = evaluator.evalulate_on_cache()\n train_total_err = train_result['loss']\n writer_tensorboard.add_scalar('Loss/Train', train_total_err, global_step=epoch)\n # log_metric('loss', train_total_err)\n train_total_acc = train_result['acc']\n writer_tensorboard.add_scalar('Accuracy/Train', train_total_acc, global_step=epoch)\n # log_metric('acc', train_total_acc)\n train_kaggle_score = train_result['kaggle_score']\n writer_tensorboard.add_scalar('Kaggle_Score/Train', train_kaggle_score, global_step=epoch)\n # log_metric('kaggle_score', train_kaggle_score)\n dict_metrics_train = {\n 'Loss/Train': train_total_err,\n 'Accuracy/Train': train_total_acc,\n 'Kaggle_Score/Train': train_kaggle_score,\n }\n log_metrics(dict_metrics_train, step=epoch)\n print(f\"Epoch {epoch} Training, Loss {train_total_err}, Acc {train_total_acc}\")\n evaluator.clear_cache()\n # compute validation error\n self.model.eval()\n val_itr = iter(self.loader_val)\n with torch.no_grad():\n for index, (data_pixel, data_labels) in enumerate(val_itr):\n input_data = data_pixel.float().cuda()\n data_labels = data_labels.cuda()\n grapheme_logits, vowel_logits, consonant_logits = self.model(input_data)\n eval_result = evaluator(grapheme_logits, vowel_logits, consonant_logits, data_labels)\n eval_result = {k: eval_result[k].item() for k in eval_result}\n total_err += eval_result['loss']\n total_acc += eval_result['acc']\n # print(total_err / (1 + input_index), total_acc / (1 + input_index))\n val_result = evaluator.evalulate_on_cache()\n val_total_err = val_result['loss']\n writer_tensorboard.add_scalar('Loss/Val', val_total_err, global_step=epoch)\n val_total_acc = val_result['acc']\n writer_tensorboard.add_scalar('Accuracy/Val', val_total_acc, global_step=epoch)\n val_kaggle_score = val_result['kaggle_score']\n writer_tensorboard.add_scalar('Kaggle_Score/Val', val_kaggle_score, global_step=epoch)\n dict_metrics_val = {\n 'Loss/Validation': val_total_err,\n 'Accuracy/Validation': val_total_acc,\n 'Kaggle_Score/Validation': val_kaggle_score,\n }\n log_metrics(dict_metrics_val, step=epoch)\n # Write to disk.\n writer_tensorboard.flush()\n print(f\"Epoch {epoch} Eval, Loss {val_total_err}, Acc {val_total_acc}\")\n evaluator.clear_cache()\n print(\"Saving the model (epoch %d)\" % epoch)\n torch.save({\n \"epoch\": epoch + 1,\n \"model_state\": self.model.state_dict(),\n \"optimizer_state\": optimizer.state_dict(),\n }, state_fpath)\n print(f\"Making a backup (step {epoch})\")\n backup_fpath = os.path.join(self.backup_dir, f\"model_bak_{epoch}.pt\")\n torch.save({\n \"epoch\": epoch + 1,\n \"model_state\": self.model.state_dict(),\n \"optimizer_state\": optimizer.state_dict(),\n }, backup_fpath)\n # Dump the traces\n perf_trace.append(\n {\n 'epoch': epoch,\n 'train_err': train_total_err,\n 'train_acc': train_total_acc,\n 'train_kaggle_score': train_kaggle_score,\n 'val_err': val_total_err,\n 'val_acc': val_total_acc,\n 'val_kaggle_score': val_kaggle_score\n }\n )\n pickle.dump(perf_trace, open(perf_path, 'wb'))\n # store epoch full result separately\n epoch_result = {\n 'epoch': epoch,\n 'train_result': train_result,\n 'val_result': val_result\n }\n pickle.dump(epoch_result, open(os.path.join(self.results_dir, 'result_epoch_{0}.p'.format(epoch)), 'wb'))","def calculate_batch_metrics(self):\n pass","def _AddMetric(self, metric):\n machine = metric.machine_id\n time = metric.timestamp\n payload = DotDict(json.loads(metric.payload)).flatten()\n\n self.machines.add(machine)\n self.timestamps.add(time)\n for k in payload:\n if k not in self.counter_data:\n continue\n val = payload.get(k, None)\n if val is not None:\n self.counter_data[k].AddSample(machine, time, val)","def on_epoch_end(self, epoch: int, logs: dict = None):\n if logs is None:\n logs = {}\n\n # reset the index\n self.model.reset_index()\n\n # rebuild the index\n self.model.index(self.targets, self.target_labels, verbose=0)\n\n results = _compute_classification_metrics(\n queries=self.queries,\n query_labels=self.query_labels,\n model=self.model,\n evaluator=self.evaluator,\n metrics=self.metrics,\n k=self.k,\n matcher=self.matcher,\n distance_thresholds=self.distance_thresholds)\n\n mstr = []\n for metric_name, vals in results.items():\n float_val = vals[0]\n logs[metric_name] = float_val\n mstr.append(f'{metric_name}: {float_val:.4f}')\n if self.tb_writer:\n with self.tb_writer.as_default():\n tf.summary.scalar(metric_name, float_val, step=epoch)\n\n # reset the index to prevent users from accidently using this after the\n # callback\n self.model.reset_index()\n\n print(' - '.join(mstr))","def on_test_epoch_end(self) -> None:\n self.log_dict(self.test_metrics.compute())\n self.test_metrics.reset()","def initialize(self, runInfo, inputs, initDict) :\n super().initialize(runInfo, inputs, initDict)\n for metricIn in self.assemblerDict['Metric']:\n self.metricsDict[metricIn[2]] = metricIn[3]","def init_metrics(losses):\n metrics = {'train': {}, 'valid': {}}\n for mode, d in metrics.items():\n metrics[mode] = dict([(k, 0) for k in losses])\n\n return metrics","def add_metrics(_dict):\n for key, itr in _dict.items():\n if key not in self.metric_cols:\n self.metric_cols.append(key)","def _train_epoch(self, epoch):\n self.model.train()\n self.train_metrics.reset()\n for batch_idx, (data, target_seg, target_class) in enumerate(self.data_loader):\n data, target_seg, target_class = data.to(self.device), target_seg.to(self.device), target_class.to(self.device)\n\n self.optimizer.zero_grad()\n output_seg, output_class = self.model(data)\n loss = self.criterion((output_seg, output_class), target_seg, target_class, epoch)\n loss.backward()\n self.optimizer.step()\n\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\n self.train_metrics.update('loss', loss.item())\n for met in self.metric_ftns:\n if met.__name__ == \"accuracy\":\n self.train_metrics.update(met.__name__, met(output_class, target_class))\n else:\n self.train_metrics.update(met.__name__, met(output_seg, target_seg))\n\n if batch_idx % self.log_step == 0:\n self.logger.debug('Train Epoch: {} {} Loss: {:.6f}'.format(\n epoch,\n self._progress(batch_idx),\n loss.item()))\n\n self._visualize_input(data.cpu())\n\n if batch_idx == self.len_epoch:\n break\n log = self.train_metrics.result()\n\n if self.do_validation:\n val_log = self._valid_epoch(epoch)\n log.update(**{'val_'+k : v for k, v in val_log.items()})\n\n if self.lr_scheduler is not None:\n self.lr_scheduler.step()\n\n return log","def set_metrics(self):","def _valid_epoch(self, epoch):\n self.model.eval()\n self.valid_metrics.reset()\n with torch.no_grad():\n for batch_idx, (data, target_seg, target_class) in enumerate(self.valid_data_loader):\n data, target_seg, target_class = data.to(self.device), target_seg.to(self.device), target_class.to(self.device)\n\n output_seg, output_class = self.model(data)\n loss = self.criterion((output_seg, output_class), target_seg, target_class, epoch)\n\n self.writer.set_step((epoch - 1) * len(self.valid_data_loader) + batch_idx, 'valid')\n self.valid_metrics.update('loss', loss.item())\n for met in self.metric_ftns:\n if met.__name__ == \"accuracy\":\n self.valid_metrics.update(met.__name__, met(output_class, target_class))\n else:\n self.valid_metrics.update(met.__name__, met(output_seg, target_seg))\n\n data_cpu = data.cpu()\n self._visualize_input(data_cpu)\n self._visualize_prediction(data_cpu, output_seg.cpu(), target_seg.cpu())\n\n # add histogram of model parameters to the tensorboard\n for name, p in self.model.named_parameters():\n self.writer.add_histogram(name, p, bins='auto')\n return self.valid_metrics.result()","def __call__(self, trainer, epoch):\n if epoch >= self.ignore_before:\n if epoch - self.best_epoch < self.patience:\n if isinstance(self.retain_metric, str):\n current_res = trainer.val_metrics[self.retain_metric][-1]\n else:\n current_res = trainer.val_metrics[self.retain_metric.__name__][-1]\n if self.window is None:\n if self._has_improved(current_res):\n self.best_epoch = epoch\n self.best_res = current_res\n trainer.best_metric = current_res\n trainer.best_model = trainer.model\n else: # window mod\n # get validation metrics in certain window\n try:\n if isinstance(self.retain_metric, str):\n start = len(trainer.val_metrics[self.retain_metric]) - self.window\n start = 0 if start < 0 else start\n\n window_val_metrics = trainer.val_metrics[self.retain_metric][start:]\n else:\n start = len(trainer.val_metrics[self.retain_metric.__name__]) - self.window\n start = 0 if start < 0 else start\n window_val_metrics = trainer.val_metrics[self.retain_metric.__name__][start:]\n except KeyError:\n print(\n \"Couldn't find {} in validation metrics. Using \\\n loss instead.\".format(\n self.retain_metric\n )\n )\n start = len(trainer.val_metrics[self.retain_metric]) - self.window\n start = 0 if start < 0 else start\n window_val_metrics = trainer.val_metrics[\"loss\"][start:]\n\n # build mean\n mean_window_res = np.mean(window_val_metrics)\n\n # only safe when improvement to previous epoch detected\n # only a value BETTER than before can be the minimum/maximum of a\n # window with better mean than a previously detected window\n if len(window_val_metrics) == 1 \\\n or self._first_val_better(window_val_metrics[-1], window_val_metrics[-2]) \\\n or self._current_window_save_idx == -1:\n if self._current_window_save_idx == -1:\n self._current_window_save_idx = 0\n self._state_dict_storage[self._current_window_save_idx] = deepcopy(trainer.model.state_dict())\n # increase save idx and take modulo\n self._current_window_save_idx += 1\n self._current_window_save_idx = divmod(self._current_window_save_idx, self.window)[1]\n else: # only increase current_window_save_idx (for modulo index calculation to work)\n self._current_window_save_idx += 1\n self._current_window_save_idx = divmod(self._current_window_save_idx, self.window)[1]\n\n # always update current window best result - it might be at some point overall best result\n current_window_best_idx = self._get_cur_win_best_idx(window_val_metrics)\n if current_window_best_idx == len(window_val_metrics) - 1 \\\n or self._current_window_best_res == -1: # case of improvement or initialisation\n # overwrite model_state saved so far\n self._current_window_best_model_save_idx = self._current_window_save_idx\n self._current_window_best_epoch = epoch\n self._current_window_best_res = window_val_metrics[-1]\n\n # check if mean has improved and copy values as best model result\n if self._has_window_mean_improved(mean_window_res):\n self.best_mean_res = mean_window_res\n self.best_window_start = 0 if epoch - self.window + 1 < 0 else epoch - self.window + 1\n # save current window best as overall best\n self.best_res = self._current_window_best_res\n self.best_model = copy.deepcopy(self._state_dict_storage[self._current_window_best_model_save_idx])\n self.best_epoch = self._current_window_best_epoch\n trainer.best_metric = self._current_window_best_res\n trainer.best_model = trainer.model\n if self.info:\n print(\"Found a window with better validation metric mean:\")\n print(\"\\t metric mean: {}\".format(mean_window_res))\n print(\"\\t epoch start: {}\".format(self.best_window_start))\n print(\"\\t best result: {}\".format(self.best_res))\n\n else:\n # end training run\n trainer.stop_training = True\n if self.window is None:\n print(\"Early stopping at epoch {}.\\nBest model was at epoch {} with val metric score = {}\".format(\n epoch, self.best_epoch, self.best_res)\n )\n else:\n print(\"Early stopping with window mode at epoch {}.\\n\"\n \"Best results were achieved at epoch {} with val metric score = {}.\\n\"\n \"Best window of size {} achieved a mean result of {} and started at epoch {}.\".format(\n epoch, self.best_epoch, self.best_res, self.window, self.best_mean_res, self.best_window_start)\n )","def on_epoch_start(self):","def _train_epoch(self, epoch):\n self.model.train()\n self.train_metrics.reset()\n for batch_idx, (data, target) in enumerate(self.data_loader):\n data, target = data.to(self.device), target.to(self.device)\n\n self.optimizer.zero_grad()\n\n if self.config[\"amp\"]:\n # AMP!\n with autocast():\n output = self.model(data)\n loss = self.criterion(output, target)\n else:\n output = self.model(data)\n loss = self.criterion(output, target)\n\n loss.backward()\n self.optimizer.step()\n\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\n self.train_metrics.update(\"loss\", loss.item())\n for met in self.metric_ftns:\n self.train_metrics.update(met.__name__, met(output, target))\n\n if batch_idx % self.log_step == 0:\n self.logger.debug(\n \"Train Epoch: {} {} Loss: {:.6f}\".format(\n epoch, self._progress(batch_idx), loss.item()\n )\n )\n self.writer.add_image(\n \"input\", make_grid(data.cpu(), nrow=8, normalize=True)\n )\n\n if batch_idx == self.len_epoch:\n break\n log = self.train_metrics.result()\n\n if self.do_validation:\n val_log = self._valid_epoch(epoch)\n log.update(**{\"val_\" + k: v for k, v in val_log.items()})\n\n if self.lr_scheduler is not None:\n self.lr_scheduler.step()\n return log","def train_epoch(self, epoch):\n device_mapper = self.device_mapper\n self.model.train()\n self.train_metrics.reset()\n for batch_idx, data in enumerate(self.data_loader):\n data = device_mapper.map_modules(data, non_blocking=True)\n\n self.optimizer.zero_grad()\n output = self.model(data)\n loss = self.loss(output, data)\n loss.backward()\n self.optimizer.step()\n\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\n self.train_metrics.update('loss', loss.item(), batch_size=output.size(0))\n for met in self.metrics:\n self.train_metrics.update(met.name(), met(output, data), batch_size=output.size(0))\n\n if batch_idx % self.log_step == 0:\n self.logger.debug('Train Epoch: %d %s Loss: %.6f', epoch, self._progress(batch_idx), loss.item())\n\n if batch_idx == self.len_epoch:\n break\n log = self.train_metrics.result()\n\n if self.do_validation:\n val_log = self.valid_epoch(epoch)\n log.update(**{'val_' + k: v for k, v in val_log.items()})\n\n if self.lr_scheduler is not None:\n if isinstance(self.lr_scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau):\n self.lr_scheduler.step(log[\"val_roc_auc\"])\n else:\n self.lr_scheduler.step()\n return log","def __call__(self, epoch):\n # Compute the new dynamic learning rate, log in onto TensorBoard and\n # return the result for the training process\n learning_rate = self.schedule(epoch)\n tf.summary.scalar('learning rate', data=learning_rate, step=epoch)\n return learning_rate","def write_training_metrics(self) -> None:\n self.trainer_metrics.write_training_metrics()","def test_metrics_on_restart(fake_training_fn, tmpdir):\n\n fake_training = fake_training_fn(tmpdir)\n assert fake_training()\n\n t1_values = {\n metric.name: get_metric_data(metric, tmpdir)\n for metric in fake_training.trainer._metrics\n }\n print(t1_values)\n\n restart = fake_training_fn(tmpdir)\n\n t2_values = {\n metric.name: get_metric_data(metric, tmpdir)\n for metric in restart.trainer._metrics\n }\n print(t2_values)\n assert t1_values == t2_values","def update(self, y_true: list[Number], y_pred: list[Number]) -> ForecastingMetric:","def training_epoch_end(self, outputs: Any) -> None:\n self.log_dict(self.train_metrics.compute())\n self.train_metrics.reset()","def on_epoch_end(self, trainer, pl_module):\n self._log_epoch_metrics(trainer, pl_module)","def update(self, step, metrics):\n self.steps_arr.append(step)\n for key, val in metrics.items():\n if isinstance(val, tf.Tensor):\n try:\n self.data[key].append(val.numpy())\n except KeyError:\n self.data[key] = [val.numpy()]","def epoch(self):\n old_vals = (self._controller.kp, self._controller.ki, self._controller.kd)\n gamma = 0.01\n grad = self._get_gradient()\n\n new_vals = [p - gamma*g for p, g in zip(old_vals, grad)]\n\n self._controller.kp = new_vals[0] if new_vals[0] > 0 else 0\n self._controller.ki = new_vals[1] if new_vals[1] > 0 else 0\n self._controller.kd = new_vals[2] if new_vals[2] > 0 else 0","def update_history(self, start_training, start_epoch, epoch, res_trackers_dict):\n self.history.get('epoch_index', []).append(epoch+1)\n self.history.get('time_epoch', []).append(time.time()-start_epoch)\n self.history.get('time_cumulative', []).append(time.time()-start_training)\n\n self.history.get('train', {}).get('gen_loss', []).append(res_trackers_dict['loss_tracker_train_gen'])\n self.history.get('train', {}).get('gen_mae', []).append(res_trackers_dict['metric_tracker_train_gen'])\n self.history.get('train', {}).get('disc_loss', []).append(res_trackers_dict['loss_tracker_train_disc'])\n self.history.get('train', {}).get('disc_acc', []).append(res_trackers_dict['metric_tracker_train_disc'])\n\n self.history.get('val', {}).get('gen_loss', []).append(res_trackers_dict['loss_tracker_val_gen'])\n self.history.get('val', {}).get('gen_mae', []).append(res_trackers_dict['metric_tracker_val_gen'])\n self.history.get('val', {}).get('disc_loss', []).append(res_trackers_dict['loss_tracker_val_disc'])\n self.history.get('val', {}).get('disc_acc', []).append(res_trackers_dict['metric_tracker_val_disc'])","def update_training_dict(self, feed_dict):\n self._update_with_dual(feed_dict, 'hebb_init_pl') # re-initialize hebbian at the start of episode\n self._update_with_dual(feed_dict, 'init_pl') # re-initialize rnn state at the start of episode\n self._update_with_dual(feed_dict, 'mask') # mask","def _valid_epoch(self, epoch):\n self.model.eval()\n self.valid_metrics.reset()\n with torch.no_grad():\n for batch_idx, (data, target, _) in enumerate(self.valid_data_loader):\n data, target = data.to(device=self.device, dtype=torch.float), target.to(self.device, dtype=torch.float)\n\n output = self.model(data)\n\n if self.only_scored_classes:\n # Only consider classes that are scored with the Challenge metric.\n if self.config[\"loss\"][\"type\"] == \"weighted_bce_with_logits_loss\":\n loss = self.criterion(output[:, self.indices], target[:, self.indices], self.weights)\n else:\n loss = self.criterion(output[:, self.indices], target[:, self.indices])\n else:\n loss = self.criterion(output, target)\n\n self.writer.set_step((epoch - 1) * len(self.valid_data_loader) + batch_idx, 'valid')\n self.valid_metrics.update('loss', loss.item())\n\n output_logit = self.sigmoid(output)\n for met in self.metric_ftns:\n self.valid_metrics.update(met.__name__, met(self._to_np(output_logit), self._to_np(target)))\n # self.writer.add_image('input', make_grid(data.cpu(), nrow=8, normalize=True))\n\n if self.lr_scheduler is not None and self.config[\"lr_scheduler\"][\"type\"] == \"ReduceLROnPlateau\":\n self.lr_scheduler.step(self.valid_metrics.result()[\"challenge_metric\"])\n\n # add histogram of model parameters to the tensorboard\n # for name, p in self.model.named_parameters():\n # self.writer.add_histogram(name, p, bins='auto')\n return self.valid_metrics.result()","def add_metrics(self, metrics):\n for i, metric in enumerate(self.config.metrics):\n tf.summary.scalar(metric, metrics[i])","def plot_metrics_over_iterations(metrics, epoch):\n total_elbo, total_cond_log_like, total_kl = metrics\n legend = ['ELBO', 'log p(x | z)']\n\n for level in range(len(total_kl)):\n legend.append('KL Divergence, Level ' + str(level))\n\n nans = np.zeros((1, 2 + len(total_kl)))\n nans.fill(np.nan)\n indices = np.ones((1, 2 + len(total_kl)))\n\n handle = plot_line(nans, indices, legend=legend,\n title='Average Metrics During Inference Iterations, Epoch ' + str(epoch),\n xlabel='Inference Iterations', ylabel='Metrics (Nats)')\n\n iterations = np.arange(0, total_elbo.shape[1]).astype(int)\n\n ave_elbo = np.mean(total_elbo, axis=0)\n update_trace(ave_elbo, iterations, win=handle, name='ELBO')\n\n ave_recon = np.mean(total_cond_log_like, axis=0)\n update_trace(ave_recon, iterations, win=handle, name='log p(x | z)')\n\n for level in range(len(total_kl)):\n ave_kl = np.mean(total_kl[level], axis=0)\n update_trace(ave_kl, iterations, win=handle, name='KL Divergence, Level ' + str(level))","def save_to_json(self, dir_to_save):\n\n # Check that folder is exitsts or create it\n os.makedirs(dir_to_save, exist_ok=True)\n json_filename = os.path.join(dir_to_save, \"epoch_metrics.json\")\n # fill the dict\n metrics_dict = {\n \"train_mIoU\": str(self.train_mIoU.result().numpy()),\n \"val_mIoU\": str(self.val_mIoU.result().numpy()),\n \"train_loss\": str(self.train_loss.result().numpy()),\n \"val_loss\": str(self.val_loss.result().numpy()),\n \"train_accuracy\": str(self.train_accuracy.result().numpy()),\n \"val_accuracy\": str(self.val_accuracy.result().numpy()),\n \"train_confusion_matrix\": self.train_mIoU.total_cm.numpy().tolist(),\n \"val_confusion_matrix\": self.val_mIoU.total_cm.numpy().tolist(),\n }\n save_to_json(json_filename, metrics_dict)","def on_validation_epoch_end(self, trainer, pl_module):\n self._log_epoch_metrics(trainer, pl_module)","def on_epoch_end(self, epoch, logs={}):\n self.losses.append(logs.get(\"loss\"))\n self.val_losses.append(logs.get(\"val_loss\"))","def on_epoch_start(self):\n self.current_epoch += 1\n self.current_lr = self.fn(self.current_epoch)\n self.model.set_learning_rate(self.current_lr)\n self.epochs += [self.current_epoch]\n self.learning_rate += [self.current_lr]","def training_metrics(self):\r\n if self._training_metrics is None:\r\n # Builds the per-task metrics and losses.\r\n self._training_metrics = {}\r\n for name, task in self.multi_task.tasks.items():\r\n self._training_metrics[name] = task.build_metrics(training=True)\r\n return self._training_metrics","def evaluate_epoch(eval_dl, model, criterion, epoch, writer):\n print('\\neval epoch {}'.format(epoch))\n device = next(model.parameters()).device\n\n model.eval()\n recall = Recall(lambda x: (x[0], x[1]))\n precision = Precision(lambda x: (x[0], x[1]))\n mean_recall = []\n mean_precision = []\n mean_loss = []\n with torch.no_grad():\n for idx, (inputs, targets) in enumerate(eval_dl):\n inputs, targets = inputs.to(device), targets.to(device)\n outputs = model(inputs)\n loss = criterion(outputs, targets)\n\n preds = outputs.argmax(1)\n\n precision.update((preds, targets))\n recall.update((preds, targets))\n mean_loss.append(loss.item())\n mean_recall.append(recall.compute().item())\n mean_precision.append(precision.compute().item())\n\n # print('val-epoch:{} [{}/{}], loss: {:5.3}'.format(epoch, idx + 1, len(dataloader), loss.item()))\n writer.add_scalar('test/loss', loss.item(), len(eval_dl) * epoch + idx)\n\n mean_precision, mean_recall = np.array(mean_precision).mean(), np.array(mean_recall).mean()\n f1 = mean_precision * mean_recall * 2 / (mean_precision + mean_recall + 1e-20)\n\n print('precision: {:07.5}, recall: {:07.5}, f1: {:07.5}\\n'.format(mean_precision, mean_recall, f1))\n writer.add_scalar('test/epoch-loss', np.array(mean_loss).mean(), epoch)\n writer.add_scalar('test/f1', f1, epoch)\n writer.add_scalar('test/precision', mean_precision, epoch)\n writer.add_scalar('test/recall', mean_recall, epoch)","def on_epoch_end(self, epoch, logs={}):\n tmp = K.eval(self.beta)\n self._beta.append(tmp)","def run_epoch(self, epoch, data_loader, training=False):\n if training:\n self.model.train()\n else:\n self.model.eval()\n\n epoch_metrics = {\"loss\": 0.0}\n overall_parsing_counts = {\"correct\": 0, \"predicted\": 0, \"gold\": 0}\n num_evaluated_batches = 0\n\n with torch.set_grad_enabled(training):\n for sentences, target in data_loader:\n # Run model\n target = self._to_device(target)\n output, parsing_counts = self.parser.evaluate_batch(sentences)\n\n # Compute loss\n output, target = self._unroll_sequence_batch(output), self._unroll_sequence_batch(target)\n loss = self.criterion(output, target)\n\n # Add metrics to overall total\n epoch_metrics[\"loss\"] += loss.item()\n for count in \"gold\", \"predicted\", \"correct\":\n overall_parsing_counts[count] += parsing_counts[count]\n\n # Perform backpropagation (when training)\n if training:\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # Print progress\n num_evaluated_batches += 1\n self.logger.debug('{} Epoch: {} {} Loss: {:.6f}'.format(\n \"Training\" if training else \"Validation\",\n epoch,\n self._progress(num_evaluated_batches, data_loader),\n loss.item()))\n\n epoch_metrics.update(self.compute_prf(overall_parsing_counts))\n\n return epoch_metrics","def update_metric(self, metric, value):\n if self.is_number(value):\n self.logger.debug(\"Collected raw metric: %s = %s\" % (metric, value))\n self.raw_metrics[metric] = value","def __init__(self, metrics, gt, pred):\n self.dict_metrics = self.compute_metrics(metrics, gt, pred)","def _get_epoch_acc(self, is_test: bool = False) -> Dict[str, float]:\n n_total = (\n len(self.testloader.dataset) if is_test else len(self.trainloader.dataset)\n )\n acc = dict()\n for module_name in self.n_correct_epoch:\n accuracy = 100 * self.n_correct_epoch[module_name] / n_total\n acc.update({module_name + \"_acc\": accuracy})\n self.n_correct_epoch.clear()\n\n return acc","def test_epoch_end(self, outputs: Any) -> None:\n self.log_dict(self.test_metrics.compute())\n self.test_metrics.reset()","def eval_epoch(model, validation_data, pred_loss_func, opt):\n\n model.eval()\n\n total_event_ll = 0 # cumulative event log-likelihood\n total_time_se = 0 # cumulative time prediction squared-error\n total_time_error = 0 # cumulative time prediction squared-error\n total_time_latitude = 0 # cumulative latitude prediction squared-error\n total_time_longitude = 0 # cumulative longitude prediction squared-error\n\n total_event_rate = 0 # cumulative number of correct prediction\n total_num_event = 0 # number of total events\n total_num_pred = 0 # number of predictions\n with torch.no_grad():\n for batch in tqdm(validation_data, mininterval=2,\n desc=' - (Validation) ', leave=False):\n \"\"\" prepare data \"\"\"\n event_time, time_gap, event_type, latitude, longitude = map(lambda x: x.to(opt.device), batch)\n\n \"\"\" forward \"\"\"\n enc_out, prediction = model(event_type, event_time, latitude, longitude) # change the event_time to time gap\n\n \"\"\" compute loss \"\"\"\n event_ll, non_event_ll = Utils.log_likelihood(model, enc_out, time_gap, event_type, latitude, longitude) # change the event_time to time gap\n event_loss = -torch.sum(event_ll - non_event_ll)\n\n _, pred_num = Utils.type_loss(prediction[0], event_type, pred_loss_func)\n\n se = Utils.time_loss(prediction[1], event_time) # change the event_time to time gap\n le = Utils.time_loss(prediction[2], latitude)\n ge = Utils.time_loss(prediction[3], longitude)\n\n \"\"\" note keeping \"\"\"\n total_event_ll += -event_loss.item()\n total_time_se += se.item() + le.item() + ge.item()\n total_time_error += se.item()\n total_time_latitude += le.item()\n total_time_longitude += ge.item()\n\n total_event_rate += pred_num.item()\n total_num_event += event_type.ne(Constants.PAD).sum().item()\n total_num_pred += event_type.ne(Constants.PAD).sum().item() - event_time.shape[0] # change the event_time to time gap\n\n test_rmse = np.sqrt(total_time_se / total_num_pred)\n test_time_rmse = np.sqrt(total_time_error / total_num_pred)\n test_latitude_rmse = np.sqrt(total_time_latitude / total_num_pred)\n test_longitude_rmse = np.sqrt(total_time_longitude / total_num_pred)\n\n return total_event_ll / total_num_event, total_event_rate / total_num_pred, test_time_rmse, test_latitude_rmse, test_longitude_rmse, test_rmse","def on_batch_end(self, epoch, logs={}):\n self.update_count = self.update_count + 1\n\n new_beta = min(\n 1.0 * self.update_count / self.total_anneal_steps, self.anneal_cap\n )\n\n K.set_value(self.beta, new_beta)","def visdom_append_metrics(vis, metrics, first_epoch=False):\n visited = {}\n\n sorted_metrics = sorted(metrics.columns, key=_column_original_name)\n for metric_basename, metric_list in it.groupby(sorted_metrics, key=_column_original_name):\n metric_list = list(metric_list)\n\n for metric in metric_list:\n if vis.win_exists(metric_basename) and (not visited.get(metric, False)) and first_epoch:\n update = 'replace'\n elif not vis.win_exists(metric_basename):\n update = None\n else:\n update = 'append'\n\n vis.line(\n metrics[metric].values,\n metrics.index.values,\n win=metric_basename,\n name=metric,\n opts={\n 'title': metric_basename,\n 'showlegend': True\n },\n update=update\n )\n\n if metric_basename != metric and len(metric_list) > 1:\n if vis.win_exists(metric) and first_epoch:\n update = 'replace'\n elif not vis.win_exists(metric):\n update = None\n else:\n update = 'append'\n\n vis.line(\n metrics[metric].values,\n metrics.index.values,\n win=metric,\n name=metric,\n opts={\n 'title': metric,\n 'showlegend': True\n },\n update=update\n )","def logPerformanceAndCompounds(self, epoch, metrics, scores):\n \n # Add epoch and best epoch to metrics, and order columns\n metrics['Epoch'] = epoch\n metrics = {k : metrics[k] for k in ['Epoch'] + [k for k in metrics.keys() if k != 'Epoch']}\n metrics['best_epoch'] = self.last_save\n \n # Add epoch to scores, and order columns\n scores['Epoch'] = epoch\n if 'Accurate' in scores.columns:\n scores = scores[['Epoch', 'SMILES', 'Frags', 'Valid', 'Accurate', 'Desired'] + self.env.getScorerKeys()]\n else:\n scores = scores[['Epoch', 'SMILES', 'Valid', 'Desired'] + self.env.getScorerKeys()]\n\n self.monitor.savePerformanceInfo(metrics, df_smiles=scores)\n self.monitor.endStep(None, epoch)","def _fill_mean_dict(self, running_metrics: Dict, mean_dict: Dict) -> None:\n for key, value in running_metrics.items():\n mean = np.mean(value)\n mean_dict[key].append(mean)","def begin_epoch(self, epoch, model):\n super().begin_epoch(epoch, model)\n if hasattr(self.criterion, \"set_epoch\"):\n self.criterion.set_epoch(epoch)","def run_epoch(self, sess, epoch_num, validate=True):\n total_loss = 0\n accuracies = []\n for i in range(self.batches_per_epoch):\n batch = self.loader.get_batch()\n if self.config.print_every and i % self.config.print_every == 0:\n if validate:\n val_accuracy = self.eval_validation_accuracy()\n print(\"step {}, validation accuracy {:.3f}\".format(i, val_accuracy))\n accuracies.append((i + epoch_num * self.batches_per_epoch, val_accuracy))\n else:\n if self.include_coverage and self.include_entropy:\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1], batch[2], batch[3])\n elif self.include_coverage:\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1], batch[2])\n elif self.include_entropy:\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1], batch[2])\n else:\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1])\n print(\"step {}, training accuracy {:.3f}\".format(i, train_accuracy))\n \n if self.include_coverage and self.include_entropy:\n _, loss_val = sess.run([self.train_op, self.loss],\n feed_dict={self.x: batch[0], self.c: batch[1], self.e: batch[2], self.y_: batch[2], \n self.keep_prob: 1-self.config.dropout_prob})\n elif self.include_coverage:\n _, loss_val = sess.run([self.train_op, self.loss],\n feed_dict={self.x: batch[0], self.c: batch[1], self.y_: batch[2], \n self.keep_prob: 1-self.config.dropout_prob})\n elif self.include_entropy:\n _, loss_val = sess.run([self.train_op, self.loss],\n feed_dict={self.x: batch[0], self.e: batch[1], self.y_: batch[2], \n self.keep_prob: 1-self.config.dropout_prob})\n else:\n attention, _, loss_val = sess.run([self.attention, self.train_op, self.loss],\n feed_dict={self.x: batch[0], self.y_: batch[1],\n self.keep_prob: 1-self.config.dropout_prob})\n\t\tpdb.set_trace()\n\t\tnp.savetxt(\"a.csv\", attention[0], delimiter=\",\")\n total_loss += loss_val\n\n return total_loss / self.batches_per_epoch, accuracies"],"string":"[\n \"def calculate_epoch_metrics(self, val_metrics=False):\\n metric_names = self.tracked_metrics()\\n\\n for metric in metric_names:\\n if val_metrics:\\n mean_val = np.array(self.metrics_history[f\\\"val_{metric}\\\"][\\\"batch_vals\\\"]).mean()\\n self.metrics_history[f\\\"val_{metric}\\\"][\\\"epoch_vals\\\"].append(mean_val)\\n else:\\n mean_val = np.array(self.metrics_history[metric][\\\"batch_vals\\\"]).mean()\\n self.metrics_history[metric][\\\"epoch_vals\\\"].append(mean_val)\",\n \"def on_epoch_end(self):\\n self.current_metric = self.model.metric(self.metric_fn, self.data)\\n self.current_epoch += 1\\n self.metrics += [self.current_metric]\\n self.epochs += [self.current_epoch]\\n if self.verbose:\\n print('Epoch {} \\\\t{}: {}'.format(\\n self.current_epoch,\\n self.metric_name,\\n self.current_metric))\",\n \"def before_training_epoch(self, epoch, **kw):\\n self.current_row = {MetricName(\\\"epoch\\\"): epoch}\",\n \"def update_epoch(self):\\n raise NotImplementedError\",\n \"def update_metrics(self, metrics, predictions, labels):\\n return\",\n \"def add_epoch(self, ckpt_path, hyperparameters, metric_val):\\n epoch = {\\n 'ckpt_path': ckpt_path,\\n 'hyperparameters': hyperparameters,\\n 'metric_val': metric_val\\n }\\n self._history.append(epoch)\",\n \"def add_entry(self, epoch: int, loss: float, accuracy: float, run: int = 1) -> None:\\n self.run = run\\n self.current = epoch\\n self.metrics[f\\\"R{run}E{epoch}\\\"] = \\\\\\n dict(epoch=epoch, loss=loss, accuracy=accuracy, run=run)\",\n \"def update_metrics(self, state: TrainState, step: int, train_metrics: List[MetricsDict], t0):\\n if not self.logflag:\\n return\\n\\n eval_metrics: List[Any] = []\\n\\n # Build summary dictionary for logging\\n # Include training stats\\n train_metrics = common_utils.get_metrics(train_metrics)\\n summary = {\\n f\\\"train_{k}\\\": v\\n for k, v in jax.tree_util.tree_map(lambda x: x.mean(), train_metrics).items()\\n }\\n epoch = step // self.steps_per_epoch\\n summary[\\\"epoch\\\"] = epoch\\n summary[\\\"time\\\"] = time.time() - t0\\n\\n # Eval over testing set\\n for _ in range(self.steps_per_eval):\\n eval_batch = next(self.eval_dt_iter)\\n metrics = self.p_eval_step(state, eval_batch)\\n eval_metrics.append(metrics)\\n # Compute testing metrics\\n eval_metrics = common_utils.get_metrics(eval_metrics)\\n\\n # Add testing stats to summary\\n summary_eval = jax.tree_util.tree_map(lambda x: x.mean(), eval_metrics)\\n summary.update(summary_eval)\\n\\n # Update iteration stats object\\n assert isinstance(self.itstat_object, IterationStats) # for mypy\\n self.itstat_object.insert(self.itstat_insert_func(ArgumentStruct(**summary)))\",\n \"def _valid_epoch(self, epoch):\\n self.model.eval()\\n total_val_loss = 0\\n total_val_metrics = np.zeros(len(self.metrics))\\n length = len(self.valid_loader)\\n total_pm25_loss = 0\\n total_pm10_loss = 0\\n pm25_loss = 0\\n pm10_loss = 0\\n\\n with torch.no_grad():\\n\\n for batch_idx, (data, target) in enumerate(self.valid_loader):\\n data, target = data.to(self.device), target.to(self.device)\\n target = target.squeeze()\\n output = self.model(data)\\n # print(output)\\n loss = self.loss(output, target)\\n\\n # pm25_predict, pm10_predict = torch.chunk(output, 2, dim=1)\\n # pm25_target, pm10_target = torch.chunk(target, 2, dim=1)\\n # pm25_loss = self.loss(pm25_predict, pm25_target)\\n # pm10_loss = self.loss(pm10_predict, pm10_target)\\n # total_pm25_loss += pm25_loss.item()\\n # total_pm10_loss += pm10_loss.item()\\n\\n self.writer.set_step((epoch - 1) * len(self.valid_loader) + batch_idx, 'valid')\\n self.writer.add_scalar('loss', loss.item())\\n total_val_loss += loss.item()\\n total_val_metrics += self._eval_metrics(output, target)\\n\\n return {\\n 'val_loss': total_val_loss / length,\\n 'val_rmse_loss':np.sqrt(total_val_loss / length),\\n 'val_pm25_loss': np.sqrt(total_pm25_loss / length),\\n 'val_pm10_loss': np.sqrt(total_pm10_loss / length)\\n }\",\n \"def _compute_running_metrics(self,\\n model_output: torch.Tensor,\\n batch: Tuple[torch.Tensor, torch.Tensor],\\n running_metrics: dict) -> None:\\n for metric in self.metrics:\\n if metric.__name__ == 'word_error_rate' or metric.__name__ == 'character_error_rate':\\n metric_result = metric(model_output, batch, self.decoder)\\n else:\\n metric_result = metric(model_output, batch)\\n if type(metric_result) == torch.Tensor:\\n metric_result = metric_result.item()\\n\\n running_metrics[metric.__name__].append(metric_result)\",\n \"def run_epoch(self, train, dev, epoch):\\n # iterate over dataset\\n for i, (words, labels) in enumerate(minibatches(train, self.config.batch_size)):\\n fd, _ = self.get_feed_dict(words, labels, self.config.lr,\\n self.config.dropout)\\n\\n _, train_loss= self.sess.run(\\n [self.train_op, self.loss], feed_dict=fd)\\n\\n# =============================================================================\\n# # tensorboard\\n# if i % 10 == 0:\\n# self.file_writer.add_summary(summary, epoch*nbatches + i)\\n# =============================================================================\\n\\n metrics = self.run_evaluate(dev)\\n msg = \\\" - \\\".join([\\\"{} {:04.2f}\\\".format(k, v)\\n for k, v in metrics.items()])\\n print(msg)\\n\\n return metrics[\\\"f1\\\"]\",\n \"def __init_metrics(self):\\n\\n batch = {}\\n # split data into batches of size batch_size or less\\n for metric_name, metric_pattern in self.metrics.items():\\n # get the batch list for that metric\\n batch_list = []\\n for s in range(1, self.schema + 1):\\n for t in range(1, self.table + 1):\\n k = '/metrics/type=IndexTable/keyspace={}/scope={}/name={}/mean'.format(s, t, metric_name)\\n # from Python 3.6 onwards, the standard dict type maintains insertion order by default\\n batch[k] = 0\\n # if the batch has batch_size items or at the end of iteration,\\n # append the batch to list of that metric and create a new empty batch\\n if len(batch) == self.batch_size or (s == self.schema and t == self.table):\\n batch_list.append(batch)\\n batch = {}\\n\\n # parse metric patterns\\n l = metric_pattern.split()\\n if l[0] == '(>':\\n self.metrics[metric_name] = IncMetricStruct(float(int(l[1])), float(l[2][1:]), float(l[4][:-2]),\\n batch_list)\\n else:\\n self.metrics[metric_name] = RandMetricStruct(float(l[0][1:]), float(l[-1][:-1]), batch_list)\",\n \"def set_epoch(self, epoch):\\r\\n pass\",\n \"def reset_epoch_cache(self):\\n self.epoch_cache = {\\\"train\\\":PerformanceBatch(), \\n \\\"val\\\":PerformanceBatch(), \\n \\\"test\\\":PerformanceBatch()}\",\n \"def update(self, current_iter, *metrics, **named_metrics):\\n\\n # Same order as __init__() in python>=3.6\\n if len(metrics) > 0:\\n for key, metric in zip(self.metrics.keys(), metrics):\\n self.metrics[key].append((current_iter, metric))\\n \\n # Random order with names\\n elif len(named_metrics) > 0:\\n for name, metric in named_metrics.item():\\n self.metrics[name].append((metric))\\n\\n else:\\n raise ValueError(\\\"No valid value to update losses\\\")\",\n \"def on_train_epoch_end(self) -> None:\\n self.log_dict(self.train_metrics.compute())\\n self.train_metrics.reset()\",\n \"def compute_metrics(self):\\n self.finalize_output_dict()\\n self.metric_dict = {\\n key: value(self.output_dict[\\\"labels\\\"], self.output_dict[\\\"pred_probs\\\"])\\n for key, value in self.metric_fns.items()\\n }\",\n \"def _update_metric(\\n metrics: List[mlflow.entities.Metric], dataset: MetricsDict = {}\\n ) -> MetricsDict:\\n for metric in metrics:\\n metric_dict = {\\\"step\\\": metric.step, \\\"value\\\": metric.value}\\n if metric.key in dataset:\\n if isinstance(dataset[metric.key], list):\\n dataset[metric.key].append(metric_dict)\\n else:\\n dataset[metric.key] = [dataset[metric.key], metric_dict]\\n else:\\n dataset[metric.key] = metric_dict\\n return dataset\",\n \"def add_metrics(self, metric_dict: dict):\\n self.metric_dict.update(metric_dict)\",\n \"def test_compute_metrics(self):\\n with self.test_session() as sess:\\n tf.set_random_seed(1234)\\n dut = _setup_trainer(self.tmpdir)\\n\\n sess.run(tf.global_variables_initializer())\\n sess.run((dut.train_iterator.initializer,\\n dut.train_metric_reset_op))\\n\\n train_mloss = sess.run(dut.train_mean_loss)\\n\\n # Without update, it should be zero.\\n self.assertEqual(train_mloss, 0.)\\n\\n sess.run((dut.train_op, dut.train_mean_loss_update_op))\\n\\n train_mloss = sess.run(dut.train_mean_loss)\\n\\n # After update.\\n self.assertAlmostEqual(train_mloss, 5.2298584)\",\n \"def before_epoch(self):\\n if self.trainer._mode == 'train':\\n with open(os.path.join(self.root_path, 'metrics.txt'), 'a+') as fout:\\n if hasattr(self.trainer, '_metrics'):\\n fout.write(\\n str(self.trainer._epoch - 1) + '\\\\t' +\\n str(self.trainer._metrics) + '\\\\n')\",\n \"def epoch(self, learning_rate=None, metrics=None):\\n # Calculate statistics from epoch\\n train_loss = self.train_loss / self.train_samples\\n train_losses = {k: v / self.train_samples for k, v in self.train_losses.items()}\\n\\n if self.val_samples > 0:\\n val_loss = self.val_loss / self.val_samples\\n val_losses = {k: v / self.val_samples for k, v in self.val_losses.items()}\\n else:\\n val_loss = None\\n val_losses = None\\n\\n self.n_batches_last = self.i_train_batch\\n self.i_epoch += 1\\n self.i_train_batch = 0\\n self.i_val_batch = 0\\n\\n metric_values = {}\\n if metrics is not None:\\n for m in metrics:\\n try:\\n metric_values[m.name] = m.get_values()\\n except AttributeError as e:\\n pass\\n\\n # Combine stats in dataset\\n data = {}\\n data[\\\"training_loss\\\"] = ((\\\"epochs\\\",), [train_loss])\\n if len(train_losses) > 1:\\n for t in train_losses:\\n k = \\\"training_loss_\\\" + t\\n data[k] = ((\\\"epochs\\\",), [train_losses[t]])\\n\\n if val_loss is not None:\\n data[\\\"validation_loss\\\"] = ((\\\"epochs\\\",), [val_loss])\\n if len(val_losses) > 1:\\n for t in val_losses:\\n k = \\\"validation_loss_\\\" + t\\n data[k] = ((\\\"epochs\\\",), [val_losses[t]])\\n\\n for name, values in metric_values.items():\\n if isinstance(values, dict):\\n for target, value in values.items():\\n k = name + \\\"_\\\" + target\\n data[k] = ((\\\"epochs\\\",), [value])\\n else:\\n data[name] = ((\\\"epochs\\\"), [values])\\n data[\\\"epochs\\\"] = [self.i_epoch]\\n dataset = xr.Dataset(data)\\n if self.history is None:\\n self.history = xr.Dataset(dataset)\\n else:\\n self.history = xr.concat([self.history, dataset], dim=\\\"epochs\\\")\\n\\n # Write output\\n self.progress.update_table(\\n self.i_epoch,\\n total_loss_training=train_loss,\\n total_loss_validation=val_loss,\\n losses_training=train_losses,\\n losses_validation=val_losses,\\n learning_rate=learning_rate,\\n metrics=metric_values,\\n )\",\n \"def on_epoch_begin(self, epoch, logs=None):\",\n \"def on_epoch_begin(self, epoch, logs=None):\",\n \"def next_epoch(self):\\n update_table = [None for _ in range(2 ** self.bit_count)]\\n for w in self.frequency_map:\\n frequency = self.frequency_map[w]\\n for h in self.hash_functions:\\n c = get_hash(h(), repr(w)) % 2 ** self.bit_count\\n if not update_table[c] or frequency > update_table[c]:\\n update_table[c] = frequency\\n # Update statistics table\\n debug_hit_something = False\\n for c in range(len(update_table)):\\n if update_table[c] is not None:\\n debug_hit_something = True\\n freq = update_table[c] / self.tweet_count\\n self._update_bucket(freq, self.buckets[c])\\n else:\\n pass\\n assert debug_hit_something is True\\n self.epoch += 1\\n self.index[self.epoch] = dict()\\n self.trending_topics = []\",\n \"def on_validation_epoch_end(self) -> None:\\n self.log_dict(self.val_metrics.compute())\\n self.val_metrics.reset()\",\n \"def update_ema(metrics, metric, mode, iteration):\\n decay = 0.99 if mode == 'train' else 0.9\\n d = decay if iteration > 10 else 0.5\\n\\n for key, value in metric.items():\\n metrics[mode][key] = metrics[mode][key] * d + value * (1 - d)\\n\\n return metrics\",\n \"def on_epoch_begin(self, epoch, logs={}):\\n self.current_progress = 0\\n self.loss = 0\\n self.accuracy = 0\",\n \"def _train_epoch(self, epoch: int) -> Dict[str, float]:\\n logger.info(\\\"Epoch %d/%d\\\", epoch, self._num_epochs - 1)\\n peak_cpu_usage = peak_memory_mb()\\n logger.info(f\\\"Peak CPU memory usage MB: {peak_cpu_usage}\\\")\\n gpu_usage = []\\n for gpu, memory in gpu_memory_mb().items():\\n gpu_usage.append((gpu, memory))\\n logger.info(f\\\"GPU {gpu} memory usage MB: {memory}\\\")\\n\\n train_loss = 0.0\\n # Set the model to \\\"train\\\" mode.\\n self.model.train()\\n\\n num_gpus = len(self._cuda_devices)\\n\\n # Get tqdm for the training batches\\n raw_train_generator = self.iterator(self.train_data,\\n num_epochs=1,\\n shuffle=self.shuffle)\\n train_generator = lazy_groups_of(raw_train_generator, num_gpus)\\n num_training_batches = math.ceil(self.iterator.get_num_batches(self.train_data)/num_gpus)\\n self._last_log = time.time()\\n last_save_time = time.time()\\n\\n batches_this_epoch = 0\\n if self._batch_num_total is None:\\n self._batch_num_total = 0\\n\\n histogram_parameters = set(self.model.get_parameters_for_histogram_tensorboard_logging())\\n\\n logger.info(\\\"Training\\\")\\n train_generator_tqdm = Tqdm.tqdm(train_generator,\\n total=num_training_batches)\\n cumulative_batch_size = 0\\n for batch_group in train_generator_tqdm:\\n batches_this_epoch += 1\\n self._batch_num_total += 1\\n batch_num_total = self._batch_num_total\\n\\n self.optimizer.zero_grad()\\n\\n output_dict = self.get_output_dict(batch_group, for_training=True)\\n loss = self.get_batch_loss(output_dict, for_training=True)\\n\\n if torch.isnan(loss):\\n raise ValueError(\\\"nan loss encountered\\\")\\n\\n loss.backward()\\n\\n train_loss += loss.item()\\n\\n batch_grad_norm = self.rescale_gradients()\\n\\n # This does nothing if batch_num_total is None or you are using a\\n # scheduler which doesn't update per batch.\\n if self._learning_rate_scheduler:\\n self._learning_rate_scheduler.step_batch(batch_num_total)\\n if self._momentum_scheduler:\\n self._momentum_scheduler.step_batch(batch_num_total)\\n\\n if self._tensorboard.should_log_histograms_this_batch():\\n # get the magnitude of parameter updates for logging\\n # We need a copy of current parameters to compute magnitude of updates,\\n # and copy them to CPU so large models won't go OOM on the GPU.\\n param_updates = {name: param.detach().cpu().clone()\\n for name, param in self.model.named_parameters()}\\n self.optimizer.step()\\n for name, param in self.model.named_parameters():\\n param_updates[name].sub_(param.detach().cpu())\\n update_norm = torch.norm(param_updates[name].view(-1, ))\\n param_norm = torch.norm(param.view(-1, )).cpu()\\n self._tensorboard.add_train_scalar(\\\"gradient_update/\\\" + name,\\n update_norm / (param_norm + 1e-7))\\n else:\\n self.optimizer.step()\\n\\n # Update moving averages\\n if self._moving_average is not None:\\n self._moving_average.apply(batch_num_total)\\n\\n # Update the description with the latest metrics\\n metrics = training_util.get_metrics(self.model, train_loss, batches_this_epoch)\\n description = training_util.description_from_metrics(metrics)\\n\\n train_generator_tqdm.set_description(description, refresh=False)\\n\\n # Log parameter values to Tensorboard\\n if self._tensorboard.should_log_this_batch():\\n self._tensorboard.log_parameter_and_gradient_statistics(self.model, batch_grad_norm)\\n self._tensorboard.log_learning_rates(self.model, self.optimizer)\\n\\n self._tensorboard.add_train_scalar(\\\"loss/loss_train\\\", metrics[\\\"loss\\\"])\\n self._tensorboard.log_metrics({\\\"epoch_metrics/\\\" + k: v for k, v in metrics.items()})\\n\\n if self.tensorboard_log_batch_callback:\\n self.tensorboard_log_batch_callback(output_dict, self._tensorboard)\\n\\n if self._tensorboard.should_log_histograms_this_batch():\\n self._tensorboard.log_histograms(self.model, histogram_parameters)\\n\\n if self._log_batch_size_period:\\n cur_batch = sum([training_util.get_batch_size(batch) for batch in batch_group])\\n cumulative_batch_size += cur_batch\\n if (batches_this_epoch - 1) % self._log_batch_size_period == 0:\\n average = cumulative_batch_size/batches_this_epoch\\n logger.info(f\\\"current batch size: {cur_batch} mean batch size: {average}\\\")\\n self._tensorboard.add_train_scalar(\\\"current_batch_size\\\", cur_batch)\\n self._tensorboard.add_train_scalar(\\\"mean_batch_size\\\", average)\\n\\n # Save model if needed.\\n if self._model_save_interval is not None and (\\n time.time() - last_save_time > self._model_save_interval\\n ):\\n last_save_time = time.time()\\n self._save_checkpoint(\\n '{0}.{1}'.format(epoch, training_util.time_to_str(int(last_save_time)))\\n )\\n metrics = training_util.get_metrics(self.model, train_loss, batches_this_epoch, reset=True)\\n metrics['cpu_memory_MB'] = peak_cpu_usage\\n for (gpu_num, memory) in gpu_usage:\\n metrics['gpu_'+str(gpu_num)+'_memory_MB'] = memory\\n return metrics\",\n \"def test_epoch_monitor():\\n dim = 1\\n batch_size = 3\\n n_batches = 10\\n m = n_batches * batch_size\\n\\n dataset = ArangeDataset(m)\\n model = SoftmaxModel(dim)\\n monitor = Monitor.get_monitor(model)\\n learning_rate = 1e-3\\n data_specs = (model.get_input_space(), model.get_input_source())\\n cost = DummyCost()\\n termination_criterion = EpochCounter(1)\\n\\n monitor_rate = 3\\n em = EpochMonitor(model=model,\\n tick_rate=None,\\n monitor_rate=monitor_rate)\\n\\n algorithm = SGD(learning_rate,\\n cost,\\n batch_size=batch_size,\\n train_iteration_mode='sequential',\\n monitoring_dataset=dataset,\\n termination_criterion=termination_criterion,\\n update_callbacks=[em],\\n set_batch_size=False)\\n\\n algorithm.setup(dataset=dataset, model=model)\\n algorithm.train(dataset)\\n\\n for key, val in monitor.channels.items():\\n assert len(val.val_record) == n_batches//monitor_rate\",\n \"def init_metrics():\\n metrics = defaultdict(list)\\n metrics['best_acc'] = 0.0\\n metrics['best_loss'] = float('inf')\\n metrics['best_epoch'] = 0\\n return metrics\",\n \"def set_metrics(metric_dict, cd_loss, cd_corrects, cd_report):\\n metric_dict['cd_losses'].append(cd_loss.item())\\n metric_dict['cd_corrects'].append(cd_corrects.item())\\n metric_dict['cd_precisions'].append(cd_report[0])\\n metric_dict['cd_recalls'].append(cd_report[1])\\n metric_dict['cd_f1scores'].append(cd_report[2])\\n\\n return metric_dict\",\n \"def set_epoch(self, epoch):\\n self.epoch = epoch\",\n \"def _train_epoch(self, epoch):\\n self.model.train()\\n\\n\\n total_loss = 0\\n total_metrics = np.zeros(len(self.metrics))\\n length = len(self.data_loader)\\n total_pm25_loss = 0\\n total_pm10_loss = 0\\n pm25_loss = 0\\n pm10_loss = 0\\n\\n for batch_idx, (data, target) in enumerate(self.data_loader):\\n data, target = data.to(self.device), target.to(self.device)\\n\\n self.optimizer.zero_grad()\\n output = self.model(data)\\n # print(output.shape, target.shape)\\n target = target.squeeze()\\n model_loss = self.loss(output, target)\\n\\n # print(output.shape, target.shape)\\n # pm25_predict, pm10_predict = torch.chunk(output, 2, dim=1)\\n # pm25_target, pm10_target = torch.chunk(target, 2, dim=1)\\n # pm25_loss = self.loss(pm25_predict, pm25_target)\\n # pm10_loss = self.loss(pm10_predict, pm10_target)\\n # total_pm25_loss += pm25_loss.item()\\n # total_pm10_loss += pm10_loss.item()\\n\\n l2_reg = torch.tensor(0.0).to(self.device)\\n if self.config['trainer']['l2_regularization']:\\n for param in self.model.parameters():\\n l2_reg += torch.norm(param, p=2)\\n loss = model_loss + self.config['trainer']['l2_lambda'] * l2_reg\\n else:\\n loss = model_loss\\n\\n loss.backward()\\n # torch.nn.utils.clip_grad_norm(self.model.parameters(), 1)\\n self.optimizer.step()\\n\\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\\n self.writer.add_scalar('loss', loss.item())\\n total_loss += loss.item()\\n # total_metrics += self._eval_metrics(output, target)\\n\\n if batch_idx % self.log_step == 0:\\n self.logger.debug('Train Epoch: {} {} Loss: {:.6f} model_loss: {:.6f} pm25_loss {:.6f} pm10_loss {:.6f} l2_loss: {:.6f}'.format(\\n epoch,\\n self._progress(batch_idx),\\n loss.item(),\\n model_loss.item(),\\n pm25_loss,\\n pm10_loss,\\n l2_reg.item()))\\n\\n if batch_idx == self.len_epoch:\\n break\\n\\n log = {\\n 'loss': total_loss / length,\\n 'rmse_pm25_loss': np.sqrt(total_pm25_loss / length),\\n 'rmse_pm10_loss': np.sqrt(total_pm10_loss / length)\\n }\\n\\n\\n val_log = self._valid_epoch(epoch)\\n log.update(val_log)\\n\\n if self.lr_scheduler is not None:\\n self.lr_scheduler.step(val_log['val_loss'])\\n\\n return log\",\n \"def on_epoch_end(self, epoch, logs=None):\",\n \"def on_epoch_end(self, epoch, logs=None):\",\n \"def build_metrics_dict(node):\\n\\n # Initialize tensors\\n n = 0\\n n = _recv(n,node)\\n keys = [[0 for j in range(8)] for i in range(n)] # max_seq_len for metric name is 8\\n values = [0.0 for i in range(n)]\\n higher_is_better = [0 for i in range(n)]\\n\\n # Read data\\n keys = _recv(keys,node)\\n values = _recv(values,node)\\n higher_is_better = _recv(higher_is_better,node)\\n\\n # Reorganize output + decode dict keys\\n orig_keys = [encode_string(key, string_to_int=False) for key in keys]\\n values_dict = [{'value': float(v), 'higher_is_better': bool(higher_is_better[i])} for i, v in enumerate(values)]\\n metrics = dict(zip(orig_keys,values_dict))\\n num_instances = int(metrics.pop('num')['value'])\\n\\n result = None, metrics, num_instances\\n \\n return result\",\n \"def get(self):\\n if self.num_examples <= 0:\\n raise ValueError(\\\"total_sample must be positive.\\\")\\n avg_hit_at_one = self.sum_hit_at_one / self.num_examples\\n avg_perr = self.sum_perr / self.num_examples\\n avg_loss = self.sum_loss / self.num_examples\\n\\n epoch_info_dict = {\\\"avg_hit_at_one\\\": avg_hit_at_one, \\n \\\"avg_perr\\\": avg_perr,\\n \\\"avg_f1score\\\": avg_f1score,\\n \\\"avg_f2score\\\": avg_f2score,\\n \\\"avg_loss\\\": avg_loss}\\n return epoch_info_dict\",\n \"def on_epoch_end(self, epoch: int, logs: dict):\\n # Metric calculated once per \\\"n\\\" epochs\\n metric = logs.get(self.metric, 0.0)\\n\\n if self.mode == \\\"max\\\":\\n if metric > self.thresh:\\n self.model.model.save(\\n f\\\"{self.path}/model_{epoch+1:04d}_{metric:.4f}.h5\\\"\\n )\\n K.set_value(self.thresh, metric)\\n\\n elif self.mode == \\\"min\\\":\\n if metric < self.thresh:\\n self.model.model.save(\\n f\\\"{self.path}/model_{epoch+1:04d}_{metric:.4f}.h5\\\"\\n )\\n K.set_value(self.thresh, metric)\\n else:\\n raise NotImplementedError(\\n f\\\"{self.mode} mode has not been implemented for this callback\\\"\\n )\\n\\n return super().on_epoch_end(epoch, logs=logs)\",\n \"def after_evaluation(self, epoch, **kw):\\n if self.loss_txt is not None:\\n self.current_row[MetricName(\\\"timestamp\\\")] = f\\\"{datetime.now():%H:%M:%S}\\\"\\n\\n # output log file\\n with open(self.loss_txt, \\\"a\\\") as f:\\n # remove columns where no value was found on the first epoch (could be != 1 if training was resumed)\\n if epoch == self.first_epoch:\\n for k in list(self.headers.keys()):\\n if k not in self.current_row:\\n del self.headers[k]\\n\\n # make headers on epoch 1\\n if epoch == 1:\\n # write header\\n f.write(\\\"\\\\t\\\".join(self.headers.values()) + \\\"\\\\n\\\")\\n\\n for col in self.headers:\\n assert col in self.current_row, str(col) + \\\" \\\" + str(self.current_row.keys())\\n\\n assert all(col in self.current_row for col in self.headers)\\n\\n f.write(\\\"\\\\t\\\".join([str(self.current_row[col]) for col in self.headers]) + \\\"\\\\n\\\")\\n\\n self.current_row = {}\",\n \"def refresh_stats(self) -> None:\\n try:\\n self._mallctl(\\\"epoch\\\", read=False, write=1)\\n except Exception as e:\\n logger.warning(\\\"Failed to reload jemalloc stats: %s\\\", e)\",\n \"def _valid_epoch(self, epoch):\\n self.model.eval()\\n self.valid_metrics.reset()\\n with torch.no_grad():\\n for batch_idx, (data, target) in enumerate(self.valid_data_loader):\\n data, target = data.to(self.device), target.to(self.device)\\n\\n output = self.model(data)\\n loss = self.criterion(output, target)\\n\\n self.writer.set_step(\\n (epoch - 1) * len(self.valid_data_loader) + batch_idx, \\\"valid\\\"\\n )\\n self.valid_metrics.update(\\\"loss\\\", loss.item())\\n for met in self.metric_ftns:\\n self.valid_metrics.update(met.__name__, met(output, target))\\n self.writer.add_image(\\n \\\"input\\\", make_grid(data.cpu(), nrow=8, normalize=True)\\n )\\n\\n # add histogram of model parameters to the tensorboard\\n for name, p in self.model.named_parameters():\\n self.writer.add_histogram(name, p, bins=\\\"auto\\\")\\n return self.valid_metrics.result()\",\n \"def update(self, feed_dict=None):\\n if feed_dict is None:\\n feed_dict = {}\\n\\n for key, value in six.iteritems(self.data):\\n if isinstance(key, tf.Tensor) and \\\"Placeholder\\\" in key.op.type:\\n feed_dict[key] = value\\n\\n sess = get_session()\\n t = sess.run(self.increment_t)\\n\\n if self.debug:\\n sess.run(self.op_check)\\n\\n if self.logging and self.n_print != 0:\\n if t == 1 or t % self.n_print == 0:\\n summary = sess.run(self.summarize, feed_dict)\\n self.train_writer.add_summary(summary, t)\\n\\n return {'t': t}\",\n \"def _evaluate_during_fit(self, test_loader, epoch):\",\n \"def after_val_epoch(self,\\n runner,\\n metrics: Optional[Dict[str, float]] = None) -> None:\\n tag, log_str = runner.log_processor.get_log_after_epoch(\\n runner, len(runner.val_dataloader), 'val')\\n runner.logger.info(log_str)\\n if self.log_metric_by_epoch:\\n # Accessing the epoch attribute of the runner will trigger\\n # the construction of the train_loop. Therefore, to avoid\\n # triggering the construction of the train_loop during\\n # validation, check before accessing the epoch.\\n if (isinstance(runner._train_loop, dict)\\n or runner._train_loop is None):\\n epoch = 0\\n else:\\n epoch = runner.epoch\\n runner.visualizer.add_scalars(\\n tag, step=epoch, file_path=self.json_log_path)\\n else:\\n if (isinstance(runner._train_loop, dict)\\n or runner._train_loop is None):\\n iter = 0\\n else:\\n iter = runner.iter\\n runner.visualizer.add_scalars(\\n tag, step=iter, file_path=self.json_log_path)\",\n \"def on_epoch_end(self):\\n self.epoch += 1\\n metric = self.metric_fn()\\n if metric < self.best:\\n self.best = metric\\n self.count = 0\\n else:\\n self.count += 1\\n if self.count > self.patience:\\n self.model.stop_training()\\n if self.verbose:\\n print(self.name+' after '+str(self.epoch)+' epochs')\",\n \"def compute_epoch_statistics(self, output_dict):\\n epoch_statistics = {\\n \\\"auc\\\": roc_auc_score(\\n output_dict[\\\"labels\\\"].cpu().numpy(),\\n output_dict[\\\"pred_probs\\\"][:, 1].cpu().numpy(),\\n ),\\n \\\"auprc\\\": average_precision_score(\\n output_dict[\\\"labels\\\"].cpu().numpy(),\\n output_dict[\\\"pred_probs\\\"][:, 1].cpu().numpy(),\\n ),\\n \\\"brier\\\": brier_score_loss(\\n output_dict[\\\"labels\\\"].cpu().numpy(),\\n output_dict[\\\"pred_probs\\\"][:, 1].cpu().numpy(),\\n ),\\n }\\n\\n return epoch_statistics\",\n \"def update(self, data: Mapping[str, np.ndarray]) -> Self:\\n\\n for metric in self.metrics:\\n metric.update(data)\\n\\n return self\",\n \"def init_metrics(self):\\n\\n self.metrics = {}\\n\\n self.metrics['train_loss'] = np.zeros(0)\\n self.metrics['test_loss'] = np.zeros(0)\\n\\n # self.orth_clf = LinearDecoder(self, self.q_, MeanClassifier)\\n # self.metrics['train_orthogonality'] = np.zeros(0)\\n # self.metrics['test_orthogonality'] = np.zeros(0)\\n\\n self.metrics['train_parallelism'] = np.zeros((0,self.q_)) \\n self.metrics['test_parallelism'] = np.zeros((0,self.q_))\",\n \"def _train_epoch(self, epoch):\\n raise NotImplementedError\",\n \"def _train_epoch(self, epoch):\\n raise NotImplementedError\",\n \"def _train_epoch(self, epoch):\\n raise NotImplementedError\",\n \"def _train_epoch(self, epoch):\\n raise NotImplementedError\",\n \"def train_epoch(self, epoch, evaluator, optimizer, perf_path, perf_trace, state_fpath, writer_tensorboard):\\n\\n # Train an epoch\\n self.model.train()\\n print('Start epoch', epoch)\\n train_itr = iter(self.loader_train)\\n total_err = 0\\n total_acc = 0\\n\\n for index, (data_pixel, data_labels) in enumerate(train_itr):\\n\\n # compute\\n input_data = data_pixel.float().cuda()\\n data_labels = data_labels.cuda()\\n\\n # Use the model the produce the classification\\n grapheme_logits, vowel_logits, consonant_logits = self.model(input_data)\\n\\n # produce evaluator results\\n eval_result = evaluator(grapheme_logits, vowel_logits, consonant_logits, data_labels)\\n\\n # set optimizer to zero.\\n optimizer.zero_grad()\\n\\n # back propogate the evaluation results.\\n eval_result['loss'].backward()\\n\\n # optimizer take step forward.\\n optimizer.step()\\n\\n # tabulate the steps from the evaluation\\n eval_result = {k: eval_result[k].item() for k in eval_result}\\n\\n # update every hundreds' of\\n if index % 100 == 0:\\n print(index, eval_result['loss'], eval_result['acc'])\\n train_result = evaluator.evalulate_on_cache()\\n train_total_err = train_result['loss']\\n writer_tensorboard.add_scalar('Loss/Train', train_total_err, global_step=epoch)\\n # log_metric('loss', train_total_err)\\n train_total_acc = train_result['acc']\\n writer_tensorboard.add_scalar('Accuracy/Train', train_total_acc, global_step=epoch)\\n # log_metric('acc', train_total_acc)\\n train_kaggle_score = train_result['kaggle_score']\\n writer_tensorboard.add_scalar('Kaggle_Score/Train', train_kaggle_score, global_step=epoch)\\n # log_metric('kaggle_score', train_kaggle_score)\\n dict_metrics_train = {\\n 'Loss/Train': train_total_err,\\n 'Accuracy/Train': train_total_acc,\\n 'Kaggle_Score/Train': train_kaggle_score,\\n }\\n log_metrics(dict_metrics_train, step=epoch)\\n print(f\\\"Epoch {epoch} Training, Loss {train_total_err}, Acc {train_total_acc}\\\")\\n evaluator.clear_cache()\\n # compute validation error\\n self.model.eval()\\n val_itr = iter(self.loader_val)\\n with torch.no_grad():\\n for index, (data_pixel, data_labels) in enumerate(val_itr):\\n input_data = data_pixel.float().cuda()\\n data_labels = data_labels.cuda()\\n grapheme_logits, vowel_logits, consonant_logits = self.model(input_data)\\n eval_result = evaluator(grapheme_logits, vowel_logits, consonant_logits, data_labels)\\n eval_result = {k: eval_result[k].item() for k in eval_result}\\n total_err += eval_result['loss']\\n total_acc += eval_result['acc']\\n # print(total_err / (1 + input_index), total_acc / (1 + input_index))\\n val_result = evaluator.evalulate_on_cache()\\n val_total_err = val_result['loss']\\n writer_tensorboard.add_scalar('Loss/Val', val_total_err, global_step=epoch)\\n val_total_acc = val_result['acc']\\n writer_tensorboard.add_scalar('Accuracy/Val', val_total_acc, global_step=epoch)\\n val_kaggle_score = val_result['kaggle_score']\\n writer_tensorboard.add_scalar('Kaggle_Score/Val', val_kaggle_score, global_step=epoch)\\n dict_metrics_val = {\\n 'Loss/Validation': val_total_err,\\n 'Accuracy/Validation': val_total_acc,\\n 'Kaggle_Score/Validation': val_kaggle_score,\\n }\\n log_metrics(dict_metrics_val, step=epoch)\\n # Write to disk.\\n writer_tensorboard.flush()\\n print(f\\\"Epoch {epoch} Eval, Loss {val_total_err}, Acc {val_total_acc}\\\")\\n evaluator.clear_cache()\\n print(\\\"Saving the model (epoch %d)\\\" % epoch)\\n torch.save({\\n \\\"epoch\\\": epoch + 1,\\n \\\"model_state\\\": self.model.state_dict(),\\n \\\"optimizer_state\\\": optimizer.state_dict(),\\n }, state_fpath)\\n print(f\\\"Making a backup (step {epoch})\\\")\\n backup_fpath = os.path.join(self.backup_dir, f\\\"model_bak_{epoch}.pt\\\")\\n torch.save({\\n \\\"epoch\\\": epoch + 1,\\n \\\"model_state\\\": self.model.state_dict(),\\n \\\"optimizer_state\\\": optimizer.state_dict(),\\n }, backup_fpath)\\n # Dump the traces\\n perf_trace.append(\\n {\\n 'epoch': epoch,\\n 'train_err': train_total_err,\\n 'train_acc': train_total_acc,\\n 'train_kaggle_score': train_kaggle_score,\\n 'val_err': val_total_err,\\n 'val_acc': val_total_acc,\\n 'val_kaggle_score': val_kaggle_score\\n }\\n )\\n pickle.dump(perf_trace, open(perf_path, 'wb'))\\n # store epoch full result separately\\n epoch_result = {\\n 'epoch': epoch,\\n 'train_result': train_result,\\n 'val_result': val_result\\n }\\n pickle.dump(epoch_result, open(os.path.join(self.results_dir, 'result_epoch_{0}.p'.format(epoch)), 'wb'))\",\n \"def calculate_batch_metrics(self):\\n pass\",\n \"def _AddMetric(self, metric):\\n machine = metric.machine_id\\n time = metric.timestamp\\n payload = DotDict(json.loads(metric.payload)).flatten()\\n\\n self.machines.add(machine)\\n self.timestamps.add(time)\\n for k in payload:\\n if k not in self.counter_data:\\n continue\\n val = payload.get(k, None)\\n if val is not None:\\n self.counter_data[k].AddSample(machine, time, val)\",\n \"def on_epoch_end(self, epoch: int, logs: dict = None):\\n if logs is None:\\n logs = {}\\n\\n # reset the index\\n self.model.reset_index()\\n\\n # rebuild the index\\n self.model.index(self.targets, self.target_labels, verbose=0)\\n\\n results = _compute_classification_metrics(\\n queries=self.queries,\\n query_labels=self.query_labels,\\n model=self.model,\\n evaluator=self.evaluator,\\n metrics=self.metrics,\\n k=self.k,\\n matcher=self.matcher,\\n distance_thresholds=self.distance_thresholds)\\n\\n mstr = []\\n for metric_name, vals in results.items():\\n float_val = vals[0]\\n logs[metric_name] = float_val\\n mstr.append(f'{metric_name}: {float_val:.4f}')\\n if self.tb_writer:\\n with self.tb_writer.as_default():\\n tf.summary.scalar(metric_name, float_val, step=epoch)\\n\\n # reset the index to prevent users from accidently using this after the\\n # callback\\n self.model.reset_index()\\n\\n print(' - '.join(mstr))\",\n \"def on_test_epoch_end(self) -> None:\\n self.log_dict(self.test_metrics.compute())\\n self.test_metrics.reset()\",\n \"def initialize(self, runInfo, inputs, initDict) :\\n super().initialize(runInfo, inputs, initDict)\\n for metricIn in self.assemblerDict['Metric']:\\n self.metricsDict[metricIn[2]] = metricIn[3]\",\n \"def init_metrics(losses):\\n metrics = {'train': {}, 'valid': {}}\\n for mode, d in metrics.items():\\n metrics[mode] = dict([(k, 0) for k in losses])\\n\\n return metrics\",\n \"def add_metrics(_dict):\\n for key, itr in _dict.items():\\n if key not in self.metric_cols:\\n self.metric_cols.append(key)\",\n \"def _train_epoch(self, epoch):\\n self.model.train()\\n self.train_metrics.reset()\\n for batch_idx, (data, target_seg, target_class) in enumerate(self.data_loader):\\n data, target_seg, target_class = data.to(self.device), target_seg.to(self.device), target_class.to(self.device)\\n\\n self.optimizer.zero_grad()\\n output_seg, output_class = self.model(data)\\n loss = self.criterion((output_seg, output_class), target_seg, target_class, epoch)\\n loss.backward()\\n self.optimizer.step()\\n\\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\\n self.train_metrics.update('loss', loss.item())\\n for met in self.metric_ftns:\\n if met.__name__ == \\\"accuracy\\\":\\n self.train_metrics.update(met.__name__, met(output_class, target_class))\\n else:\\n self.train_metrics.update(met.__name__, met(output_seg, target_seg))\\n\\n if batch_idx % self.log_step == 0:\\n self.logger.debug('Train Epoch: {} {} Loss: {:.6f}'.format(\\n epoch,\\n self._progress(batch_idx),\\n loss.item()))\\n\\n self._visualize_input(data.cpu())\\n\\n if batch_idx == self.len_epoch:\\n break\\n log = self.train_metrics.result()\\n\\n if self.do_validation:\\n val_log = self._valid_epoch(epoch)\\n log.update(**{'val_'+k : v for k, v in val_log.items()})\\n\\n if self.lr_scheduler is not None:\\n self.lr_scheduler.step()\\n\\n return log\",\n \"def set_metrics(self):\",\n \"def _valid_epoch(self, epoch):\\n self.model.eval()\\n self.valid_metrics.reset()\\n with torch.no_grad():\\n for batch_idx, (data, target_seg, target_class) in enumerate(self.valid_data_loader):\\n data, target_seg, target_class = data.to(self.device), target_seg.to(self.device), target_class.to(self.device)\\n\\n output_seg, output_class = self.model(data)\\n loss = self.criterion((output_seg, output_class), target_seg, target_class, epoch)\\n\\n self.writer.set_step((epoch - 1) * len(self.valid_data_loader) + batch_idx, 'valid')\\n self.valid_metrics.update('loss', loss.item())\\n for met in self.metric_ftns:\\n if met.__name__ == \\\"accuracy\\\":\\n self.valid_metrics.update(met.__name__, met(output_class, target_class))\\n else:\\n self.valid_metrics.update(met.__name__, met(output_seg, target_seg))\\n\\n data_cpu = data.cpu()\\n self._visualize_input(data_cpu)\\n self._visualize_prediction(data_cpu, output_seg.cpu(), target_seg.cpu())\\n\\n # add histogram of model parameters to the tensorboard\\n for name, p in self.model.named_parameters():\\n self.writer.add_histogram(name, p, bins='auto')\\n return self.valid_metrics.result()\",\n \"def __call__(self, trainer, epoch):\\n if epoch >= self.ignore_before:\\n if epoch - self.best_epoch < self.patience:\\n if isinstance(self.retain_metric, str):\\n current_res = trainer.val_metrics[self.retain_metric][-1]\\n else:\\n current_res = trainer.val_metrics[self.retain_metric.__name__][-1]\\n if self.window is None:\\n if self._has_improved(current_res):\\n self.best_epoch = epoch\\n self.best_res = current_res\\n trainer.best_metric = current_res\\n trainer.best_model = trainer.model\\n else: # window mod\\n # get validation metrics in certain window\\n try:\\n if isinstance(self.retain_metric, str):\\n start = len(trainer.val_metrics[self.retain_metric]) - self.window\\n start = 0 if start < 0 else start\\n\\n window_val_metrics = trainer.val_metrics[self.retain_metric][start:]\\n else:\\n start = len(trainer.val_metrics[self.retain_metric.__name__]) - self.window\\n start = 0 if start < 0 else start\\n window_val_metrics = trainer.val_metrics[self.retain_metric.__name__][start:]\\n except KeyError:\\n print(\\n \\\"Couldn't find {} in validation metrics. Using \\\\\\n loss instead.\\\".format(\\n self.retain_metric\\n )\\n )\\n start = len(trainer.val_metrics[self.retain_metric]) - self.window\\n start = 0 if start < 0 else start\\n window_val_metrics = trainer.val_metrics[\\\"loss\\\"][start:]\\n\\n # build mean\\n mean_window_res = np.mean(window_val_metrics)\\n\\n # only safe when improvement to previous epoch detected\\n # only a value BETTER than before can be the minimum/maximum of a\\n # window with better mean than a previously detected window\\n if len(window_val_metrics) == 1 \\\\\\n or self._first_val_better(window_val_metrics[-1], window_val_metrics[-2]) \\\\\\n or self._current_window_save_idx == -1:\\n if self._current_window_save_idx == -1:\\n self._current_window_save_idx = 0\\n self._state_dict_storage[self._current_window_save_idx] = deepcopy(trainer.model.state_dict())\\n # increase save idx and take modulo\\n self._current_window_save_idx += 1\\n self._current_window_save_idx = divmod(self._current_window_save_idx, self.window)[1]\\n else: # only increase current_window_save_idx (for modulo index calculation to work)\\n self._current_window_save_idx += 1\\n self._current_window_save_idx = divmod(self._current_window_save_idx, self.window)[1]\\n\\n # always update current window best result - it might be at some point overall best result\\n current_window_best_idx = self._get_cur_win_best_idx(window_val_metrics)\\n if current_window_best_idx == len(window_val_metrics) - 1 \\\\\\n or self._current_window_best_res == -1: # case of improvement or initialisation\\n # overwrite model_state saved so far\\n self._current_window_best_model_save_idx = self._current_window_save_idx\\n self._current_window_best_epoch = epoch\\n self._current_window_best_res = window_val_metrics[-1]\\n\\n # check if mean has improved and copy values as best model result\\n if self._has_window_mean_improved(mean_window_res):\\n self.best_mean_res = mean_window_res\\n self.best_window_start = 0 if epoch - self.window + 1 < 0 else epoch - self.window + 1\\n # save current window best as overall best\\n self.best_res = self._current_window_best_res\\n self.best_model = copy.deepcopy(self._state_dict_storage[self._current_window_best_model_save_idx])\\n self.best_epoch = self._current_window_best_epoch\\n trainer.best_metric = self._current_window_best_res\\n trainer.best_model = trainer.model\\n if self.info:\\n print(\\\"Found a window with better validation metric mean:\\\")\\n print(\\\"\\\\t metric mean: {}\\\".format(mean_window_res))\\n print(\\\"\\\\t epoch start: {}\\\".format(self.best_window_start))\\n print(\\\"\\\\t best result: {}\\\".format(self.best_res))\\n\\n else:\\n # end training run\\n trainer.stop_training = True\\n if self.window is None:\\n print(\\\"Early stopping at epoch {}.\\\\nBest model was at epoch {} with val metric score = {}\\\".format(\\n epoch, self.best_epoch, self.best_res)\\n )\\n else:\\n print(\\\"Early stopping with window mode at epoch {}.\\\\n\\\"\\n \\\"Best results were achieved at epoch {} with val metric score = {}.\\\\n\\\"\\n \\\"Best window of size {} achieved a mean result of {} and started at epoch {}.\\\".format(\\n epoch, self.best_epoch, self.best_res, self.window, self.best_mean_res, self.best_window_start)\\n )\",\n \"def on_epoch_start(self):\",\n \"def _train_epoch(self, epoch):\\n self.model.train()\\n self.train_metrics.reset()\\n for batch_idx, (data, target) in enumerate(self.data_loader):\\n data, target = data.to(self.device), target.to(self.device)\\n\\n self.optimizer.zero_grad()\\n\\n if self.config[\\\"amp\\\"]:\\n # AMP!\\n with autocast():\\n output = self.model(data)\\n loss = self.criterion(output, target)\\n else:\\n output = self.model(data)\\n loss = self.criterion(output, target)\\n\\n loss.backward()\\n self.optimizer.step()\\n\\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\\n self.train_metrics.update(\\\"loss\\\", loss.item())\\n for met in self.metric_ftns:\\n self.train_metrics.update(met.__name__, met(output, target))\\n\\n if batch_idx % self.log_step == 0:\\n self.logger.debug(\\n \\\"Train Epoch: {} {} Loss: {:.6f}\\\".format(\\n epoch, self._progress(batch_idx), loss.item()\\n )\\n )\\n self.writer.add_image(\\n \\\"input\\\", make_grid(data.cpu(), nrow=8, normalize=True)\\n )\\n\\n if batch_idx == self.len_epoch:\\n break\\n log = self.train_metrics.result()\\n\\n if self.do_validation:\\n val_log = self._valid_epoch(epoch)\\n log.update(**{\\\"val_\\\" + k: v for k, v in val_log.items()})\\n\\n if self.lr_scheduler is not None:\\n self.lr_scheduler.step()\\n return log\",\n \"def train_epoch(self, epoch):\\n device_mapper = self.device_mapper\\n self.model.train()\\n self.train_metrics.reset()\\n for batch_idx, data in enumerate(self.data_loader):\\n data = device_mapper.map_modules(data, non_blocking=True)\\n\\n self.optimizer.zero_grad()\\n output = self.model(data)\\n loss = self.loss(output, data)\\n loss.backward()\\n self.optimizer.step()\\n\\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\\n self.train_metrics.update('loss', loss.item(), batch_size=output.size(0))\\n for met in self.metrics:\\n self.train_metrics.update(met.name(), met(output, data), batch_size=output.size(0))\\n\\n if batch_idx % self.log_step == 0:\\n self.logger.debug('Train Epoch: %d %s Loss: %.6f', epoch, self._progress(batch_idx), loss.item())\\n\\n if batch_idx == self.len_epoch:\\n break\\n log = self.train_metrics.result()\\n\\n if self.do_validation:\\n val_log = self.valid_epoch(epoch)\\n log.update(**{'val_' + k: v for k, v in val_log.items()})\\n\\n if self.lr_scheduler is not None:\\n if isinstance(self.lr_scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau):\\n self.lr_scheduler.step(log[\\\"val_roc_auc\\\"])\\n else:\\n self.lr_scheduler.step()\\n return log\",\n \"def __call__(self, epoch):\\n # Compute the new dynamic learning rate, log in onto TensorBoard and\\n # return the result for the training process\\n learning_rate = self.schedule(epoch)\\n tf.summary.scalar('learning rate', data=learning_rate, step=epoch)\\n return learning_rate\",\n \"def write_training_metrics(self) -> None:\\n self.trainer_metrics.write_training_metrics()\",\n \"def test_metrics_on_restart(fake_training_fn, tmpdir):\\n\\n fake_training = fake_training_fn(tmpdir)\\n assert fake_training()\\n\\n t1_values = {\\n metric.name: get_metric_data(metric, tmpdir)\\n for metric in fake_training.trainer._metrics\\n }\\n print(t1_values)\\n\\n restart = fake_training_fn(tmpdir)\\n\\n t2_values = {\\n metric.name: get_metric_data(metric, tmpdir)\\n for metric in restart.trainer._metrics\\n }\\n print(t2_values)\\n assert t1_values == t2_values\",\n \"def update(self, y_true: list[Number], y_pred: list[Number]) -> ForecastingMetric:\",\n \"def training_epoch_end(self, outputs: Any) -> None:\\n self.log_dict(self.train_metrics.compute())\\n self.train_metrics.reset()\",\n \"def on_epoch_end(self, trainer, pl_module):\\n self._log_epoch_metrics(trainer, pl_module)\",\n \"def update(self, step, metrics):\\n self.steps_arr.append(step)\\n for key, val in metrics.items():\\n if isinstance(val, tf.Tensor):\\n try:\\n self.data[key].append(val.numpy())\\n except KeyError:\\n self.data[key] = [val.numpy()]\",\n \"def epoch(self):\\n old_vals = (self._controller.kp, self._controller.ki, self._controller.kd)\\n gamma = 0.01\\n grad = self._get_gradient()\\n\\n new_vals = [p - gamma*g for p, g in zip(old_vals, grad)]\\n\\n self._controller.kp = new_vals[0] if new_vals[0] > 0 else 0\\n self._controller.ki = new_vals[1] if new_vals[1] > 0 else 0\\n self._controller.kd = new_vals[2] if new_vals[2] > 0 else 0\",\n \"def update_history(self, start_training, start_epoch, epoch, res_trackers_dict):\\n self.history.get('epoch_index', []).append(epoch+1)\\n self.history.get('time_epoch', []).append(time.time()-start_epoch)\\n self.history.get('time_cumulative', []).append(time.time()-start_training)\\n\\n self.history.get('train', {}).get('gen_loss', []).append(res_trackers_dict['loss_tracker_train_gen'])\\n self.history.get('train', {}).get('gen_mae', []).append(res_trackers_dict['metric_tracker_train_gen'])\\n self.history.get('train', {}).get('disc_loss', []).append(res_trackers_dict['loss_tracker_train_disc'])\\n self.history.get('train', {}).get('disc_acc', []).append(res_trackers_dict['metric_tracker_train_disc'])\\n\\n self.history.get('val', {}).get('gen_loss', []).append(res_trackers_dict['loss_tracker_val_gen'])\\n self.history.get('val', {}).get('gen_mae', []).append(res_trackers_dict['metric_tracker_val_gen'])\\n self.history.get('val', {}).get('disc_loss', []).append(res_trackers_dict['loss_tracker_val_disc'])\\n self.history.get('val', {}).get('disc_acc', []).append(res_trackers_dict['metric_tracker_val_disc'])\",\n \"def update_training_dict(self, feed_dict):\\n self._update_with_dual(feed_dict, 'hebb_init_pl') # re-initialize hebbian at the start of episode\\n self._update_with_dual(feed_dict, 'init_pl') # re-initialize rnn state at the start of episode\\n self._update_with_dual(feed_dict, 'mask') # mask\",\n \"def _valid_epoch(self, epoch):\\n self.model.eval()\\n self.valid_metrics.reset()\\n with torch.no_grad():\\n for batch_idx, (data, target, _) in enumerate(self.valid_data_loader):\\n data, target = data.to(device=self.device, dtype=torch.float), target.to(self.device, dtype=torch.float)\\n\\n output = self.model(data)\\n\\n if self.only_scored_classes:\\n # Only consider classes that are scored with the Challenge metric.\\n if self.config[\\\"loss\\\"][\\\"type\\\"] == \\\"weighted_bce_with_logits_loss\\\":\\n loss = self.criterion(output[:, self.indices], target[:, self.indices], self.weights)\\n else:\\n loss = self.criterion(output[:, self.indices], target[:, self.indices])\\n else:\\n loss = self.criterion(output, target)\\n\\n self.writer.set_step((epoch - 1) * len(self.valid_data_loader) + batch_idx, 'valid')\\n self.valid_metrics.update('loss', loss.item())\\n\\n output_logit = self.sigmoid(output)\\n for met in self.metric_ftns:\\n self.valid_metrics.update(met.__name__, met(self._to_np(output_logit), self._to_np(target)))\\n # self.writer.add_image('input', make_grid(data.cpu(), nrow=8, normalize=True))\\n\\n if self.lr_scheduler is not None and self.config[\\\"lr_scheduler\\\"][\\\"type\\\"] == \\\"ReduceLROnPlateau\\\":\\n self.lr_scheduler.step(self.valid_metrics.result()[\\\"challenge_metric\\\"])\\n\\n # add histogram of model parameters to the tensorboard\\n # for name, p in self.model.named_parameters():\\n # self.writer.add_histogram(name, p, bins='auto')\\n return self.valid_metrics.result()\",\n \"def add_metrics(self, metrics):\\n for i, metric in enumerate(self.config.metrics):\\n tf.summary.scalar(metric, metrics[i])\",\n \"def plot_metrics_over_iterations(metrics, epoch):\\n total_elbo, total_cond_log_like, total_kl = metrics\\n legend = ['ELBO', 'log p(x | z)']\\n\\n for level in range(len(total_kl)):\\n legend.append('KL Divergence, Level ' + str(level))\\n\\n nans = np.zeros((1, 2 + len(total_kl)))\\n nans.fill(np.nan)\\n indices = np.ones((1, 2 + len(total_kl)))\\n\\n handle = plot_line(nans, indices, legend=legend,\\n title='Average Metrics During Inference Iterations, Epoch ' + str(epoch),\\n xlabel='Inference Iterations', ylabel='Metrics (Nats)')\\n\\n iterations = np.arange(0, total_elbo.shape[1]).astype(int)\\n\\n ave_elbo = np.mean(total_elbo, axis=0)\\n update_trace(ave_elbo, iterations, win=handle, name='ELBO')\\n\\n ave_recon = np.mean(total_cond_log_like, axis=0)\\n update_trace(ave_recon, iterations, win=handle, name='log p(x | z)')\\n\\n for level in range(len(total_kl)):\\n ave_kl = np.mean(total_kl[level], axis=0)\\n update_trace(ave_kl, iterations, win=handle, name='KL Divergence, Level ' + str(level))\",\n \"def save_to_json(self, dir_to_save):\\n\\n # Check that folder is exitsts or create it\\n os.makedirs(dir_to_save, exist_ok=True)\\n json_filename = os.path.join(dir_to_save, \\\"epoch_metrics.json\\\")\\n # fill the dict\\n metrics_dict = {\\n \\\"train_mIoU\\\": str(self.train_mIoU.result().numpy()),\\n \\\"val_mIoU\\\": str(self.val_mIoU.result().numpy()),\\n \\\"train_loss\\\": str(self.train_loss.result().numpy()),\\n \\\"val_loss\\\": str(self.val_loss.result().numpy()),\\n \\\"train_accuracy\\\": str(self.train_accuracy.result().numpy()),\\n \\\"val_accuracy\\\": str(self.val_accuracy.result().numpy()),\\n \\\"train_confusion_matrix\\\": self.train_mIoU.total_cm.numpy().tolist(),\\n \\\"val_confusion_matrix\\\": self.val_mIoU.total_cm.numpy().tolist(),\\n }\\n save_to_json(json_filename, metrics_dict)\",\n \"def on_validation_epoch_end(self, trainer, pl_module):\\n self._log_epoch_metrics(trainer, pl_module)\",\n \"def on_epoch_end(self, epoch, logs={}):\\n self.losses.append(logs.get(\\\"loss\\\"))\\n self.val_losses.append(logs.get(\\\"val_loss\\\"))\",\n \"def on_epoch_start(self):\\n self.current_epoch += 1\\n self.current_lr = self.fn(self.current_epoch)\\n self.model.set_learning_rate(self.current_lr)\\n self.epochs += [self.current_epoch]\\n self.learning_rate += [self.current_lr]\",\n \"def training_metrics(self):\\r\\n if self._training_metrics is None:\\r\\n # Builds the per-task metrics and losses.\\r\\n self._training_metrics = {}\\r\\n for name, task in self.multi_task.tasks.items():\\r\\n self._training_metrics[name] = task.build_metrics(training=True)\\r\\n return self._training_metrics\",\n \"def evaluate_epoch(eval_dl, model, criterion, epoch, writer):\\n print('\\\\neval epoch {}'.format(epoch))\\n device = next(model.parameters()).device\\n\\n model.eval()\\n recall = Recall(lambda x: (x[0], x[1]))\\n precision = Precision(lambda x: (x[0], x[1]))\\n mean_recall = []\\n mean_precision = []\\n mean_loss = []\\n with torch.no_grad():\\n for idx, (inputs, targets) in enumerate(eval_dl):\\n inputs, targets = inputs.to(device), targets.to(device)\\n outputs = model(inputs)\\n loss = criterion(outputs, targets)\\n\\n preds = outputs.argmax(1)\\n\\n precision.update((preds, targets))\\n recall.update((preds, targets))\\n mean_loss.append(loss.item())\\n mean_recall.append(recall.compute().item())\\n mean_precision.append(precision.compute().item())\\n\\n # print('val-epoch:{} [{}/{}], loss: {:5.3}'.format(epoch, idx + 1, len(dataloader), loss.item()))\\n writer.add_scalar('test/loss', loss.item(), len(eval_dl) * epoch + idx)\\n\\n mean_precision, mean_recall = np.array(mean_precision).mean(), np.array(mean_recall).mean()\\n f1 = mean_precision * mean_recall * 2 / (mean_precision + mean_recall + 1e-20)\\n\\n print('precision: {:07.5}, recall: {:07.5}, f1: {:07.5}\\\\n'.format(mean_precision, mean_recall, f1))\\n writer.add_scalar('test/epoch-loss', np.array(mean_loss).mean(), epoch)\\n writer.add_scalar('test/f1', f1, epoch)\\n writer.add_scalar('test/precision', mean_precision, epoch)\\n writer.add_scalar('test/recall', mean_recall, epoch)\",\n \"def on_epoch_end(self, epoch, logs={}):\\n tmp = K.eval(self.beta)\\n self._beta.append(tmp)\",\n \"def run_epoch(self, epoch, data_loader, training=False):\\n if training:\\n self.model.train()\\n else:\\n self.model.eval()\\n\\n epoch_metrics = {\\\"loss\\\": 0.0}\\n overall_parsing_counts = {\\\"correct\\\": 0, \\\"predicted\\\": 0, \\\"gold\\\": 0}\\n num_evaluated_batches = 0\\n\\n with torch.set_grad_enabled(training):\\n for sentences, target in data_loader:\\n # Run model\\n target = self._to_device(target)\\n output, parsing_counts = self.parser.evaluate_batch(sentences)\\n\\n # Compute loss\\n output, target = self._unroll_sequence_batch(output), self._unroll_sequence_batch(target)\\n loss = self.criterion(output, target)\\n\\n # Add metrics to overall total\\n epoch_metrics[\\\"loss\\\"] += loss.item()\\n for count in \\\"gold\\\", \\\"predicted\\\", \\\"correct\\\":\\n overall_parsing_counts[count] += parsing_counts[count]\\n\\n # Perform backpropagation (when training)\\n if training:\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # Print progress\\n num_evaluated_batches += 1\\n self.logger.debug('{} Epoch: {} {} Loss: {:.6f}'.format(\\n \\\"Training\\\" if training else \\\"Validation\\\",\\n epoch,\\n self._progress(num_evaluated_batches, data_loader),\\n loss.item()))\\n\\n epoch_metrics.update(self.compute_prf(overall_parsing_counts))\\n\\n return epoch_metrics\",\n \"def update_metric(self, metric, value):\\n if self.is_number(value):\\n self.logger.debug(\\\"Collected raw metric: %s = %s\\\" % (metric, value))\\n self.raw_metrics[metric] = value\",\n \"def __init__(self, metrics, gt, pred):\\n self.dict_metrics = self.compute_metrics(metrics, gt, pred)\",\n \"def _get_epoch_acc(self, is_test: bool = False) -> Dict[str, float]:\\n n_total = (\\n len(self.testloader.dataset) if is_test else len(self.trainloader.dataset)\\n )\\n acc = dict()\\n for module_name in self.n_correct_epoch:\\n accuracy = 100 * self.n_correct_epoch[module_name] / n_total\\n acc.update({module_name + \\\"_acc\\\": accuracy})\\n self.n_correct_epoch.clear()\\n\\n return acc\",\n \"def test_epoch_end(self, outputs: Any) -> None:\\n self.log_dict(self.test_metrics.compute())\\n self.test_metrics.reset()\",\n \"def eval_epoch(model, validation_data, pred_loss_func, opt):\\n\\n model.eval()\\n\\n total_event_ll = 0 # cumulative event log-likelihood\\n total_time_se = 0 # cumulative time prediction squared-error\\n total_time_error = 0 # cumulative time prediction squared-error\\n total_time_latitude = 0 # cumulative latitude prediction squared-error\\n total_time_longitude = 0 # cumulative longitude prediction squared-error\\n\\n total_event_rate = 0 # cumulative number of correct prediction\\n total_num_event = 0 # number of total events\\n total_num_pred = 0 # number of predictions\\n with torch.no_grad():\\n for batch in tqdm(validation_data, mininterval=2,\\n desc=' - (Validation) ', leave=False):\\n \\\"\\\"\\\" prepare data \\\"\\\"\\\"\\n event_time, time_gap, event_type, latitude, longitude = map(lambda x: x.to(opt.device), batch)\\n\\n \\\"\\\"\\\" forward \\\"\\\"\\\"\\n enc_out, prediction = model(event_type, event_time, latitude, longitude) # change the event_time to time gap\\n\\n \\\"\\\"\\\" compute loss \\\"\\\"\\\"\\n event_ll, non_event_ll = Utils.log_likelihood(model, enc_out, time_gap, event_type, latitude, longitude) # change the event_time to time gap\\n event_loss = -torch.sum(event_ll - non_event_ll)\\n\\n _, pred_num = Utils.type_loss(prediction[0], event_type, pred_loss_func)\\n\\n se = Utils.time_loss(prediction[1], event_time) # change the event_time to time gap\\n le = Utils.time_loss(prediction[2], latitude)\\n ge = Utils.time_loss(prediction[3], longitude)\\n\\n \\\"\\\"\\\" note keeping \\\"\\\"\\\"\\n total_event_ll += -event_loss.item()\\n total_time_se += se.item() + le.item() + ge.item()\\n total_time_error += se.item()\\n total_time_latitude += le.item()\\n total_time_longitude += ge.item()\\n\\n total_event_rate += pred_num.item()\\n total_num_event += event_type.ne(Constants.PAD).sum().item()\\n total_num_pred += event_type.ne(Constants.PAD).sum().item() - event_time.shape[0] # change the event_time to time gap\\n\\n test_rmse = np.sqrt(total_time_se / total_num_pred)\\n test_time_rmse = np.sqrt(total_time_error / total_num_pred)\\n test_latitude_rmse = np.sqrt(total_time_latitude / total_num_pred)\\n test_longitude_rmse = np.sqrt(total_time_longitude / total_num_pred)\\n\\n return total_event_ll / total_num_event, total_event_rate / total_num_pred, test_time_rmse, test_latitude_rmse, test_longitude_rmse, test_rmse\",\n \"def on_batch_end(self, epoch, logs={}):\\n self.update_count = self.update_count + 1\\n\\n new_beta = min(\\n 1.0 * self.update_count / self.total_anneal_steps, self.anneal_cap\\n )\\n\\n K.set_value(self.beta, new_beta)\",\n \"def visdom_append_metrics(vis, metrics, first_epoch=False):\\n visited = {}\\n\\n sorted_metrics = sorted(metrics.columns, key=_column_original_name)\\n for metric_basename, metric_list in it.groupby(sorted_metrics, key=_column_original_name):\\n metric_list = list(metric_list)\\n\\n for metric in metric_list:\\n if vis.win_exists(metric_basename) and (not visited.get(metric, False)) and first_epoch:\\n update = 'replace'\\n elif not vis.win_exists(metric_basename):\\n update = None\\n else:\\n update = 'append'\\n\\n vis.line(\\n metrics[metric].values,\\n metrics.index.values,\\n win=metric_basename,\\n name=metric,\\n opts={\\n 'title': metric_basename,\\n 'showlegend': True\\n },\\n update=update\\n )\\n\\n if metric_basename != metric and len(metric_list) > 1:\\n if vis.win_exists(metric) and first_epoch:\\n update = 'replace'\\n elif not vis.win_exists(metric):\\n update = None\\n else:\\n update = 'append'\\n\\n vis.line(\\n metrics[metric].values,\\n metrics.index.values,\\n win=metric,\\n name=metric,\\n opts={\\n 'title': metric,\\n 'showlegend': True\\n },\\n update=update\\n )\",\n \"def logPerformanceAndCompounds(self, epoch, metrics, scores):\\n \\n # Add epoch and best epoch to metrics, and order columns\\n metrics['Epoch'] = epoch\\n metrics = {k : metrics[k] for k in ['Epoch'] + [k for k in metrics.keys() if k != 'Epoch']}\\n metrics['best_epoch'] = self.last_save\\n \\n # Add epoch to scores, and order columns\\n scores['Epoch'] = epoch\\n if 'Accurate' in scores.columns:\\n scores = scores[['Epoch', 'SMILES', 'Frags', 'Valid', 'Accurate', 'Desired'] + self.env.getScorerKeys()]\\n else:\\n scores = scores[['Epoch', 'SMILES', 'Valid', 'Desired'] + self.env.getScorerKeys()]\\n\\n self.monitor.savePerformanceInfo(metrics, df_smiles=scores)\\n self.monitor.endStep(None, epoch)\",\n \"def _fill_mean_dict(self, running_metrics: Dict, mean_dict: Dict) -> None:\\n for key, value in running_metrics.items():\\n mean = np.mean(value)\\n mean_dict[key].append(mean)\",\n \"def begin_epoch(self, epoch, model):\\n super().begin_epoch(epoch, model)\\n if hasattr(self.criterion, \\\"set_epoch\\\"):\\n self.criterion.set_epoch(epoch)\",\n \"def run_epoch(self, sess, epoch_num, validate=True):\\n total_loss = 0\\n accuracies = []\\n for i in range(self.batches_per_epoch):\\n batch = self.loader.get_batch()\\n if self.config.print_every and i % self.config.print_every == 0:\\n if validate:\\n val_accuracy = self.eval_validation_accuracy()\\n print(\\\"step {}, validation accuracy {:.3f}\\\".format(i, val_accuracy))\\n accuracies.append((i + epoch_num * self.batches_per_epoch, val_accuracy))\\n else:\\n if self.include_coverage and self.include_entropy:\\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1], batch[2], batch[3])\\n elif self.include_coverage:\\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1], batch[2])\\n elif self.include_entropy:\\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1], batch[2])\\n else:\\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1])\\n print(\\\"step {}, training accuracy {:.3f}\\\".format(i, train_accuracy))\\n \\n if self.include_coverage and self.include_entropy:\\n _, loss_val = sess.run([self.train_op, self.loss],\\n feed_dict={self.x: batch[0], self.c: batch[1], self.e: batch[2], self.y_: batch[2], \\n self.keep_prob: 1-self.config.dropout_prob})\\n elif self.include_coverage:\\n _, loss_val = sess.run([self.train_op, self.loss],\\n feed_dict={self.x: batch[0], self.c: batch[1], self.y_: batch[2], \\n self.keep_prob: 1-self.config.dropout_prob})\\n elif self.include_entropy:\\n _, loss_val = sess.run([self.train_op, self.loss],\\n feed_dict={self.x: batch[0], self.e: batch[1], self.y_: batch[2], \\n self.keep_prob: 1-self.config.dropout_prob})\\n else:\\n attention, _, loss_val = sess.run([self.attention, self.train_op, self.loss],\\n feed_dict={self.x: batch[0], self.y_: batch[1],\\n self.keep_prob: 1-self.config.dropout_prob})\\n\\t\\tpdb.set_trace()\\n\\t\\tnp.savetxt(\\\"a.csv\\\", attention[0], delimiter=\\\",\\\")\\n total_loss += loss_val\\n\\n return total_loss / self.batches_per_epoch, accuracies\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.653285","0.6474349","0.64158195","0.63220245","0.6176943","0.6079535","0.6050288","0.6017538","0.5881254","0.58689195","0.5808414","0.5795073","0.5788146","0.5759678","0.5751611","0.5738101","0.573619","0.57162505","0.56976926","0.5689485","0.5674656","0.56521153","0.56493783","0.56493783","0.56237316","0.56063765","0.559592","0.55880964","0.5565592","0.5562108","0.5559709","0.5548663","0.5546571","0.55288905","0.5509183","0.5509183","0.5508521","0.5498766","0.5498296","0.54945695","0.54839236","0.5479305","0.5477553","0.54754466","0.5474711","0.54588115","0.54555184","0.5450125","0.5449853","0.5433546","0.5433546","0.5433546","0.5433546","0.54272425","0.54056776","0.5402542","0.5401479","0.5395286","0.5387184","0.53863406","0.53720576","0.53530246","0.53501254","0.5347165","0.5339538","0.53290164","0.5314452","0.5310681","0.5308192","0.52993983","0.5282141","0.5281083","0.5279342","0.5277588","0.5276524","0.52678114","0.5267158","0.52656233","0.52576375","0.5257547","0.52500564","0.5249662","0.5247359","0.52468646","0.5231715","0.52280635","0.52223366","0.5220627","0.5213835","0.5208045","0.5204806","0.5203857","0.5203277","0.5187468","0.51806176","0.51698357","0.516817","0.51588976","0.51521194","0.5141222"],"string":"[\n \"0.653285\",\n \"0.6474349\",\n \"0.64158195\",\n \"0.63220245\",\n \"0.6176943\",\n \"0.6079535\",\n \"0.6050288\",\n \"0.6017538\",\n \"0.5881254\",\n \"0.58689195\",\n \"0.5808414\",\n \"0.5795073\",\n \"0.5788146\",\n \"0.5759678\",\n \"0.5751611\",\n \"0.5738101\",\n \"0.573619\",\n \"0.57162505\",\n \"0.56976926\",\n \"0.5689485\",\n \"0.5674656\",\n \"0.56521153\",\n \"0.56493783\",\n \"0.56493783\",\n \"0.56237316\",\n \"0.56063765\",\n \"0.559592\",\n \"0.55880964\",\n \"0.5565592\",\n \"0.5562108\",\n \"0.5559709\",\n \"0.5548663\",\n \"0.5546571\",\n \"0.55288905\",\n \"0.5509183\",\n \"0.5509183\",\n \"0.5508521\",\n \"0.5498766\",\n \"0.5498296\",\n \"0.54945695\",\n \"0.54839236\",\n \"0.5479305\",\n \"0.5477553\",\n \"0.54754466\",\n \"0.5474711\",\n \"0.54588115\",\n \"0.54555184\",\n \"0.5450125\",\n \"0.5449853\",\n \"0.5433546\",\n \"0.5433546\",\n \"0.5433546\",\n \"0.5433546\",\n \"0.54272425\",\n \"0.54056776\",\n \"0.5402542\",\n \"0.5401479\",\n \"0.5395286\",\n \"0.5387184\",\n \"0.53863406\",\n \"0.53720576\",\n \"0.53530246\",\n \"0.53501254\",\n \"0.5347165\",\n \"0.5339538\",\n \"0.53290164\",\n \"0.5314452\",\n \"0.5310681\",\n \"0.5308192\",\n \"0.52993983\",\n \"0.5282141\",\n \"0.5281083\",\n \"0.5279342\",\n \"0.5277588\",\n \"0.5276524\",\n \"0.52678114\",\n \"0.5267158\",\n \"0.52656233\",\n \"0.52576375\",\n \"0.5257547\",\n \"0.52500564\",\n \"0.5249662\",\n \"0.5247359\",\n \"0.52468646\",\n \"0.5231715\",\n \"0.52280635\",\n \"0.52223366\",\n \"0.5220627\",\n \"0.5213835\",\n \"0.5208045\",\n \"0.5204806\",\n \"0.5203857\",\n \"0.5203277\",\n \"0.5187468\",\n \"0.51806176\",\n \"0.51698357\",\n \"0.516817\",\n \"0.51588976\",\n \"0.51521194\",\n \"0.5141222\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5343309"},"document_rank":{"kind":"string","value":"64"}}},{"rowIdx":91498,"cells":{"query":{"kind":"string","value":"Initialize the output dict"},"document":{"kind":"string","value":"def init_output_dict(self):\n return {\n \"outputs\": torch.FloatTensor(),\n \"pred_probs\": torch.FloatTensor(),\n \"labels\": torch.LongTensor(),\n }"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _populate_output(self):\n pass","def initialize_output_dict(self, label: Optional[str] = None):\n if label is not None or not self._does_output_dict_contain_info():\n for species in self.species_list:\n if label is None or species.label == label:\n if species.label not in self.output:\n self.output[species.label] = dict()\n if 'paths' not in self.output[species.label]:\n self.output[species.label]['paths'] = dict()\n path_keys = ['geo', 'freq', 'sp', 'composite']\n for key in path_keys:\n if key not in self.output[species.label]['paths']:\n self.output[species.label]['paths'][key] = ''\n if 'irc' not in self.output[species.label]['paths'] and species.is_ts:\n self.output[species.label]['paths']['irc'] = list()\n if 'job_types' not in self.output[species.label]:\n self.output[species.label]['job_types'] = dict()\n for job_type in list(set(self.job_types.keys())) + ['opt', 'freq', 'sp', 'composite', 'onedmin']:\n if job_type in ['rotors', 'bde']:\n # rotors could be invalidated due to many reasons,\n # also could be falsely identified in a species that has no torsional modes.\n self.output[species.label]['job_types'][job_type] = True\n else:\n self.output[species.label]['job_types'][job_type] = False\n keys = ['conformers', 'isomorphism', 'convergence', 'restart', 'errors', 'warnings', 'info']\n for key in keys:\n if key not in self.output[species.label]:\n if key == 'convergence':\n self.output[species.label][key] = None\n else:\n self.output[species.label][key] = ''","def finalize_output_dict(self):\n self.output_dict = {\n key: torch.cat(value).numpy() for key, value in self.output_dict.items()\n }","def _init_(self):\n self.res = {}","def _get_output_dictionary(self):\n\n return_dictionary = {}\n\n for output_path in self.provided_outputs:\n return_dictionary[output_path.full_path] = self.get_value(output_path)\n\n return return_dictionary","def output_data_definitions(self):\n return {}","def __init__(self):\n self._results = {}\n self._logs = {}","def finalize_output_dict(self, output_dict):\n return {key: output_dict[key].cpu().numpy() for key in output_dict.keys()}","def __init__(self):\n self.result_obj = {}","def __init__(self):\n self.result_obj = {}","def _initialize_summary_output(ns_list):\n\n summary_dict = {}\n summary_dict[\"CLUSTER\"] = {}\n\n summary_dict[\"CLUSTER\"][\"server_version\"] = []\n summary_dict[\"CLUSTER\"][\"os_version\"] = []\n summary_dict[\"CLUSTER\"][\"active_features\"] = []\n summary_dict[\"CLUSTER\"][\"migrations_in_progress\"] = False\n\n summary_dict[\"CLUSTER\"][\"device\"] = {}\n summary_dict[\"CLUSTER\"][\"device\"][\"count\"] = 0\n summary_dict[\"CLUSTER\"][\"device\"][\"count_per_node\"] = 0\n summary_dict[\"CLUSTER\"][\"device\"][\"count_same_across_nodes\"] = True\n summary_dict[\"CLUSTER\"][\"device\"][\"total\"] = 0\n summary_dict[\"CLUSTER\"][\"device\"][\"used\"] = 0\n summary_dict[\"CLUSTER\"][\"device\"][\"aval\"] = 0\n summary_dict[\"CLUSTER\"][\"device\"][\"used_pct\"] = 0\n summary_dict[\"CLUSTER\"][\"device\"][\"aval_pct\"] = 0\n\n summary_dict[\"CLUSTER\"][\"memory\"] = {}\n summary_dict[\"CLUSTER\"][\"memory\"][\"total\"] = 0\n summary_dict[\"CLUSTER\"][\"memory\"][\"aval\"] = 0\n summary_dict[\"CLUSTER\"][\"memory\"][\"aval_pct\"] = 0\n\n summary_dict[\"CLUSTER\"][\"active_ns\"] = 0\n summary_dict[\"CLUSTER\"][\"ns_count\"] = 0\n\n summary_dict[\"CLUSTER\"][\"license_data\"] = {}\n summary_dict[\"CLUSTER\"][\"license_data\"][\"memory_size\"] = 0\n summary_dict[\"CLUSTER\"][\"license_data\"][\"device_size\"] = 0\n\n summary_dict[\"FEATURES\"] = {}\n summary_dict[\"FEATURES\"][\"NAMESPACE\"] = {}\n\n for ns in ns_list:\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns] = {}\n\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"devices_total\"] = 0\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"devices_per_node\"] = 0\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"devices_count_same_across_nodes\"] = True\n\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"memory_total\"] = 0\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"memory_aval\"] = 0\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"memory_available_pct\"] = 0\n\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"disk_total\"] = 0\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"disk_used\"] = 0\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"disk_aval\"] = 0\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"disk_used_pct\"] = 0\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"disk_available_pct\"] = 0\n\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"repl_factor\"] = 0\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"master_objects\"] = 0\n\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"license_data\"] = {}\n\n summary_dict[\"FEATURES\"][\"NAMESPACE\"][ns][\"migrations_in_progress\"] = False\n\n return summary_dict","def prepare_results(self) -> dict:\n if not hasattr(self, \"results\"):\n raise AttributeError(\n \"Results have not been finalized. Please call \"\n \"finalize_results() before saving output.\"\n )\n\n output = {\n \"armory_version\": armory.__version__,\n \"config\": self.config,\n \"results\": self.results,\n \"timestamp\": int(self.time_stamp),\n }\n return output","def __init__(self):\n self.output = []","def __init__(self):\n dict = defaultdict(list)\n self.conversion_dict = dict","def _init_results(self) -> None:\n pt_bond_dimensions = {}\n for site, pt in enumerate(self._process_tensors):\n if pt is not None:\n pt_bond_dimensions[site] = pt.get_bond_dimensions()\n\n self._results = {\n 'time':[],\n 'norm': [],\n 'bond_dimensions': [],\n 'dynamics': {},\n 'pt_bond_dimensions': pt_bond_dimensions,\n }\n for sites in self._dynamics_sites:\n self._results['dynamics'][sites] = Dynamics(name=f\"site{sites}\")","def generate(self) -> Dict[str, Any]:\n raise NotImplementedError","def __init__(self):\n super(ExponentialOutputs, self).__init__()\n #dictionary of time, outputs\n self.out_pop_time_series = []","def output(self):\n return {\n \"time\": self.time,\n \"dmx\": self.dmx\n }","def __init__(self):\n self.inputs = {}","def initialize(self, runInfo, inputs, initDict) :\n super().initialize(runInfo, inputs, initDict)\n for metricIn in self.assemblerDict['Metric']:\n self.metricsDict[metricIn[2]] = metricIn[3]","def output_result(self):\n output = {}\n output['draw'] = str(int(self.params['draw']))\n output['recordsTotal'] = str(self.cardinality)\n output['recordsFiltered'] = str(self.cardinality_filtered)\n if self.error:\n output['error'] = self.error\n return output\n\n output['data'] = self.results\n for k, v in self.yadcf_params:\n output[k] = v\n return output","def __init__(self,n):\n\t\tself._dictOut={}\n\t\tself._dictIn = {}\n\t\tfor i in range(n):\n\t\t\tself._dictOut[i]=[]\n\t\t\tself._dictIn[i] = []","def output_from_json(self, output: Dict[str, Any]) -> OutputInfo:","def construct_output_dict():\n list_of_recipes = construct_list_of_recipes()\n output_dict = {}\n for recipe_list in list_of_recipes:\n recipe_instance = construct_recipe_object(recipe_list)\n recipe_dict = recipe_instance.construct_json_rep_obj()\n for k, v in recipe_dict.iteritems():\n output_dict[k] = v\n output_dict = filter_output_dict(output_dict)\n return {'recipes': output_dict}","def __init__(self):\n self._summary = {}","def output_definition(self):\n return {\n 'error': [0.0, 10.0]\n }","def output_data(self):\n pass","def create_results_dict(self, n_options):\n if n_options == 1:\n self.results_dict[0] = {\"configuration\": [\"user\"]}\n for name in self.results_metadata[\"names\"]:\n self.results_dict[0][name] = []\n else:\n self.results_dict = {}\n for i in range(n_options):\n self.results_dict[i] = {\"configuration\": []}\n for name in self.results_metadata[\"names\"]:\n self.results_dict[i][name] = []","def create_dicts(self):\n \n # remove this string from filename to make output file names more manageable\n pre_output1 = self.file1.replace(\"_Guys121919_CGH_1100_Jul11\", '')\n pre_output2 = self.file2.replace(\"_Guys121919_CGH_1100_Jul11\", '')\n \n # Build the output file name.\n # if prefix is present add it\n if self.out_file_prefix is not None:\n # concatenate prefix, filenames and dyes into output filename file1_file1_dye_file2_file2_dye.txt\n self.outputfilename = self.out_file_prefix+pre_output1.replace(\".txt\", '') + \"_\" + self.file1_dye + \"_\" + pre_output2.replace(\".txt\", '') + \"_\" + self.file2_dye + \".txt\"\n # if no prefix don't add it!\n else:\n # concatenate filenames and dyes into output filename file1_file1_dye_file2_file2_dye.txt\n self.outputfilename = pre_output1.replace(\".txt\", '') + \"_\" + self.file1_dye + \"_\" + pre_output2.replace(\".txt\", '') + \"_\" + self.file2_dye + \".txt\"\n\n # add temp to end of file name to create a temporary output filename\n self.tempoutputfilename = self.outputfilename.replace(\".txt\", '') + \"temp.txt\"\n\n # open temp output file\n self.tempoutputfile = open(self.outputfolder + self.tempoutputfilename, 'w')\n\n \n # open FE files\n file1_open = open(self.chosenfolder + self.file1, 'r')\n file2_open = open(self.chosenfolder + self.file2, 'r')\n\n # open file1 and create a dict of the features.\n for linenumber, line in enumerate(file1_open):\n if linenumber >= 10:\n splitline = line.split('\\t')\n self.file1_dict[int(splitline[1])] = line\n # get n of rows in file1 (take the linenumber of the last line)\n self.file1_len = linenumber\n\n # repeat for features in second file but first writing the feparam and stats to temp file - when pairing with control this ensures the \"header\" comes from the test (file2) not control (file1), NB NEITHER ARE ACCURATE!!!!\n for linenumber, line in enumerate(file2_open):\n if linenumber < 10:\n self.tempoutputfile.write(line)\n # then add all features to a dictionary, with the unique feature number as a key\n if linenumber >= 10:\n splitline = line.split('\\t')\n self.file2_dict[int(splitline[1])] = line\n # get n of rows in file2\n self.file2_len = linenumber\n\n # close files\n file1_open.close()\n file2_open.close()","def __init__(self, out):\r\n super(PHPTMAPIMapHandler, self).__init__()\r\n self._out = out\r\n self._counter = 0","def __init__(self, output_mediator):\n super(ElasticSearchOutputModule, self).__init__(output_mediator)\n self._counter = 0\n self._data = []\n self._doc_type = None\n self._elastic_db = None\n self._index_name = None","def _generate_output(self):\n raise NotImplementedError()","def __init__(self):\n self.memory = {}\n self.sum_ = {}","def output_data_definitions(self):\n return {\n self.key_outputs: DataDefinition([-1, self.output_size], [torch.Tensor], \"Batch of outputs [BATCH_SIZE x OUTPUT_SIZE]\")\n }","def __generate_dict(self, test_output_dir, types, _table):\n # dump json from file to dict\n\n table_dict = CaseDump(os.path.join(test_output_dir, _table + OUT_SUFFIX), CASE_FILE_TYPE_JSON).dump()\n\n # foreach key from statistic report, split it into table/type/key/sub_value\n type_dict = {}\n for _key in table_dict.keys():\n # wipe off table\n _key = _key.replace(\"%s_\" % _table, \"\")\n for _type in types:\n # wipe off type\n if _type and _type in _key:\n if _type not in type_dict.keys():\n type_dict[_type] = {}\n _key = _key.replace(\"%s_\" % _type, \"\")\n # if has sub_value, set RESULT_DICT[table][type][key] = sub_value\n # else set RESULT_DICT[table][type][key] = None\n if \"#\" in _key:\n sub_value = _key.split(\"#\")\n type_dict[_type][sub_value[0]] = sub_value[1]\n else:\n type_dict[_type][_key] = \"\"\n break\n\n global RESULT_DICT\n RESULT_DICT[_table] = type_dict","def outputs(self):\n return {\"path_to_mapping_json\": File_IO(\n self.node.outputs[0])}","def __init__(self):\n self.cnt = {}","def parsed_output(output_elements):\n parsed_output = {}\n for stanza, stanza_value in output_elements.items():\n fake_section = MagicMock()\n fake_section.options = {}\n fake_section.name = stanza\n parsed_output.update({stanza: fake_section})\n for option, value in stanza_value.items():\n fake_setting = MagicMock()\n fake_setting.name = option\n fake_setting.value = value\n parsed_output[stanza].options.update({option: fake_setting})\n return parsed_output","def _populate_output(self):\n self._store_atomic_queries_table()\n self._store_composite_queries_table()","def _create_sample(self, policy_output, next_state, reward, done, info,\n env_id):\n return {\n \"policy_output\": policy_output,\n \"next_state\": next_state,\n \"reward\": reward,\n \"done\": done,\n \"info\": info,\n \"env_id\": env_id\n }","def __init__(self):\n self.info = dict()","def __init__(self, n):\n self._dictOut = {}\n self._dictIn = {}\n for i in range(n):\n self._dictOut[i] = []\n self._dictIn[i] = []","def __init__(self):\n self.d = {}","def __init__(self):\n self.d = {}","def __init__(self):\n self.d = {}","def __init__(self):\n self.d = {}","def __init__(self):\n self.stats = {}\n self.stats['hits'] = 0\n self.stats['operations'] = {}\n self.stats['operations']['GetCapabilities'] = {}\n self.stats['operations']['GetCapabilities']['hits'] = 0\n self.stats['operations']['POST'] = {}\n self.stats['operations']['POST']['hits'] = 0","def __init__(self):\n self.run = OrderedDict()","def base_dict():\n out = OrderedDict()\n ao(out, 'name', 'String', 'Name', name='Name')\n ao(out, 'mro', 'List', name='mro', attr=['Hidden'])\n ao(out, 'comment', 'String', '')\n ao(out, 'preset', 'Preset', '', attr=['Hidden'])\n ao(out, 'dev', 'String', attr=['Hidden'])\n ao(out, 'devpath', 'String', attr=['Hidden'])\n ao(out, 'fullpath', 'String', attr=['Hidden'])\n ao(out, 'zerotime', 'Float', name='Start time', attr=['Hidden'])\n ao(out, 'initInstrument', 'Progress', attr=['Hidden'])\n return out","def __init__(self):\n self._main_dictionary = defaultdict(set)","def __init__(self, properties):\n self.attributes = {}\n self.output_info = {}\n for key, node in properties.walk():\n self.attributes[key[1]] = node.get_value().strip(\" '\")","def initialize_output(self):\n # set dims and store as 'output' class variable\n rows = self.obs\n dims = len(self.cols)\n self.output = pd.DataFrame(np.zeros((rows, dims)), columns=self.cols)","def __init__(self):\n self.params = {}\n self.counts = 0\n self.failed = 0\n self.path = os.path.join(os.getcwd(), OUTPUT_DIR)\n \n if not os.path.exists(self.path):\n os.makedirs(self.path)","def init_results(self):\n results = {}\n for i in range(len(self.agents)):\n actor = self.agents[i]\n actor.set_name(\"Actor\") # the filename part of the name is set in actor using filename from init_agents\n results[actor.name] = 0\n return results","def __init__(self):\n self.d = {}\n self.h = []","def run(self, input):\n return {}","def createDict( self ):\n self.d = {}\n self.d['comp1'] = compensation_channel('comp1', 0, (-479.0, -10.0))\n self.d['comp2'] = compensation_channel('comp2', 1, (-479.0, -10.0))\n self.addCalibration()","def __init__(self):\n self.mapr = OrderedDict()\n self.counter = 0","def generate_dict(self):\n # verify preferred timestamp exists in the structure...\n if not self._check_preferred_timestamps():\n raise SampleException(\"Preferred timestamp not in particle!\")\n\n # build response structure\n self._encoding_errors = []\n if self._values is None:\n self._values = self._build_parsed_values()\n result = self._build_base_structure()\n result[DataParticleKey.STREAM_NAME] = self.data_particle_type()\n result[DataParticleKey.VALUES] = self._values\n\n return result","def __init__(self):\n self.dict = {}","def __init__(self):\n self.dict = {}","def __init__(self, params, out):\n self.configurations = []\n self.out = out\n self.add_configuration(params)","def _build_dictionary(self):\n print(\"Building Dictionary...\")\n self.dictionary = Dictionary(self.load_files())","def get_data(self):\n self.data = dict()\n # list to save all the attributes we are going to create\n self.attr = []\n # list to save all the groups available in the incomming input\n self.groups.extend(self.values.keys())\n # Grouping\n self.parse_data()","def output(self):\n args = []\n for i in range(0, len(self.args)):\n args.append({\"id\": i + 1, \"value\": self.args[i]})\n\n val = {\n \"id\": self.id,\n \"device\": self.device.id,\n \"enabled\": 1,\n \"name\": self.name,\n \"template\": self.template,\n \"arguments\": args\n }\n\n if self.start != None and self.stop != None:\n val[\"start\"] = self.start.output()\n val[\"stop\"] = self.stop.output()\n\n if self.days_of_week != None:\n val[\"days_of_week\"] = self.days_of_week\n\n return val","def _init_profiles(self):\n self._profiles = {\n k: np.zeros((len(self.hybrid_time_index), len(self.hybrid_meta)),\n dtype=np.float32)\n for k in OUTPUT_PROFILE_NAMES}","def __init__(self):\n self.l = {}\n self.s = {}","def __init__(self):\n self.dGrph = {}\n self.__prime_ip = []\n self.__prime_op = []\n self.__op_fanout = {}","def output(self):\n return {\n \"id\": self.id,\n \"name\": self.name,\n \"type\": 2,\n \"enabled\": 1,\n \"days_of_week\": self.days,\n \"time\": self.time.output()\n }","def build_default_output(self):\n\t\t# To simplify writing data into final output file in specific order,\n\t\t# store rows and columns headers in specific order. \n\t\tcohorts_data = collections.OrderedDict()\n\t\tstart = end = self.max\n\t\tcount = 1\n\t\twhile count <= self.cohorts_number and end > self.min:\n\t\t\tstart = end - datetime.timedelta(days=6)\n\t\t\tcohorts_data[(start, end)] = None\n\t\t\tend = start - datetime.timedelta(days=1)\n\t\t\tcount += 1\n\n\t\t# Save available cohorts for later use.\n\t\tself.cohorts = cohorts_data.keys()\n\t\tcohorts_data = self.add_default_cohort_values(cohorts_data)\n\t\treturn cohorts_data","def __init__ (self):\n self.lengths = {}\n self.lower_counts = {}\n self.upper_counts = {}\n self.digit_counts = {}\n self.symbol_counts = {}\n self.class_counts = {}\n self.word_counts = {}","def prepare_multiple_out_parsers(run_dict):\n output_parser_dict = {}\n for run_label, run_name in run_dict.items():\n output_parser_dict[run_label] = OutputParser(run_name, use_most_recent=False)\n return output_parser_dict","def _output_dict(self):\n lang = self.ddnGuiLanguage.get()\n\n fileout = os.path.normpath('{}/{}-{}.xml'.\\\n format(self.MapCreator, self.Source, self.ddnCurProject.get()))\n linesout = ['<?xml version=\"1.0\" encoding=\"UTF-8\"?>', \\\n '<DictionarySet xmlns:mc=\"urn:fmosoft-map-creator\" xmlns=\"urn:fmosoft-map-creator\" Version=\"1\">', \\\n ' <Dictionary SourceLanguage=\"{}\" SourceLanguageIsPredefined=\"true\" TargetLanguage=\"{}\" TargetLanguageIsPredefined=\"false\">'.\\\n format(self.Source, self.ddnCurProject.get()), \\\n ]\n for child in self.tree.get_children('approved'):\n vv = self.tree.item(child)['values']\n linesout.append(' <Translation Source=\"{}\" Target=\"{}\"/>'.format(vv[0], vv[1]))\n linesout.append(' </Dictionary>')\n linesout.append('</DictionarySet>')\n linesout.append('')\n\n if os.path.exists(fileout):\n os.remove(fileout)\n\n if fileout:\n output = codecs.open(fileout, mode='w', encoding='utf-8')\n output.write('\\n'.join(linesout))\n output.close()\n pass","def __init__(self, output_dir):\n self.output_dir = os.path.abspath(output_dir)\n # Create the file if it doesn't already exist\n os.makedirs(self.output_dir, exist_ok=True)\n self.f = None\n self.data = None\n self.L = None","def initialize(self,inputDict):\n pass","def __init__(self):\n\t\tappionScript.AppionScript.__init__(self)\n\t\tself.rundata = {}\n\t\t### extra appionLoop functions:\n\t\tself._addDefaultParams()\n\t\tself.setFunctionResultKeys()\n\t\tself._setRunAndParameters()\n\t\t#self.specialCreateOutputDirs()\n\t\tself._initializeDoneDict()\n\t\tself.result_dirs={}","def getInitParams(self):\n paramDict = super().getInitParams()\n paramDict[f'OutStream Available {self.dim}D :'] = self.availableOutStreamTypes[self.dim]\n paramDict['Plot is '] = str(self.dim) + 'D'\n for index in range(len(self.sourceName)):\n paramDict['Source Name ' + str(index) + ' :'] = self.sourceName[index]\n\n return paramDict","def serialize(self) -> dict:\n output = super().serialize()\n output[\"iteration\"] = self.iteration\n return output","def __init__(self):\r\n self.dic={}","def dict_initialise(metadata, analysistype):\n for sample in metadata:\n sample[analysistype].dnaseq = dict()\n sample[analysistype].protseq = dict()\n sample[analysistype].ntindex = dict()\n sample[analysistype].aaindex = dict()\n sample[analysistype].ntalign = dict()\n sample[analysistype].aaalign = dict()\n sample[analysistype].aaidentity = dict()\n return metadata","def outputs(self):\n pass","def __init__(self):\n self.ngramCounts = collections.defaultdict(zero_fn);\n self.continuationProb = collections.defaultdict(set_fn);\n self.total = 0;","def serialize(self) -> dict:\n return {\n \"body_value_idx\": self.body_value_idx,\n \"output_idx\": self.output_idx,\n }","def _makeimap(self):\n self.map_['source'] = 'NAOJ'\n self.map_['provider'] = 'NRO'\n self.map_['instrument'] = 'NORH'\n self.map_['phyobs'] = ''","def __init__(self):\n self.statiFile = \"\"\n self.printOrder = []\n self.instCount = 0\n self.initializedVars = {\"GF\":[],\"TF\":[],\"LF\":[]}","def generate_data(cls):\n cls.results = {}\n cls.pre_process()\n today = datetime.today()\n skip = None\n values = map(lambda a: a[0], cls.data)\n if len(values) == 0 and 'citation' not in cls.config_data_name:\n skip = True\n weights= map(lambda a: a[1], cls.data)\n if cls.config_data_name == 'reads_histogram':\n bins = range(1996, today.year+2)\n elif cls.min_year:\n bins = range(cls.min_year, today.year+2)\n else:\n try:\n bins = range(min(values),max(values)+2)\n except:\n skip = True\n if not skip:\n refereed_values = map(lambda a: a[0], cls.refereed_data)\n refereed_weights= map(lambda a: a[1], cls.refereed_data)\n # get the regular histogram\n cls.value_histogram = histogram(values,bins=bins)\n cls.refereed_value_histogram = histogram(refereed_values,bins=bins)\n # get the normalized histogram\n cls.normalized_value_histogram = histogram(values,bins=bins,weights=weights)\n cls.refereed_normalized_value_histogram = histogram(refereed_values,bins=bins,weights=refereed_weights)\n else:\n cls.value_histogram = False\n cls.results[str(today.year)] = \"0:0:0:0\"\n cls.post_process()","def __init__(self):\n self.num_counts = {}","def with_output(self, output, output_format):\n\t\tself.variables['output'] = output\n\t\tself.variables['output_format'] = output_format\n\t\treturn self","def output_data_definitions(self):\n return {\n self.key_outputs: DataDefinition(\n [-1]*(self.num_inputs_dims-1) + [self.input_size],\n [torch.Tensor],\n \"Batch of outputs [DIM 1 x DIM 2 x ... x INPUT_SIZE]\")\n }","def get_outputs():\n outputs = {}\n for obj in vars(acsploit.output).values():\n if hasattr(obj, 'OUTPUT_NAME'):\n outputs[obj.OUTPUT_NAME] = obj\n\n return outputs","def _to_dict(self) -> \"OrderedDict[str, OrderedDict]\":\n description = OrderedDict() # type: 'OrderedDict'\n description[\"oml:run\"] = OrderedDict()\n description[\"oml:run\"][\"@xmlns:oml\"] = \"http://openml.org/openml\"\n description[\"oml:run\"][\"oml:task_id\"] = self.task_id\n description[\"oml:run\"][\"oml:flow_id\"] = self.flow_id\n if self.setup_string is not None:\n description[\"oml:run\"][\"oml:setup_string\"] = self.setup_string\n if self.error_message is not None:\n description[\"oml:run\"][\"oml:error_message\"] = self.error_message\n if self.run_details is not None:\n description[\"oml:run\"][\"oml:run_details\"] = self.run_details\n description[\"oml:run\"][\"oml:parameter_setting\"] = self.parameter_settings\n if self.tags is not None:\n description[\"oml:run\"][\"oml:tag\"] = self.tags\n if (self.fold_evaluations is not None and len(self.fold_evaluations) > 0) or (\n self.sample_evaluations is not None and len(self.sample_evaluations) > 0\n ):\n description[\"oml:run\"][\"oml:output_data\"] = OrderedDict()\n description[\"oml:run\"][\"oml:output_data\"][\"oml:evaluation\"] = list()\n if self.fold_evaluations is not None:\n for measure in self.fold_evaluations:\n for repeat in self.fold_evaluations[measure]:\n for fold, value in self.fold_evaluations[measure][repeat].items():\n current = OrderedDict(\n [\n (\"@repeat\", str(repeat)),\n (\"@fold\", str(fold)),\n (\"oml:name\", measure),\n (\"oml:value\", str(value)),\n ]\n )\n description[\"oml:run\"][\"oml:output_data\"][\"oml:evaluation\"].append(current)\n if self.sample_evaluations is not None:\n for measure in self.sample_evaluations:\n for repeat in self.sample_evaluations[measure]:\n for fold in self.sample_evaluations[measure][repeat]:\n for sample, value in self.sample_evaluations[measure][repeat][fold].items():\n current = OrderedDict(\n [\n (\"@repeat\", str(repeat)),\n (\"@fold\", str(fold)),\n (\"@sample\", str(sample)),\n (\"oml:name\", measure),\n (\"oml:value\", str(value)),\n ]\n )\n description[\"oml:run\"][\"oml:output_data\"][\"oml:evaluation\"].append(\n current\n )\n return description","def __init__(self):\n self.key2value = {}\n self.key2time = {}","def _parse_output_variables(self):\n self._output_variables_by_name = {}\n self._output_variables_by_type = {}\n for ov in self._output_variables:\n # parse the variable to get individual parts\n parsed_variable = self.parse_variable(ov)\n variable_name = parsed_variable.get('name')\n variable_type = parsed_variable.get('type')\n\n # store the variables in dict by name (e.g. \"status_code\")\n self._output_variables_by_name[variable_name] = {'variable': ov}\n\n # store the variables in dict by name-type (e.g. \"status_code-String\")\n self._output_variables_by_type[f'{variable_name}-{variable_type}'] = {'variable': ov}","def generate_output_data(self):\n for socket_name, c in self.__taskobject.outputs.items():\n data = Data(self.__project, type=c['type'])\n if c['optional']:\n data.enable(False)\n self.__outputs[socket_name] = {'data': data, 'enable': False}\n else:\n data.enable(True)\n self.__outputs[socket_name] = {'data': data, 'enable': True}","def _transform_outputs(self) -> None:\n self.outputs = None if self.outputs == {} else self.outputs","def _create_output_alternatives(self, predictions):\n return {self.head_name: (self._problem_type, predictions)}","def __init__(self, all_loadouts):\n self._name_to_loadout = {}\n self._id_to_loadout = {}\n for loadout_dict in all_loadouts:\n loadout = Loadout(**loadout_dict)\n self._id_to_loadout[loadout.id] = loadout\n self._name_to_loadout[loadout.name.lower()] = loadout","def __init__(self):\n\n # initialise the empty mappings dictionary\n self.data = {\n 'loan_id': None,\n 'product': None,\n 'origination_date': None,\n 'reversion_date': None,\n 'rate_term': None,\n 'loan_amount': None,\n 'initial_rate': None,\n 'reversion_rate': None,\n 'term': None,\n 'interest_only_amount': None,\n 'upfront_fees': None,\n 'upfront_costs': None,\n 'entity_eir': None\n }","def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.results = collections.defaultdict(collections.deque)","def cache(self):\n return {'output': self.output, 'series': self.series}"],"string":"[\n \"def _populate_output(self):\\n pass\",\n \"def initialize_output_dict(self, label: Optional[str] = None):\\n if label is not None or not self._does_output_dict_contain_info():\\n for species in self.species_list:\\n if label is None or species.label == label:\\n if species.label not in self.output:\\n self.output[species.label] = dict()\\n if 'paths' not in self.output[species.label]:\\n self.output[species.label]['paths'] = dict()\\n path_keys = ['geo', 'freq', 'sp', 'composite']\\n for key in path_keys:\\n if key not in self.output[species.label]['paths']:\\n self.output[species.label]['paths'][key] = ''\\n if 'irc' not in self.output[species.label]['paths'] and species.is_ts:\\n self.output[species.label]['paths']['irc'] = list()\\n if 'job_types' not in self.output[species.label]:\\n self.output[species.label]['job_types'] = dict()\\n for job_type in list(set(self.job_types.keys())) + ['opt', 'freq', 'sp', 'composite', 'onedmin']:\\n if job_type in ['rotors', 'bde']:\\n # rotors could be invalidated due to many reasons,\\n # also could be falsely identified in a species that has no torsional modes.\\n self.output[species.label]['job_types'][job_type] = True\\n else:\\n self.output[species.label]['job_types'][job_type] = False\\n keys = ['conformers', 'isomorphism', 'convergence', 'restart', 'errors', 'warnings', 'info']\\n for key in keys:\\n if key not in self.output[species.label]:\\n if key == 'convergence':\\n self.output[species.label][key] = None\\n else:\\n self.output[species.label][key] = ''\",\n \"def finalize_output_dict(self):\\n self.output_dict = {\\n key: torch.cat(value).numpy() for key, value in self.output_dict.items()\\n }\",\n \"def _init_(self):\\n self.res = {}\",\n \"def _get_output_dictionary(self):\\n\\n return_dictionary = {}\\n\\n for output_path in self.provided_outputs:\\n return_dictionary[output_path.full_path] = self.get_value(output_path)\\n\\n return return_dictionary\",\n \"def output_data_definitions(self):\\n return {}\",\n \"def __init__(self):\\n self._results = {}\\n self._logs = {}\",\n \"def finalize_output_dict(self, output_dict):\\n return {key: output_dict[key].cpu().numpy() for key in output_dict.keys()}\",\n \"def __init__(self):\\n self.result_obj = {}\",\n \"def __init__(self):\\n self.result_obj = {}\",\n \"def _initialize_summary_output(ns_list):\\n\\n summary_dict = {}\\n summary_dict[\\\"CLUSTER\\\"] = {}\\n\\n summary_dict[\\\"CLUSTER\\\"][\\\"server_version\\\"] = []\\n summary_dict[\\\"CLUSTER\\\"][\\\"os_version\\\"] = []\\n summary_dict[\\\"CLUSTER\\\"][\\\"active_features\\\"] = []\\n summary_dict[\\\"CLUSTER\\\"][\\\"migrations_in_progress\\\"] = False\\n\\n summary_dict[\\\"CLUSTER\\\"][\\\"device\\\"] = {}\\n summary_dict[\\\"CLUSTER\\\"][\\\"device\\\"][\\\"count\\\"] = 0\\n summary_dict[\\\"CLUSTER\\\"][\\\"device\\\"][\\\"count_per_node\\\"] = 0\\n summary_dict[\\\"CLUSTER\\\"][\\\"device\\\"][\\\"count_same_across_nodes\\\"] = True\\n summary_dict[\\\"CLUSTER\\\"][\\\"device\\\"][\\\"total\\\"] = 0\\n summary_dict[\\\"CLUSTER\\\"][\\\"device\\\"][\\\"used\\\"] = 0\\n summary_dict[\\\"CLUSTER\\\"][\\\"device\\\"][\\\"aval\\\"] = 0\\n summary_dict[\\\"CLUSTER\\\"][\\\"device\\\"][\\\"used_pct\\\"] = 0\\n summary_dict[\\\"CLUSTER\\\"][\\\"device\\\"][\\\"aval_pct\\\"] = 0\\n\\n summary_dict[\\\"CLUSTER\\\"][\\\"memory\\\"] = {}\\n summary_dict[\\\"CLUSTER\\\"][\\\"memory\\\"][\\\"total\\\"] = 0\\n summary_dict[\\\"CLUSTER\\\"][\\\"memory\\\"][\\\"aval\\\"] = 0\\n summary_dict[\\\"CLUSTER\\\"][\\\"memory\\\"][\\\"aval_pct\\\"] = 0\\n\\n summary_dict[\\\"CLUSTER\\\"][\\\"active_ns\\\"] = 0\\n summary_dict[\\\"CLUSTER\\\"][\\\"ns_count\\\"] = 0\\n\\n summary_dict[\\\"CLUSTER\\\"][\\\"license_data\\\"] = {}\\n summary_dict[\\\"CLUSTER\\\"][\\\"license_data\\\"][\\\"memory_size\\\"] = 0\\n summary_dict[\\\"CLUSTER\\\"][\\\"license_data\\\"][\\\"device_size\\\"] = 0\\n\\n summary_dict[\\\"FEATURES\\\"] = {}\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"] = {}\\n\\n for ns in ns_list:\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns] = {}\\n\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"devices_total\\\"] = 0\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"devices_per_node\\\"] = 0\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"devices_count_same_across_nodes\\\"] = True\\n\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"memory_total\\\"] = 0\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"memory_aval\\\"] = 0\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"memory_available_pct\\\"] = 0\\n\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"disk_total\\\"] = 0\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"disk_used\\\"] = 0\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"disk_aval\\\"] = 0\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"disk_used_pct\\\"] = 0\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"disk_available_pct\\\"] = 0\\n\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"repl_factor\\\"] = 0\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"master_objects\\\"] = 0\\n\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"license_data\\\"] = {}\\n\\n summary_dict[\\\"FEATURES\\\"][\\\"NAMESPACE\\\"][ns][\\\"migrations_in_progress\\\"] = False\\n\\n return summary_dict\",\n \"def prepare_results(self) -> dict:\\n if not hasattr(self, \\\"results\\\"):\\n raise AttributeError(\\n \\\"Results have not been finalized. Please call \\\"\\n \\\"finalize_results() before saving output.\\\"\\n )\\n\\n output = {\\n \\\"armory_version\\\": armory.__version__,\\n \\\"config\\\": self.config,\\n \\\"results\\\": self.results,\\n \\\"timestamp\\\": int(self.time_stamp),\\n }\\n return output\",\n \"def __init__(self):\\n self.output = []\",\n \"def __init__(self):\\n dict = defaultdict(list)\\n self.conversion_dict = dict\",\n \"def _init_results(self) -> None:\\n pt_bond_dimensions = {}\\n for site, pt in enumerate(self._process_tensors):\\n if pt is not None:\\n pt_bond_dimensions[site] = pt.get_bond_dimensions()\\n\\n self._results = {\\n 'time':[],\\n 'norm': [],\\n 'bond_dimensions': [],\\n 'dynamics': {},\\n 'pt_bond_dimensions': pt_bond_dimensions,\\n }\\n for sites in self._dynamics_sites:\\n self._results['dynamics'][sites] = Dynamics(name=f\\\"site{sites}\\\")\",\n \"def generate(self) -> Dict[str, Any]:\\n raise NotImplementedError\",\n \"def __init__(self):\\n super(ExponentialOutputs, self).__init__()\\n #dictionary of time, outputs\\n self.out_pop_time_series = []\",\n \"def output(self):\\n return {\\n \\\"time\\\": self.time,\\n \\\"dmx\\\": self.dmx\\n }\",\n \"def __init__(self):\\n self.inputs = {}\",\n \"def initialize(self, runInfo, inputs, initDict) :\\n super().initialize(runInfo, inputs, initDict)\\n for metricIn in self.assemblerDict['Metric']:\\n self.metricsDict[metricIn[2]] = metricIn[3]\",\n \"def output_result(self):\\n output = {}\\n output['draw'] = str(int(self.params['draw']))\\n output['recordsTotal'] = str(self.cardinality)\\n output['recordsFiltered'] = str(self.cardinality_filtered)\\n if self.error:\\n output['error'] = self.error\\n return output\\n\\n output['data'] = self.results\\n for k, v in self.yadcf_params:\\n output[k] = v\\n return output\",\n \"def __init__(self,n):\\n\\t\\tself._dictOut={}\\n\\t\\tself._dictIn = {}\\n\\t\\tfor i in range(n):\\n\\t\\t\\tself._dictOut[i]=[]\\n\\t\\t\\tself._dictIn[i] = []\",\n \"def output_from_json(self, output: Dict[str, Any]) -> OutputInfo:\",\n \"def construct_output_dict():\\n list_of_recipes = construct_list_of_recipes()\\n output_dict = {}\\n for recipe_list in list_of_recipes:\\n recipe_instance = construct_recipe_object(recipe_list)\\n recipe_dict = recipe_instance.construct_json_rep_obj()\\n for k, v in recipe_dict.iteritems():\\n output_dict[k] = v\\n output_dict = filter_output_dict(output_dict)\\n return {'recipes': output_dict}\",\n \"def __init__(self):\\n self._summary = {}\",\n \"def output_definition(self):\\n return {\\n 'error': [0.0, 10.0]\\n }\",\n \"def output_data(self):\\n pass\",\n \"def create_results_dict(self, n_options):\\n if n_options == 1:\\n self.results_dict[0] = {\\\"configuration\\\": [\\\"user\\\"]}\\n for name in self.results_metadata[\\\"names\\\"]:\\n self.results_dict[0][name] = []\\n else:\\n self.results_dict = {}\\n for i in range(n_options):\\n self.results_dict[i] = {\\\"configuration\\\": []}\\n for name in self.results_metadata[\\\"names\\\"]:\\n self.results_dict[i][name] = []\",\n \"def create_dicts(self):\\n \\n # remove this string from filename to make output file names more manageable\\n pre_output1 = self.file1.replace(\\\"_Guys121919_CGH_1100_Jul11\\\", '')\\n pre_output2 = self.file2.replace(\\\"_Guys121919_CGH_1100_Jul11\\\", '')\\n \\n # Build the output file name.\\n # if prefix is present add it\\n if self.out_file_prefix is not None:\\n # concatenate prefix, filenames and dyes into output filename file1_file1_dye_file2_file2_dye.txt\\n self.outputfilename = self.out_file_prefix+pre_output1.replace(\\\".txt\\\", '') + \\\"_\\\" + self.file1_dye + \\\"_\\\" + pre_output2.replace(\\\".txt\\\", '') + \\\"_\\\" + self.file2_dye + \\\".txt\\\"\\n # if no prefix don't add it!\\n else:\\n # concatenate filenames and dyes into output filename file1_file1_dye_file2_file2_dye.txt\\n self.outputfilename = pre_output1.replace(\\\".txt\\\", '') + \\\"_\\\" + self.file1_dye + \\\"_\\\" + pre_output2.replace(\\\".txt\\\", '') + \\\"_\\\" + self.file2_dye + \\\".txt\\\"\\n\\n # add temp to end of file name to create a temporary output filename\\n self.tempoutputfilename = self.outputfilename.replace(\\\".txt\\\", '') + \\\"temp.txt\\\"\\n\\n # open temp output file\\n self.tempoutputfile = open(self.outputfolder + self.tempoutputfilename, 'w')\\n\\n \\n # open FE files\\n file1_open = open(self.chosenfolder + self.file1, 'r')\\n file2_open = open(self.chosenfolder + self.file2, 'r')\\n\\n # open file1 and create a dict of the features.\\n for linenumber, line in enumerate(file1_open):\\n if linenumber >= 10:\\n splitline = line.split('\\\\t')\\n self.file1_dict[int(splitline[1])] = line\\n # get n of rows in file1 (take the linenumber of the last line)\\n self.file1_len = linenumber\\n\\n # repeat for features in second file but first writing the feparam and stats to temp file - when pairing with control this ensures the \\\"header\\\" comes from the test (file2) not control (file1), NB NEITHER ARE ACCURATE!!!!\\n for linenumber, line in enumerate(file2_open):\\n if linenumber < 10:\\n self.tempoutputfile.write(line)\\n # then add all features to a dictionary, with the unique feature number as a key\\n if linenumber >= 10:\\n splitline = line.split('\\\\t')\\n self.file2_dict[int(splitline[1])] = line\\n # get n of rows in file2\\n self.file2_len = linenumber\\n\\n # close files\\n file1_open.close()\\n file2_open.close()\",\n \"def __init__(self, out):\\r\\n super(PHPTMAPIMapHandler, self).__init__()\\r\\n self._out = out\\r\\n self._counter = 0\",\n \"def __init__(self, output_mediator):\\n super(ElasticSearchOutputModule, self).__init__(output_mediator)\\n self._counter = 0\\n self._data = []\\n self._doc_type = None\\n self._elastic_db = None\\n self._index_name = None\",\n \"def _generate_output(self):\\n raise NotImplementedError()\",\n \"def __init__(self):\\n self.memory = {}\\n self.sum_ = {}\",\n \"def output_data_definitions(self):\\n return {\\n self.key_outputs: DataDefinition([-1, self.output_size], [torch.Tensor], \\\"Batch of outputs [BATCH_SIZE x OUTPUT_SIZE]\\\")\\n }\",\n \"def __generate_dict(self, test_output_dir, types, _table):\\n # dump json from file to dict\\n\\n table_dict = CaseDump(os.path.join(test_output_dir, _table + OUT_SUFFIX), CASE_FILE_TYPE_JSON).dump()\\n\\n # foreach key from statistic report, split it into table/type/key/sub_value\\n type_dict = {}\\n for _key in table_dict.keys():\\n # wipe off table\\n _key = _key.replace(\\\"%s_\\\" % _table, \\\"\\\")\\n for _type in types:\\n # wipe off type\\n if _type and _type in _key:\\n if _type not in type_dict.keys():\\n type_dict[_type] = {}\\n _key = _key.replace(\\\"%s_\\\" % _type, \\\"\\\")\\n # if has sub_value, set RESULT_DICT[table][type][key] = sub_value\\n # else set RESULT_DICT[table][type][key] = None\\n if \\\"#\\\" in _key:\\n sub_value = _key.split(\\\"#\\\")\\n type_dict[_type][sub_value[0]] = sub_value[1]\\n else:\\n type_dict[_type][_key] = \\\"\\\"\\n break\\n\\n global RESULT_DICT\\n RESULT_DICT[_table] = type_dict\",\n \"def outputs(self):\\n return {\\\"path_to_mapping_json\\\": File_IO(\\n self.node.outputs[0])}\",\n \"def __init__(self):\\n self.cnt = {}\",\n \"def parsed_output(output_elements):\\n parsed_output = {}\\n for stanza, stanza_value in output_elements.items():\\n fake_section = MagicMock()\\n fake_section.options = {}\\n fake_section.name = stanza\\n parsed_output.update({stanza: fake_section})\\n for option, value in stanza_value.items():\\n fake_setting = MagicMock()\\n fake_setting.name = option\\n fake_setting.value = value\\n parsed_output[stanza].options.update({option: fake_setting})\\n return parsed_output\",\n \"def _populate_output(self):\\n self._store_atomic_queries_table()\\n self._store_composite_queries_table()\",\n \"def _create_sample(self, policy_output, next_state, reward, done, info,\\n env_id):\\n return {\\n \\\"policy_output\\\": policy_output,\\n \\\"next_state\\\": next_state,\\n \\\"reward\\\": reward,\\n \\\"done\\\": done,\\n \\\"info\\\": info,\\n \\\"env_id\\\": env_id\\n }\",\n \"def __init__(self):\\n self.info = dict()\",\n \"def __init__(self, n):\\n self._dictOut = {}\\n self._dictIn = {}\\n for i in range(n):\\n self._dictOut[i] = []\\n self._dictIn[i] = []\",\n \"def __init__(self):\\n self.d = {}\",\n \"def __init__(self):\\n self.d = {}\",\n \"def __init__(self):\\n self.d = {}\",\n \"def __init__(self):\\n self.d = {}\",\n \"def __init__(self):\\n self.stats = {}\\n self.stats['hits'] = 0\\n self.stats['operations'] = {}\\n self.stats['operations']['GetCapabilities'] = {}\\n self.stats['operations']['GetCapabilities']['hits'] = 0\\n self.stats['operations']['POST'] = {}\\n self.stats['operations']['POST']['hits'] = 0\",\n \"def __init__(self):\\n self.run = OrderedDict()\",\n \"def base_dict():\\n out = OrderedDict()\\n ao(out, 'name', 'String', 'Name', name='Name')\\n ao(out, 'mro', 'List', name='mro', attr=['Hidden'])\\n ao(out, 'comment', 'String', '')\\n ao(out, 'preset', 'Preset', '', attr=['Hidden'])\\n ao(out, 'dev', 'String', attr=['Hidden'])\\n ao(out, 'devpath', 'String', attr=['Hidden'])\\n ao(out, 'fullpath', 'String', attr=['Hidden'])\\n ao(out, 'zerotime', 'Float', name='Start time', attr=['Hidden'])\\n ao(out, 'initInstrument', 'Progress', attr=['Hidden'])\\n return out\",\n \"def __init__(self):\\n self._main_dictionary = defaultdict(set)\",\n \"def __init__(self, properties):\\n self.attributes = {}\\n self.output_info = {}\\n for key, node in properties.walk():\\n self.attributes[key[1]] = node.get_value().strip(\\\" '\\\")\",\n \"def initialize_output(self):\\n # set dims and store as 'output' class variable\\n rows = self.obs\\n dims = len(self.cols)\\n self.output = pd.DataFrame(np.zeros((rows, dims)), columns=self.cols)\",\n \"def __init__(self):\\n self.params = {}\\n self.counts = 0\\n self.failed = 0\\n self.path = os.path.join(os.getcwd(), OUTPUT_DIR)\\n \\n if not os.path.exists(self.path):\\n os.makedirs(self.path)\",\n \"def init_results(self):\\n results = {}\\n for i in range(len(self.agents)):\\n actor = self.agents[i]\\n actor.set_name(\\\"Actor\\\") # the filename part of the name is set in actor using filename from init_agents\\n results[actor.name] = 0\\n return results\",\n \"def __init__(self):\\n self.d = {}\\n self.h = []\",\n \"def run(self, input):\\n return {}\",\n \"def createDict( self ):\\n self.d = {}\\n self.d['comp1'] = compensation_channel('comp1', 0, (-479.0, -10.0))\\n self.d['comp2'] = compensation_channel('comp2', 1, (-479.0, -10.0))\\n self.addCalibration()\",\n \"def __init__(self):\\n self.mapr = OrderedDict()\\n self.counter = 0\",\n \"def generate_dict(self):\\n # verify preferred timestamp exists in the structure...\\n if not self._check_preferred_timestamps():\\n raise SampleException(\\\"Preferred timestamp not in particle!\\\")\\n\\n # build response structure\\n self._encoding_errors = []\\n if self._values is None:\\n self._values = self._build_parsed_values()\\n result = self._build_base_structure()\\n result[DataParticleKey.STREAM_NAME] = self.data_particle_type()\\n result[DataParticleKey.VALUES] = self._values\\n\\n return result\",\n \"def __init__(self):\\n self.dict = {}\",\n \"def __init__(self):\\n self.dict = {}\",\n \"def __init__(self, params, out):\\n self.configurations = []\\n self.out = out\\n self.add_configuration(params)\",\n \"def _build_dictionary(self):\\n print(\\\"Building Dictionary...\\\")\\n self.dictionary = Dictionary(self.load_files())\",\n \"def get_data(self):\\n self.data = dict()\\n # list to save all the attributes we are going to create\\n self.attr = []\\n # list to save all the groups available in the incomming input\\n self.groups.extend(self.values.keys())\\n # Grouping\\n self.parse_data()\",\n \"def output(self):\\n args = []\\n for i in range(0, len(self.args)):\\n args.append({\\\"id\\\": i + 1, \\\"value\\\": self.args[i]})\\n\\n val = {\\n \\\"id\\\": self.id,\\n \\\"device\\\": self.device.id,\\n \\\"enabled\\\": 1,\\n \\\"name\\\": self.name,\\n \\\"template\\\": self.template,\\n \\\"arguments\\\": args\\n }\\n\\n if self.start != None and self.stop != None:\\n val[\\\"start\\\"] = self.start.output()\\n val[\\\"stop\\\"] = self.stop.output()\\n\\n if self.days_of_week != None:\\n val[\\\"days_of_week\\\"] = self.days_of_week\\n\\n return val\",\n \"def _init_profiles(self):\\n self._profiles = {\\n k: np.zeros((len(self.hybrid_time_index), len(self.hybrid_meta)),\\n dtype=np.float32)\\n for k in OUTPUT_PROFILE_NAMES}\",\n \"def __init__(self):\\n self.l = {}\\n self.s = {}\",\n \"def __init__(self):\\n self.dGrph = {}\\n self.__prime_ip = []\\n self.__prime_op = []\\n self.__op_fanout = {}\",\n \"def output(self):\\n return {\\n \\\"id\\\": self.id,\\n \\\"name\\\": self.name,\\n \\\"type\\\": 2,\\n \\\"enabled\\\": 1,\\n \\\"days_of_week\\\": self.days,\\n \\\"time\\\": self.time.output()\\n }\",\n \"def build_default_output(self):\\n\\t\\t# To simplify writing data into final output file in specific order,\\n\\t\\t# store rows and columns headers in specific order. \\n\\t\\tcohorts_data = collections.OrderedDict()\\n\\t\\tstart = end = self.max\\n\\t\\tcount = 1\\n\\t\\twhile count <= self.cohorts_number and end > self.min:\\n\\t\\t\\tstart = end - datetime.timedelta(days=6)\\n\\t\\t\\tcohorts_data[(start, end)] = None\\n\\t\\t\\tend = start - datetime.timedelta(days=1)\\n\\t\\t\\tcount += 1\\n\\n\\t\\t# Save available cohorts for later use.\\n\\t\\tself.cohorts = cohorts_data.keys()\\n\\t\\tcohorts_data = self.add_default_cohort_values(cohorts_data)\\n\\t\\treturn cohorts_data\",\n \"def __init__ (self):\\n self.lengths = {}\\n self.lower_counts = {}\\n self.upper_counts = {}\\n self.digit_counts = {}\\n self.symbol_counts = {}\\n self.class_counts = {}\\n self.word_counts = {}\",\n \"def prepare_multiple_out_parsers(run_dict):\\n output_parser_dict = {}\\n for run_label, run_name in run_dict.items():\\n output_parser_dict[run_label] = OutputParser(run_name, use_most_recent=False)\\n return output_parser_dict\",\n \"def _output_dict(self):\\n lang = self.ddnGuiLanguage.get()\\n\\n fileout = os.path.normpath('{}/{}-{}.xml'.\\\\\\n format(self.MapCreator, self.Source, self.ddnCurProject.get()))\\n linesout = ['<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>', \\\\\\n '<DictionarySet xmlns:mc=\\\"urn:fmosoft-map-creator\\\" xmlns=\\\"urn:fmosoft-map-creator\\\" Version=\\\"1\\\">', \\\\\\n ' <Dictionary SourceLanguage=\\\"{}\\\" SourceLanguageIsPredefined=\\\"true\\\" TargetLanguage=\\\"{}\\\" TargetLanguageIsPredefined=\\\"false\\\">'.\\\\\\n format(self.Source, self.ddnCurProject.get()), \\\\\\n ]\\n for child in self.tree.get_children('approved'):\\n vv = self.tree.item(child)['values']\\n linesout.append(' <Translation Source=\\\"{}\\\" Target=\\\"{}\\\"/>'.format(vv[0], vv[1]))\\n linesout.append(' </Dictionary>')\\n linesout.append('</DictionarySet>')\\n linesout.append('')\\n\\n if os.path.exists(fileout):\\n os.remove(fileout)\\n\\n if fileout:\\n output = codecs.open(fileout, mode='w', encoding='utf-8')\\n output.write('\\\\n'.join(linesout))\\n output.close()\\n pass\",\n \"def __init__(self, output_dir):\\n self.output_dir = os.path.abspath(output_dir)\\n # Create the file if it doesn't already exist\\n os.makedirs(self.output_dir, exist_ok=True)\\n self.f = None\\n self.data = None\\n self.L = None\",\n \"def initialize(self,inputDict):\\n pass\",\n \"def __init__(self):\\n\\t\\tappionScript.AppionScript.__init__(self)\\n\\t\\tself.rundata = {}\\n\\t\\t### extra appionLoop functions:\\n\\t\\tself._addDefaultParams()\\n\\t\\tself.setFunctionResultKeys()\\n\\t\\tself._setRunAndParameters()\\n\\t\\t#self.specialCreateOutputDirs()\\n\\t\\tself._initializeDoneDict()\\n\\t\\tself.result_dirs={}\",\n \"def getInitParams(self):\\n paramDict = super().getInitParams()\\n paramDict[f'OutStream Available {self.dim}D :'] = self.availableOutStreamTypes[self.dim]\\n paramDict['Plot is '] = str(self.dim) + 'D'\\n for index in range(len(self.sourceName)):\\n paramDict['Source Name ' + str(index) + ' :'] = self.sourceName[index]\\n\\n return paramDict\",\n \"def serialize(self) -> dict:\\n output = super().serialize()\\n output[\\\"iteration\\\"] = self.iteration\\n return output\",\n \"def __init__(self):\\r\\n self.dic={}\",\n \"def dict_initialise(metadata, analysistype):\\n for sample in metadata:\\n sample[analysistype].dnaseq = dict()\\n sample[analysistype].protseq = dict()\\n sample[analysistype].ntindex = dict()\\n sample[analysistype].aaindex = dict()\\n sample[analysistype].ntalign = dict()\\n sample[analysistype].aaalign = dict()\\n sample[analysistype].aaidentity = dict()\\n return metadata\",\n \"def outputs(self):\\n pass\",\n \"def __init__(self):\\n self.ngramCounts = collections.defaultdict(zero_fn);\\n self.continuationProb = collections.defaultdict(set_fn);\\n self.total = 0;\",\n \"def serialize(self) -> dict:\\n return {\\n \\\"body_value_idx\\\": self.body_value_idx,\\n \\\"output_idx\\\": self.output_idx,\\n }\",\n \"def _makeimap(self):\\n self.map_['source'] = 'NAOJ'\\n self.map_['provider'] = 'NRO'\\n self.map_['instrument'] = 'NORH'\\n self.map_['phyobs'] = ''\",\n \"def __init__(self):\\n self.statiFile = \\\"\\\"\\n self.printOrder = []\\n self.instCount = 0\\n self.initializedVars = {\\\"GF\\\":[],\\\"TF\\\":[],\\\"LF\\\":[]}\",\n \"def generate_data(cls):\\n cls.results = {}\\n cls.pre_process()\\n today = datetime.today()\\n skip = None\\n values = map(lambda a: a[0], cls.data)\\n if len(values) == 0 and 'citation' not in cls.config_data_name:\\n skip = True\\n weights= map(lambda a: a[1], cls.data)\\n if cls.config_data_name == 'reads_histogram':\\n bins = range(1996, today.year+2)\\n elif cls.min_year:\\n bins = range(cls.min_year, today.year+2)\\n else:\\n try:\\n bins = range(min(values),max(values)+2)\\n except:\\n skip = True\\n if not skip:\\n refereed_values = map(lambda a: a[0], cls.refereed_data)\\n refereed_weights= map(lambda a: a[1], cls.refereed_data)\\n # get the regular histogram\\n cls.value_histogram = histogram(values,bins=bins)\\n cls.refereed_value_histogram = histogram(refereed_values,bins=bins)\\n # get the normalized histogram\\n cls.normalized_value_histogram = histogram(values,bins=bins,weights=weights)\\n cls.refereed_normalized_value_histogram = histogram(refereed_values,bins=bins,weights=refereed_weights)\\n else:\\n cls.value_histogram = False\\n cls.results[str(today.year)] = \\\"0:0:0:0\\\"\\n cls.post_process()\",\n \"def __init__(self):\\n self.num_counts = {}\",\n \"def with_output(self, output, output_format):\\n\\t\\tself.variables['output'] = output\\n\\t\\tself.variables['output_format'] = output_format\\n\\t\\treturn self\",\n \"def output_data_definitions(self):\\n return {\\n self.key_outputs: DataDefinition(\\n [-1]*(self.num_inputs_dims-1) + [self.input_size],\\n [torch.Tensor],\\n \\\"Batch of outputs [DIM 1 x DIM 2 x ... x INPUT_SIZE]\\\")\\n }\",\n \"def get_outputs():\\n outputs = {}\\n for obj in vars(acsploit.output).values():\\n if hasattr(obj, 'OUTPUT_NAME'):\\n outputs[obj.OUTPUT_NAME] = obj\\n\\n return outputs\",\n \"def _to_dict(self) -> \\\"OrderedDict[str, OrderedDict]\\\":\\n description = OrderedDict() # type: 'OrderedDict'\\n description[\\\"oml:run\\\"] = OrderedDict()\\n description[\\\"oml:run\\\"][\\\"@xmlns:oml\\\"] = \\\"http://openml.org/openml\\\"\\n description[\\\"oml:run\\\"][\\\"oml:task_id\\\"] = self.task_id\\n description[\\\"oml:run\\\"][\\\"oml:flow_id\\\"] = self.flow_id\\n if self.setup_string is not None:\\n description[\\\"oml:run\\\"][\\\"oml:setup_string\\\"] = self.setup_string\\n if self.error_message is not None:\\n description[\\\"oml:run\\\"][\\\"oml:error_message\\\"] = self.error_message\\n if self.run_details is not None:\\n description[\\\"oml:run\\\"][\\\"oml:run_details\\\"] = self.run_details\\n description[\\\"oml:run\\\"][\\\"oml:parameter_setting\\\"] = self.parameter_settings\\n if self.tags is not None:\\n description[\\\"oml:run\\\"][\\\"oml:tag\\\"] = self.tags\\n if (self.fold_evaluations is not None and len(self.fold_evaluations) > 0) or (\\n self.sample_evaluations is not None and len(self.sample_evaluations) > 0\\n ):\\n description[\\\"oml:run\\\"][\\\"oml:output_data\\\"] = OrderedDict()\\n description[\\\"oml:run\\\"][\\\"oml:output_data\\\"][\\\"oml:evaluation\\\"] = list()\\n if self.fold_evaluations is not None:\\n for measure in self.fold_evaluations:\\n for repeat in self.fold_evaluations[measure]:\\n for fold, value in self.fold_evaluations[measure][repeat].items():\\n current = OrderedDict(\\n [\\n (\\\"@repeat\\\", str(repeat)),\\n (\\\"@fold\\\", str(fold)),\\n (\\\"oml:name\\\", measure),\\n (\\\"oml:value\\\", str(value)),\\n ]\\n )\\n description[\\\"oml:run\\\"][\\\"oml:output_data\\\"][\\\"oml:evaluation\\\"].append(current)\\n if self.sample_evaluations is not None:\\n for measure in self.sample_evaluations:\\n for repeat in self.sample_evaluations[measure]:\\n for fold in self.sample_evaluations[measure][repeat]:\\n for sample, value in self.sample_evaluations[measure][repeat][fold].items():\\n current = OrderedDict(\\n [\\n (\\\"@repeat\\\", str(repeat)),\\n (\\\"@fold\\\", str(fold)),\\n (\\\"@sample\\\", str(sample)),\\n (\\\"oml:name\\\", measure),\\n (\\\"oml:value\\\", str(value)),\\n ]\\n )\\n description[\\\"oml:run\\\"][\\\"oml:output_data\\\"][\\\"oml:evaluation\\\"].append(\\n current\\n )\\n return description\",\n \"def __init__(self):\\n self.key2value = {}\\n self.key2time = {}\",\n \"def _parse_output_variables(self):\\n self._output_variables_by_name = {}\\n self._output_variables_by_type = {}\\n for ov in self._output_variables:\\n # parse the variable to get individual parts\\n parsed_variable = self.parse_variable(ov)\\n variable_name = parsed_variable.get('name')\\n variable_type = parsed_variable.get('type')\\n\\n # store the variables in dict by name (e.g. \\\"status_code\\\")\\n self._output_variables_by_name[variable_name] = {'variable': ov}\\n\\n # store the variables in dict by name-type (e.g. \\\"status_code-String\\\")\\n self._output_variables_by_type[f'{variable_name}-{variable_type}'] = {'variable': ov}\",\n \"def generate_output_data(self):\\n for socket_name, c in self.__taskobject.outputs.items():\\n data = Data(self.__project, type=c['type'])\\n if c['optional']:\\n data.enable(False)\\n self.__outputs[socket_name] = {'data': data, 'enable': False}\\n else:\\n data.enable(True)\\n self.__outputs[socket_name] = {'data': data, 'enable': True}\",\n \"def _transform_outputs(self) -> None:\\n self.outputs = None if self.outputs == {} else self.outputs\",\n \"def _create_output_alternatives(self, predictions):\\n return {self.head_name: (self._problem_type, predictions)}\",\n \"def __init__(self, all_loadouts):\\n self._name_to_loadout = {}\\n self._id_to_loadout = {}\\n for loadout_dict in all_loadouts:\\n loadout = Loadout(**loadout_dict)\\n self._id_to_loadout[loadout.id] = loadout\\n self._name_to_loadout[loadout.name.lower()] = loadout\",\n \"def __init__(self):\\n\\n # initialise the empty mappings dictionary\\n self.data = {\\n 'loan_id': None,\\n 'product': None,\\n 'origination_date': None,\\n 'reversion_date': None,\\n 'rate_term': None,\\n 'loan_amount': None,\\n 'initial_rate': None,\\n 'reversion_rate': None,\\n 'term': None,\\n 'interest_only_amount': None,\\n 'upfront_fees': None,\\n 'upfront_costs': None,\\n 'entity_eir': None\\n }\",\n \"def __init__(self, **kwargs):\\n super().__init__(**kwargs)\\n self.results = collections.defaultdict(collections.deque)\",\n \"def cache(self):\\n return {'output': self.output, 'series': self.series}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7403707","0.7319638","0.719789","0.718091","0.6895616","0.6818378","0.6713962","0.66572535","0.6627214","0.6627214","0.6626906","0.6612285","0.6525927","0.651021","0.6355464","0.6314832","0.63007283","0.6230506","0.62086916","0.61997986","0.61873674","0.6164668","0.61605483","0.61078596","0.6100489","0.6096754","0.609426","0.6093817","0.60798216","0.60755986","0.6060157","0.6059228","0.60571337","0.6028316","0.6022378","0.602117","0.60179853","0.6013864","0.5994065","0.5992699","0.5990634","0.59872496","0.59783363","0.59783363","0.59783363","0.59783363","0.5965413","0.59652656","0.5956702","0.5955674","0.5950198","0.59452486","0.5943724","0.5940564","0.5938132","0.59358907","0.5932202","0.5931815","0.5920413","0.59185886","0.59185886","0.5909113","0.5905609","0.59026235","0.5883045","0.5878047","0.5877979","0.5865574","0.58582395","0.5850332","0.58492","0.5848667","0.5844906","0.58427036","0.5840967","0.5838365","0.5832879","0.58320826","0.5825691","0.5817053","0.5807381","0.58054334","0.5804975","0.57979304","0.5796452","0.579533","0.5794277","0.5791969","0.5788101","0.57872975","0.5785425","0.5785193","0.5783066","0.5780806","0.57805365","0.5774369","0.57741416","0.57693416","0.5766547","0.57649404"],"string":"[\n \"0.7403707\",\n \"0.7319638\",\n \"0.719789\",\n \"0.718091\",\n \"0.6895616\",\n \"0.6818378\",\n \"0.6713962\",\n \"0.66572535\",\n \"0.6627214\",\n \"0.6627214\",\n \"0.6626906\",\n \"0.6612285\",\n \"0.6525927\",\n \"0.651021\",\n \"0.6355464\",\n \"0.6314832\",\n \"0.63007283\",\n \"0.6230506\",\n \"0.62086916\",\n \"0.61997986\",\n \"0.61873674\",\n \"0.6164668\",\n \"0.61605483\",\n \"0.61078596\",\n \"0.6100489\",\n \"0.6096754\",\n \"0.609426\",\n \"0.6093817\",\n \"0.60798216\",\n \"0.60755986\",\n \"0.6060157\",\n \"0.6059228\",\n \"0.60571337\",\n \"0.6028316\",\n \"0.6022378\",\n \"0.602117\",\n \"0.60179853\",\n \"0.6013864\",\n \"0.5994065\",\n \"0.5992699\",\n \"0.5990634\",\n \"0.59872496\",\n \"0.59783363\",\n \"0.59783363\",\n \"0.59783363\",\n \"0.59783363\",\n \"0.5965413\",\n \"0.59652656\",\n \"0.5956702\",\n \"0.5955674\",\n \"0.5950198\",\n \"0.59452486\",\n \"0.5943724\",\n \"0.5940564\",\n \"0.5938132\",\n \"0.59358907\",\n \"0.5932202\",\n \"0.5931815\",\n \"0.5920413\",\n \"0.59185886\",\n \"0.59185886\",\n \"0.5909113\",\n \"0.5905609\",\n \"0.59026235\",\n \"0.5883045\",\n \"0.5878047\",\n \"0.5877979\",\n \"0.5865574\",\n \"0.58582395\",\n \"0.5850332\",\n \"0.58492\",\n \"0.5848667\",\n \"0.5844906\",\n \"0.58427036\",\n \"0.5840967\",\n \"0.5838365\",\n \"0.5832879\",\n \"0.58320826\",\n \"0.5825691\",\n \"0.5817053\",\n \"0.5807381\",\n \"0.58054334\",\n \"0.5804975\",\n \"0.57979304\",\n \"0.5796452\",\n \"0.579533\",\n \"0.5794277\",\n \"0.5791969\",\n \"0.5788101\",\n \"0.57872975\",\n \"0.5785425\",\n \"0.5785193\",\n \"0.5783066\",\n \"0.5780806\",\n \"0.57805365\",\n \"0.5774369\",\n \"0.57741416\",\n \"0.57693416\",\n \"0.5766547\",\n \"0.57649404\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7332433"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":91499,"cells":{"query":{"kind":"string","value":"Compute epoch statistics after an epoch of training using an output_dict."},"document":{"kind":"string","value":"def compute_epoch_statistics(self, output_dict):\n epoch_statistics = {\n \"auc\": roc_auc_score(\n output_dict[\"labels\"].cpu().numpy(),\n output_dict[\"pred_probs\"][:, 1].cpu().numpy(),\n ),\n \"auprc\": average_precision_score(\n output_dict[\"labels\"].cpu().numpy(),\n output_dict[\"pred_probs\"][:, 1].cpu().numpy(),\n ),\n \"brier\": brier_score_loss(\n output_dict[\"labels\"].cpu().numpy(),\n output_dict[\"pred_probs\"][:, 1].cpu().numpy(),\n ),\n }\n\n return epoch_statistics"},"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 training_epoch_end(self, outputs: Any) -> None:\n self.log_dict(self.train_metrics.compute())\n self.train_metrics.reset()","def validation_epoch_end(self, outputs):\n avg_loss = torch.stack([x['val_loss'] for x in outputs]).mean()\n val_acc = sum([x['n_correct_pred'] for x in outputs]) / sum(x['n_pred'] for x in outputs)\n tensorboard_logs = {'val_loss': avg_loss, 'val_acc': val_acc}\n return {'val_loss': avg_loss, 'log': tensorboard_logs}","def training_epoch_end(self, outputs):\n epoch_loss, epoch_accuracy = self._parse_outputs(\n outputs=outputs, calculate_confusion_matrix=False)\n self.log('training loss', np.mean(epoch_loss),\n on_epoch=True, prog_bar=True)\n self.log('training accuracy', np.mean(epoch_accuracy))","def test_epoch_end(self, outputs):\n avg_loss = torch.stack([x[\"test_loss\"] for x in outputs]).mean()\n tensorboard_logs = {\"test_loss\": avg_loss}\n return {\"avg_test_loss\": avg_loss, \"log\": tensorboard_logs}","def test_epoch_end(self, outputs):\n avg_loss = torch.stack([x[\"test_loss\"] for x in outputs]).mean()\n tensorboard_logs = {\"test_loss\": avg_loss}\n return {\"avg_test_loss\": avg_loss, \"log\": tensorboard_logs}","def test_epoch_end(self, outputs: Any) -> None:\n self.log_dict(self.test_metrics.compute())\n self.test_metrics.reset()","def build_stats(history, eval_output, time_callback):\n stats = {}\n if eval_output:\n stats['accuracy_top_1'] = eval_output[1].item()\n stats['eval_loss'] = eval_output[0].item()\n\n if history and history.history:\n train_hist = history.history\n # Gets final loss from training.\n stats['loss'] = train_hist['loss'][-1].item()\n # Gets top_1 training accuracy.\n if 'categorical_accuracy' in train_hist:\n stats[TRAIN_TOP_1] = train_hist['categorical_accuracy'][-1].item()\n elif 'sparse_categorical_accuracy' in train_hist:\n stats[TRAIN_TOP_1] = train_hist['sparse_categorical_accuracy'][-1].item()\n\n if time_callback:\n timestamp_log = time_callback.timestamp_log\n stats['step_timestamp_log'] = timestamp_log\n stats['train_finish_time'] = time_callback.train_finish_time\n if len(timestamp_log) > 1:\n stats['avg_exp_per_second'] = (\n time_callback.batch_size * time_callback.log_steps *\n (len(time_callback.timestamp_log)-1) /\n (timestamp_log[-1].timestamp - timestamp_log[0].timestamp))\n\n return stats","def get(self):\n if self.num_examples <= 0:\n raise ValueError(\"total_sample must be positive.\")\n avg_hit_at_one = self.sum_hit_at_one / self.num_examples\n avg_perr = self.sum_perr / self.num_examples\n avg_loss = self.sum_loss / self.num_examples\n\n epoch_info_dict = {\"avg_hit_at_one\": avg_hit_at_one, \n \"avg_perr\": avg_perr,\n \"avg_f1score\": avg_f1score,\n \"avg_f2score\": avg_f2score,\n \"avg_loss\": avg_loss}\n return epoch_info_dict","def validation_epoch_end(self, outputs):\n avg_loss = torch.stack([x[\"val_loss\"] for x in outputs]).mean()\n tensorboard_logs = {\"val_loss\": avg_loss}\n return {\"avg_val_loss\": avg_loss, \"log\": tensorboard_logs}","def validation_epoch_end(self, outputs):\n avg_loss = torch.stack([x[\"val_loss\"] for x in outputs]).mean()\n tensorboard_logs = {\"val_loss\": avg_loss}\n return {\"avg_val_loss\": avg_loss, \"log\": tensorboard_logs}","def test_epoch_end(self, outputs):\n epoch_loss, epoch_accuracy, confmat = self._parse_outputs(\n outputs=outputs, calculate_confusion_matrix=True)\n self.log('test loss', np.mean(epoch_loss))\n self.log('test accuracy', np.mean(epoch_accuracy))\n print(confmat)","def validation_epoch_end(self, outputs: Any) -> None:\n self.log_dict(self.val_metrics.compute())\n self.val_metrics.reset()","def validation_epoch_end(self, outputs):\n # outputs contain data for 2 dataloaders - val and test\n for out_idx, outputs_i in enumerate(outputs):\n # validation loss\n val_loss_mean = torch.stack([x['val_loss_b'] for x in outputs_i]).mean()\n\n # predicts\n logits = np.concatenate([x['logits_b'] for x in outputs_i], axis=0)\n labels = np.concatenate([x['labels_b'] for x in outputs_i], axis=0)\n emph_probs = np.concatenate([x['emph_probs_b'] for x in outputs_i], axis=0)\n probs = np.exp(logits) / np.sum(np.exp(logits), axis=2, keepdims=True)\n preds = np.argmax(logits, axis=2)\n\n label_map = {i: label for i, label in enumerate(self.labels)}\n out_label_list = [[] for _ in range(labels.shape[0])]\n preds_list = [[] for _ in range(labels.shape[0])]\n probs_list = [[] for _ in range(labels.shape[0])]\n emph_probs_list = [[] for _ in range(labels.shape[0])]\n\n for i in range(labels.shape[0]):\n for j in range(labels.shape[1]):\n if labels[i, j] != self.pad_token_label_id:\n out_label_list[i].append(label_map[labels[i][j]])\n preds_list[i].append(label_map[preds[i][j]])\n probs_list[i].append(probs[i][j][1])\n emph_probs_list[i].append(emph_probs[i][j])\n\n # for validation\n if out_idx == 0:\n # show random example\n rand_idx = np.random.randint(0, len(out_label_list))\n logger.info('True: %s', out_label_list[rand_idx])\n logger.info('Pred: %s', preds_list[rand_idx])\n logger.info('Emph: %s', emph_probs_list[rand_idx])\n logger.info('Prob: %s', probs_list[rand_idx])\n\n # validation score\n val_score = match_m(probs_list, emph_probs_list)\n val_score_mean = np.mean(list(val_score.values()))\n\n # validation accuracy\n val_acc = accuracy_score(out_label_list, preds_list)\n\n # validation f1 score\n val_f1 = f1_score(out_label_list, preds_list)\n\n # score_logs\n score_logs = {\n 'val_score1': val_score[1],\n 'val_score2': val_score[2],\n 'val_score3': val_score[3],\n 'val_score4': val_score[4],\n 'val_score_mean': val_score_mean,\n }\n\n # logs\n logs = {\n 'val_loss': val_loss_mean.detach().numpy(),\n 'val_acc': val_acc,\n 'val_f1': val_f1,\n 'val_score_mean': val_score_mean,\n }\n\n # output dict\n output = {\n 'val_loss': val_loss_mean,\n 'val_f1': val_f1,\n 'val_acc': val_acc,\n 'progress_bar': logs,\n 'log': {**logs, **score_logs},\n }\n\n # write validation results to csv\n csv_dict = {k: v for k, v in vars(self.hparams).items() if k in FIELDNAMES}\n csv_dict.update(score_logs)\n csv_dict.update(logs)\n\n csv_dict['current_epoch'] = self.current_epoch\n csv_dict['global_step'] = self.global_step\n\n write_csv('results.csv', csv_dict)\n self.preds['val'][self.current_epoch][self.global_step] = probs_list\n\n # save prediction for test\n if out_idx == 1:\n self.preds['test'][self.current_epoch][self.global_step] = probs_list\n\n # write to file all val and test predictions\n with open('predicts/' + self.model_id_name + '.pkl', 'wb') as f:\n pickle.dump(self.preds, f)\n\n return output","def on_epoch_end(self, epoch, logs={}):\n self.predhis.append(self.modelx.predict(self.x_testx))\n y_true = np.argmax(self.y_testx, 1)\n y_pred = np.argmax(self.modelx.predict(self.x_testx, batch_size=self.batch_sizex, verbose=0), axis=1)\n \n self.clas_rpt.append(report_to_df(classification_report(y_true, y_pred)))\n self.conf_mtrx.append(confusion_matrix(y_true, y_pred, labels = range(self.nb_classes)))\n #self.conf_mtrx[epoch] = confusion_matrix(y_true, y_pred, labels = range(self.nb_classes))\n return self","def test_epoch_end(self, outputs):\n # extract test results\n targets = []\n preds = []\n \n for idx in range(len(outputs)):\n targets.append(outputs[idx][0])\n preds.append(outputs[idx][1])\n \n targets = torch.cat(targets, dim=0)\n preds = torch.cat(preds, dim=0)\n\n # compute group specific scores\n grp_1_idcs = targets == 0\n grp_2_idcs = targets == 1\n\n grp_1_targets = targets[grp_1_idcs]\n grp_2_targets = targets[grp_2_idcs]\n \n accuracy_grp_1 = torch.true_divide(torch.sum(preds[grp_1_idcs]== grp_1_targets), grp_1_targets.shape[0])\n accuracy_grp_2 = torch.true_divide(torch.sum(preds[grp_2_idcs] == grp_2_targets), grp_2_targets.shape[0])\n\n self.log('test/accuracy_grp_1', accuracy_grp_1)\n self.log('test/accuracy_grp_2', accuracy_grp_2)","def on_train_epoch_end(self, outputs):\n for callback in self.callbacks:\n callback.on_train_epoch_end(self, self.get_model(), outputs)","def run_epoch(session, model, input_, is_training, global_step, summary_writer, config, epoch_rem=0, COUNT=0):\n loss_acum = 0.0\n acc_acum = 0.0\n if FLAGS.only_val:\n matrices = np.zeros([config.num_actions, config.num_actions], dtype=np.int32)\n n_mistakes = np.zeros([1, config.num_actions], dtype=np.int32)\n mistake_labs = np.empty([0, 4], dtype=np.int32)\n\n fetches = {\n \"loss\": model.loss,\n # \"final_state\": model.final_state,\n \"accuracy\": model.accuracy\n }\n if is_training:\n fetches.update({\n \"train_op\": model.train_op,\n \"global_step\": global_step,\n \"learning_rate\": model.lr\n })\n if FLAGS.only_val:\n fetches.update({\n \"confusion_matrix\": model.confusion_matrix,\n \"mistakes_per_class\": model.mistakes_per_class,\n \"mistake_labs\": model.mistake_labs,\n \"logits\": model.logits,\n \"labels\": model.labels,\n \"idxs\": model.idxs\n })\n of = open('/tmp/%02d.txt' % COUNT, 'w')\n\n epoch_size = epoch_rem if epoch_rem > 0 else (input_.train_epoch_size if is_training else input_.val_epoch_size)\n t = trange(epoch_size, disable=not FLAGS.verbose, dynamic_ncols=True)\n for batch in t:\n options = None\n run_metadata = None\n if is_training and (batch % epoch_size == epoch_size - 1) and FLAGS.run_metadata: # Record execution stats\n options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)\n run_metadata = tf.RunMetadata()\n\n vals = session.run(fetches=fetches, options=options, run_metadata=run_metadata)\n loss = vals[\"loss\"]\n # state = vals[\"final_state\"]\n accuracy = vals[\"accuracy\"]\n\n if is_training:\n learning_rate = vals[\"learning_rate\"]\n global_step_val = vals[\"global_step\"]\n\n loss_acum += loss\n acc_acum += accuracy\n if FLAGS.only_val:\n matrices += np.squeeze(vals[\"confusion_matrix\"], axis=(0,3))\n n_mistakes += np.squeeze(vals[\"mistakes_per_class\"], axis=(0,3))\n mistake_labs = np.concatenate((mistake_labs,vals[\"mistake_labs\"]), axis=0)\n for logits, label, idx in zip(vals[\"logits\"], vals[\"labels\"], vals[\"idxs\"]):\n out = \", \".join(str(l) for l in logits)\n out += \", \" + str(label)\n out += \", \" + str(idx)\n print(out, file=of)\n\n postfix = {\n 'loss': \"%.3f\" % (loss_acum / (batch + 1)),\n 'acc': \"%.3f\" % (acc_acum / (batch + 1))\n }\n if is_training:\n postfix.update({'l_rate': \"%.1E\" % learning_rate})\n if run_metadata is not None:\n summary_writer.add_run_metadata(run_metadata, 'S:%d' % global_step_val)\n\n t.set_postfix(postfix)\n\n if FLAGS.only_val:\n import matplotlib\n matplotlib.use('Agg')\n from matplotlib import pyplot as plt\n plt.imshow(matrices/epoch_size, interpolation='nearest')\n plt.savefig(FLAGS.save_path+'/confusion_matrix.png')\n\n plt.imshow(n_mistakes/epoch_size, interpolation='nearest')\n plt.savefig(FLAGS.save_path+'/mistakes_per_class.png')\n\n np.savetxt(FLAGS.save_path+'/mistake_labs.txt', mistake_labs, fmt='%i,%i,%i,%i')\n print(np.histogram(mistake_labs[:,1], bins=np.arange(config.num_subjects)))\n print(np.histogram(mistake_labs[:,2], bins=np.arange(config.num_actions)))\n print(np.mean(mistake_labs[:,3]))\n of.close()\n\n return loss_acum / epoch_size, acc_acum / epoch_size","def _evaluate_during_fit(self, test_loader, epoch):","def eval_epoch(self, final=False, save_predictions=False):\n t1 = time()\n output = {'tp': [], 'fp': [], 'fn': [], 'tn': [], 'loss': [], 'preds': [],'truth': [], 'true': 0,'true_sep':np.zeros(self.rel_size)}\n test_info = []\n test_result = []\n self.model.eval()\n test_iter = self.iterator(self.data['test'], batch_size=self.params['batch'], shuffle_=False)\n # preds=[]\n # truths=[]\n for batch_idx, batch in enumerate(test_iter):\n batch = self.convert_batch(batch, istrain=False, save=True)\n\n with torch.no_grad():\n loss, stats, predictions, select, pred_pairs, multi_truths, mask, _ = self.model(\n batch) # pred_pairs <#pair, relations_num>\n pred_pairs = torch.sigmoid(pred_pairs)\n\n output['loss'] += [loss.item()]\n output['tp'] += [stats['tp'].to('cpu').data.numpy()]\n output['fp'] += [stats['fp'].to('cpu').data.numpy()]\n output['fn'] += [stats['fn'].to('cpu').data.numpy()]\n output['tn'] += [stats['tn'].to('cpu').data.numpy()]\n output['preds'] += [predictions.to('cpu').data.numpy()]\n # preds.extend(predictions.to('cpu').data.numpy())\n # truths.extend(truth.to('cpu').data.numpy())\n\n if True:\n test_infos = batch['info'][select[0].to('cpu').data.numpy(),\n select[1].to('cpu').data.numpy(),\n select[2].to('cpu').data.numpy()][mask.to('cpu').data.numpy()]\n test_info += [test_infos]\n\n pred_pairs = pred_pairs.data.cpu().numpy()\n multi_truths = multi_truths.data.cpu().numpy()\n output['true'] += multi_truths.sum() - multi_truths[:, self.loader.label2ignore].sum()\n output['true_sep'] = output['true_sep'] +multi_truths.sum(axis=0)\n if save_predictions:\n assert test_infos.shape[0] == len(pred_pairs), print(\n \"test info=%d, pred_pair=%d\" % (len(test_infos.shape[0]), len(pred_pairs)))\n for pair_id in range(len(pred_pairs)):\n multi_truth = multi_truths[pair_id] #第pair_id个实体对的true\n for r in range(0, self.rel_size):\n if r == self.loader.label2ignore:\n continue\n\n test_result.append((int(multi_truth[r]) == 1, float(pred_pairs[pair_id][r]),\n test_infos[pair_id]['intrain'],test_infos[pair_id]['cross'], self.loader.index2rel[r], r,\n len(test_info) - 1, pair_id))\n\n\n # estimate performance\n total_loss, scores = self.performance(output)\n # pairs*rel_size*batch\n test_result.sort(key=lambda x: x[1], reverse=True)\n\n input_theta, w, f1,p,r,scores_class = self.tune_f1_theta(test_result, output['true'],output['true_sep'], self.params['input_theta'], isTest=save_predictions)\n\n t2 = time()\n if not final:\n self.test_res['loss'] += [total_loss]\n # self.test_res['score'] += [scores[self.primary_metric]]\n self.test_res['score'] += [f1]\n self.test_res['p'] = p\n self.test_res['r'] = r\n print(' TEST | LOSS = {:.05f}, '.format(total_loss), end=\"\")\n print_results(scores, scores_class, self.show_class, t2 - t1)\n # print(\"不同类别：\")\n # t = classification_report(truths, preds,target_names=[\"NA\",\"父母子女\", \"祖孙\", \"兄弟姐妹\", \"叔伯姑舅姨\", \"夫妻\", \"其他亲戚\", \"好友\", \"上下级\", \"师生\", \"合作\", \"情侣\", \"对立\", \"共现\", \"同学\", \"同门\"])\n # print(t)\n\n if save_predictions:\n\n test_result = test_result[: w + 1]\n test_result_pred = []\n test_result_info = []\n for item in test_result:\n test_result_pred.append([(item[-3], item[1])]) #预测的关系是的概率\n test_result_info.append([test_info[item[-2]][item[-1]]])\n assert (item[-3] in test_info[item[-2]][item[-1]]['rel']) == item[0], print(\"item\\n\", item, \"\\n\",\n test_info[item[-2]][\n item[-1]])\n write_errors(test_result_pred, test_result_info, self.preds_file, map_=self.loader.index2rel, type=\"theta\")\n write_preds(test_result_pred, test_result_info, self.preds_file, map_=self.loader.index2rel)\n # f1_score_t=f1_score(truths, preds, average='micro')\n # print(f1, scores['micro_f'], f1_score_t)\n\n return f1, scores['micro_f'],input_theta,p,r","def finalize_output_dict(self, output_dict):\n return {key: output_dict[key].cpu().numpy() for key in output_dict.keys()}","def evaluate(epoch_number):\r\n model.eval() # turn on the eval() switch to disable dropout\r\n total_loss = 0\r\n total_correct = 0\r\n total_spl = 0\r\n total_xrl = 0\r\n total_Xrl = 0\r\n total_Yrl = 0\r\n total_cl = 0\r\n total_ol = 0\r\n Ysave = []\r\n for batch, i in enumerate(range(0, len(data_val), args.batch_size)):\r\n data, targets, lenth = package(data_val[i:min(len(data_val), i+args.batch_size)], volatile=True)\r\n if args.cuda:\r\n data = data.cuda()\r\n targets = targets.cuda()\r\n hidden = model.init_hidden(data.size(1))\r\n x, y, x_re, X, Y, Y_fromX, X_fromY, pred, outp, outp_fromY = model.forward(data, hidden,lenth, \"eval\",epoch_number)\r\n Ysave.append( (Y.cpu(), pred.cpu(), targets.cpu()) )\r\n output_flat = pred.view(data.size(1), -1)\r\n loss, sparse_loss, x_re_loss, X_re_loss, Y_re_loss, class_loss, outp_loss= \\\r\n criterion(x, y, x_re, X, Y, Y_fromX, X_fromY, pred, targets, data.size(1), outp, outp_fromY, lenth, epoch_number)\r\n total_loss += loss.data\r\n total_spl += sparse_loss.data\r\n total_xrl += x_re_loss.data\r\n total_Xrl += X_re_loss.data\r\n total_Yrl += Y_re_loss.data\r\n total_cl += class_loss.data\r\n total_ol += outp_loss.data\r\n\r\n prediction = torch.max(output_flat, 1)[1]\r\n total_correct += torch.sum((prediction == targets).float())\r\n\r\n ave_loss = total_loss / (len(data_val) // args.batch_size)\r\n ave_spl = total_spl / (len(data_val) // args.batch_size)\r\n ave_xrl = total_xrl / (len(data_val) // args.batch_size)\r\n ave_Xrl = total_Xrl / (len(data_val) // args.batch_size)\r\n ave_Yrl = total_Yrl / (len(data_val) // args.batch_size)\r\n ave_cl = total_cl / (len(data_val) // args.batch_size)\r\n ave_ol = total_ol / (len(data_val) // args.batch_size)\r\n\r\n if epoch_number is 15:\r\n f = open(\"../Y.pkl\",\"wb\")\r\n pkl.dump(Ysave, f)\r\n f.close()\r\n return ave_loss, total_correct.data[0] / len(data_val), ave_spl, ave_xrl, ave_Xrl,ave_Yrl, ave_cl, ave_ol","def _train_epoch(self, epoch: int) -> Dict[str, float]:\n logger.info(\"Epoch %d/%d\", epoch, self._num_epochs - 1)\n peak_cpu_usage = peak_memory_mb()\n logger.info(f\"Peak CPU memory usage MB: {peak_cpu_usage}\")\n gpu_usage = []\n for gpu, memory in gpu_memory_mb().items():\n gpu_usage.append((gpu, memory))\n logger.info(f\"GPU {gpu} memory usage MB: {memory}\")\n\n train_loss = 0.0\n # Set the model to \"train\" mode.\n self.model.train()\n\n num_gpus = len(self._cuda_devices)\n\n # Get tqdm for the training batches\n raw_train_generator = self.iterator(self.train_data,\n num_epochs=1,\n shuffle=self.shuffle)\n train_generator = lazy_groups_of(raw_train_generator, num_gpus)\n num_training_batches = math.ceil(self.iterator.get_num_batches(self.train_data)/num_gpus)\n self._last_log = time.time()\n last_save_time = time.time()\n\n batches_this_epoch = 0\n if self._batch_num_total is None:\n self._batch_num_total = 0\n\n histogram_parameters = set(self.model.get_parameters_for_histogram_tensorboard_logging())\n\n logger.info(\"Training\")\n train_generator_tqdm = Tqdm.tqdm(train_generator,\n total=num_training_batches)\n cumulative_batch_size = 0\n for batch_group in train_generator_tqdm:\n batches_this_epoch += 1\n self._batch_num_total += 1\n batch_num_total = self._batch_num_total\n\n self.optimizer.zero_grad()\n\n output_dict = self.get_output_dict(batch_group, for_training=True)\n loss = self.get_batch_loss(output_dict, for_training=True)\n\n if torch.isnan(loss):\n raise ValueError(\"nan loss encountered\")\n\n loss.backward()\n\n train_loss += loss.item()\n\n batch_grad_norm = self.rescale_gradients()\n\n # This does nothing if batch_num_total is None or you are using a\n # scheduler which doesn't update per batch.\n if self._learning_rate_scheduler:\n self._learning_rate_scheduler.step_batch(batch_num_total)\n if self._momentum_scheduler:\n self._momentum_scheduler.step_batch(batch_num_total)\n\n if self._tensorboard.should_log_histograms_this_batch():\n # get the magnitude of parameter updates for logging\n # We need a copy of current parameters to compute magnitude of updates,\n # and copy them to CPU so large models won't go OOM on the GPU.\n param_updates = {name: param.detach().cpu().clone()\n for name, param in self.model.named_parameters()}\n self.optimizer.step()\n for name, param in self.model.named_parameters():\n param_updates[name].sub_(param.detach().cpu())\n update_norm = torch.norm(param_updates[name].view(-1, ))\n param_norm = torch.norm(param.view(-1, )).cpu()\n self._tensorboard.add_train_scalar(\"gradient_update/\" + name,\n update_norm / (param_norm + 1e-7))\n else:\n self.optimizer.step()\n\n # Update moving averages\n if self._moving_average is not None:\n self._moving_average.apply(batch_num_total)\n\n # Update the description with the latest metrics\n metrics = training_util.get_metrics(self.model, train_loss, batches_this_epoch)\n description = training_util.description_from_metrics(metrics)\n\n train_generator_tqdm.set_description(description, refresh=False)\n\n # Log parameter values to Tensorboard\n if self._tensorboard.should_log_this_batch():\n self._tensorboard.log_parameter_and_gradient_statistics(self.model, batch_grad_norm)\n self._tensorboard.log_learning_rates(self.model, self.optimizer)\n\n self._tensorboard.add_train_scalar(\"loss/loss_train\", metrics[\"loss\"])\n self._tensorboard.log_metrics({\"epoch_metrics/\" + k: v for k, v in metrics.items()})\n\n if self.tensorboard_log_batch_callback:\n self.tensorboard_log_batch_callback(output_dict, self._tensorboard)\n\n if self._tensorboard.should_log_histograms_this_batch():\n self._tensorboard.log_histograms(self.model, histogram_parameters)\n\n if self._log_batch_size_period:\n cur_batch = sum([training_util.get_batch_size(batch) for batch in batch_group])\n cumulative_batch_size += cur_batch\n if (batches_this_epoch - 1) % self._log_batch_size_period == 0:\n average = cumulative_batch_size/batches_this_epoch\n logger.info(f\"current batch size: {cur_batch} mean batch size: {average}\")\n self._tensorboard.add_train_scalar(\"current_batch_size\", cur_batch)\n self._tensorboard.add_train_scalar(\"mean_batch_size\", average)\n\n # Save model if needed.\n if self._model_save_interval is not None and (\n time.time() - last_save_time > self._model_save_interval\n ):\n last_save_time = time.time()\n self._save_checkpoint(\n '{0}.{1}'.format(epoch, training_util.time_to_str(int(last_save_time)))\n )\n metrics = training_util.get_metrics(self.model, train_loss, batches_this_epoch, reset=True)\n metrics['cpu_memory_MB'] = peak_cpu_usage\n for (gpu_num, memory) in gpu_usage:\n metrics['gpu_'+str(gpu_num)+'_memory_MB'] = memory\n return metrics","def _valid_epoch(self, epoch):\n self.model.eval()\n total_val_loss = 0\n total_val_metrics = np.zeros(len(self.metrics))\n length = len(self.valid_loader)\n total_pm25_loss = 0\n total_pm10_loss = 0\n pm25_loss = 0\n pm10_loss = 0\n\n with torch.no_grad():\n\n for batch_idx, (data, target) in enumerate(self.valid_loader):\n data, target = data.to(self.device), target.to(self.device)\n target = target.squeeze()\n output = self.model(data)\n # print(output)\n loss = self.loss(output, target)\n\n # pm25_predict, pm10_predict = torch.chunk(output, 2, dim=1)\n # pm25_target, pm10_target = torch.chunk(target, 2, dim=1)\n # pm25_loss = self.loss(pm25_predict, pm25_target)\n # pm10_loss = self.loss(pm10_predict, pm10_target)\n # total_pm25_loss += pm25_loss.item()\n # total_pm10_loss += pm10_loss.item()\n\n self.writer.set_step((epoch - 1) * len(self.valid_loader) + batch_idx, 'valid')\n self.writer.add_scalar('loss', loss.item())\n total_val_loss += loss.item()\n total_val_metrics += self._eval_metrics(output, target)\n\n return {\n 'val_loss': total_val_loss / length,\n 'val_rmse_loss':np.sqrt(total_val_loss / length),\n 'val_pm25_loss': np.sqrt(total_pm25_loss / length),\n 'val_pm10_loss': np.sqrt(total_pm10_loss / length)\n }","def on_train_epoch_end(self) -> None:\n self.log_dict(self.train_metrics.compute())\n self.train_metrics.reset()","def _eval_epoch(model, dl_val, criterion):\n model.eval()\n\n loss_val = 0\n cls_loss_val = 0\n reg_loss_val = 0\n len_val = 0\n\n y_true = []\n y_pred = []\n\n with torch.no_grad():\n for i, sample in enumerate(dl_val):\n sys.stdout.write(\"\\r\")\n\n images, cls_target, reg_target = sample\n images = images.cuda()\n cls_target = cls_target.cuda()\n reg_target = reg_target.cuda()\n\n cls_output, reg_output = model(images)\n total_loss, cls_loss, reg_loss = criterion(cls_output, reg_output,\n cls_target, reg_target)\n\n loss_val += total_loss.cpu().item() * images.size(0)\n cls_loss_val += cls_loss.cpu().item() * images.size(0)\n reg_loss_val += reg_loss.cpu().item() * images.size(0)\n len_val += images.size(0)\n\n y_true += calculate_detect_prediction(cls_target, reg_target,\n cfg.target_size, cfg.prob_thresh, cfg.overlap_iou_thresh,\n cfg.num_classes)\n y_pred += calculate_detect_prediction(cls_output, reg_output,\n cfg.target_size, cfg.prob_thresh, cfg.overlap_iou_thresh)\n\n sys.stdout.write(f\"Validation: {i + 1}/{len(dl_val)}\")\n\n loss_val /= len_val\n cls_loss_val /= len_val\n reg_loss_val /= len_val\n\n map_score = calculate_map(y_true, y_pred, cfg.num_classes)\n\n sys.stdout.flush()\n\n return loss_val, cls_loss_val, reg_loss_val, map_score","def validation_epoch_end(self, outputs):\n epoch_loss, epoch_accuracy = self._parse_outputs(\n outputs=outputs, calculate_confusion_matrix=False)\n self.log('validation loss', np.mean(epoch_loss),\n on_epoch=True, prog_bar=True)\n self.log('validation accuracy', np.mean(epoch_accuracy))","def compute_stats(self, epoch, loader, setname):\n args = self.args\n self.model.eval()\n ndevbatches = len(self.dev_loader)\n logging.info(f\"Evaluating {ndevbatches} batches ...\")\n\n recons, gts = defaultdict(list), defaultdict(list)\n acquisition_machine_by_fname = dict()\n with torch.no_grad():\n for batch_idx, batch in enumerate(self.dev_loader):\n progress = epoch + batch_idx/ndevbatches\n logging_epoch = batch_idx % args.log_interval == 0\n logging_epoch_info = batch_idx % (2 * args.log_interval) == 0\n log = logging.info if logging_epoch_info else logging.debug\n\n self.start_of_test_batch_hook(progress, logging_epoch)\n\n batch = self.preprocess_data(batch)\n output, target = self.predict(batch)\n output = self.unnorm(output, batch)\n target = self.unnorm(target, batch)\n fname, slice = batch.fname, batch.slice\n\n for i in range(output.shape[0]):\n slice_cpu = slice[i].item()\n recons[fname[i]].append((slice_cpu, output[i].float().cpu().numpy()))\n gts[fname[i]].append((slice_cpu, target[i].float().cpu().numpy()))\n\n acquisition_type = batch.attrs_dict['acquisition'][i]\n machine_type = batch.attrs_dict['system'][i]\n acquisition_machine_by_fname[fname[i]] = machine_type + '_' + acquisition_type\n\n if logging_epoch or batch_idx == ndevbatches-1:\n gpu_memory_gb = torch.cuda.memory_allocated()/1000000000\n host_memory_gb = utils.host_memory_usage_in_gb()\n log(f\"Evaluated {batch_idx+1} of {ndevbatches} (GPU Mem: {gpu_memory_gb:2.3f}gb Host Mem: {gpu_memory_gb:2.3f}gb)\")\n sys.stdout.flush()\n\n if self.args.debug_epoch_stats:\n break\n del output, target, batch\n\n logging.debug(f\"Finished evaluating\")\n self.end_of_test_epoch_hook()\n\n recons = {\n fname: np.stack([pred for _, pred in sorted(slice_preds)])\n for fname, slice_preds in recons.items()\n }\n gts = {\n fname: np.stack([pred for _, pred in sorted(slice_preds)])\n for fname, slice_preds in gts.items()\n }\n\n nmse, psnr, ssims = [], [], []\n ssim_for_acquisition_machine = defaultdict(list)\n recon_keys = list(recons.keys()).copy()\n for fname in recon_keys:\n pred_or, gt_or = recons[fname].squeeze(1), gts[fname].squeeze(1)\n pred, gt = transforms.center_crop_to_smallest(pred_or, gt_or)\n del pred_or, gt_or\n\n ssim = evaluate.ssim(gt, pred)\n acquisition_machine = acquisition_machine_by_fname[fname]\n ssim_for_acquisition_machine[acquisition_machine].append(ssim)\n ssims.append(ssim)\n nmse.append(evaluate.nmse(gt, pred))\n psnr.append(evaluate.psnr(gt, pred))\n del gt, pred\n del recons[fname], gts[fname]\n\n if len(nmse) == 0:\n nmse.append(0)\n ssims.append(0)\n psnr.append(0)\n\n min_vol_ssim = np.argmin(ssims)\n min_vol = str(recon_keys[min_vol_ssim])\n logging.info(f\"Min vol ssims: {min_vol}\")\n sys.stdout.flush()\n\n del recons, gts\n\n acquisition_machine_losses = dict.fromkeys(self.dev_data.system_acquisitions, 0)\n for key, value in ssim_for_acquisition_machine.items():\n acquisition_machine_losses[key] = np.mean(value)\n\n losses = {'NMSE': np.mean(nmse),\n 'PSNR': np.mean(psnr),\n 'SSIM': np.mean(ssims),\n 'SSIM_var': np.var(ssims),\n 'SSIM_min': np.min(ssims),\n **acquisition_machine_losses}\n\n return losses","def pre_epoch_finish(self, input, output, metric_manager, train_stage: TrainStage):\n if train_stage == TrainStage.VALIDATE:\n generated_imgs, _, _, _, real_imgs = output\n self.add_generated_image(\n generated_imgs, nrow=self.display_imgs, height=self.height,\n width=self.width, name='generated')\n self.add_generated_image(\n real_imgs, nrow=self.display_imgs, height=self.height,\n width=self.width, name='real')","def on_epoch_end(self, epoch: int, logs: dict = None):\n if logs is None:\n logs = {}\n\n # reset the index\n self.model.reset_index()\n\n # rebuild the index\n self.model.index(self.targets, self.target_labels, verbose=0)\n\n results = _compute_classification_metrics(\n queries=self.queries,\n query_labels=self.query_labels,\n model=self.model,\n evaluator=self.evaluator,\n metrics=self.metrics,\n k=self.k,\n matcher=self.matcher,\n distance_thresholds=self.distance_thresholds)\n\n mstr = []\n for metric_name, vals in results.items():\n float_val = vals[0]\n logs[metric_name] = float_val\n mstr.append(f'{metric_name}: {float_val:.4f}')\n if self.tb_writer:\n with self.tb_writer.as_default():\n tf.summary.scalar(metric_name, float_val, step=epoch)\n\n # reset the index to prevent users from accidently using this after the\n # callback\n self.model.reset_index()\n\n print(' - '.join(mstr))","def finalize_output_dict(self):\n self.output_dict = {\n key: torch.cat(value).numpy() for key, value in self.output_dict.items()\n }","def on_test_epoch_end(self) -> None:\n self.log_dict(self.test_metrics.compute())\n self.test_metrics.reset()","def run_epoch(self, session):\n start_time = time.time()\n costs = 0.0\n iters = 0\n\n fetches = {\n \"cost\": self._cost,\n \"final_state\": self._final_state,\n }\n\n if(self._is_training):\n fetches[\"train_op\"] = self._train_op\n\n state = session.run(self._initial_state)\n\n for step in range(self._input.epoch_size):\n feed_dict = {}\n for i, (c, h) in enumerate(self._initial_state):\n feed_dict[c] = state[i].c\n feed_dict[h] = state[i].h\n\n vals = session.run(fetches, feed_dict)\n cost = vals[\"cost\"]\n state = vals[\"final_state\"]\n\n costs += cost\n iters += self._input.num_steps\n\n return np.exp(costs / iters)","def _extract_epoch_results(\n self, epoch: int = -1\n ) -> Dict[str, Dict[str, DLTypes.TrackableType]]:\n return {\n \"Static hyperparameters\": self._static_hyperparameters,\n \"Dynamic hyperparameters\": {\n name: value[epoch]\n for name, value in self._dynamic_hyperparameters.items()\n },\n \"Training results\": {\n name: value[epoch] for name, value in self._training_summaries.items()\n },\n \"Validation results\": {\n name: value[epoch] for name, value in self._validation_summaries.items()\n },\n }","def run_epoch(self, sess, epoch_num, validate=True):\n total_loss = 0\n accuracies = []\n for i in range(self.batches_per_epoch):\n batch = self.loader.get_batch()\n if self.config.print_every and i % self.config.print_every == 0:\n if validate:\n val_accuracy = self.eval_validation_accuracy()\n print(\"step {}, validation accuracy {:.3f}\".format(i, val_accuracy))\n accuracies.append((i + epoch_num * self.batches_per_epoch, val_accuracy))\n else:\n if self.include_coverage and self.include_entropy:\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1], batch[2], batch[3])\n elif self.include_coverage:\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1], batch[2])\n elif self.include_entropy:\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1], batch[2])\n else:\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1])\n print(\"step {}, training accuracy {:.3f}\".format(i, train_accuracy))\n \n if self.include_coverage and self.include_entropy:\n _, loss_val = sess.run([self.train_op, self.loss],\n feed_dict={self.x: batch[0], self.c: batch[1], self.e: batch[2], self.y_: batch[2], \n self.keep_prob: 1-self.config.dropout_prob})\n elif self.include_coverage:\n _, loss_val = sess.run([self.train_op, self.loss],\n feed_dict={self.x: batch[0], self.c: batch[1], self.y_: batch[2], \n self.keep_prob: 1-self.config.dropout_prob})\n elif self.include_entropy:\n _, loss_val = sess.run([self.train_op, self.loss],\n feed_dict={self.x: batch[0], self.e: batch[1], self.y_: batch[2], \n self.keep_prob: 1-self.config.dropout_prob})\n else:\n attention, _, loss_val = sess.run([self.attention, self.train_op, self.loss],\n feed_dict={self.x: batch[0], self.y_: batch[1],\n self.keep_prob: 1-self.config.dropout_prob})\n\t\tpdb.set_trace()\n\t\tnp.savetxt(\"a.csv\", attention[0], delimiter=\",\")\n total_loss += loss_val\n\n return total_loss / self.batches_per_epoch, accuracies","def run_epoch(self, dataloader, train=True):\n losses = []\n accs = []\n for imgs, targets in dataloader:\n imgs, targets = imgs.to(self.device), targets.to(self.device)\n\n # calc. the losses\n output = self.resnet(imgs)\n loss = self.criterion(output, targets)\n\n if train:\n # update the parameters\n self.optimizer.zero_grad() # initialize gradients\n loss.backward()\n self.optimizer.step()\n\n # save training results\n if self.total_steps % 10 == 0:\n accuracy = self.calc_batch_accuracy(output, targets)\n accs.append(accuracy.item())\n losses.append(loss.item())\n self.log_performance(self.summary_writer,\n {'loss': loss.item(), 'acc': accuracy.item()},\n self.epoch,\n self.total_steps)\n\n if self.total_steps % 100 == 0:\n self.save_module_summary(\n self.summary_writer, self.resnet.module, self.total_steps)\n\n self.total_steps += 1\n else: # no training - validation\n accuracy = self.calc_batch_accuracy(output, targets)\n accs.append(accuracy.item())\n losses.append(loss.item())\n\n avg_loss = sum(losses) / len(losses)\n avg_acc = sum(accs) / len(accs)\n return avg_loss, avg_acc","def on_epoch_end(self, epoch: int, logs: dict = None):\n _ = epoch\n if logs is None:\n logs = {}\n\n # reset the index\n self.model.reset_index()\n\n # rebuild the index\n self.model.index(self.targets, self.target_labels, verbose=0)\n\n known_results = _compute_classification_metrics(\n queries=self.queries_known,\n query_labels=self.query_labels_known,\n model=self.model,\n evaluator=self.evaluator,\n metrics=self.metrics,\n k=self.k,\n matcher=self.matcher,\n distance_thresholds=self.distance_thresholds)\n\n unknown_results = _compute_classification_metrics(\n queries=self.queries_unknown,\n query_labels=self.query_labels_unknown,\n model=self.model,\n evaluator=self.evaluator,\n metrics=self.metrics,\n k=self.k,\n matcher=self.matcher,\n distance_thresholds=self.distance_thresholds)\n\n mstr = []\n for metric_name, vals in known_results.items():\n float_val = vals[0]\n full_metric_name = f'{metric_name}_known_classes'\n logs[full_metric_name] = float_val\n mstr.append(f'{full_metric_name}: {float_val:0.4f}')\n if self.tb_writer:\n with self.tb_writer.as_default():\n tf.summary.scalar(full_metric_name, float_val, step=epoch)\n\n for metric_name, vals in unknown_results.items():\n float_val = vals[0]\n full_metric_name = f'{metric_name}_unknown_classes'\n logs[full_metric_name] = float_val\n mstr.append(f'{full_metric_name}: {float_val:0.4f}')\n if self.tb_writer:\n with self.tb_writer.as_default():\n tf.summary.scalar(full_metric_name, float_val, step=epoch)\n\n # reset the index to prevent users from accidently using this after the\n # callback\n self.model.reset_index()\n\n print(' - '.join(mstr))","def MakeSamplesFromEvalOutput(metadata, output, elapsed_seconds):\n pattern = (r'Saving dict for global step \\d+: accuracy = (\\d+\\.\\d+), '\n r'global_step = (\\d+), loss = (\\d+\\.\\d+)')\n accuracy, step, loss = regex_util.ExtractAllMatches(pattern, output).pop()\n metadata_copy = metadata.copy()\n step = int(step)\n metadata_copy['step'] = step\n num_examples_per_epoch = metadata['num_examples_per_epoch']\n metadata_copy['epoch'] = step / num_examples_per_epoch\n metadata_copy['elapsed_seconds'] = elapsed_seconds\n return [sample.Sample('Eval Loss', float(loss), '', metadata_copy),\n sample.Sample('Accuracy', float(accuracy) * 100, '%', metadata_copy)]","def train_epoch(self, epoch):\n t1 = time()\n output = {'tp': [], 'fp': [], 'fn': [], 'tn': [], 'loss': [], 'preds': [], 'true': 0, 'ttotal': []}\n self.acc_NA.clear()\n self.acc_not_NA.clear()\n self.acc_total.clear()\n\n self.model.train()\n # 多个batch的数据\n train_iter = self.iterator(self.data['train'], batch_size=self.params['batch'],\n shuffle_=self.params['shuffle_data'])\n\n for batch_idx, batch in enumerate(train_iter):\n # print(\"batch_idx\", batch_idx)\n batch = self.convert_batch(batch, istrain=True)\n\n # with autograd.detect_anomaly():\n self.optimizer.zero_grad()\n loss, stats, predictions, select, pred_pairs, multi_truths, mask, relation_label = self.model(batch)\n pred_pairs = torch.sigmoid(pred_pairs)\n # self.optimizer.zero_grad()\n loss.backward() # backward computation\n\n nn.utils.clip_grad_norm_(self.model.parameters(), self.gc) # gradient clipping\n self.optimizer.step() # update\n if self.scheduler!=None:\n self.scheduler.step()\n\n relation_label = relation_label.to('cpu').data.numpy()\n predictions = predictions.to('cpu').data.numpy()\n # batches\n output['loss'] += [float(loss.item())]\n output['tp'] += [stats['tp'].to('cpu').data.numpy()]\n output['fp'] += [stats['fp'].to('cpu').data.numpy()]\n output['fn'] += [stats['fn'].to('cpu').data.numpy()]\n output['tn'] += [stats['tn'].to('cpu').data.numpy()]\n output['preds'] += [predictions]\n output['ttotal'] += [stats['ttotal']]\n\n for i in range(predictions.shape[0]):\n label = relation_label[i]\n if label < 0:\n break\n if label == self.loader.label2ignore:\n self.acc_NA.add(predictions[i] == label)\n else:\n self.acc_not_NA.add(predictions[i] == label)\n self.acc_total.add(predictions[i] == label)\n # 一个epoch\n total_loss, scores = self.performance(output)\n t2 = time()\n\n self.train_res['loss'] += [total_loss]\n self.train_res['score'] += [scores[self.primary_metric]]\n self.train_res['p'] += [scores['micro_p']]\n self.train_res['r'] += [scores['micro_r']]\n\n print('Epoch: {:02d} | TRAIN | LOSS = {:.05f}, | NA acc: {:4.2f} | not NA acc: {:4.2f} | tot acc: {:4.2f}'.\n format(epoch, total_loss, self.acc_NA.get(), self.acc_not_NA.get(), self.acc_total.get()), end=\"\")\n print_results(scores, [], False, t2 - t1)\n print(\"TTotal\\t\", sum(output['ttotal']))\n return scores['micro_f']","def _train_epoch(self, epoch):\n self.model.train()\n self.train_metrics.reset()\n for batch_idx, (data, target) in enumerate(self.data_loader):\n data, target = data.to(self.device), target.to(self.device)\n\n self.optimizer.zero_grad()\n\n if self.config[\"amp\"]:\n # AMP!\n with autocast():\n output = self.model(data)\n loss = self.criterion(output, target)\n else:\n output = self.model(data)\n loss = self.criterion(output, target)\n\n loss.backward()\n self.optimizer.step()\n\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\n self.train_metrics.update(\"loss\", loss.item())\n for met in self.metric_ftns:\n self.train_metrics.update(met.__name__, met(output, target))\n\n if batch_idx % self.log_step == 0:\n self.logger.debug(\n \"Train Epoch: {} {} Loss: {:.6f}\".format(\n epoch, self._progress(batch_idx), loss.item()\n )\n )\n self.writer.add_image(\n \"input\", make_grid(data.cpu(), nrow=8, normalize=True)\n )\n\n if batch_idx == self.len_epoch:\n break\n log = self.train_metrics.result()\n\n if self.do_validation:\n val_log = self._valid_epoch(epoch)\n log.update(**{\"val_\" + k: v for k, v in val_log.items()})\n\n if self.lr_scheduler is not None:\n self.lr_scheduler.step()\n return log","def calculate_statistics(train_loader, net):\n net.eval()\n\n pred_list = None\n max_class_mean = {}\n print(\"Calculating statistics...\")\n for i, data in enumerate(train_loader):\n inputs = data[0]\n\n inputs = inputs.cuda()\n B, C, H, W = inputs.shape\n batch_pixel_size = C * H * W\n\n with torch.no_grad():\n outputs, _ = net(inputs)\n\n if pred_list is None:\n pred_list = outputs.data.cpu()\n else:\n pred_list = torch.cat((pred_list, outputs.cpu()), 0)\n del outputs\n\n if i % 50 == 49 or i == len(train_loader) - 1:\n pred_list = pred_list.transpose(1, 3)\n pred_list, prediction = pred_list.max(3)\n\n class_max_logits = []\n mean_dict, var_dict = {}, {}\n for c in range(datasets.num_classes):\n max_mask = pred_list[prediction == c]\n class_max_logits.append(max_mask)\n\n mean = class_max_logits[c].mean(dim=0)\n var = class_max_logits[c].var(dim=0)\n\n mean_dict[c] = mean.item()\n var_dict[c] = var.item()\n\n print(f\"class mean: {mean_dict}\")\n print(f\"class var: {var_dict}\")\n np.save(f'stats/{args.dataset[0]}_mean.npy', mean_dict)\n np.save(f'stats/{args.dataset[0]}_var.npy', var_dict)\n\n return None","def run_epoch(self, train, dev, epoch):\n # iterate over dataset\n for i, (words, labels) in enumerate(minibatches(train, self.config.batch_size)):\n fd, _ = self.get_feed_dict(words, labels, self.config.lr,\n self.config.dropout)\n\n _, train_loss= self.sess.run(\n [self.train_op, self.loss], feed_dict=fd)\n\n# =============================================================================\n# # tensorboard\n# if i % 10 == 0:\n# self.file_writer.add_summary(summary, epoch*nbatches + i)\n# =============================================================================\n\n metrics = self.run_evaluate(dev)\n msg = \" - \".join([\"{} {:04.2f}\".format(k, v)\n for k, v in metrics.items()])\n print(msg)\n\n return metrics[\"f1\"]","def on_train_end(self, logs=None):\n self.epoch_iter = 0","def eval_epoch(model, validation_data, pred_loss_func, opt):\n\n model.eval()\n\n total_event_ll = 0 # cumulative event log-likelihood\n total_time_se = 0 # cumulative time prediction squared-error\n total_time_error = 0 # cumulative time prediction squared-error\n total_time_latitude = 0 # cumulative latitude prediction squared-error\n total_time_longitude = 0 # cumulative longitude prediction squared-error\n\n total_event_rate = 0 # cumulative number of correct prediction\n total_num_event = 0 # number of total events\n total_num_pred = 0 # number of predictions\n with torch.no_grad():\n for batch in tqdm(validation_data, mininterval=2,\n desc=' - (Validation) ', leave=False):\n \"\"\" prepare data \"\"\"\n event_time, time_gap, event_type, latitude, longitude = map(lambda x: x.to(opt.device), batch)\n\n \"\"\" forward \"\"\"\n enc_out, prediction = model(event_type, event_time, latitude, longitude) # change the event_time to time gap\n\n \"\"\" compute loss \"\"\"\n event_ll, non_event_ll = Utils.log_likelihood(model, enc_out, time_gap, event_type, latitude, longitude) # change the event_time to time gap\n event_loss = -torch.sum(event_ll - non_event_ll)\n\n _, pred_num = Utils.type_loss(prediction[0], event_type, pred_loss_func)\n\n se = Utils.time_loss(prediction[1], event_time) # change the event_time to time gap\n le = Utils.time_loss(prediction[2], latitude)\n ge = Utils.time_loss(prediction[3], longitude)\n\n \"\"\" note keeping \"\"\"\n total_event_ll += -event_loss.item()\n total_time_se += se.item() + le.item() + ge.item()\n total_time_error += se.item()\n total_time_latitude += le.item()\n total_time_longitude += ge.item()\n\n total_event_rate += pred_num.item()\n total_num_event += event_type.ne(Constants.PAD).sum().item()\n total_num_pred += event_type.ne(Constants.PAD).sum().item() - event_time.shape[0] # change the event_time to time gap\n\n test_rmse = np.sqrt(total_time_se / total_num_pred)\n test_time_rmse = np.sqrt(total_time_error / total_num_pred)\n test_latitude_rmse = np.sqrt(total_time_latitude / total_num_pred)\n test_longitude_rmse = np.sqrt(total_time_longitude / total_num_pred)\n\n return total_event_ll / total_num_event, total_event_rate / total_num_pred, test_time_rmse, test_latitude_rmse, test_longitude_rmse, test_rmse","def _train_epoch(self, epoch):\n\n indexes = []\n losses2save = []\n\n start_time = time.time()\n self.model.train()\n self.train_metrics.reset()\n for batch_idx, (data, target, index) in enumerate(self.data_loader):\n indexes.append(index)\n batch_start = time.time()\n data, target = data.to(device=self.device, dtype=torch.float), target.to(self.device, dtype=torch.float)\n if self.mixup is not None:\n data, target = mixup(data, target, np.random.beta(1, 1))\n # if self.lable_smooth is not None:\n # target = target.long()\n # print('getting smooth label')\n # target = smooth_one_hot(true_labels=target, classes=108, smoothing=self.lable_smooth)\n\n self.optimizer.zero_grad()\n output = self.model(data)\n\n if self.only_scored_classes:\n # Only consider classes that are scored with the Challenge metric.\n if self.config[\"loss\"][\"type\"] == \"weighted_bce_with_logits_loss\":\n loss = self.criterion(output[:, self.indices], target[:, self.indices], self.weights)\n else:\n loss = self.criterion(output[:, self.indices], target[:, self.indices])\n cost_w = F.binary_cross_entropy_with_logits(output[:, self.indices], target[:, self.indices], reduce=False)\n # cost_w = torch.sum(cost_w, dim=1)\n cost_v = torch.reshape(cost_w, (len(cost_w), 24))\n cost_tmp = cost_v.cpu().detach().numpy()\n losses2save.append(cost_tmp)\n loss = torch.sum(cost_w)/len(cost_w)\n else:\n loss = self.criterion(output, target)\n\n loss.backward()\n self.optimizer.step()\n\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\n self.train_metrics.update('loss', loss.item())\n\n output_logit = self.sigmoid(output)\n for met in self.metric_ftns:\n self.train_metrics.update(met.__name__, met(self._to_np(output_logit), self._to_np(target)))\n\n if batch_idx % self.log_step == 0:\n batch_end = time.time()\n self.logger.debug('Train Epoch: {} {} Loss: {:.6f}, 1 batch cost time {:.2f}'.format(\n epoch,\n self._progress(batch_idx),\n loss.item(),\n batch_end - batch_start))\n # self.writer.add_image('input', make_grid(data.cpu(), nrow=8, normalize=True))\n\n if batch_idx == self.len_epoch:\n break\n log = self.train_metrics.result()\n\n end_time = time.time()\n print(\"training epoch cost {} seconds\".format(end_time-start_time))\n if self.do_validation:\n val_log = self._valid_epoch(epoch)\n log.update(**{'val_'+k : v for k, v in val_log.items()})\n\n if self.lr_scheduler is not None:\n if self.config['lr_scheduler']['type'] == 'ReduceLROnPlateau':\n self.lr_scheduler.step(log['val_loss'])\n elif self.config['lr_scheduler']['type'] == 'GradualWarmupScheduler':\n self.lr_scheduler.step(epoch, log['val_loss'])\n else:\n self.lr_scheduler.step()\n\n return np.concatenate(indexes), np.concatenate(losses2save), log","def _compute_running_metrics(self,\n model_output: torch.Tensor,\n batch: Tuple[torch.Tensor, torch.Tensor],\n running_metrics: dict) -> None:\n for metric in self.metrics:\n if metric.__name__ == 'word_error_rate' or metric.__name__ == 'character_error_rate':\n metric_result = metric(model_output, batch, self.decoder)\n else:\n metric_result = metric(model_output, batch)\n if type(metric_result) == torch.Tensor:\n metric_result = metric_result.item()\n\n running_metrics[metric.__name__].append(metric_result)","def on_epoch_begin(self, epoch, logs={}):\n self.current_progress = 0\n self.loss = 0\n self.accuracy = 0","def validation_end(self, outputs):\n # if returned a scalar from validation_step, outputs is a list of tensor scalars\n # we return just the average in this case (if we want)\n # return torch.stack(outputs).mean()\n\n val_loss_mean = 0\n val_acc_mean = 0\n for output in outputs:\n val_loss = output['val_loss']\n\n # reduce manually when using dp\n if self.trainer.use_dp or self.trainer.use_ddp2:\n val_loss = torch.mean(val_loss)\n val_loss_mean += val_loss\n\n # reduce manually when using dp\n val_acc = output['val_acc']\n if self.trainer.use_dp or self.trainer.use_ddp2:\n val_acc = torch.mean(val_acc)\n\n val_acc_mean += val_acc\n\n val_loss_mean /= len(outputs)\n val_acc_mean /= len(outputs)\n tqdm_dict = {'val_loss': val_loss_mean, 'val_acc': val_acc_mean}\n result = {'progress_bar': tqdm_dict, 'log': tqdm_dict, 'val_loss': val_loss_mean}\n return result","def compute_metrics(self, outputs: List[Dict[str, torch.Tensor]]) -> dict:\n distance_pos, distance_neg = [], []\n for minibatch in outputs:\n minibatch = minibatch[\"val_prediction\"]\n src_embedding = minibatch[\"src_sentemb\"]\n ref_embedding = minibatch[\"ref_sentemb\"]\n pos_embedding = minibatch[\"pos_sentemb\"]\n neg_embedding = minibatch[\"neg_sentemb\"]\n\n distance_src_pos = F.pairwise_distance(pos_embedding, src_embedding)\n distance_ref_pos = F.pairwise_distance(pos_embedding, ref_embedding)\n harmonic_distance_pos = (2 * distance_src_pos * distance_ref_pos) / (\n distance_src_pos + distance_ref_pos\n )\n distance_pos.append(harmonic_distance_pos)\n\n distance_src_neg = F.pairwise_distance(neg_embedding, src_embedding)\n distance_ref_neg = F.pairwise_distance(neg_embedding, ref_embedding)\n harmonic_distance_neg = (2 * distance_src_neg * distance_ref_neg) / (\n distance_src_neg + distance_ref_neg\n )\n distance_neg.append(harmonic_distance_neg)\n\n return {\n \"kendall\": self.metrics.compute(\n torch.cat(distance_pos), torch.cat(distance_neg)\n )\n }","def init_output_dict(self):\n return {\n \"outputs\": torch.FloatTensor(),\n \"pred_probs\": torch.FloatTensor(),\n \"labels\": torch.LongTensor(),\n }","def run_epoch(data_iter, model, loss_compute, print_every=50, num_batches=0, phase=\"train\", epoch_num=0):\n\n start = time.time()\n total_tokens = 0\n total_loss = 0\n print_tokens = 0\n\n for i, batch in tqdm(enumerate(data_iter, 1)):\n out, _, pre_output = model.forward(batch.src, batch.trg,\n batch.src_mask, batch.trg_mask,\n batch.src_lengths, batch.trg_lengths)\n loss = loss_compute(pre_output, batch.trg_y, batch.nseqs)\n #print(f'epoch loss {loss}')\n total_loss += loss\n total_tokens += batch.ntokens\n print_tokens += batch.ntokens\n \n if model.training and i % print_every == 0:\n elapsed = time.time() - start\n print(\"Epoch Step: %d Loss: %f Tokens per Sec: %f\" %\n (i, loss / batch.nseqs, print_tokens / elapsed))\n start = time.time()\n print_tokens = 0\n\n if num_batches > 0 and i > num_batches:\n break\n\n return math.exp(total_loss / float(total_tokens)), total_loss\n #return total_loss / float(total_tokens)","def _valid_epoch(self, epoch):\n self.model.eval()\n self.valid_metrics.reset()\n with torch.no_grad():\n for batch_idx, (data, target, _) in enumerate(self.valid_data_loader):\n data, target = data.to(device=self.device, dtype=torch.float), target.to(self.device, dtype=torch.float)\n\n output = self.model(data)\n\n if self.only_scored_classes:\n # Only consider classes that are scored with the Challenge metric.\n if self.config[\"loss\"][\"type\"] == \"weighted_bce_with_logits_loss\":\n loss = self.criterion(output[:, self.indices], target[:, self.indices], self.weights)\n else:\n loss = self.criterion(output[:, self.indices], target[:, self.indices])\n else:\n loss = self.criterion(output, target)\n\n self.writer.set_step((epoch - 1) * len(self.valid_data_loader) + batch_idx, 'valid')\n self.valid_metrics.update('loss', loss.item())\n\n output_logit = self.sigmoid(output)\n for met in self.metric_ftns:\n self.valid_metrics.update(met.__name__, met(self._to_np(output_logit), self._to_np(target)))\n # self.writer.add_image('input', make_grid(data.cpu(), nrow=8, normalize=True))\n\n if self.lr_scheduler is not None and self.config[\"lr_scheduler\"][\"type\"] == \"ReduceLROnPlateau\":\n self.lr_scheduler.step(self.valid_metrics.result()[\"challenge_metric\"])\n\n # add histogram of model parameters to the tensorboard\n # for name, p in self.model.named_parameters():\n # self.writer.add_histogram(name, p, bins='auto')\n return self.valid_metrics.result()","def _get_epoch_acc(self, is_test: bool = False) -> Dict[str, float]:\n n_total = (\n len(self.testloader.dataset) if is_test else len(self.trainloader.dataset)\n )\n acc = dict()\n for module_name in self.n_correct_epoch:\n accuracy = 100 * self.n_correct_epoch[module_name] / n_total\n acc.update({module_name + \"_acc\": accuracy})\n self.n_correct_epoch.clear()\n\n return acc","def after_evaluation(self, epoch, **kw):\n if self.loss_txt is not None:\n self.current_row[MetricName(\"timestamp\")] = f\"{datetime.now():%H:%M:%S}\"\n\n # output log file\n with open(self.loss_txt, \"a\") as f:\n # remove columns where no value was found on the first epoch (could be != 1 if training was resumed)\n if epoch == self.first_epoch:\n for k in list(self.headers.keys()):\n if k not in self.current_row:\n del self.headers[k]\n\n # make headers on epoch 1\n if epoch == 1:\n # write header\n f.write(\"\\t\".join(self.headers.values()) + \"\\n\")\n\n for col in self.headers:\n assert col in self.current_row, str(col) + \" \" + str(self.current_row.keys())\n\n assert all(col in self.current_row for col in self.headers)\n\n f.write(\"\\t\".join([str(self.current_row[col]) for col in self.headers]) + \"\\n\")\n\n self.current_row = {}","def eval_epoch(self, epoch_num: int) -> float:\n epoch_loss = 0.0\n # hidden_start = torch.zeros(self.batch_size, self.rnn_size).to(device)\n with torch.no_grad():\n # for batch_num, (x, y) in enumerate(make_batches(self.dev_data,\n # self.batch_size,\n # self.max_len)):\n acc = 0;\n for batch_num, batch_tuple in enumerate(self.train_data):\n print('batch: ', batch_num)\n # reset gradients\n # self.optimizer.zero_grad()\n # x = len(batch_tuple[0])\n # y = len(batch_tuple[0][0])\n # batch x timesteps x hidden_size\n x, y = batch_tuple\n # x = x.to(self.device)\n # y = y.to(self.device)\n hidden_states = self.model(x)\n # batch x timesteps x vocab_size\n # logits = self.model.get_logits(hidden_states)\n\n batch_loss = self.model.get_loss(hidden_states, y)\n epoch_loss += batch_loss.item()\n hidden_states_m = torch.argmax(hidden_states, dim=1)\n acc += sum(hidden_states_m == y).item()\n # we use a stateful RNN, which means the first hidden state for\n # the next batch is the last hidden state of the current batch\n # hidden_states.detach_()\n # hidden_start = hidden_states[:,-1,:]\n\n epoch_loss /= (batch_num + 1)\n\n return epoch_loss, acc","def MakeSamplesFromTrainOutput(metadata, output, elapsed_seconds, step):\n samples = []\n metadata_copy = metadata.copy()\n metadata_copy['step'] = int(step)\n metadata_copy['epoch'] = step / metadata['num_examples_per_epoch']\n metadata_copy['elapsed_seconds'] = elapsed_seconds\n\n get_mean = lambda matches: sum(float(x) for x in matches) / len(matches)\n loss = get_mean(regex_util.ExtractAllMatches(\n r'Loss for final step: (\\d+\\.\\d+)', output))\n samples.append(sample.Sample('Loss', float(loss), '', metadata_copy))\n\n if 'global_step/sec: ' in output:\n global_step_sec = get_mean(regex_util.ExtractAllMatches(\n r'global_step/sec: (\\S+)', output))\n samples.append(sample.Sample(\n 'Global Steps Per Second', global_step_sec,\n 'global_steps/sec', metadata_copy))\n examples_sec = global_step_sec * metadata['train_batch_size']\n if 'examples/sec: ' in output:\n examples_sec_log = get_mean(regex_util.ExtractAllMatches(\n r'examples/sec: (\\S+)', output))\n precision = abs(examples_sec_log - examples_sec) / examples_sec_log\n assert precision < EXAMPLES_PER_SECOND_PRECISION, 'examples/sec is wrong.'\n examples_sec = examples_sec_log\n samples.append(sample.Sample('Examples Per Second', examples_sec,\n 'examples/sec', metadata_copy))\n return samples","def _train_epoch(self, epoch):\n self.model.train()\n self.train_metrics.reset()\n for batch_idx, (data, target_seg, target_class) in enumerate(self.data_loader):\n data, target_seg, target_class = data.to(self.device), target_seg.to(self.device), target_class.to(self.device)\n\n self.optimizer.zero_grad()\n output_seg, output_class = self.model(data)\n loss = self.criterion((output_seg, output_class), target_seg, target_class, epoch)\n loss.backward()\n self.optimizer.step()\n\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\n self.train_metrics.update('loss', loss.item())\n for met in self.metric_ftns:\n if met.__name__ == \"accuracy\":\n self.train_metrics.update(met.__name__, met(output_class, target_class))\n else:\n self.train_metrics.update(met.__name__, met(output_seg, target_seg))\n\n if batch_idx % self.log_step == 0:\n self.logger.debug('Train Epoch: {} {} Loss: {:.6f}'.format(\n epoch,\n self._progress(batch_idx),\n loss.item()))\n\n self._visualize_input(data.cpu())\n\n if batch_idx == self.len_epoch:\n break\n log = self.train_metrics.result()\n\n if self.do_validation:\n val_log = self._valid_epoch(epoch)\n log.update(**{'val_'+k : v for k, v in val_log.items()})\n\n if self.lr_scheduler is not None:\n self.lr_scheduler.step()\n\n return log","def run_epoch(data_iter, model, loss_compute, ctx):\r\n start = time.time()\r\n total_tokens = 0\r\n total_loss = 0\r\n tokens = 0\r\n for i, batch in enumerate(data_iter):\r\n out = model(batch.src, batch.trg, batch.src_mask, batch.trg_mask)\r\n loss = loss_compute(out, batch.trg_y, batch.ntokens)\r\n total_loss += loss\r\n total_tokens += batch.ntokens\r\n tokens += batch.ntokens\r\n if i % 50 == 1:\r\n elapsed = time.time() - start\r\n ctx.logger.info(\"Epoch Step: %d Loss: %f Tokens per Sec: %f\",\r\n i, loss / batch.ntokens, tokens / elapsed)\r\n start = time.time()\r\n tokens = 0\r\n return total_loss / total_tokens","def on_epoch_end(self, epoch, logs=None):","def on_epoch_end(self, epoch, logs=None):","def run_epoch(session, model, eval_op=None, verbose=False, epoch_size=1):\n start_time = time.time()\n all_words = 0\n costs = 0.0\n predicts = []\n\n fetches = {\n \"cost\": model.cost,\n \"mask\": model.mask,\n \"predict\": model.predicts,\n \"seqlen\": model.seq_len,\n \"loss\": model.loss,\n \"label\": model.label,\n \"label_flat\": model.label_flat,\n \"not_space\": model.not_space\n }\n if eval_op is not None:\n fetches[\"eval_op\"] = eval_op\n # if debug:\n # fetches[\"inputs\"] = model.Dinputs\n # fetches[\"states\"] = model.Dstates\n # fetches[\"outputs\"] = model.Doutput\n\n logging.info(\"Epoch size: %d\" % epoch_size) \n print_idx = 0\n for step in range(epoch_size):\n vals = session.run(fetches)\n cost = vals[\"cost\"]\n mask = vals[\"mask\"]\n predict = vals[\"predict\"]\n label = vals[\"label\"]\n np.set_printoptions(threshold=np.nan)\n \n if eval_op is None:\n \n # if step > 497:\n # #for i in range(len(mask)):\n # # print(mask[i])\n # print(np.sum(mask, axis=1))\n # print(vals[\"seqlen\"])\n mask = np.array(np.round(mask), dtype=np.int32)\n shape = mask.shape\n # if step > 10 and step < 20:\n # print(predict)\n # print(np.argmax(predict, 1))\n predict = np.reshape(np.argmax(predict, 1), shape).tolist()\n mask = np.sum(mask, axis=1).tolist()\n for i in range(shape[0]):\n predicts.append(predict[i][:mask[i]])\n\n costs += cost\n words = np.sum(mask)\n all_words += words\n\n if epoch_size < 100:\n verbose = False\n\n if (step * 10 / epoch_size) > print_idx and eval_op is not None:\n print_idx = step * 10 / epoch_size + 1\n logging.info(\"%.3f perplexity: %.3f speed: %.0f wps\" %\n (step * 1.0 / epoch_size, np.exp(costs / step),\n num_gpus * all_words / (time.time() - start_time)))\n predict = np.argmax(predict, 1)\n label_flat = np.reshape(label, [-1])\n all_label_equal = np.equal(predict, label_flat)\n not_space_label = np.not_equal(label_flat, np.zeros(np.shape(label_flat)))\n not_space_equal = all_label_equal * not_space_label\n not_space_label_count = np.sum(not_space_label)\n not_space_equal_count = np.sum(not_space_equal)\n none_space_accuracy = not_space_equal_count / not_space_label_count\n logging.info(\"not space label: %d\" % not_space_label_count)\n logging.info(\"not space correct: %d\" % not_space_equal_count)\n logging.info(\"not space accuracy: %.3f\" % none_space_accuracy)\n logging.info(\"cost: %.3f\" % (costs / step))\n if np.isnan(np.exp(costs / step)):\n print(\"perplexity is nan\")\n print(\"cost: %f step: %d\" % (costs, step))\n return np.exp(costs / step)\n\n if eval_op is None:\n predict = np.reshape(predict, [-1])\n label_flat = np.reshape(label, [-1])\n all_label_equal = np.equal(predict, label_flat)\n not_space_label = np.not_equal(label_flat, np.zeros(np.shape(label_flat)))\n not_space_equal = all_label_equal * not_space_label\n not_space_label_count = np.sum(not_space_label)\n not_space_equal_count = np.sum(not_space_equal)\n none_space_accuracy = not_space_equal_count / not_space_label_count\n logging.info(\"not space label: %d\" % not_space_label_count)\n logging.info(\"not space correct: %d\" % not_space_equal_count)\n logging.info(\"not space accuracy: %.3f\" % none_space_accuracy)\n logging.info(\"cost: %.3f\" % (costs / step))\n return np.exp(costs / epoch_size), predicts\n # elif get_post:\n # # Keep in mind, when get_post, num_steps=1, batch_size=1\n # return np.exp(costs / iters), posteriors\n else:\n return np.exp(costs / epoch_size)","def evaluate_epoch(eval_dl, model, criterion, epoch, writer):\n device = next(model.parameters()).device\n\n model.eval()\n loss = 0\n correct = 0\n with torch.no_grad():\n for idx, (image, target) in enumerate(eval_dl):\n image = image.to(device, non_blocking=True)\n target = target.to(device, non_blocking=True)\n output = model(image)\n loss += criterion(output, target).item()\n\n pred = output.argmax(dim=1, keepdim=True) # get the index of the max log-probability\n correct += pred.eq(target.view_as(pred)).sum().item()\n\n loss /= len(eval_dl.dataset) / eval_dl.batch_size\n val_acc = 100. * correct / len(eval_dl.dataset)\n print('\\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n loss, correct, len(eval_dl.dataset),\n 100. * correct / len(eval_dl.dataset)))\n writer.add_scalar('loss/val', loss, len(eval_dl) * epoch)\n writer.add_scalar('acc/val', correct / len(eval_dl.dataset), epoch)\n\n return val_acc","def compute_metrics(self):\n self.finalize_output_dict()\n self.metric_dict = {\n key: value(self.output_dict[\"labels\"], self.output_dict[\"pred_probs\"])\n for key, value in self.metric_fns.items()\n }","def step(self):\n fit_default_config = {\"verbose\": self.verbose}\n fit_default_config.update(self.config.get(\"fit_config\", {}))\n\n history = self.model.fit(self.train_dataset, **fit_default_config)\n if history is None:\n stats = {}\n else:\n stats = {\"train_\" + k: v[-1] for k, v in history.history.items()}\n\n self.epoch += 1\n return stats","def epoch_diagnostics(self, train_loss, train_err, test_loss, test_err):\n m = self.nbatches\n logging.info(\"Epoch diagnostics computation\")\n\n layernum = 0\n layer_gradient_norm_sqs = []\n gavg_norm_acum = 0.0\n gavg_acum = []\n for group in self.param_groups:\n for p in group['params']:\n\n layer_gradient_norm_sqs.append([])\n gavg = self.state[p]['gavg'].cpu()\n gavg_acum.append(gavg.numpy())\n gavg_norm_acum += gavg.norm()**2 #torch.dot(gavg, gavg)\n layernum += 1\n\n gradient_norm_sqs = []\n vr_step_variance = []\n cos_acums = []\n variances = []\n\n for batch_id in range(m):\n norm_acum = 0.0\n ginorm_acum = 0.0\n vr_acum = 0.0\n layernum = 0\n cos_acum = 0.0\n var_acum = 0.0\n for group in self.param_groups:\n for p in group['params']:\n param_state = self.state[p]\n\n gktbl = param_state['gktbl']\n gavg = param_state['gavg'].type_as(p.data).cpu()\n\n gi = gktbl[batch_id, :]\n var_norm_sq = (gi-gavg).norm()**2 #torch.dot(gi-gavg, gi-gavg)\n norm_acum += var_norm_sq\n ginorm_acum += gi.norm()**2 #torch.dot(gi, gi)\n layer_gradient_norm_sqs[layernum].append(var_norm_sq)\n\n gktbl_old = param_state['gktbl_old']\n gavg_old = param_state['gavg_old'].type_as(p.data).cpu()\n gi_old = gktbl_old[batch_id, :]\n #pdb.set_trace()\n vr_step = gi - gi_old + gavg_old\n vr_acum += (vr_step - gavg).norm()**2 #torch.dot(vr_step - gavg, vr_step - gavg)\n cos_acum += torch.sum(gavg*gi)\n\n var_acum += (gi - gavg).norm()**2\n\n layernum += 1\n gradient_norm_sqs.append(norm_acum)\n vr_step_variance.append(vr_acum)\n cosim = cos_acum/math.sqrt(ginorm_acum*gavg_norm_acum)\n #pdb.set_trace()\n cos_acums.append(cosim)\n variances.append(var_acum)\n\n variance = sum(variances)/len(variances)\n\n print(\"mean cosine: {}\".format(sum(cos_acums)/len(cos_acums)))\n\n #pdb.set_trace()\n\n with open('stats/{}fastdiagnostics_epoch{}.pkl'.format(self.test_name, self.epoch), 'wb') as output:\n pickle.dump({\n 'train_loss': train_loss,\n 'train_err': train_err,\n 'test_loss': test_loss,\n 'test_err': test_err,\n 'epoch': self.epoch,\n #'layer_gradient_norm_sqs': layer_gradient_norm_sqs,\n #'gradient_norm_sqs': gradient_norm_sqs,\n #'vr_step_variance': vr_step_variance,\n #'cosine_distances': cos_acums,\n #'variances': variances,\n 'variance': variance,\n #'gavg_norm': gavg_norm_acum,\n #'gavg': gavg_acum,\n #'iterate_distances': self.inrun_iterate_distances,\n #'grad_distances': self.inrun_grad_distances,\n }, output)\n print(\"Epoch diagnostics saved\")\n #pdb.set_trace()\n\n self.inrun_iterate_distances = []\n self.inrun_grad_distances = []","def run_validation(self):\n stats = {'loss': 0,\n 'accuracy': 0,\n 'time_error': 0,\n 'location_error': np.zeros(3),\n 'total_pts': 0,\n 'scatter': []}\n run_variables = [self.loss, self.conf, self.occ, self.occ_t, self.occ_loc, self.output['time'],\n self.output['location']]\n\n self.session.run(self.val_init)\n while True:\n try:\n (loss, confidences, occurrences, times,\n locations, time_output, location_output) = self.session.run(run_variables)\n n_pts = confidences.shape[0]\n stats['loss'] += loss * n_pts\n stats['accuracy'] += np.sum(np.round(confidences) == occurrences)\n stats['time_error'] += np.sum(np.abs(times-time_output))\n stats['location_error'] += np.sum(np.abs(times - time_output), axis=0)\n stats['scatter'].append(location_output - locations)\n stats['total_pts'] += n_pts\n except tf.errors.OutOfRangeError:\n stats['loss'] /= stats['total_pts']\n stats['accuracy'] /= stats['total_pts']\n stats['time_error'] /= stats['total_pts']\n stats['location_error'] /= stats['total_pts']\n stats['scatter'] = np.concatenate(stats['scatter'], axis=0)\n return stats","def on_epoch_end(self):\n self.epoch += 1\n metric = self.metric_fn()\n if metric < self.best:\n self.best = metric\n self.count = 0\n else:\n self.count += 1\n if self.count > self.patience:\n self.model.stop_training()\n if self.verbose:\n print(self.name+' after '+str(self.epoch)+' epochs')","def _train_epoch(self, epoch):\n self.model.train()\n\n\n total_loss = 0\n total_metrics = np.zeros(len(self.metrics))\n length = len(self.data_loader)\n total_pm25_loss = 0\n total_pm10_loss = 0\n pm25_loss = 0\n pm10_loss = 0\n\n for batch_idx, (data, target) in enumerate(self.data_loader):\n data, target = data.to(self.device), target.to(self.device)\n\n self.optimizer.zero_grad()\n output = self.model(data)\n # print(output.shape, target.shape)\n target = target.squeeze()\n model_loss = self.loss(output, target)\n\n # print(output.shape, target.shape)\n # pm25_predict, pm10_predict = torch.chunk(output, 2, dim=1)\n # pm25_target, pm10_target = torch.chunk(target, 2, dim=1)\n # pm25_loss = self.loss(pm25_predict, pm25_target)\n # pm10_loss = self.loss(pm10_predict, pm10_target)\n # total_pm25_loss += pm25_loss.item()\n # total_pm10_loss += pm10_loss.item()\n\n l2_reg = torch.tensor(0.0).to(self.device)\n if self.config['trainer']['l2_regularization']:\n for param in self.model.parameters():\n l2_reg += torch.norm(param, p=2)\n loss = model_loss + self.config['trainer']['l2_lambda'] * l2_reg\n else:\n loss = model_loss\n\n loss.backward()\n # torch.nn.utils.clip_grad_norm(self.model.parameters(), 1)\n self.optimizer.step()\n\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\n self.writer.add_scalar('loss', loss.item())\n total_loss += loss.item()\n # total_metrics += self._eval_metrics(output, target)\n\n if batch_idx % self.log_step == 0:\n self.logger.debug('Train Epoch: {} {} Loss: {:.6f} model_loss: {:.6f} pm25_loss {:.6f} pm10_loss {:.6f} l2_loss: {:.6f}'.format(\n epoch,\n self._progress(batch_idx),\n loss.item(),\n model_loss.item(),\n pm25_loss,\n pm10_loss,\n l2_reg.item()))\n\n if batch_idx == self.len_epoch:\n break\n\n log = {\n 'loss': total_loss / length,\n 'rmse_pm25_loss': np.sqrt(total_pm25_loss / length),\n 'rmse_pm10_loss': np.sqrt(total_pm10_loss / length)\n }\n\n\n val_log = self._valid_epoch(epoch)\n log.update(val_log)\n\n if self.lr_scheduler is not None:\n self.lr_scheduler.step(val_log['val_loss'])\n\n return log","def get_output_stats(self, output):\n\t\ttype_dict = {}\n\t\ttype_full_dict = {}\n\t\ttotal = 0\n\t\tfor key in output.keys():\n\t\t\tif output[key]['deleted'] == \"0\":\n\t\t\t\ttry:\n\t\t\t\t\ttype_dict[output[key]['type']] += 1\n\t\t\t\texcept:\n\t\t\t\t\ttype_dict[output[key]['type']] = 1\n\t\t\t\ttry:\n\t\t\t\t\ttype_full_dict[output[key]['type_full']] += 1\n\t\t\t\texcept:\n\t\t\t\t\ttype_full_dict[output[key]['type_full']] = 1\n\t\t\t\ttotal += 1\n\t\tfinal_stats = {}\n\t\tfor key in type_dict.keys():\n\t\t\tfinal_stats[key + \"(\" + str(type_dict[key]) + \"/\" + str(int(np.rint((type_dict[key]/total)*100))) + \"%)\"] = {'count': type_dict[key], 'percent_of_total': (type_dict[key]/total)*100}\n\t\t\tfor k in type_full_dict.keys():\n\t\t\t\tif k == None:\n\t\t\t\t\tpass\n\t\t\t\telif k.startswith(key):\n\t\t\t\t\tfinal_stats[key + \"(\" + str(type_dict[key]) + \"/\" + str(int(np.rint((type_dict[key]/total)*100))) + \"%)\"][k + \"(\" + str(type_full_dict[k]) + \"/\" + str(int(np.rint((type_full_dict[k]/total)*100))) + \"%)\"] = {'count': type_full_dict[k], 'percent_of_total': (type_full_dict[k]/total)*100, 'percent_of_' + key + '(s)': (type_full_dict[k]/type_dict[key])*100}\n\t\treturn (final_stats, total)","def _collect_stats(self, trainer: pl.Trainer, pl_module: AnomalyModule) -> None:\n predictions = Trainer(accelerator=trainer.accelerator, devices=trainer.num_devices).predict(\n model=self._create_inference_model(pl_module), dataloaders=trainer.datamodule.train_dataloader()\n )\n pl_module.normalization_metrics.reset()\n for batch in predictions:\n if \"pred_scores\" in batch.keys():\n pl_module.normalization_metrics.update(anomaly_scores=batch[\"pred_scores\"])\n if \"anomaly_maps\" in batch.keys():\n pl_module.normalization_metrics.update(anomaly_maps=batch[\"anomaly_maps\"])\n pl_module.normalization_metrics.compute()","def train_epoch(self, epoch, evaluator, optimizer, perf_path, perf_trace, state_fpath, writer_tensorboard):\n\n # Train an epoch\n self.model.train()\n print('Start epoch', epoch)\n train_itr = iter(self.loader_train)\n total_err = 0\n total_acc = 0\n\n for index, (data_pixel, data_labels) in enumerate(train_itr):\n\n # compute\n input_data = data_pixel.float().cuda()\n data_labels = data_labels.cuda()\n\n # Use the model the produce the classification\n grapheme_logits, vowel_logits, consonant_logits = self.model(input_data)\n\n # produce evaluator results\n eval_result = evaluator(grapheme_logits, vowel_logits, consonant_logits, data_labels)\n\n # set optimizer to zero.\n optimizer.zero_grad()\n\n # back propogate the evaluation results.\n eval_result['loss'].backward()\n\n # optimizer take step forward.\n optimizer.step()\n\n # tabulate the steps from the evaluation\n eval_result = {k: eval_result[k].item() for k in eval_result}\n\n # update every hundreds' of\n if index % 100 == 0:\n print(index, eval_result['loss'], eval_result['acc'])\n train_result = evaluator.evalulate_on_cache()\n train_total_err = train_result['loss']\n writer_tensorboard.add_scalar('Loss/Train', train_total_err, global_step=epoch)\n # log_metric('loss', train_total_err)\n train_total_acc = train_result['acc']\n writer_tensorboard.add_scalar('Accuracy/Train', train_total_acc, global_step=epoch)\n # log_metric('acc', train_total_acc)\n train_kaggle_score = train_result['kaggle_score']\n writer_tensorboard.add_scalar('Kaggle_Score/Train', train_kaggle_score, global_step=epoch)\n # log_metric('kaggle_score', train_kaggle_score)\n dict_metrics_train = {\n 'Loss/Train': train_total_err,\n 'Accuracy/Train': train_total_acc,\n 'Kaggle_Score/Train': train_kaggle_score,\n }\n log_metrics(dict_metrics_train, step=epoch)\n print(f\"Epoch {epoch} Training, Loss {train_total_err}, Acc {train_total_acc}\")\n evaluator.clear_cache()\n # compute validation error\n self.model.eval()\n val_itr = iter(self.loader_val)\n with torch.no_grad():\n for index, (data_pixel, data_labels) in enumerate(val_itr):\n input_data = data_pixel.float().cuda()\n data_labels = data_labels.cuda()\n grapheme_logits, vowel_logits, consonant_logits = self.model(input_data)\n eval_result = evaluator(grapheme_logits, vowel_logits, consonant_logits, data_labels)\n eval_result = {k: eval_result[k].item() for k in eval_result}\n total_err += eval_result['loss']\n total_acc += eval_result['acc']\n # print(total_err / (1 + input_index), total_acc / (1 + input_index))\n val_result = evaluator.evalulate_on_cache()\n val_total_err = val_result['loss']\n writer_tensorboard.add_scalar('Loss/Val', val_total_err, global_step=epoch)\n val_total_acc = val_result['acc']\n writer_tensorboard.add_scalar('Accuracy/Val', val_total_acc, global_step=epoch)\n val_kaggle_score = val_result['kaggle_score']\n writer_tensorboard.add_scalar('Kaggle_Score/Val', val_kaggle_score, global_step=epoch)\n dict_metrics_val = {\n 'Loss/Validation': val_total_err,\n 'Accuracy/Validation': val_total_acc,\n 'Kaggle_Score/Validation': val_kaggle_score,\n }\n log_metrics(dict_metrics_val, step=epoch)\n # Write to disk.\n writer_tensorboard.flush()\n print(f\"Epoch {epoch} Eval, Loss {val_total_err}, Acc {val_total_acc}\")\n evaluator.clear_cache()\n print(\"Saving the model (epoch %d)\" % epoch)\n torch.save({\n \"epoch\": epoch + 1,\n \"model_state\": self.model.state_dict(),\n \"optimizer_state\": optimizer.state_dict(),\n }, state_fpath)\n print(f\"Making a backup (step {epoch})\")\n backup_fpath = os.path.join(self.backup_dir, f\"model_bak_{epoch}.pt\")\n torch.save({\n \"epoch\": epoch + 1,\n \"model_state\": self.model.state_dict(),\n \"optimizer_state\": optimizer.state_dict(),\n }, backup_fpath)\n # Dump the traces\n perf_trace.append(\n {\n 'epoch': epoch,\n 'train_err': train_total_err,\n 'train_acc': train_total_acc,\n 'train_kaggle_score': train_kaggle_score,\n 'val_err': val_total_err,\n 'val_acc': val_total_acc,\n 'val_kaggle_score': val_kaggle_score\n }\n )\n pickle.dump(perf_trace, open(perf_path, 'wb'))\n # store epoch full result separately\n epoch_result = {\n 'epoch': epoch,\n 'train_result': train_result,\n 'val_result': val_result\n }\n pickle.dump(epoch_result, open(os.path.join(self.results_dir, 'result_epoch_{0}.p'.format(epoch)), 'wb'))","def on_epoch_end(self):\n if self.shuffle:\n np.random.shuffle(self.statistics)\n self.mapping = self.__build_mapping()","def epoch_end(self, run_context):\n cb_params = run_context.original_args()\n result = self.model.eval(self.ds_eval)\n print(\"result:\", result)\n if result['top_1_accuracy'] > self.top1:\n self.top1 = result['top_1_accuracy']\n file_name = 'attention_cluster_{}_{}.ckpt'.format(self.config.fc, self.config.natt)\n save_checkpoint(save_obj=cb_params.train_network,\n ckpt_file_name=os.path.join(self.config.result_dir, file_name))\n print(\"Best checkpoint saved!\")","def on_validation_epoch_end(self) -> None:\n self.log_dict(self.val_metrics.compute())\n self.val_metrics.reset()","def evaluate_epoch(eval_dl, model, criterion, epoch, writer):\n print('\\neval epoch {}'.format(epoch))\n device = next(model.parameters()).device\n\n model.eval()\n recall = Recall(lambda x: (x[0], x[1]))\n precision = Precision(lambda x: (x[0], x[1]))\n mean_recall = []\n mean_precision = []\n mean_loss = []\n with torch.no_grad():\n for idx, (inputs, targets) in enumerate(eval_dl):\n inputs, targets = inputs.to(device), targets.to(device)\n outputs = model(inputs)\n loss = criterion(outputs, targets)\n\n preds = outputs.argmax(1)\n\n precision.update((preds, targets))\n recall.update((preds, targets))\n mean_loss.append(loss.item())\n mean_recall.append(recall.compute().item())\n mean_precision.append(precision.compute().item())\n\n # print('val-epoch:{} [{}/{}], loss: {:5.3}'.format(epoch, idx + 1, len(dataloader), loss.item()))\n writer.add_scalar('test/loss', loss.item(), len(eval_dl) * epoch + idx)\n\n mean_precision, mean_recall = np.array(mean_precision).mean(), np.array(mean_recall).mean()\n f1 = mean_precision * mean_recall * 2 / (mean_precision + mean_recall + 1e-20)\n\n print('precision: {:07.5}, recall: {:07.5}, f1: {:07.5}\\n'.format(mean_precision, mean_recall, f1))\n writer.add_scalar('test/epoch-loss', np.array(mean_loss).mean(), epoch)\n writer.add_scalar('test/f1', f1, epoch)\n writer.add_scalar('test/precision', mean_precision, epoch)\n writer.add_scalar('test/recall', mean_recall, epoch)","def train_visualization(output_path): \n log_path = output_path + 'output.log'\n Train_Cost, Valid_Cost, Test_Cost, Train_Acc, Valid_Acc, Test_Acc = log_reader(log_path)\n n_epoch = len(Train_Cost)\n\n x1 = range(n_epoch)\n x2 = range(n_epoch)\n y1 = Train_Cost\n y2 = Valid_Cost\n y3 = Test_Cost\n y4 = Train_Acc\n y5 = Valid_Acc\n y6 = Test_Acc\n plt.subplot(2, 1, 1)\n plt.plot(x1, y1, label=\"Train_Cost\", linewidth=2)\n plt.plot(x1, y2, label=\"Valid_Cost\", linewidth=2)\n plt.plot(x1, y3, label=\"Test_Cost\", linewidth=2)\n\n plt.title('binary cross entropy vs. epoches')\n plt.ylabel('binary cross entropy')\n plt.legend(loc='best')\n plt.subplot(2, 1, 2)\n plt.plot(x2, y4, label=\"Train_Acc\", linewidth=2)\n plt.plot(x2, y5, label=\"Valid_Acc\", linewidth=2)\n plt.plot(x2, y6, label=\"Test_Acc\", linewidth=2)\n plt.xlabel('Accuracy@20 vs. epoches')\n plt.ylabel('Accuracy@20')\n plt.legend(loc='best')\n plt.savefig(output_path + 'loss_fig.png')\n # plt.show()","def evaluate_epoch(\n axes,\n tr_loader,\n val_loader,\n te_loader,\n model,\n criterion,\n epoch,\n stats,\n include_test=False,\n update_plot=True,\n multiclass=False,\n):\n\n def _get_metrics(loader):\n y_true, y_pred = [], []\n # correct, total = 0, 0\n\n running_loss = []\n\n # for X, y in loader:\n for i, batch in enumerate(loader):\n with torch.no_grad():\n print(\"evaluating... batch number\", i)\n # X = torch.Tensor(batch[\"image\"]).to(\"cuda\")\n # y = torch.Tensor(batch[\"depth\"]).to(device=\"cuda\")\n X = torch.Tensor(batch[\"image\"])\n y = torch.Tensor(batch[\"depth\"])\n\n output = model(X)\n predicted = predictions(output.data)\n y_true.append(y)\n y_pred.append(predicted)\n\n # total += y.size(0)\n\n # correct += (predicted == y).sum().item()\n\n # Calculate the net loss of this batch\n loss = criterion(predicted, y)\n # gradient_loss = gradient_criterion(predicted, y, device=\"cuda\")\n # running_loss.append(criterion(output, y).item())\n running_loss.append(loss)\n\n y_true = torch.cat(y_true)\n y_pred = torch.cat(y_pred)\n\n loss = np.mean(running_loss)\n\n acc = 0.9\n auroc = 0.9\n\n return acc, loss, auroc\n\n print(\"evaluating training set...\")\n train_acc, train_loss, train_auc = _get_metrics(tr_loader)\n print(\"evaluating validation set\")\n val_acc, val_loss, val_auc = _get_metrics(val_loader)\n\n stats_at_epoch = [\n val_acc,\n val_loss,\n val_auc,\n train_acc,\n train_loss,\n train_auc,\n ]\n if include_test:\n print(\"evaluating testing set...\")\n stats_at_epoch += list(_get_metrics(te_loader))\n\n stats.append(stats_at_epoch)\n # utils.log_training(epoch, stats)\n # if update_plot:\n # utils.update_training_plot(axes, epoch, stats)","def on_epoch_end(self, epoch, logs=None):\n loss = None\n acc = None\n if self.x is not None and self.y is not None:\n loss, acc = self.model.evaluate(x=self.x, y=self.y, batch_size=self.batch_size)\n elif self.x is not None and self.y is None:\n loss, acc = self.model.evaluate(x=self.x, steps=self.steps)\n if logs:\n self.epoch_iter += 1\n f = open(self.log_file_path, \"a\")\n f.write(\"ep {} - \"\n \"rl : {} ;\"\n \"racc : {} ;\"\n \"l: {} ; \"\n \"acc : {} ; \"\n \"vl : {} ; \"\n \"vacc : {}\\n\"\n .format(self.epoch_iter, loss, acc, logs['loss'], logs['sparse_categorical_accuracy'] if self.acc_loss != \"std\" else logs['categorical_accuracy'],\n logs['val_loss'],\n logs['val_sparse_categorical_accuracy'] if self.acc_loss != \"std\" else logs['val_categorical_accuracy'])\n )\n f.close()","def run_epoch( self ):\n # --- Init Epoch ----\n total_epoch_loss = 0.0\n epoch_batches = self.dataset.dataloader( self.config.neuron.epoch_length )\n progress_bar = qqdm(enumerate(epoch_batches), total=len(epoch_batches), desc=format_str('blue', f'Epoch Progress'))\n for iteration, (inputs) in progress_bar:\n\n # ---- Forward / Backward ----\n prev_mechanism_weights = self.mechanism_weights.tolist()\n output = self.train ( batch = { 'inputs': inputs } )\n next_mechanism_weights = self.mechanism_weights.tolist()\n total_epoch_loss += output.local_target_loss.item()\n\n # ---- Logs ----\n self.epoch_logs (\n progress_bar,\n iteration = iteration,\n output = output,\n prev_mechanism_weights = prev_mechanism_weights,\n next_mechanism_weights = next_mechanism_weights\n )\n self.global_step += 1\n\n self.epoch_loss = total_epoch_loss / self.config.neuron.epoch_length\n self.epoch += 1","def valid_epoch(self, epoch):\n device_mapper = self.device_mapper\n self.model.eval()\n self.valid_metrics.reset()\n targets = []\n outputs = []\n with torch.no_grad():\n for batch_idx, data in enumerate(self.valid_data_loader):\n data = device_mapper.map_modules(data, non_blocking=True)\n\n output = self.model(data)\n loss = self.loss(output, data)\n\n self.writer.set_step((epoch - 1) * len(self.valid_data_loader) + batch_idx, 'valid')\n self.valid_metrics.update('loss', loss.item(), batch_size=output.size(0))\n for met in self.metrics:\n self.valid_metrics.update(met.name(), met(output, data), batch_size=output.size(0))\n\n if self.add_roc_auc:\n if not self.softmax:\n outputs.append(torch.sigmoid(output).cpu().numpy().reshape(-1))\n else:\n outputs.append(torch.nn.functional.softmax(output, dim=1)[:, 1].cpu().numpy().reshape(-1))\n targets.append(data['target'].cpu().numpy().reshape(-1))\n\n if self.add_roc_auc:\n outputs = np.concatenate(outputs)\n targets = np.concatenate(targets)\n score = roc_auc_score(targets, outputs)\n # size doesn't matter here, it's a global metric not per batch\n self.valid_metrics.update('roc_auc', score, batch_size=1)\n\n return self.valid_metrics.result()","def see_evaluation(epoch, training_acc, test_acc):\n print (\"Epoch \", epoch, \"Training acc: \", training_acc*100, \"Test acc: \", test_acc*100)","def on_predict_batch_end(\n self,\n trainer: pl.Trainer,\n pl_module: AnomalyModule,\n outputs: dict,\n batch: Any,\n batch_idx: int,\n dataloader_idx: int,\n ) -> None:\n del trainer, batch, batch_idx, dataloader_idx # These variables are not used.\n\n self._standardize_batch(outputs, pl_module)\n self._normalize_batch(outputs, pl_module)\n outputs[\"pred_labels\"] = outputs[\"pred_scores\"] >= 0.5","def run_epoch(self, epoch, data_loader, training=False):\n if training:\n self.model.train()\n else:\n self.model.eval()\n\n epoch_metrics = {\"loss\": 0.0}\n overall_parsing_counts = {\"correct\": 0, \"predicted\": 0, \"gold\": 0}\n num_evaluated_batches = 0\n\n with torch.set_grad_enabled(training):\n for sentences, target in data_loader:\n # Run model\n target = self._to_device(target)\n output, parsing_counts = self.parser.evaluate_batch(sentences)\n\n # Compute loss\n output, target = self._unroll_sequence_batch(output), self._unroll_sequence_batch(target)\n loss = self.criterion(output, target)\n\n # Add metrics to overall total\n epoch_metrics[\"loss\"] += loss.item()\n for count in \"gold\", \"predicted\", \"correct\":\n overall_parsing_counts[count] += parsing_counts[count]\n\n # Perform backpropagation (when training)\n if training:\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # Print progress\n num_evaluated_batches += 1\n self.logger.debug('{} Epoch: {} {} Loss: {:.6f}'.format(\n \"Training\" if training else \"Validation\",\n epoch,\n self._progress(num_evaluated_batches, data_loader),\n loss.item()))\n\n epoch_metrics.update(self.compute_prf(overall_parsing_counts))\n\n return epoch_metrics","def after_pred(self):\n # If training then skip\n if self.training:\n return\n\n # Get ground truths in epoch 0 i.e. start of training\n if self.epoch == 0:\n self.y_true.extend(self.y.cpu().flatten().numpy())\n\n # Get predictions from each batch and add them to prediction container\n y_pred = self.pred.detach().cpu()\n \n self.y_pred.extend(y_pred.flatten().numpy())","def _evaluate_epoch(X_train, y_train, X_val, y_val, model, criterion, epoch):\n\n #this function is inspired by an EECS 445 project done by Justin Weilbach\n\n print('evaluating epoch')\n correct, total = 0, 0\n running_loss = []\n for i, image in enumerate(X_train):\n with torch.no_grad():\n label = y_train[i]\n label = torch.from_numpy(np.asarray(label))\n label = label.type(torch.LongTensor)\n label = torch.tensor([label])\n\n image = torch.from_numpy(image)\n image = image.type(torch.FloatTensor)\n image = image.unsqueeze(0)\n\n output = model(image)\n total += label.size(0)\n\n label = label.float()\n correct_output = np.argmax(output)\n if float(label) == float(correct_output):\n correct += 1\n\n label = label.long()\n running_loss.append(criterion(output, label).item())\n\n train_loss = np.mean(running_loss)\n train_acc = correct / total\n print('training loss: ' + str(train_loss))\n print('train acc: ' + str(train_acc))\n correct, total = 0, 0\n running_loss = []\n for i, image in enumerate(X_val):\n with torch.no_grad():\n label = y_val[i]\n label = torch.from_numpy(np.asarray(label))\n label = label.type(torch.LongTensor)\n label = torch.tensor([label])\n\n image = torch.from_numpy(image)\n image = image.type(torch.FloatTensor)\n image = image.unsqueeze(0)\n\n output = model(image)\n total += label.size(0)\n\n label = label.float()\n correct_output = np.argmax(output)\n if float(label) == float(correct_output):\n correct += 1\n\n label = label.long()\n running_loss.append(criterion(output, label).item())\n\n val_loss = np.mean(running_loss)\n val_acc = correct / total\n print('val loss: ' + str(val_loss))\n print('val acc: ' + str(val_acc))\n \n return val_loss, train_loss, val_acc, train_acc","def on_epoch_end(self, epoch: int, logs: dict):\n loss = logs[\"loss\"]\n original = logs[\"original\"]\n reconstructed = logs[\"reconstructed\"]\n\n col_count = min(original.shape[0], 10)\n figure, axes = plt.subplots(3, col_count, figsize=(15, 5))\n\n # these are the layers to show histograms\n for bins_col in range(len(self.layer_names)):\n\n # get the layer\n layer = self.model.get_layer(self.layer_names[bins_col])\n\n # set the title for the plot\n axes[0][bins_col].set_title(layer.name)\n\n # extract the kernels weights\n kernel_weights = [\n kernel\n for kernel in layer.trainable_variables\n if \"kernel\" in kernel.name\n ][0]\n\n axes[0][bins_col].hist(kernel_weights.numpy().reshape(-1))\n\n quantiles = [0.05, 0.95]\n for n in range(col_count):\n q_test = np.quantile(original[n], quantiles)\n axes[1][n].imshow(original[n], cmap=\"gray\", vmin=q_test[0], vmax=q_test[1])\n\n reshape_test_image = np.reshape(reconstructed[n], (64, 64))\n reshape_test_image = resize(\n reshape_test_image, (256, 256), order=3, anti_aliasing=True\n )\n\n q_re = np.quantile(reshape_test_image, quantiles)\n\n if self.filter_test_image:\n reshape_test_image -= q_re[0]\n reshape_test_image /= q_re[1] - q_re[0]\n\n filtered_test_image = anisotropic_diffusion_(\n reshape_test_image, niter=20, kappa=0.1, option=3, gradient_scale=8\n )\n axes[2][n].imshow(filtered_test_image, cmap=\"gray\", vmin=0.0, vmax=1.0)\n else:\n axes[2][n].imshow(\n reshape_test_image, cmap=\"gray\", vmin=q_re[0], vmax=q_re[1]\n )\n\n figure.suptitle(f\"Epoch {epoch}: loss={loss:0.2f}\")\n\n # make the save path, if needed\n self.path.mkdir(parents=True, exist_ok=True)\n\n # save and close\n figure.savefig(self.path / f\"{epoch}-figure.png\")\n plt.close(figure)","def _train_epoch(self, epoch):\n self.model.train()\n total_loss = 0\n\n self.logger.info('Train Epoch: {}'.format(epoch))\n\n for batch_idx, (data) in enumerate(self.train_loader):\n start_it = time()\n data = data.to(self.device)\n\n self.optimizer.zero_grad()\n output = self.model(data)\n if isinstance(output, tuple):\n loss = self.model.loss(data, *output)\n else:\n loss = self.model.loss(data, output)\n loss.backward()\n self.optimizer.step()\n\n step = epoch * len(self.train_loader) + batch_idx\n self.tb_writer.add_scalar('train/loss', loss.item(), step)\n # self.comet_writer.log_metric('loss', loss.item(), step)\n\n total_loss += loss.item()\n\n end_it = time()\n time_it = end_it - start_it\n if batch_idx % self.log_step == 0:\n self.logger.info(\n ' > [{}/{} ({:.0f}%), {:.2f}s] Loss: {:.6f} '.format(\n batch_idx * self.train_loader.batch_size + data.size(\n 0),\n len(self.train_loader.dataset),\n 100.0 * batch_idx / len(self.train_loader),\n time_it * (len(self.train_loader) - batch_idx),\n loss.item()))\n # grid = make_grid(data.cpu(), nrow=8, normalize=True)\n # self.tb_writer.add_image('input', grid, step)\n\n self.logger.info(' > Total loss: {:.6f}'.format(\n total_loss / len(self.train_loader)\n ))\n\n return total_loss / len(self.train_loader)","def process_outputs(self, data, output, save=True):\n\n pred_spline = output['pred_polys']\n\n # preds = self.spline.sample_point(pred_spline)\n preds = pred_spline\n torch.cuda.synchronize()\n preds = preds.cpu().numpy()\n\n pred_spline = pred_spline.cpu()\n pred_spline = pred_spline.numpy()\n\n instances = data['instance']\n polys = []\n results = []\n for i, instance in enumerate(instances):\n detection = defaultdict(float)\n poly = preds[i]\n poly = poly * data['patch_w'][i]\n poly[:, 0] += data['starting_point'][i][0]\n poly[:, 1] += data['starting_point'][i][1]\n detection['image_id'] = instance['image_path']\n img_h, img_w = instance['height'], instance['width']\n\n detection['poly'] = poly\n detection['image_size'] = [img_w, img_h]\n # pred_sp = pred_spline[i]\n # pred_sp = pred_sp * data['patch_w'][i]\n # pred_sp[:, 0] += data['starting_point'][i][0]\n # pred_sp[:, 1] += data['starting_point'][i][1]\n #\n # instance['spline_pos'] = pred_sp.tolist()\n\n polys.append(poly)\n\n results.append(detection)\n\n\n # if save:\n\n # predicted_poly = []\n\n\n\n # pred_mask = np.zeros((img_h, img_w), dtype=np.uint8)\n # utils.draw_poly(pred_mask, poly.astype(np.int))\n # predicted_poly.append(poly.tolist())\n #\n # # gt_mask = utils.get_full_mask_from_instance(\n # # self.min_area,\n # # instance)\n #\n # instance['my_predicted_poly'] = predicted_poly\n # # instance_id = instance['instance_id']\n # image_id = instance['image_id']\n #\n # pred_mask_fname = os.path.join(self.output_dir, '{}_pred.png'.format(image_id))\n # instance['pred_mask_fname'] = os.path.relpath(pred_mask_fname, self.output_dir)\n #\n # # gt_mask_fname = os.path.join(self.output_dir, '{}_gt.png'.format(instance_id))\n # # instance['gt_mask_fname'] = os.path.relpath(gt_mask_fname, self.output_dir)\n #\n # instance['n_corrections'] = 0\n #\n # info_fname = os.path.join(self.output_dir, '{}_info.json'.format(image_id))\n #\n # with warnings.catch_warnings():\n # warnings.simplefilter(\"ignore\")\n # sio.imsave(pred_mask_fname, pred_mask)\n # # sio.imsave(gt_mask_fname, gt_mask)\n #\n # # print '==> dumping json'\n # with open(info_fname, 'w') as f:\n # json.dump(instance, f, indent=2)\n\n return results, polys","def on_epoch_end(self):\n self.current_params = self.model.posterior_mean(self.params)\n self.current_epoch += 1\n self.parameter_values += [self.current_params]\n self.epochs += [self.current_epoch]","def run_epoch_test(session, model, verbose=False):\n # fetches = {\"ms\": model.dynamic_eval.global_ms()}\n # vals = session.run(fetches)\n # ms = vals[\"ms\"]\n # s = np.sum(np.sqrt([x for x in ms]))\n # print(s)\n\n\n\n start_time = time.time()\n losses = 0.0\n iters = 0\n\n # zeros initial state for all devices\n state = []\n for k in range(model.gpu_num):\n state.append(session.run(model.initial_state(k)))\n\n # evaluate loss and final state for all devices\n fetches = {\"loss\": model.loss}\n\n if config.dynamic_eval:\n fetches[\"update_op\"] = model.dynamic_eval.update_op()\n\n\n for k in range(model.gpu_num):\n fetches[\"final_state%d\" % k] = model.final_state(k)\n\n for step in range(model.input.epoch_size):\n # pass states between time batches\n feed_dict = {}\n for i in range(model.gpu_num):\n gpu_state = model.initial_state(i)\n for j, (c, h) in enumerate(gpu_state):\n feed_dict[c] = state[i][j].c\n feed_dict[h] = state[i][j].h\n\n vals = session.run(fetches, feed_dict)\n\n loss = vals[\"loss\"]\n\n for k in range(model.gpu_num):\n state[k] = vals[\"final_state%d\" % k]\n\n losses += loss\n iters += model.input.time_steps\n\n if verbose and step % (model.input.epoch_size // 10) == 0:\n print(\"%.3f perplexity: %.3f bits: %.3f speed: %.0f wps\" %\n (step * 1.0 / model.input.epoch_size, np.exp(losses / iters), np.log2(np.exp(losses / iters)),\n iters * model.input.batch_size / (time.time() - start_time)))\n\n return np.exp(losses / iters)","def on_epoch_begin(self, epoch, logs=None):","def on_epoch_begin(self, epoch, logs=None):","def run_epoch(session,\n model,\n dataset,\n is_train=False,\n plot_attention_weights=False):\n assert dataset is not None\n n_words = len([word for sample in dataset for word in sample if word > 0])\n epoch_size = int(math.ceil(len(dataset) / model.batch_size))\n # producer = lm_data_producer(dataset, model.batch_size, model.num_steps)\n\n fetches = {\"step_cost\": model.batch_loss, \"niters\": model.nwords}\n if is_train:\n fetches[\"eval_op\"] = model.train_op\n if plot_attention_weights:\n fetches[\"weights\"] = model.attention_weights\n\n costs = 0.0\n iters = 0\n start_time = time.time()\n # for step, (x, y) in enumerate(producer):\n for step in range(epoch_size):\n step_time = time.time()\n vals = session.run(fetches, {})\n step_cost = vals[\"step_cost\"]\n costs += step_cost\n # iters += np.sum(x > 0)\n iters += vals[\"niters\"]\n\n # print information regarding the current training process\n if is_train:\n if step % (epoch_size // 20) == 10:\n print(\"{:.3f} - aprox. loss {:.8f} - approx. speed: {:.0f} wps\".format(\n step * 1.0 / epoch_size, costs / (step + 1),\n iters / (time.time() - start_time)))\n # print information regarding the current training process\n else:\n if step % (epoch_size // 10) == 5:\n print(\"{:.3f} - approx. speed: {:.0f} wps\".format(\n step * 1.0 / epoch_size, iters / (time.time() - start_time)))\n\n return np.exp(costs / n_words)","def after_train_iter(self,\n runner: Runner,\n batch_idx: int,\n data_batch: DATA_BATCH = None,\n outputs: Optional[dict] = None) -> None:\n\n if not self.every_n_iters(runner, self.interval):\n return\n\n model = runner.model.module if is_model_wrapper(\n runner.model) else runner.model\n\n for key in self.module_keys:\n # get current ema states\n ema_net = getattr(model, key)\n states_ema = ema_net.state_dict(keep_vars=False)\n # get currently original states\n net = getattr(model, key[:-4])\n states_orig = net.state_dict(keep_vars=True)\n\n for k, v in states_orig.items():\n if runner.iter < self.start_iter:\n states_ema[k].data.copy_(v.data)\n else:\n states_ema[k] = self.interp_func(\n v, states_ema[k], trainable=v.requires_grad).detach()\n ema_net.load_state_dict(states_ema, strict=True)","def eval(epoch):\n global best_acc\n\n net.eval()\n test_loss_accumulator = 0\n correct = 0\n total = 0\n test_accuracy = None\n test_loss = None\n for batch_idx, (inputs, targets) in enumerate(trainloader):\n\n if use_cuda:\n inputs, targets = inputs.cuda(), targets.cuda()\n inputs, targets = Variable(inputs, volatile=True), Variable(targets)\n outputs = net(inputs)\n loss = criterion(outputs, targets)\n\n test_loss_accumulator += loss.data[0]\n _, predicted = torch.max(outputs.data, 1)\n total += targets.size(0)\n correct += predicted.eq(targets.data).cpu().sum()\n\n test_accuracy = 100. * correct / total\n test_loss = test_loss_accumulator / (batch_idx + 1)\n progress_bar(batch_idx, len(trainloader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)'\n % (test_loss, test_accuracy, correct, total))\n\n if ((batch_idx + 1) * mini_batch_size) > max_training_examples:\n break\n print()\n\n\n\n return EvalPerf(test_loss, test_accuracy)","def test(self):\r\n \r\n args = self.args\r\n model = self.model\r\n dataset = self.dataset\r\n \r\n dataset.set_split('test')\r\n batch_generator = generate_nmt_batches(dataset, \r\n batch_size=len(dataset), \r\n device=args.device)\r\n\r\n acc_sum = 0.0\r\n model.eval()\r\n \r\n for batch_index, batch_dict in enumerate(batch_generator):\r\n # step 1. compute the output\r\n if isinstance(model,NMTModelWithMLTM):\r\n y_pred = model(batch_dict['x_source'], \r\n batch_dict['x_source_mltm_vector'],\r\n batch_dict['x_source_length'], \r\n batch_dict['x_target'])\r\n else:\r\n y_pred = model(batch_dict['x_source'], \r\n batch_dict['x_source_length'], \r\n batch_dict['x_target'])\r\n\r\n acc_t = compute_accuracy(y_pred, batch_dict['y_target'], self.mask_index)\r\n acc_sum += acc_t\r\n \r\n return acc_sum / (batch_index+1)","def on_epoch_end(self, epoch, logs={}):\n for (k, v) in logs.items():\n l = self.H.get(k, [])\n l.append(v)\n self.H[k] = l \n # check to see if the training history should be serialized to file\n if self.jsonPath is not None:\n f = open(self.jsonPath, \"w\")\n # Encodes a Python object as a JSON string.\n f.write(json.dumps(self.H))\n f.close() \n # ensure at least two epochs have passed before plotting\n # (epoch starts at zero)\n if len(self.H[\"loss\"]) > 1:\n N = np.arange(0, len(self.H[\"loss\"]))\n plt.style.use(\"ggplot\")\n plt.figure()\n plt.plot(N, self.H[\"loss\"], label=\"train_loss\")\n plt.plot(N, self.H[\"val_loss\"], label=\"val_loss\")\n plt.plot(N, self.H[\"acc\"], label=\"train_acc\")\n plt.plot(N, self.H[\"val_acc\"], label=\"val_acc\")\n plt.title(\"Training Loss and Acc [Epoch {}]\".format(\n len(self.H[\"loss\"])))\n plt.xlabel(\"Epoch #\")\n plt.ylabel(\"Loss/Acc\")\n plt.legend()\n plt.savefig(self.figPath)\n plt.close()","def train_epoch(self, epoch):\n device_mapper = self.device_mapper\n self.model.train()\n self.train_metrics.reset()\n for batch_idx, data in enumerate(self.data_loader):\n data = device_mapper.map_modules(data, non_blocking=True)\n\n self.optimizer.zero_grad()\n output = self.model(data)\n loss = self.loss(output, data)\n loss.backward()\n self.optimizer.step()\n\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\n self.train_metrics.update('loss', loss.item(), batch_size=output.size(0))\n for met in self.metrics:\n self.train_metrics.update(met.name(), met(output, data), batch_size=output.size(0))\n\n if batch_idx % self.log_step == 0:\n self.logger.debug('Train Epoch: %d %s Loss: %.6f', epoch, self._progress(batch_idx), loss.item())\n\n if batch_idx == self.len_epoch:\n break\n log = self.train_metrics.result()\n\n if self.do_validation:\n val_log = self.valid_epoch(epoch)\n log.update(**{'val_' + k: v for k, v in val_log.items()})\n\n if self.lr_scheduler is not None:\n if isinstance(self.lr_scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau):\n self.lr_scheduler.step(log[\"val_roc_auc\"])\n else:\n self.lr_scheduler.step()\n return log","def on_epoch_end(self, epoch, logs=None):\r\n step = epoch if self.update_freq == 'epoch' else self._samples_seen\r\n self._log_metrics(logs, prefix='epoch_', step=step)\r\n\r\n if self.histogram_freq and epoch % self.histogram_freq == 0:\r\n self._log_weights(epoch)\r\n\r\n if self.embeddings_freq and epoch % self.embeddings_freq == 0:\r\n self._log_embeddings(epoch)","def process_evaluation_epoch(aggregates):\n if 'losses' in aggregates:\n eloss = torch.mean(torch.stack(aggregates['losses'])).item()\n else:\n eloss = None\n\n hypotheses = aggregates['preds']\n references = aggregates['txts']\n\n wer, scores, num_words = word_error_rate(hypotheses, references)\n multi_gpu = dist.is_initialized()\n if multi_gpu:\n if eloss is not None:\n eloss /= dist.get_world_size()\n eloss_tensor = torch.tensor(eloss).cuda()\n dist.all_reduce(eloss_tensor)\n eloss = eloss_tensor.item()\n\n scores_tensor = torch.tensor(scores).cuda()\n dist.all_reduce(scores_tensor)\n scores = scores_tensor.item()\n num_words_tensor = torch.tensor(num_words).cuda()\n dist.all_reduce(num_words_tensor)\n num_words = num_words_tensor.item()\n wer = scores * 1.0 / num_words\n return wer, eloss","def train_epoch(model, train_dataloader, optimizer, loss_fn):\n model.train()\n total_training_loss = 0\n for batch_index, batch in enumerate(train_dataloader):\n batch = batch[0].view(-1,1,28,28).float()\n output_batch = model(batch)\n loss = loss_fn(batch, output_batch, model.prev_means, model.prev_vars)\n optimizer.zero_grad()\n loss.backward()\n optimizer.step()\n total_training_loss += loss"],"string":"[\n \"def training_epoch_end(self, outputs: Any) -> None:\\n self.log_dict(self.train_metrics.compute())\\n self.train_metrics.reset()\",\n \"def validation_epoch_end(self, outputs):\\n avg_loss = torch.stack([x['val_loss'] for x in outputs]).mean()\\n val_acc = sum([x['n_correct_pred'] for x in outputs]) / sum(x['n_pred'] for x in outputs)\\n tensorboard_logs = {'val_loss': avg_loss, 'val_acc': val_acc}\\n return {'val_loss': avg_loss, 'log': tensorboard_logs}\",\n \"def training_epoch_end(self, outputs):\\n epoch_loss, epoch_accuracy = self._parse_outputs(\\n outputs=outputs, calculate_confusion_matrix=False)\\n self.log('training loss', np.mean(epoch_loss),\\n on_epoch=True, prog_bar=True)\\n self.log('training accuracy', np.mean(epoch_accuracy))\",\n \"def test_epoch_end(self, outputs):\\n avg_loss = torch.stack([x[\\\"test_loss\\\"] for x in outputs]).mean()\\n tensorboard_logs = {\\\"test_loss\\\": avg_loss}\\n return {\\\"avg_test_loss\\\": avg_loss, \\\"log\\\": tensorboard_logs}\",\n \"def test_epoch_end(self, outputs):\\n avg_loss = torch.stack([x[\\\"test_loss\\\"] for x in outputs]).mean()\\n tensorboard_logs = {\\\"test_loss\\\": avg_loss}\\n return {\\\"avg_test_loss\\\": avg_loss, \\\"log\\\": tensorboard_logs}\",\n \"def test_epoch_end(self, outputs: Any) -> None:\\n self.log_dict(self.test_metrics.compute())\\n self.test_metrics.reset()\",\n \"def build_stats(history, eval_output, time_callback):\\n stats = {}\\n if eval_output:\\n stats['accuracy_top_1'] = eval_output[1].item()\\n stats['eval_loss'] = eval_output[0].item()\\n\\n if history and history.history:\\n train_hist = history.history\\n # Gets final loss from training.\\n stats['loss'] = train_hist['loss'][-1].item()\\n # Gets top_1 training accuracy.\\n if 'categorical_accuracy' in train_hist:\\n stats[TRAIN_TOP_1] = train_hist['categorical_accuracy'][-1].item()\\n elif 'sparse_categorical_accuracy' in train_hist:\\n stats[TRAIN_TOP_1] = train_hist['sparse_categorical_accuracy'][-1].item()\\n\\n if time_callback:\\n timestamp_log = time_callback.timestamp_log\\n stats['step_timestamp_log'] = timestamp_log\\n stats['train_finish_time'] = time_callback.train_finish_time\\n if len(timestamp_log) > 1:\\n stats['avg_exp_per_second'] = (\\n time_callback.batch_size * time_callback.log_steps *\\n (len(time_callback.timestamp_log)-1) /\\n (timestamp_log[-1].timestamp - timestamp_log[0].timestamp))\\n\\n return stats\",\n \"def get(self):\\n if self.num_examples <= 0:\\n raise ValueError(\\\"total_sample must be positive.\\\")\\n avg_hit_at_one = self.sum_hit_at_one / self.num_examples\\n avg_perr = self.sum_perr / self.num_examples\\n avg_loss = self.sum_loss / self.num_examples\\n\\n epoch_info_dict = {\\\"avg_hit_at_one\\\": avg_hit_at_one, \\n \\\"avg_perr\\\": avg_perr,\\n \\\"avg_f1score\\\": avg_f1score,\\n \\\"avg_f2score\\\": avg_f2score,\\n \\\"avg_loss\\\": avg_loss}\\n return epoch_info_dict\",\n \"def validation_epoch_end(self, outputs):\\n avg_loss = torch.stack([x[\\\"val_loss\\\"] for x in outputs]).mean()\\n tensorboard_logs = {\\\"val_loss\\\": avg_loss}\\n return {\\\"avg_val_loss\\\": avg_loss, \\\"log\\\": tensorboard_logs}\",\n \"def validation_epoch_end(self, outputs):\\n avg_loss = torch.stack([x[\\\"val_loss\\\"] for x in outputs]).mean()\\n tensorboard_logs = {\\\"val_loss\\\": avg_loss}\\n return {\\\"avg_val_loss\\\": avg_loss, \\\"log\\\": tensorboard_logs}\",\n \"def test_epoch_end(self, outputs):\\n epoch_loss, epoch_accuracy, confmat = self._parse_outputs(\\n outputs=outputs, calculate_confusion_matrix=True)\\n self.log('test loss', np.mean(epoch_loss))\\n self.log('test accuracy', np.mean(epoch_accuracy))\\n print(confmat)\",\n \"def validation_epoch_end(self, outputs: Any) -> None:\\n self.log_dict(self.val_metrics.compute())\\n self.val_metrics.reset()\",\n \"def validation_epoch_end(self, outputs):\\n # outputs contain data for 2 dataloaders - val and test\\n for out_idx, outputs_i in enumerate(outputs):\\n # validation loss\\n val_loss_mean = torch.stack([x['val_loss_b'] for x in outputs_i]).mean()\\n\\n # predicts\\n logits = np.concatenate([x['logits_b'] for x in outputs_i], axis=0)\\n labels = np.concatenate([x['labels_b'] for x in outputs_i], axis=0)\\n emph_probs = np.concatenate([x['emph_probs_b'] for x in outputs_i], axis=0)\\n probs = np.exp(logits) / np.sum(np.exp(logits), axis=2, keepdims=True)\\n preds = np.argmax(logits, axis=2)\\n\\n label_map = {i: label for i, label in enumerate(self.labels)}\\n out_label_list = [[] for _ in range(labels.shape[0])]\\n preds_list = [[] for _ in range(labels.shape[0])]\\n probs_list = [[] for _ in range(labels.shape[0])]\\n emph_probs_list = [[] for _ in range(labels.shape[0])]\\n\\n for i in range(labels.shape[0]):\\n for j in range(labels.shape[1]):\\n if labels[i, j] != self.pad_token_label_id:\\n out_label_list[i].append(label_map[labels[i][j]])\\n preds_list[i].append(label_map[preds[i][j]])\\n probs_list[i].append(probs[i][j][1])\\n emph_probs_list[i].append(emph_probs[i][j])\\n\\n # for validation\\n if out_idx == 0:\\n # show random example\\n rand_idx = np.random.randint(0, len(out_label_list))\\n logger.info('True: %s', out_label_list[rand_idx])\\n logger.info('Pred: %s', preds_list[rand_idx])\\n logger.info('Emph: %s', emph_probs_list[rand_idx])\\n logger.info('Prob: %s', probs_list[rand_idx])\\n\\n # validation score\\n val_score = match_m(probs_list, emph_probs_list)\\n val_score_mean = np.mean(list(val_score.values()))\\n\\n # validation accuracy\\n val_acc = accuracy_score(out_label_list, preds_list)\\n\\n # validation f1 score\\n val_f1 = f1_score(out_label_list, preds_list)\\n\\n # score_logs\\n score_logs = {\\n 'val_score1': val_score[1],\\n 'val_score2': val_score[2],\\n 'val_score3': val_score[3],\\n 'val_score4': val_score[4],\\n 'val_score_mean': val_score_mean,\\n }\\n\\n # logs\\n logs = {\\n 'val_loss': val_loss_mean.detach().numpy(),\\n 'val_acc': val_acc,\\n 'val_f1': val_f1,\\n 'val_score_mean': val_score_mean,\\n }\\n\\n # output dict\\n output = {\\n 'val_loss': val_loss_mean,\\n 'val_f1': val_f1,\\n 'val_acc': val_acc,\\n 'progress_bar': logs,\\n 'log': {**logs, **score_logs},\\n }\\n\\n # write validation results to csv\\n csv_dict = {k: v for k, v in vars(self.hparams).items() if k in FIELDNAMES}\\n csv_dict.update(score_logs)\\n csv_dict.update(logs)\\n\\n csv_dict['current_epoch'] = self.current_epoch\\n csv_dict['global_step'] = self.global_step\\n\\n write_csv('results.csv', csv_dict)\\n self.preds['val'][self.current_epoch][self.global_step] = probs_list\\n\\n # save prediction for test\\n if out_idx == 1:\\n self.preds['test'][self.current_epoch][self.global_step] = probs_list\\n\\n # write to file all val and test predictions\\n with open('predicts/' + self.model_id_name + '.pkl', 'wb') as f:\\n pickle.dump(self.preds, f)\\n\\n return output\",\n \"def on_epoch_end(self, epoch, logs={}):\\n self.predhis.append(self.modelx.predict(self.x_testx))\\n y_true = np.argmax(self.y_testx, 1)\\n y_pred = np.argmax(self.modelx.predict(self.x_testx, batch_size=self.batch_sizex, verbose=0), axis=1)\\n \\n self.clas_rpt.append(report_to_df(classification_report(y_true, y_pred)))\\n self.conf_mtrx.append(confusion_matrix(y_true, y_pred, labels = range(self.nb_classes)))\\n #self.conf_mtrx[epoch] = confusion_matrix(y_true, y_pred, labels = range(self.nb_classes))\\n return self\",\n \"def test_epoch_end(self, outputs):\\n # extract test results\\n targets = []\\n preds = []\\n \\n for idx in range(len(outputs)):\\n targets.append(outputs[idx][0])\\n preds.append(outputs[idx][1])\\n \\n targets = torch.cat(targets, dim=0)\\n preds = torch.cat(preds, dim=0)\\n\\n # compute group specific scores\\n grp_1_idcs = targets == 0\\n grp_2_idcs = targets == 1\\n\\n grp_1_targets = targets[grp_1_idcs]\\n grp_2_targets = targets[grp_2_idcs]\\n \\n accuracy_grp_1 = torch.true_divide(torch.sum(preds[grp_1_idcs]== grp_1_targets), grp_1_targets.shape[0])\\n accuracy_grp_2 = torch.true_divide(torch.sum(preds[grp_2_idcs] == grp_2_targets), grp_2_targets.shape[0])\\n\\n self.log('test/accuracy_grp_1', accuracy_grp_1)\\n self.log('test/accuracy_grp_2', accuracy_grp_2)\",\n \"def on_train_epoch_end(self, outputs):\\n for callback in self.callbacks:\\n callback.on_train_epoch_end(self, self.get_model(), outputs)\",\n \"def run_epoch(session, model, input_, is_training, global_step, summary_writer, config, epoch_rem=0, COUNT=0):\\n loss_acum = 0.0\\n acc_acum = 0.0\\n if FLAGS.only_val:\\n matrices = np.zeros([config.num_actions, config.num_actions], dtype=np.int32)\\n n_mistakes = np.zeros([1, config.num_actions], dtype=np.int32)\\n mistake_labs = np.empty([0, 4], dtype=np.int32)\\n\\n fetches = {\\n \\\"loss\\\": model.loss,\\n # \\\"final_state\\\": model.final_state,\\n \\\"accuracy\\\": model.accuracy\\n }\\n if is_training:\\n fetches.update({\\n \\\"train_op\\\": model.train_op,\\n \\\"global_step\\\": global_step,\\n \\\"learning_rate\\\": model.lr\\n })\\n if FLAGS.only_val:\\n fetches.update({\\n \\\"confusion_matrix\\\": model.confusion_matrix,\\n \\\"mistakes_per_class\\\": model.mistakes_per_class,\\n \\\"mistake_labs\\\": model.mistake_labs,\\n \\\"logits\\\": model.logits,\\n \\\"labels\\\": model.labels,\\n \\\"idxs\\\": model.idxs\\n })\\n of = open('/tmp/%02d.txt' % COUNT, 'w')\\n\\n epoch_size = epoch_rem if epoch_rem > 0 else (input_.train_epoch_size if is_training else input_.val_epoch_size)\\n t = trange(epoch_size, disable=not FLAGS.verbose, dynamic_ncols=True)\\n for batch in t:\\n options = None\\n run_metadata = None\\n if is_training and (batch % epoch_size == epoch_size - 1) and FLAGS.run_metadata: # Record execution stats\\n options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)\\n run_metadata = tf.RunMetadata()\\n\\n vals = session.run(fetches=fetches, options=options, run_metadata=run_metadata)\\n loss = vals[\\\"loss\\\"]\\n # state = vals[\\\"final_state\\\"]\\n accuracy = vals[\\\"accuracy\\\"]\\n\\n if is_training:\\n learning_rate = vals[\\\"learning_rate\\\"]\\n global_step_val = vals[\\\"global_step\\\"]\\n\\n loss_acum += loss\\n acc_acum += accuracy\\n if FLAGS.only_val:\\n matrices += np.squeeze(vals[\\\"confusion_matrix\\\"], axis=(0,3))\\n n_mistakes += np.squeeze(vals[\\\"mistakes_per_class\\\"], axis=(0,3))\\n mistake_labs = np.concatenate((mistake_labs,vals[\\\"mistake_labs\\\"]), axis=0)\\n for logits, label, idx in zip(vals[\\\"logits\\\"], vals[\\\"labels\\\"], vals[\\\"idxs\\\"]):\\n out = \\\", \\\".join(str(l) for l in logits)\\n out += \\\", \\\" + str(label)\\n out += \\\", \\\" + str(idx)\\n print(out, file=of)\\n\\n postfix = {\\n 'loss': \\\"%.3f\\\" % (loss_acum / (batch + 1)),\\n 'acc': \\\"%.3f\\\" % (acc_acum / (batch + 1))\\n }\\n if is_training:\\n postfix.update({'l_rate': \\\"%.1E\\\" % learning_rate})\\n if run_metadata is not None:\\n summary_writer.add_run_metadata(run_metadata, 'S:%d' % global_step_val)\\n\\n t.set_postfix(postfix)\\n\\n if FLAGS.only_val:\\n import matplotlib\\n matplotlib.use('Agg')\\n from matplotlib import pyplot as plt\\n plt.imshow(matrices/epoch_size, interpolation='nearest')\\n plt.savefig(FLAGS.save_path+'/confusion_matrix.png')\\n\\n plt.imshow(n_mistakes/epoch_size, interpolation='nearest')\\n plt.savefig(FLAGS.save_path+'/mistakes_per_class.png')\\n\\n np.savetxt(FLAGS.save_path+'/mistake_labs.txt', mistake_labs, fmt='%i,%i,%i,%i')\\n print(np.histogram(mistake_labs[:,1], bins=np.arange(config.num_subjects)))\\n print(np.histogram(mistake_labs[:,2], bins=np.arange(config.num_actions)))\\n print(np.mean(mistake_labs[:,3]))\\n of.close()\\n\\n return loss_acum / epoch_size, acc_acum / epoch_size\",\n \"def _evaluate_during_fit(self, test_loader, epoch):\",\n \"def eval_epoch(self, final=False, save_predictions=False):\\n t1 = time()\\n output = {'tp': [], 'fp': [], 'fn': [], 'tn': [], 'loss': [], 'preds': [],'truth': [], 'true': 0,'true_sep':np.zeros(self.rel_size)}\\n test_info = []\\n test_result = []\\n self.model.eval()\\n test_iter = self.iterator(self.data['test'], batch_size=self.params['batch'], shuffle_=False)\\n # preds=[]\\n # truths=[]\\n for batch_idx, batch in enumerate(test_iter):\\n batch = self.convert_batch(batch, istrain=False, save=True)\\n\\n with torch.no_grad():\\n loss, stats, predictions, select, pred_pairs, multi_truths, mask, _ = self.model(\\n batch) # pred_pairs <#pair, relations_num>\\n pred_pairs = torch.sigmoid(pred_pairs)\\n\\n output['loss'] += [loss.item()]\\n output['tp'] += [stats['tp'].to('cpu').data.numpy()]\\n output['fp'] += [stats['fp'].to('cpu').data.numpy()]\\n output['fn'] += [stats['fn'].to('cpu').data.numpy()]\\n output['tn'] += [stats['tn'].to('cpu').data.numpy()]\\n output['preds'] += [predictions.to('cpu').data.numpy()]\\n # preds.extend(predictions.to('cpu').data.numpy())\\n # truths.extend(truth.to('cpu').data.numpy())\\n\\n if True:\\n test_infos = batch['info'][select[0].to('cpu').data.numpy(),\\n select[1].to('cpu').data.numpy(),\\n select[2].to('cpu').data.numpy()][mask.to('cpu').data.numpy()]\\n test_info += [test_infos]\\n\\n pred_pairs = pred_pairs.data.cpu().numpy()\\n multi_truths = multi_truths.data.cpu().numpy()\\n output['true'] += multi_truths.sum() - multi_truths[:, self.loader.label2ignore].sum()\\n output['true_sep'] = output['true_sep'] +multi_truths.sum(axis=0)\\n if save_predictions:\\n assert test_infos.shape[0] == len(pred_pairs), print(\\n \\\"test info=%d, pred_pair=%d\\\" % (len(test_infos.shape[0]), len(pred_pairs)))\\n for pair_id in range(len(pred_pairs)):\\n multi_truth = multi_truths[pair_id] #第pair_id个实体对的true\\n for r in range(0, self.rel_size):\\n if r == self.loader.label2ignore:\\n continue\\n\\n test_result.append((int(multi_truth[r]) == 1, float(pred_pairs[pair_id][r]),\\n test_infos[pair_id]['intrain'],test_infos[pair_id]['cross'], self.loader.index2rel[r], r,\\n len(test_info) - 1, pair_id))\\n\\n\\n # estimate performance\\n total_loss, scores = self.performance(output)\\n # pairs*rel_size*batch\\n test_result.sort(key=lambda x: x[1], reverse=True)\\n\\n input_theta, w, f1,p,r,scores_class = self.tune_f1_theta(test_result, output['true'],output['true_sep'], self.params['input_theta'], isTest=save_predictions)\\n\\n t2 = time()\\n if not final:\\n self.test_res['loss'] += [total_loss]\\n # self.test_res['score'] += [scores[self.primary_metric]]\\n self.test_res['score'] += [f1]\\n self.test_res['p'] = p\\n self.test_res['r'] = r\\n print(' TEST | LOSS = {:.05f}, '.format(total_loss), end=\\\"\\\")\\n print_results(scores, scores_class, self.show_class, t2 - t1)\\n # print(\\\"不同类别：\\\")\\n # t = classification_report(truths, preds,target_names=[\\\"NA\\\",\\\"父母子女\\\", \\\"祖孙\\\", \\\"兄弟姐妹\\\", \\\"叔伯姑舅姨\\\", \\\"夫妻\\\", \\\"其他亲戚\\\", \\\"好友\\\", \\\"上下级\\\", \\\"师生\\\", \\\"合作\\\", \\\"情侣\\\", \\\"对立\\\", \\\"共现\\\", \\\"同学\\\", \\\"同门\\\"])\\n # print(t)\\n\\n if save_predictions:\\n\\n test_result = test_result[: w + 1]\\n test_result_pred = []\\n test_result_info = []\\n for item in test_result:\\n test_result_pred.append([(item[-3], item[1])]) #预测的关系是的概率\\n test_result_info.append([test_info[item[-2]][item[-1]]])\\n assert (item[-3] in test_info[item[-2]][item[-1]]['rel']) == item[0], print(\\\"item\\\\n\\\", item, \\\"\\\\n\\\",\\n test_info[item[-2]][\\n item[-1]])\\n write_errors(test_result_pred, test_result_info, self.preds_file, map_=self.loader.index2rel, type=\\\"theta\\\")\\n write_preds(test_result_pred, test_result_info, self.preds_file, map_=self.loader.index2rel)\\n # f1_score_t=f1_score(truths, preds, average='micro')\\n # print(f1, scores['micro_f'], f1_score_t)\\n\\n return f1, scores['micro_f'],input_theta,p,r\",\n \"def finalize_output_dict(self, output_dict):\\n return {key: output_dict[key].cpu().numpy() for key in output_dict.keys()}\",\n \"def evaluate(epoch_number):\\r\\n model.eval() # turn on the eval() switch to disable dropout\\r\\n total_loss = 0\\r\\n total_correct = 0\\r\\n total_spl = 0\\r\\n total_xrl = 0\\r\\n total_Xrl = 0\\r\\n total_Yrl = 0\\r\\n total_cl = 0\\r\\n total_ol = 0\\r\\n Ysave = []\\r\\n for batch, i in enumerate(range(0, len(data_val), args.batch_size)):\\r\\n data, targets, lenth = package(data_val[i:min(len(data_val), i+args.batch_size)], volatile=True)\\r\\n if args.cuda:\\r\\n data = data.cuda()\\r\\n targets = targets.cuda()\\r\\n hidden = model.init_hidden(data.size(1))\\r\\n x, y, x_re, X, Y, Y_fromX, X_fromY, pred, outp, outp_fromY = model.forward(data, hidden,lenth, \\\"eval\\\",epoch_number)\\r\\n Ysave.append( (Y.cpu(), pred.cpu(), targets.cpu()) )\\r\\n output_flat = pred.view(data.size(1), -1)\\r\\n loss, sparse_loss, x_re_loss, X_re_loss, Y_re_loss, class_loss, outp_loss= \\\\\\r\\n criterion(x, y, x_re, X, Y, Y_fromX, X_fromY, pred, targets, data.size(1), outp, outp_fromY, lenth, epoch_number)\\r\\n total_loss += loss.data\\r\\n total_spl += sparse_loss.data\\r\\n total_xrl += x_re_loss.data\\r\\n total_Xrl += X_re_loss.data\\r\\n total_Yrl += Y_re_loss.data\\r\\n total_cl += class_loss.data\\r\\n total_ol += outp_loss.data\\r\\n\\r\\n prediction = torch.max(output_flat, 1)[1]\\r\\n total_correct += torch.sum((prediction == targets).float())\\r\\n\\r\\n ave_loss = total_loss / (len(data_val) // args.batch_size)\\r\\n ave_spl = total_spl / (len(data_val) // args.batch_size)\\r\\n ave_xrl = total_xrl / (len(data_val) // args.batch_size)\\r\\n ave_Xrl = total_Xrl / (len(data_val) // args.batch_size)\\r\\n ave_Yrl = total_Yrl / (len(data_val) // args.batch_size)\\r\\n ave_cl = total_cl / (len(data_val) // args.batch_size)\\r\\n ave_ol = total_ol / (len(data_val) // args.batch_size)\\r\\n\\r\\n if epoch_number is 15:\\r\\n f = open(\\\"../Y.pkl\\\",\\\"wb\\\")\\r\\n pkl.dump(Ysave, f)\\r\\n f.close()\\r\\n return ave_loss, total_correct.data[0] / len(data_val), ave_spl, ave_xrl, ave_Xrl,ave_Yrl, ave_cl, ave_ol\",\n \"def _train_epoch(self, epoch: int) -> Dict[str, float]:\\n logger.info(\\\"Epoch %d/%d\\\", epoch, self._num_epochs - 1)\\n peak_cpu_usage = peak_memory_mb()\\n logger.info(f\\\"Peak CPU memory usage MB: {peak_cpu_usage}\\\")\\n gpu_usage = []\\n for gpu, memory in gpu_memory_mb().items():\\n gpu_usage.append((gpu, memory))\\n logger.info(f\\\"GPU {gpu} memory usage MB: {memory}\\\")\\n\\n train_loss = 0.0\\n # Set the model to \\\"train\\\" mode.\\n self.model.train()\\n\\n num_gpus = len(self._cuda_devices)\\n\\n # Get tqdm for the training batches\\n raw_train_generator = self.iterator(self.train_data,\\n num_epochs=1,\\n shuffle=self.shuffle)\\n train_generator = lazy_groups_of(raw_train_generator, num_gpus)\\n num_training_batches = math.ceil(self.iterator.get_num_batches(self.train_data)/num_gpus)\\n self._last_log = time.time()\\n last_save_time = time.time()\\n\\n batches_this_epoch = 0\\n if self._batch_num_total is None:\\n self._batch_num_total = 0\\n\\n histogram_parameters = set(self.model.get_parameters_for_histogram_tensorboard_logging())\\n\\n logger.info(\\\"Training\\\")\\n train_generator_tqdm = Tqdm.tqdm(train_generator,\\n total=num_training_batches)\\n cumulative_batch_size = 0\\n for batch_group in train_generator_tqdm:\\n batches_this_epoch += 1\\n self._batch_num_total += 1\\n batch_num_total = self._batch_num_total\\n\\n self.optimizer.zero_grad()\\n\\n output_dict = self.get_output_dict(batch_group, for_training=True)\\n loss = self.get_batch_loss(output_dict, for_training=True)\\n\\n if torch.isnan(loss):\\n raise ValueError(\\\"nan loss encountered\\\")\\n\\n loss.backward()\\n\\n train_loss += loss.item()\\n\\n batch_grad_norm = self.rescale_gradients()\\n\\n # This does nothing if batch_num_total is None or you are using a\\n # scheduler which doesn't update per batch.\\n if self._learning_rate_scheduler:\\n self._learning_rate_scheduler.step_batch(batch_num_total)\\n if self._momentum_scheduler:\\n self._momentum_scheduler.step_batch(batch_num_total)\\n\\n if self._tensorboard.should_log_histograms_this_batch():\\n # get the magnitude of parameter updates for logging\\n # We need a copy of current parameters to compute magnitude of updates,\\n # and copy them to CPU so large models won't go OOM on the GPU.\\n param_updates = {name: param.detach().cpu().clone()\\n for name, param in self.model.named_parameters()}\\n self.optimizer.step()\\n for name, param in self.model.named_parameters():\\n param_updates[name].sub_(param.detach().cpu())\\n update_norm = torch.norm(param_updates[name].view(-1, ))\\n param_norm = torch.norm(param.view(-1, )).cpu()\\n self._tensorboard.add_train_scalar(\\\"gradient_update/\\\" + name,\\n update_norm / (param_norm + 1e-7))\\n else:\\n self.optimizer.step()\\n\\n # Update moving averages\\n if self._moving_average is not None:\\n self._moving_average.apply(batch_num_total)\\n\\n # Update the description with the latest metrics\\n metrics = training_util.get_metrics(self.model, train_loss, batches_this_epoch)\\n description = training_util.description_from_metrics(metrics)\\n\\n train_generator_tqdm.set_description(description, refresh=False)\\n\\n # Log parameter values to Tensorboard\\n if self._tensorboard.should_log_this_batch():\\n self._tensorboard.log_parameter_and_gradient_statistics(self.model, batch_grad_norm)\\n self._tensorboard.log_learning_rates(self.model, self.optimizer)\\n\\n self._tensorboard.add_train_scalar(\\\"loss/loss_train\\\", metrics[\\\"loss\\\"])\\n self._tensorboard.log_metrics({\\\"epoch_metrics/\\\" + k: v for k, v in metrics.items()})\\n\\n if self.tensorboard_log_batch_callback:\\n self.tensorboard_log_batch_callback(output_dict, self._tensorboard)\\n\\n if self._tensorboard.should_log_histograms_this_batch():\\n self._tensorboard.log_histograms(self.model, histogram_parameters)\\n\\n if self._log_batch_size_period:\\n cur_batch = sum([training_util.get_batch_size(batch) for batch in batch_group])\\n cumulative_batch_size += cur_batch\\n if (batches_this_epoch - 1) % self._log_batch_size_period == 0:\\n average = cumulative_batch_size/batches_this_epoch\\n logger.info(f\\\"current batch size: {cur_batch} mean batch size: {average}\\\")\\n self._tensorboard.add_train_scalar(\\\"current_batch_size\\\", cur_batch)\\n self._tensorboard.add_train_scalar(\\\"mean_batch_size\\\", average)\\n\\n # Save model if needed.\\n if self._model_save_interval is not None and (\\n time.time() - last_save_time > self._model_save_interval\\n ):\\n last_save_time = time.time()\\n self._save_checkpoint(\\n '{0}.{1}'.format(epoch, training_util.time_to_str(int(last_save_time)))\\n )\\n metrics = training_util.get_metrics(self.model, train_loss, batches_this_epoch, reset=True)\\n metrics['cpu_memory_MB'] = peak_cpu_usage\\n for (gpu_num, memory) in gpu_usage:\\n metrics['gpu_'+str(gpu_num)+'_memory_MB'] = memory\\n return metrics\",\n \"def _valid_epoch(self, epoch):\\n self.model.eval()\\n total_val_loss = 0\\n total_val_metrics = np.zeros(len(self.metrics))\\n length = len(self.valid_loader)\\n total_pm25_loss = 0\\n total_pm10_loss = 0\\n pm25_loss = 0\\n pm10_loss = 0\\n\\n with torch.no_grad():\\n\\n for batch_idx, (data, target) in enumerate(self.valid_loader):\\n data, target = data.to(self.device), target.to(self.device)\\n target = target.squeeze()\\n output = self.model(data)\\n # print(output)\\n loss = self.loss(output, target)\\n\\n # pm25_predict, pm10_predict = torch.chunk(output, 2, dim=1)\\n # pm25_target, pm10_target = torch.chunk(target, 2, dim=1)\\n # pm25_loss = self.loss(pm25_predict, pm25_target)\\n # pm10_loss = self.loss(pm10_predict, pm10_target)\\n # total_pm25_loss += pm25_loss.item()\\n # total_pm10_loss += pm10_loss.item()\\n\\n self.writer.set_step((epoch - 1) * len(self.valid_loader) + batch_idx, 'valid')\\n self.writer.add_scalar('loss', loss.item())\\n total_val_loss += loss.item()\\n total_val_metrics += self._eval_metrics(output, target)\\n\\n return {\\n 'val_loss': total_val_loss / length,\\n 'val_rmse_loss':np.sqrt(total_val_loss / length),\\n 'val_pm25_loss': np.sqrt(total_pm25_loss / length),\\n 'val_pm10_loss': np.sqrt(total_pm10_loss / length)\\n }\",\n \"def on_train_epoch_end(self) -> None:\\n self.log_dict(self.train_metrics.compute())\\n self.train_metrics.reset()\",\n \"def _eval_epoch(model, dl_val, criterion):\\n model.eval()\\n\\n loss_val = 0\\n cls_loss_val = 0\\n reg_loss_val = 0\\n len_val = 0\\n\\n y_true = []\\n y_pred = []\\n\\n with torch.no_grad():\\n for i, sample in enumerate(dl_val):\\n sys.stdout.write(\\\"\\\\r\\\")\\n\\n images, cls_target, reg_target = sample\\n images = images.cuda()\\n cls_target = cls_target.cuda()\\n reg_target = reg_target.cuda()\\n\\n cls_output, reg_output = model(images)\\n total_loss, cls_loss, reg_loss = criterion(cls_output, reg_output,\\n cls_target, reg_target)\\n\\n loss_val += total_loss.cpu().item() * images.size(0)\\n cls_loss_val += cls_loss.cpu().item() * images.size(0)\\n reg_loss_val += reg_loss.cpu().item() * images.size(0)\\n len_val += images.size(0)\\n\\n y_true += calculate_detect_prediction(cls_target, reg_target,\\n cfg.target_size, cfg.prob_thresh, cfg.overlap_iou_thresh,\\n cfg.num_classes)\\n y_pred += calculate_detect_prediction(cls_output, reg_output,\\n cfg.target_size, cfg.prob_thresh, cfg.overlap_iou_thresh)\\n\\n sys.stdout.write(f\\\"Validation: {i + 1}/{len(dl_val)}\\\")\\n\\n loss_val /= len_val\\n cls_loss_val /= len_val\\n reg_loss_val /= len_val\\n\\n map_score = calculate_map(y_true, y_pred, cfg.num_classes)\\n\\n sys.stdout.flush()\\n\\n return loss_val, cls_loss_val, reg_loss_val, map_score\",\n \"def validation_epoch_end(self, outputs):\\n epoch_loss, epoch_accuracy = self._parse_outputs(\\n outputs=outputs, calculate_confusion_matrix=False)\\n self.log('validation loss', np.mean(epoch_loss),\\n on_epoch=True, prog_bar=True)\\n self.log('validation accuracy', np.mean(epoch_accuracy))\",\n \"def compute_stats(self, epoch, loader, setname):\\n args = self.args\\n self.model.eval()\\n ndevbatches = len(self.dev_loader)\\n logging.info(f\\\"Evaluating {ndevbatches} batches ...\\\")\\n\\n recons, gts = defaultdict(list), defaultdict(list)\\n acquisition_machine_by_fname = dict()\\n with torch.no_grad():\\n for batch_idx, batch in enumerate(self.dev_loader):\\n progress = epoch + batch_idx/ndevbatches\\n logging_epoch = batch_idx % args.log_interval == 0\\n logging_epoch_info = batch_idx % (2 * args.log_interval) == 0\\n log = logging.info if logging_epoch_info else logging.debug\\n\\n self.start_of_test_batch_hook(progress, logging_epoch)\\n\\n batch = self.preprocess_data(batch)\\n output, target = self.predict(batch)\\n output = self.unnorm(output, batch)\\n target = self.unnorm(target, batch)\\n fname, slice = batch.fname, batch.slice\\n\\n for i in range(output.shape[0]):\\n slice_cpu = slice[i].item()\\n recons[fname[i]].append((slice_cpu, output[i].float().cpu().numpy()))\\n gts[fname[i]].append((slice_cpu, target[i].float().cpu().numpy()))\\n\\n acquisition_type = batch.attrs_dict['acquisition'][i]\\n machine_type = batch.attrs_dict['system'][i]\\n acquisition_machine_by_fname[fname[i]] = machine_type + '_' + acquisition_type\\n\\n if logging_epoch or batch_idx == ndevbatches-1:\\n gpu_memory_gb = torch.cuda.memory_allocated()/1000000000\\n host_memory_gb = utils.host_memory_usage_in_gb()\\n log(f\\\"Evaluated {batch_idx+1} of {ndevbatches} (GPU Mem: {gpu_memory_gb:2.3f}gb Host Mem: {gpu_memory_gb:2.3f}gb)\\\")\\n sys.stdout.flush()\\n\\n if self.args.debug_epoch_stats:\\n break\\n del output, target, batch\\n\\n logging.debug(f\\\"Finished evaluating\\\")\\n self.end_of_test_epoch_hook()\\n\\n recons = {\\n fname: np.stack([pred for _, pred in sorted(slice_preds)])\\n for fname, slice_preds in recons.items()\\n }\\n gts = {\\n fname: np.stack([pred for _, pred in sorted(slice_preds)])\\n for fname, slice_preds in gts.items()\\n }\\n\\n nmse, psnr, ssims = [], [], []\\n ssim_for_acquisition_machine = defaultdict(list)\\n recon_keys = list(recons.keys()).copy()\\n for fname in recon_keys:\\n pred_or, gt_or = recons[fname].squeeze(1), gts[fname].squeeze(1)\\n pred, gt = transforms.center_crop_to_smallest(pred_or, gt_or)\\n del pred_or, gt_or\\n\\n ssim = evaluate.ssim(gt, pred)\\n acquisition_machine = acquisition_machine_by_fname[fname]\\n ssim_for_acquisition_machine[acquisition_machine].append(ssim)\\n ssims.append(ssim)\\n nmse.append(evaluate.nmse(gt, pred))\\n psnr.append(evaluate.psnr(gt, pred))\\n del gt, pred\\n del recons[fname], gts[fname]\\n\\n if len(nmse) == 0:\\n nmse.append(0)\\n ssims.append(0)\\n psnr.append(0)\\n\\n min_vol_ssim = np.argmin(ssims)\\n min_vol = str(recon_keys[min_vol_ssim])\\n logging.info(f\\\"Min vol ssims: {min_vol}\\\")\\n sys.stdout.flush()\\n\\n del recons, gts\\n\\n acquisition_machine_losses = dict.fromkeys(self.dev_data.system_acquisitions, 0)\\n for key, value in ssim_for_acquisition_machine.items():\\n acquisition_machine_losses[key] = np.mean(value)\\n\\n losses = {'NMSE': np.mean(nmse),\\n 'PSNR': np.mean(psnr),\\n 'SSIM': np.mean(ssims),\\n 'SSIM_var': np.var(ssims),\\n 'SSIM_min': np.min(ssims),\\n **acquisition_machine_losses}\\n\\n return losses\",\n \"def pre_epoch_finish(self, input, output, metric_manager, train_stage: TrainStage):\\n if train_stage == TrainStage.VALIDATE:\\n generated_imgs, _, _, _, real_imgs = output\\n self.add_generated_image(\\n generated_imgs, nrow=self.display_imgs, height=self.height,\\n width=self.width, name='generated')\\n self.add_generated_image(\\n real_imgs, nrow=self.display_imgs, height=self.height,\\n width=self.width, name='real')\",\n \"def on_epoch_end(self, epoch: int, logs: dict = None):\\n if logs is None:\\n logs = {}\\n\\n # reset the index\\n self.model.reset_index()\\n\\n # rebuild the index\\n self.model.index(self.targets, self.target_labels, verbose=0)\\n\\n results = _compute_classification_metrics(\\n queries=self.queries,\\n query_labels=self.query_labels,\\n model=self.model,\\n evaluator=self.evaluator,\\n metrics=self.metrics,\\n k=self.k,\\n matcher=self.matcher,\\n distance_thresholds=self.distance_thresholds)\\n\\n mstr = []\\n for metric_name, vals in results.items():\\n float_val = vals[0]\\n logs[metric_name] = float_val\\n mstr.append(f'{metric_name}: {float_val:.4f}')\\n if self.tb_writer:\\n with self.tb_writer.as_default():\\n tf.summary.scalar(metric_name, float_val, step=epoch)\\n\\n # reset the index to prevent users from accidently using this after the\\n # callback\\n self.model.reset_index()\\n\\n print(' - '.join(mstr))\",\n \"def finalize_output_dict(self):\\n self.output_dict = {\\n key: torch.cat(value).numpy() for key, value in self.output_dict.items()\\n }\",\n \"def on_test_epoch_end(self) -> None:\\n self.log_dict(self.test_metrics.compute())\\n self.test_metrics.reset()\",\n \"def run_epoch(self, session):\\n start_time = time.time()\\n costs = 0.0\\n iters = 0\\n\\n fetches = {\\n \\\"cost\\\": self._cost,\\n \\\"final_state\\\": self._final_state,\\n }\\n\\n if(self._is_training):\\n fetches[\\\"train_op\\\"] = self._train_op\\n\\n state = session.run(self._initial_state)\\n\\n for step in range(self._input.epoch_size):\\n feed_dict = {}\\n for i, (c, h) in enumerate(self._initial_state):\\n feed_dict[c] = state[i].c\\n feed_dict[h] = state[i].h\\n\\n vals = session.run(fetches, feed_dict)\\n cost = vals[\\\"cost\\\"]\\n state = vals[\\\"final_state\\\"]\\n\\n costs += cost\\n iters += self._input.num_steps\\n\\n return np.exp(costs / iters)\",\n \"def _extract_epoch_results(\\n self, epoch: int = -1\\n ) -> Dict[str, Dict[str, DLTypes.TrackableType]]:\\n return {\\n \\\"Static hyperparameters\\\": self._static_hyperparameters,\\n \\\"Dynamic hyperparameters\\\": {\\n name: value[epoch]\\n for name, value in self._dynamic_hyperparameters.items()\\n },\\n \\\"Training results\\\": {\\n name: value[epoch] for name, value in self._training_summaries.items()\\n },\\n \\\"Validation results\\\": {\\n name: value[epoch] for name, value in self._validation_summaries.items()\\n },\\n }\",\n \"def run_epoch(self, sess, epoch_num, validate=True):\\n total_loss = 0\\n accuracies = []\\n for i in range(self.batches_per_epoch):\\n batch = self.loader.get_batch()\\n if self.config.print_every and i % self.config.print_every == 0:\\n if validate:\\n val_accuracy = self.eval_validation_accuracy()\\n print(\\\"step {}, validation accuracy {:.3f}\\\".format(i, val_accuracy))\\n accuracies.append((i + epoch_num * self.batches_per_epoch, val_accuracy))\\n else:\\n if self.include_coverage and self.include_entropy:\\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1], batch[2], batch[3])\\n elif self.include_coverage:\\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1], batch[2])\\n elif self.include_entropy:\\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1], batch[2])\\n else:\\n train_accuracy = self.eval_accuracy_on_batch(batch[0], batch[1])\\n print(\\\"step {}, training accuracy {:.3f}\\\".format(i, train_accuracy))\\n \\n if self.include_coverage and self.include_entropy:\\n _, loss_val = sess.run([self.train_op, self.loss],\\n feed_dict={self.x: batch[0], self.c: batch[1], self.e: batch[2], self.y_: batch[2], \\n self.keep_prob: 1-self.config.dropout_prob})\\n elif self.include_coverage:\\n _, loss_val = sess.run([self.train_op, self.loss],\\n feed_dict={self.x: batch[0], self.c: batch[1], self.y_: batch[2], \\n self.keep_prob: 1-self.config.dropout_prob})\\n elif self.include_entropy:\\n _, loss_val = sess.run([self.train_op, self.loss],\\n feed_dict={self.x: batch[0], self.e: batch[1], self.y_: batch[2], \\n self.keep_prob: 1-self.config.dropout_prob})\\n else:\\n attention, _, loss_val = sess.run([self.attention, self.train_op, self.loss],\\n feed_dict={self.x: batch[0], self.y_: batch[1],\\n self.keep_prob: 1-self.config.dropout_prob})\\n\\t\\tpdb.set_trace()\\n\\t\\tnp.savetxt(\\\"a.csv\\\", attention[0], delimiter=\\\",\\\")\\n total_loss += loss_val\\n\\n return total_loss / self.batches_per_epoch, accuracies\",\n \"def run_epoch(self, dataloader, train=True):\\n losses = []\\n accs = []\\n for imgs, targets in dataloader:\\n imgs, targets = imgs.to(self.device), targets.to(self.device)\\n\\n # calc. the losses\\n output = self.resnet(imgs)\\n loss = self.criterion(output, targets)\\n\\n if train:\\n # update the parameters\\n self.optimizer.zero_grad() # initialize gradients\\n loss.backward()\\n self.optimizer.step()\\n\\n # save training results\\n if self.total_steps % 10 == 0:\\n accuracy = self.calc_batch_accuracy(output, targets)\\n accs.append(accuracy.item())\\n losses.append(loss.item())\\n self.log_performance(self.summary_writer,\\n {'loss': loss.item(), 'acc': accuracy.item()},\\n self.epoch,\\n self.total_steps)\\n\\n if self.total_steps % 100 == 0:\\n self.save_module_summary(\\n self.summary_writer, self.resnet.module, self.total_steps)\\n\\n self.total_steps += 1\\n else: # no training - validation\\n accuracy = self.calc_batch_accuracy(output, targets)\\n accs.append(accuracy.item())\\n losses.append(loss.item())\\n\\n avg_loss = sum(losses) / len(losses)\\n avg_acc = sum(accs) / len(accs)\\n return avg_loss, avg_acc\",\n \"def on_epoch_end(self, epoch: int, logs: dict = None):\\n _ = epoch\\n if logs is None:\\n logs = {}\\n\\n # reset the index\\n self.model.reset_index()\\n\\n # rebuild the index\\n self.model.index(self.targets, self.target_labels, verbose=0)\\n\\n known_results = _compute_classification_metrics(\\n queries=self.queries_known,\\n query_labels=self.query_labels_known,\\n model=self.model,\\n evaluator=self.evaluator,\\n metrics=self.metrics,\\n k=self.k,\\n matcher=self.matcher,\\n distance_thresholds=self.distance_thresholds)\\n\\n unknown_results = _compute_classification_metrics(\\n queries=self.queries_unknown,\\n query_labels=self.query_labels_unknown,\\n model=self.model,\\n evaluator=self.evaluator,\\n metrics=self.metrics,\\n k=self.k,\\n matcher=self.matcher,\\n distance_thresholds=self.distance_thresholds)\\n\\n mstr = []\\n for metric_name, vals in known_results.items():\\n float_val = vals[0]\\n full_metric_name = f'{metric_name}_known_classes'\\n logs[full_metric_name] = float_val\\n mstr.append(f'{full_metric_name}: {float_val:0.4f}')\\n if self.tb_writer:\\n with self.tb_writer.as_default():\\n tf.summary.scalar(full_metric_name, float_val, step=epoch)\\n\\n for metric_name, vals in unknown_results.items():\\n float_val = vals[0]\\n full_metric_name = f'{metric_name}_unknown_classes'\\n logs[full_metric_name] = float_val\\n mstr.append(f'{full_metric_name}: {float_val:0.4f}')\\n if self.tb_writer:\\n with self.tb_writer.as_default():\\n tf.summary.scalar(full_metric_name, float_val, step=epoch)\\n\\n # reset the index to prevent users from accidently using this after the\\n # callback\\n self.model.reset_index()\\n\\n print(' - '.join(mstr))\",\n \"def MakeSamplesFromEvalOutput(metadata, output, elapsed_seconds):\\n pattern = (r'Saving dict for global step \\\\d+: accuracy = (\\\\d+\\\\.\\\\d+), '\\n r'global_step = (\\\\d+), loss = (\\\\d+\\\\.\\\\d+)')\\n accuracy, step, loss = regex_util.ExtractAllMatches(pattern, output).pop()\\n metadata_copy = metadata.copy()\\n step = int(step)\\n metadata_copy['step'] = step\\n num_examples_per_epoch = metadata['num_examples_per_epoch']\\n metadata_copy['epoch'] = step / num_examples_per_epoch\\n metadata_copy['elapsed_seconds'] = elapsed_seconds\\n return [sample.Sample('Eval Loss', float(loss), '', metadata_copy),\\n sample.Sample('Accuracy', float(accuracy) * 100, '%', metadata_copy)]\",\n \"def train_epoch(self, epoch):\\n t1 = time()\\n output = {'tp': [], 'fp': [], 'fn': [], 'tn': [], 'loss': [], 'preds': [], 'true': 0, 'ttotal': []}\\n self.acc_NA.clear()\\n self.acc_not_NA.clear()\\n self.acc_total.clear()\\n\\n self.model.train()\\n # 多个batch的数据\\n train_iter = self.iterator(self.data['train'], batch_size=self.params['batch'],\\n shuffle_=self.params['shuffle_data'])\\n\\n for batch_idx, batch in enumerate(train_iter):\\n # print(\\\"batch_idx\\\", batch_idx)\\n batch = self.convert_batch(batch, istrain=True)\\n\\n # with autograd.detect_anomaly():\\n self.optimizer.zero_grad()\\n loss, stats, predictions, select, pred_pairs, multi_truths, mask, relation_label = self.model(batch)\\n pred_pairs = torch.sigmoid(pred_pairs)\\n # self.optimizer.zero_grad()\\n loss.backward() # backward computation\\n\\n nn.utils.clip_grad_norm_(self.model.parameters(), self.gc) # gradient clipping\\n self.optimizer.step() # update\\n if self.scheduler!=None:\\n self.scheduler.step()\\n\\n relation_label = relation_label.to('cpu').data.numpy()\\n predictions = predictions.to('cpu').data.numpy()\\n # batches\\n output['loss'] += [float(loss.item())]\\n output['tp'] += [stats['tp'].to('cpu').data.numpy()]\\n output['fp'] += [stats['fp'].to('cpu').data.numpy()]\\n output['fn'] += [stats['fn'].to('cpu').data.numpy()]\\n output['tn'] += [stats['tn'].to('cpu').data.numpy()]\\n output['preds'] += [predictions]\\n output['ttotal'] += [stats['ttotal']]\\n\\n for i in range(predictions.shape[0]):\\n label = relation_label[i]\\n if label < 0:\\n break\\n if label == self.loader.label2ignore:\\n self.acc_NA.add(predictions[i] == label)\\n else:\\n self.acc_not_NA.add(predictions[i] == label)\\n self.acc_total.add(predictions[i] == label)\\n # 一个epoch\\n total_loss, scores = self.performance(output)\\n t2 = time()\\n\\n self.train_res['loss'] += [total_loss]\\n self.train_res['score'] += [scores[self.primary_metric]]\\n self.train_res['p'] += [scores['micro_p']]\\n self.train_res['r'] += [scores['micro_r']]\\n\\n print('Epoch: {:02d} | TRAIN | LOSS = {:.05f}, | NA acc: {:4.2f} | not NA acc: {:4.2f} | tot acc: {:4.2f}'.\\n format(epoch, total_loss, self.acc_NA.get(), self.acc_not_NA.get(), self.acc_total.get()), end=\\\"\\\")\\n print_results(scores, [], False, t2 - t1)\\n print(\\\"TTotal\\\\t\\\", sum(output['ttotal']))\\n return scores['micro_f']\",\n \"def _train_epoch(self, epoch):\\n self.model.train()\\n self.train_metrics.reset()\\n for batch_idx, (data, target) in enumerate(self.data_loader):\\n data, target = data.to(self.device), target.to(self.device)\\n\\n self.optimizer.zero_grad()\\n\\n if self.config[\\\"amp\\\"]:\\n # AMP!\\n with autocast():\\n output = self.model(data)\\n loss = self.criterion(output, target)\\n else:\\n output = self.model(data)\\n loss = self.criterion(output, target)\\n\\n loss.backward()\\n self.optimizer.step()\\n\\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\\n self.train_metrics.update(\\\"loss\\\", loss.item())\\n for met in self.metric_ftns:\\n self.train_metrics.update(met.__name__, met(output, target))\\n\\n if batch_idx % self.log_step == 0:\\n self.logger.debug(\\n \\\"Train Epoch: {} {} Loss: {:.6f}\\\".format(\\n epoch, self._progress(batch_idx), loss.item()\\n )\\n )\\n self.writer.add_image(\\n \\\"input\\\", make_grid(data.cpu(), nrow=8, normalize=True)\\n )\\n\\n if batch_idx == self.len_epoch:\\n break\\n log = self.train_metrics.result()\\n\\n if self.do_validation:\\n val_log = self._valid_epoch(epoch)\\n log.update(**{\\\"val_\\\" + k: v for k, v in val_log.items()})\\n\\n if self.lr_scheduler is not None:\\n self.lr_scheduler.step()\\n return log\",\n \"def calculate_statistics(train_loader, net):\\n net.eval()\\n\\n pred_list = None\\n max_class_mean = {}\\n print(\\\"Calculating statistics...\\\")\\n for i, data in enumerate(train_loader):\\n inputs = data[0]\\n\\n inputs = inputs.cuda()\\n B, C, H, W = inputs.shape\\n batch_pixel_size = C * H * W\\n\\n with torch.no_grad():\\n outputs, _ = net(inputs)\\n\\n if pred_list is None:\\n pred_list = outputs.data.cpu()\\n else:\\n pred_list = torch.cat((pred_list, outputs.cpu()), 0)\\n del outputs\\n\\n if i % 50 == 49 or i == len(train_loader) - 1:\\n pred_list = pred_list.transpose(1, 3)\\n pred_list, prediction = pred_list.max(3)\\n\\n class_max_logits = []\\n mean_dict, var_dict = {}, {}\\n for c in range(datasets.num_classes):\\n max_mask = pred_list[prediction == c]\\n class_max_logits.append(max_mask)\\n\\n mean = class_max_logits[c].mean(dim=0)\\n var = class_max_logits[c].var(dim=0)\\n\\n mean_dict[c] = mean.item()\\n var_dict[c] = var.item()\\n\\n print(f\\\"class mean: {mean_dict}\\\")\\n print(f\\\"class var: {var_dict}\\\")\\n np.save(f'stats/{args.dataset[0]}_mean.npy', mean_dict)\\n np.save(f'stats/{args.dataset[0]}_var.npy', var_dict)\\n\\n return None\",\n \"def run_epoch(self, train, dev, epoch):\\n # iterate over dataset\\n for i, (words, labels) in enumerate(minibatches(train, self.config.batch_size)):\\n fd, _ = self.get_feed_dict(words, labels, self.config.lr,\\n self.config.dropout)\\n\\n _, train_loss= self.sess.run(\\n [self.train_op, self.loss], feed_dict=fd)\\n\\n# =============================================================================\\n# # tensorboard\\n# if i % 10 == 0:\\n# self.file_writer.add_summary(summary, epoch*nbatches + i)\\n# =============================================================================\\n\\n metrics = self.run_evaluate(dev)\\n msg = \\\" - \\\".join([\\\"{} {:04.2f}\\\".format(k, v)\\n for k, v in metrics.items()])\\n print(msg)\\n\\n return metrics[\\\"f1\\\"]\",\n \"def on_train_end(self, logs=None):\\n self.epoch_iter = 0\",\n \"def eval_epoch(model, validation_data, pred_loss_func, opt):\\n\\n model.eval()\\n\\n total_event_ll = 0 # cumulative event log-likelihood\\n total_time_se = 0 # cumulative time prediction squared-error\\n total_time_error = 0 # cumulative time prediction squared-error\\n total_time_latitude = 0 # cumulative latitude prediction squared-error\\n total_time_longitude = 0 # cumulative longitude prediction squared-error\\n\\n total_event_rate = 0 # cumulative number of correct prediction\\n total_num_event = 0 # number of total events\\n total_num_pred = 0 # number of predictions\\n with torch.no_grad():\\n for batch in tqdm(validation_data, mininterval=2,\\n desc=' - (Validation) ', leave=False):\\n \\\"\\\"\\\" prepare data \\\"\\\"\\\"\\n event_time, time_gap, event_type, latitude, longitude = map(lambda x: x.to(opt.device), batch)\\n\\n \\\"\\\"\\\" forward \\\"\\\"\\\"\\n enc_out, prediction = model(event_type, event_time, latitude, longitude) # change the event_time to time gap\\n\\n \\\"\\\"\\\" compute loss \\\"\\\"\\\"\\n event_ll, non_event_ll = Utils.log_likelihood(model, enc_out, time_gap, event_type, latitude, longitude) # change the event_time to time gap\\n event_loss = -torch.sum(event_ll - non_event_ll)\\n\\n _, pred_num = Utils.type_loss(prediction[0], event_type, pred_loss_func)\\n\\n se = Utils.time_loss(prediction[1], event_time) # change the event_time to time gap\\n le = Utils.time_loss(prediction[2], latitude)\\n ge = Utils.time_loss(prediction[3], longitude)\\n\\n \\\"\\\"\\\" note keeping \\\"\\\"\\\"\\n total_event_ll += -event_loss.item()\\n total_time_se += se.item() + le.item() + ge.item()\\n total_time_error += se.item()\\n total_time_latitude += le.item()\\n total_time_longitude += ge.item()\\n\\n total_event_rate += pred_num.item()\\n total_num_event += event_type.ne(Constants.PAD).sum().item()\\n total_num_pred += event_type.ne(Constants.PAD).sum().item() - event_time.shape[0] # change the event_time to time gap\\n\\n test_rmse = np.sqrt(total_time_se / total_num_pred)\\n test_time_rmse = np.sqrt(total_time_error / total_num_pred)\\n test_latitude_rmse = np.sqrt(total_time_latitude / total_num_pred)\\n test_longitude_rmse = np.sqrt(total_time_longitude / total_num_pred)\\n\\n return total_event_ll / total_num_event, total_event_rate / total_num_pred, test_time_rmse, test_latitude_rmse, test_longitude_rmse, test_rmse\",\n \"def _train_epoch(self, epoch):\\n\\n indexes = []\\n losses2save = []\\n\\n start_time = time.time()\\n self.model.train()\\n self.train_metrics.reset()\\n for batch_idx, (data, target, index) in enumerate(self.data_loader):\\n indexes.append(index)\\n batch_start = time.time()\\n data, target = data.to(device=self.device, dtype=torch.float), target.to(self.device, dtype=torch.float)\\n if self.mixup is not None:\\n data, target = mixup(data, target, np.random.beta(1, 1))\\n # if self.lable_smooth is not None:\\n # target = target.long()\\n # print('getting smooth label')\\n # target = smooth_one_hot(true_labels=target, classes=108, smoothing=self.lable_smooth)\\n\\n self.optimizer.zero_grad()\\n output = self.model(data)\\n\\n if self.only_scored_classes:\\n # Only consider classes that are scored with the Challenge metric.\\n if self.config[\\\"loss\\\"][\\\"type\\\"] == \\\"weighted_bce_with_logits_loss\\\":\\n loss = self.criterion(output[:, self.indices], target[:, self.indices], self.weights)\\n else:\\n loss = self.criterion(output[:, self.indices], target[:, self.indices])\\n cost_w = F.binary_cross_entropy_with_logits(output[:, self.indices], target[:, self.indices], reduce=False)\\n # cost_w = torch.sum(cost_w, dim=1)\\n cost_v = torch.reshape(cost_w, (len(cost_w), 24))\\n cost_tmp = cost_v.cpu().detach().numpy()\\n losses2save.append(cost_tmp)\\n loss = torch.sum(cost_w)/len(cost_w)\\n else:\\n loss = self.criterion(output, target)\\n\\n loss.backward()\\n self.optimizer.step()\\n\\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\\n self.train_metrics.update('loss', loss.item())\\n\\n output_logit = self.sigmoid(output)\\n for met in self.metric_ftns:\\n self.train_metrics.update(met.__name__, met(self._to_np(output_logit), self._to_np(target)))\\n\\n if batch_idx % self.log_step == 0:\\n batch_end = time.time()\\n self.logger.debug('Train Epoch: {} {} Loss: {:.6f}, 1 batch cost time {:.2f}'.format(\\n epoch,\\n self._progress(batch_idx),\\n loss.item(),\\n batch_end - batch_start))\\n # self.writer.add_image('input', make_grid(data.cpu(), nrow=8, normalize=True))\\n\\n if batch_idx == self.len_epoch:\\n break\\n log = self.train_metrics.result()\\n\\n end_time = time.time()\\n print(\\\"training epoch cost {} seconds\\\".format(end_time-start_time))\\n if self.do_validation:\\n val_log = self._valid_epoch(epoch)\\n log.update(**{'val_'+k : v for k, v in val_log.items()})\\n\\n if self.lr_scheduler is not None:\\n if self.config['lr_scheduler']['type'] == 'ReduceLROnPlateau':\\n self.lr_scheduler.step(log['val_loss'])\\n elif self.config['lr_scheduler']['type'] == 'GradualWarmupScheduler':\\n self.lr_scheduler.step(epoch, log['val_loss'])\\n else:\\n self.lr_scheduler.step()\\n\\n return np.concatenate(indexes), np.concatenate(losses2save), log\",\n \"def _compute_running_metrics(self,\\n model_output: torch.Tensor,\\n batch: Tuple[torch.Tensor, torch.Tensor],\\n running_metrics: dict) -> None:\\n for metric in self.metrics:\\n if metric.__name__ == 'word_error_rate' or metric.__name__ == 'character_error_rate':\\n metric_result = metric(model_output, batch, self.decoder)\\n else:\\n metric_result = metric(model_output, batch)\\n if type(metric_result) == torch.Tensor:\\n metric_result = metric_result.item()\\n\\n running_metrics[metric.__name__].append(metric_result)\",\n \"def on_epoch_begin(self, epoch, logs={}):\\n self.current_progress = 0\\n self.loss = 0\\n self.accuracy = 0\",\n \"def validation_end(self, outputs):\\n # if returned a scalar from validation_step, outputs is a list of tensor scalars\\n # we return just the average in this case (if we want)\\n # return torch.stack(outputs).mean()\\n\\n val_loss_mean = 0\\n val_acc_mean = 0\\n for output in outputs:\\n val_loss = output['val_loss']\\n\\n # reduce manually when using dp\\n if self.trainer.use_dp or self.trainer.use_ddp2:\\n val_loss = torch.mean(val_loss)\\n val_loss_mean += val_loss\\n\\n # reduce manually when using dp\\n val_acc = output['val_acc']\\n if self.trainer.use_dp or self.trainer.use_ddp2:\\n val_acc = torch.mean(val_acc)\\n\\n val_acc_mean += val_acc\\n\\n val_loss_mean /= len(outputs)\\n val_acc_mean /= len(outputs)\\n tqdm_dict = {'val_loss': val_loss_mean, 'val_acc': val_acc_mean}\\n result = {'progress_bar': tqdm_dict, 'log': tqdm_dict, 'val_loss': val_loss_mean}\\n return result\",\n \"def compute_metrics(self, outputs: List[Dict[str, torch.Tensor]]) -> dict:\\n distance_pos, distance_neg = [], []\\n for minibatch in outputs:\\n minibatch = minibatch[\\\"val_prediction\\\"]\\n src_embedding = minibatch[\\\"src_sentemb\\\"]\\n ref_embedding = minibatch[\\\"ref_sentemb\\\"]\\n pos_embedding = minibatch[\\\"pos_sentemb\\\"]\\n neg_embedding = minibatch[\\\"neg_sentemb\\\"]\\n\\n distance_src_pos = F.pairwise_distance(pos_embedding, src_embedding)\\n distance_ref_pos = F.pairwise_distance(pos_embedding, ref_embedding)\\n harmonic_distance_pos = (2 * distance_src_pos * distance_ref_pos) / (\\n distance_src_pos + distance_ref_pos\\n )\\n distance_pos.append(harmonic_distance_pos)\\n\\n distance_src_neg = F.pairwise_distance(neg_embedding, src_embedding)\\n distance_ref_neg = F.pairwise_distance(neg_embedding, ref_embedding)\\n harmonic_distance_neg = (2 * distance_src_neg * distance_ref_neg) / (\\n distance_src_neg + distance_ref_neg\\n )\\n distance_neg.append(harmonic_distance_neg)\\n\\n return {\\n \\\"kendall\\\": self.metrics.compute(\\n torch.cat(distance_pos), torch.cat(distance_neg)\\n )\\n }\",\n \"def init_output_dict(self):\\n return {\\n \\\"outputs\\\": torch.FloatTensor(),\\n \\\"pred_probs\\\": torch.FloatTensor(),\\n \\\"labels\\\": torch.LongTensor(),\\n }\",\n \"def run_epoch(data_iter, model, loss_compute, print_every=50, num_batches=0, phase=\\\"train\\\", epoch_num=0):\\n\\n start = time.time()\\n total_tokens = 0\\n total_loss = 0\\n print_tokens = 0\\n\\n for i, batch in tqdm(enumerate(data_iter, 1)):\\n out, _, pre_output = model.forward(batch.src, batch.trg,\\n batch.src_mask, batch.trg_mask,\\n batch.src_lengths, batch.trg_lengths)\\n loss = loss_compute(pre_output, batch.trg_y, batch.nseqs)\\n #print(f'epoch loss {loss}')\\n total_loss += loss\\n total_tokens += batch.ntokens\\n print_tokens += batch.ntokens\\n \\n if model.training and i % print_every == 0:\\n elapsed = time.time() - start\\n print(\\\"Epoch Step: %d Loss: %f Tokens per Sec: %f\\\" %\\n (i, loss / batch.nseqs, print_tokens / elapsed))\\n start = time.time()\\n print_tokens = 0\\n\\n if num_batches > 0 and i > num_batches:\\n break\\n\\n return math.exp(total_loss / float(total_tokens)), total_loss\\n #return total_loss / float(total_tokens)\",\n \"def _valid_epoch(self, epoch):\\n self.model.eval()\\n self.valid_metrics.reset()\\n with torch.no_grad():\\n for batch_idx, (data, target, _) in enumerate(self.valid_data_loader):\\n data, target = data.to(device=self.device, dtype=torch.float), target.to(self.device, dtype=torch.float)\\n\\n output = self.model(data)\\n\\n if self.only_scored_classes:\\n # Only consider classes that are scored with the Challenge metric.\\n if self.config[\\\"loss\\\"][\\\"type\\\"] == \\\"weighted_bce_with_logits_loss\\\":\\n loss = self.criterion(output[:, self.indices], target[:, self.indices], self.weights)\\n else:\\n loss = self.criterion(output[:, self.indices], target[:, self.indices])\\n else:\\n loss = self.criterion(output, target)\\n\\n self.writer.set_step((epoch - 1) * len(self.valid_data_loader) + batch_idx, 'valid')\\n self.valid_metrics.update('loss', loss.item())\\n\\n output_logit = self.sigmoid(output)\\n for met in self.metric_ftns:\\n self.valid_metrics.update(met.__name__, met(self._to_np(output_logit), self._to_np(target)))\\n # self.writer.add_image('input', make_grid(data.cpu(), nrow=8, normalize=True))\\n\\n if self.lr_scheduler is not None and self.config[\\\"lr_scheduler\\\"][\\\"type\\\"] == \\\"ReduceLROnPlateau\\\":\\n self.lr_scheduler.step(self.valid_metrics.result()[\\\"challenge_metric\\\"])\\n\\n # add histogram of model parameters to the tensorboard\\n # for name, p in self.model.named_parameters():\\n # self.writer.add_histogram(name, p, bins='auto')\\n return self.valid_metrics.result()\",\n \"def _get_epoch_acc(self, is_test: bool = False) -> Dict[str, float]:\\n n_total = (\\n len(self.testloader.dataset) if is_test else len(self.trainloader.dataset)\\n )\\n acc = dict()\\n for module_name in self.n_correct_epoch:\\n accuracy = 100 * self.n_correct_epoch[module_name] / n_total\\n acc.update({module_name + \\\"_acc\\\": accuracy})\\n self.n_correct_epoch.clear()\\n\\n return acc\",\n \"def after_evaluation(self, epoch, **kw):\\n if self.loss_txt is not None:\\n self.current_row[MetricName(\\\"timestamp\\\")] = f\\\"{datetime.now():%H:%M:%S}\\\"\\n\\n # output log file\\n with open(self.loss_txt, \\\"a\\\") as f:\\n # remove columns where no value was found on the first epoch (could be != 1 if training was resumed)\\n if epoch == self.first_epoch:\\n for k in list(self.headers.keys()):\\n if k not in self.current_row:\\n del self.headers[k]\\n\\n # make headers on epoch 1\\n if epoch == 1:\\n # write header\\n f.write(\\\"\\\\t\\\".join(self.headers.values()) + \\\"\\\\n\\\")\\n\\n for col in self.headers:\\n assert col in self.current_row, str(col) + \\\" \\\" + str(self.current_row.keys())\\n\\n assert all(col in self.current_row for col in self.headers)\\n\\n f.write(\\\"\\\\t\\\".join([str(self.current_row[col]) for col in self.headers]) + \\\"\\\\n\\\")\\n\\n self.current_row = {}\",\n \"def eval_epoch(self, epoch_num: int) -> float:\\n epoch_loss = 0.0\\n # hidden_start = torch.zeros(self.batch_size, self.rnn_size).to(device)\\n with torch.no_grad():\\n # for batch_num, (x, y) in enumerate(make_batches(self.dev_data,\\n # self.batch_size,\\n # self.max_len)):\\n acc = 0;\\n for batch_num, batch_tuple in enumerate(self.train_data):\\n print('batch: ', batch_num)\\n # reset gradients\\n # self.optimizer.zero_grad()\\n # x = len(batch_tuple[0])\\n # y = len(batch_tuple[0][0])\\n # batch x timesteps x hidden_size\\n x, y = batch_tuple\\n # x = x.to(self.device)\\n # y = y.to(self.device)\\n hidden_states = self.model(x)\\n # batch x timesteps x vocab_size\\n # logits = self.model.get_logits(hidden_states)\\n\\n batch_loss = self.model.get_loss(hidden_states, y)\\n epoch_loss += batch_loss.item()\\n hidden_states_m = torch.argmax(hidden_states, dim=1)\\n acc += sum(hidden_states_m == y).item()\\n # we use a stateful RNN, which means the first hidden state for\\n # the next batch is the last hidden state of the current batch\\n # hidden_states.detach_()\\n # hidden_start = hidden_states[:,-1,:]\\n\\n epoch_loss /= (batch_num + 1)\\n\\n return epoch_loss, acc\",\n \"def MakeSamplesFromTrainOutput(metadata, output, elapsed_seconds, step):\\n samples = []\\n metadata_copy = metadata.copy()\\n metadata_copy['step'] = int(step)\\n metadata_copy['epoch'] = step / metadata['num_examples_per_epoch']\\n metadata_copy['elapsed_seconds'] = elapsed_seconds\\n\\n get_mean = lambda matches: sum(float(x) for x in matches) / len(matches)\\n loss = get_mean(regex_util.ExtractAllMatches(\\n r'Loss for final step: (\\\\d+\\\\.\\\\d+)', output))\\n samples.append(sample.Sample('Loss', float(loss), '', metadata_copy))\\n\\n if 'global_step/sec: ' in output:\\n global_step_sec = get_mean(regex_util.ExtractAllMatches(\\n r'global_step/sec: (\\\\S+)', output))\\n samples.append(sample.Sample(\\n 'Global Steps Per Second', global_step_sec,\\n 'global_steps/sec', metadata_copy))\\n examples_sec = global_step_sec * metadata['train_batch_size']\\n if 'examples/sec: ' in output:\\n examples_sec_log = get_mean(regex_util.ExtractAllMatches(\\n r'examples/sec: (\\\\S+)', output))\\n precision = abs(examples_sec_log - examples_sec) / examples_sec_log\\n assert precision < EXAMPLES_PER_SECOND_PRECISION, 'examples/sec is wrong.'\\n examples_sec = examples_sec_log\\n samples.append(sample.Sample('Examples Per Second', examples_sec,\\n 'examples/sec', metadata_copy))\\n return samples\",\n \"def _train_epoch(self, epoch):\\n self.model.train()\\n self.train_metrics.reset()\\n for batch_idx, (data, target_seg, target_class) in enumerate(self.data_loader):\\n data, target_seg, target_class = data.to(self.device), target_seg.to(self.device), target_class.to(self.device)\\n\\n self.optimizer.zero_grad()\\n output_seg, output_class = self.model(data)\\n loss = self.criterion((output_seg, output_class), target_seg, target_class, epoch)\\n loss.backward()\\n self.optimizer.step()\\n\\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\\n self.train_metrics.update('loss', loss.item())\\n for met in self.metric_ftns:\\n if met.__name__ == \\\"accuracy\\\":\\n self.train_metrics.update(met.__name__, met(output_class, target_class))\\n else:\\n self.train_metrics.update(met.__name__, met(output_seg, target_seg))\\n\\n if batch_idx % self.log_step == 0:\\n self.logger.debug('Train Epoch: {} {} Loss: {:.6f}'.format(\\n epoch,\\n self._progress(batch_idx),\\n loss.item()))\\n\\n self._visualize_input(data.cpu())\\n\\n if batch_idx == self.len_epoch:\\n break\\n log = self.train_metrics.result()\\n\\n if self.do_validation:\\n val_log = self._valid_epoch(epoch)\\n log.update(**{'val_'+k : v for k, v in val_log.items()})\\n\\n if self.lr_scheduler is not None:\\n self.lr_scheduler.step()\\n\\n return log\",\n \"def run_epoch(data_iter, model, loss_compute, ctx):\\r\\n start = time.time()\\r\\n total_tokens = 0\\r\\n total_loss = 0\\r\\n tokens = 0\\r\\n for i, batch in enumerate(data_iter):\\r\\n out = model(batch.src, batch.trg, batch.src_mask, batch.trg_mask)\\r\\n loss = loss_compute(out, batch.trg_y, batch.ntokens)\\r\\n total_loss += loss\\r\\n total_tokens += batch.ntokens\\r\\n tokens += batch.ntokens\\r\\n if i % 50 == 1:\\r\\n elapsed = time.time() - start\\r\\n ctx.logger.info(\\\"Epoch Step: %d Loss: %f Tokens per Sec: %f\\\",\\r\\n i, loss / batch.ntokens, tokens / elapsed)\\r\\n start = time.time()\\r\\n tokens = 0\\r\\n return total_loss / total_tokens\",\n \"def on_epoch_end(self, epoch, logs=None):\",\n \"def on_epoch_end(self, epoch, logs=None):\",\n \"def run_epoch(session, model, eval_op=None, verbose=False, epoch_size=1):\\n start_time = time.time()\\n all_words = 0\\n costs = 0.0\\n predicts = []\\n\\n fetches = {\\n \\\"cost\\\": model.cost,\\n \\\"mask\\\": model.mask,\\n \\\"predict\\\": model.predicts,\\n \\\"seqlen\\\": model.seq_len,\\n \\\"loss\\\": model.loss,\\n \\\"label\\\": model.label,\\n \\\"label_flat\\\": model.label_flat,\\n \\\"not_space\\\": model.not_space\\n }\\n if eval_op is not None:\\n fetches[\\\"eval_op\\\"] = eval_op\\n # if debug:\\n # fetches[\\\"inputs\\\"] = model.Dinputs\\n # fetches[\\\"states\\\"] = model.Dstates\\n # fetches[\\\"outputs\\\"] = model.Doutput\\n\\n logging.info(\\\"Epoch size: %d\\\" % epoch_size) \\n print_idx = 0\\n for step in range(epoch_size):\\n vals = session.run(fetches)\\n cost = vals[\\\"cost\\\"]\\n mask = vals[\\\"mask\\\"]\\n predict = vals[\\\"predict\\\"]\\n label = vals[\\\"label\\\"]\\n np.set_printoptions(threshold=np.nan)\\n \\n if eval_op is None:\\n \\n # if step > 497:\\n # #for i in range(len(mask)):\\n # # print(mask[i])\\n # print(np.sum(mask, axis=1))\\n # print(vals[\\\"seqlen\\\"])\\n mask = np.array(np.round(mask), dtype=np.int32)\\n shape = mask.shape\\n # if step > 10 and step < 20:\\n # print(predict)\\n # print(np.argmax(predict, 1))\\n predict = np.reshape(np.argmax(predict, 1), shape).tolist()\\n mask = np.sum(mask, axis=1).tolist()\\n for i in range(shape[0]):\\n predicts.append(predict[i][:mask[i]])\\n\\n costs += cost\\n words = np.sum(mask)\\n all_words += words\\n\\n if epoch_size < 100:\\n verbose = False\\n\\n if (step * 10 / epoch_size) > print_idx and eval_op is not None:\\n print_idx = step * 10 / epoch_size + 1\\n logging.info(\\\"%.3f perplexity: %.3f speed: %.0f wps\\\" %\\n (step * 1.0 / epoch_size, np.exp(costs / step),\\n num_gpus * all_words / (time.time() - start_time)))\\n predict = np.argmax(predict, 1)\\n label_flat = np.reshape(label, [-1])\\n all_label_equal = np.equal(predict, label_flat)\\n not_space_label = np.not_equal(label_flat, np.zeros(np.shape(label_flat)))\\n not_space_equal = all_label_equal * not_space_label\\n not_space_label_count = np.sum(not_space_label)\\n not_space_equal_count = np.sum(not_space_equal)\\n none_space_accuracy = not_space_equal_count / not_space_label_count\\n logging.info(\\\"not space label: %d\\\" % not_space_label_count)\\n logging.info(\\\"not space correct: %d\\\" % not_space_equal_count)\\n logging.info(\\\"not space accuracy: %.3f\\\" % none_space_accuracy)\\n logging.info(\\\"cost: %.3f\\\" % (costs / step))\\n if np.isnan(np.exp(costs / step)):\\n print(\\\"perplexity is nan\\\")\\n print(\\\"cost: %f step: %d\\\" % (costs, step))\\n return np.exp(costs / step)\\n\\n if eval_op is None:\\n predict = np.reshape(predict, [-1])\\n label_flat = np.reshape(label, [-1])\\n all_label_equal = np.equal(predict, label_flat)\\n not_space_label = np.not_equal(label_flat, np.zeros(np.shape(label_flat)))\\n not_space_equal = all_label_equal * not_space_label\\n not_space_label_count = np.sum(not_space_label)\\n not_space_equal_count = np.sum(not_space_equal)\\n none_space_accuracy = not_space_equal_count / not_space_label_count\\n logging.info(\\\"not space label: %d\\\" % not_space_label_count)\\n logging.info(\\\"not space correct: %d\\\" % not_space_equal_count)\\n logging.info(\\\"not space accuracy: %.3f\\\" % none_space_accuracy)\\n logging.info(\\\"cost: %.3f\\\" % (costs / step))\\n return np.exp(costs / epoch_size), predicts\\n # elif get_post:\\n # # Keep in mind, when get_post, num_steps=1, batch_size=1\\n # return np.exp(costs / iters), posteriors\\n else:\\n return np.exp(costs / epoch_size)\",\n \"def evaluate_epoch(eval_dl, model, criterion, epoch, writer):\\n device = next(model.parameters()).device\\n\\n model.eval()\\n loss = 0\\n correct = 0\\n with torch.no_grad():\\n for idx, (image, target) in enumerate(eval_dl):\\n image = image.to(device, non_blocking=True)\\n target = target.to(device, non_blocking=True)\\n output = model(image)\\n loss += criterion(output, target).item()\\n\\n pred = output.argmax(dim=1, keepdim=True) # get the index of the max log-probability\\n correct += pred.eq(target.view_as(pred)).sum().item()\\n\\n loss /= len(eval_dl.dataset) / eval_dl.batch_size\\n val_acc = 100. * correct / len(eval_dl.dataset)\\n print('\\\\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\\\n'.format(\\n loss, correct, len(eval_dl.dataset),\\n 100. * correct / len(eval_dl.dataset)))\\n writer.add_scalar('loss/val', loss, len(eval_dl) * epoch)\\n writer.add_scalar('acc/val', correct / len(eval_dl.dataset), epoch)\\n\\n return val_acc\",\n \"def compute_metrics(self):\\n self.finalize_output_dict()\\n self.metric_dict = {\\n key: value(self.output_dict[\\\"labels\\\"], self.output_dict[\\\"pred_probs\\\"])\\n for key, value in self.metric_fns.items()\\n }\",\n \"def step(self):\\n fit_default_config = {\\\"verbose\\\": self.verbose}\\n fit_default_config.update(self.config.get(\\\"fit_config\\\", {}))\\n\\n history = self.model.fit(self.train_dataset, **fit_default_config)\\n if history is None:\\n stats = {}\\n else:\\n stats = {\\\"train_\\\" + k: v[-1] for k, v in history.history.items()}\\n\\n self.epoch += 1\\n return stats\",\n \"def epoch_diagnostics(self, train_loss, train_err, test_loss, test_err):\\n m = self.nbatches\\n logging.info(\\\"Epoch diagnostics computation\\\")\\n\\n layernum = 0\\n layer_gradient_norm_sqs = []\\n gavg_norm_acum = 0.0\\n gavg_acum = []\\n for group in self.param_groups:\\n for p in group['params']:\\n\\n layer_gradient_norm_sqs.append([])\\n gavg = self.state[p]['gavg'].cpu()\\n gavg_acum.append(gavg.numpy())\\n gavg_norm_acum += gavg.norm()**2 #torch.dot(gavg, gavg)\\n layernum += 1\\n\\n gradient_norm_sqs = []\\n vr_step_variance = []\\n cos_acums = []\\n variances = []\\n\\n for batch_id in range(m):\\n norm_acum = 0.0\\n ginorm_acum = 0.0\\n vr_acum = 0.0\\n layernum = 0\\n cos_acum = 0.0\\n var_acum = 0.0\\n for group in self.param_groups:\\n for p in group['params']:\\n param_state = self.state[p]\\n\\n gktbl = param_state['gktbl']\\n gavg = param_state['gavg'].type_as(p.data).cpu()\\n\\n gi = gktbl[batch_id, :]\\n var_norm_sq = (gi-gavg).norm()**2 #torch.dot(gi-gavg, gi-gavg)\\n norm_acum += var_norm_sq\\n ginorm_acum += gi.norm()**2 #torch.dot(gi, gi)\\n layer_gradient_norm_sqs[layernum].append(var_norm_sq)\\n\\n gktbl_old = param_state['gktbl_old']\\n gavg_old = param_state['gavg_old'].type_as(p.data).cpu()\\n gi_old = gktbl_old[batch_id, :]\\n #pdb.set_trace()\\n vr_step = gi - gi_old + gavg_old\\n vr_acum += (vr_step - gavg).norm()**2 #torch.dot(vr_step - gavg, vr_step - gavg)\\n cos_acum += torch.sum(gavg*gi)\\n\\n var_acum += (gi - gavg).norm()**2\\n\\n layernum += 1\\n gradient_norm_sqs.append(norm_acum)\\n vr_step_variance.append(vr_acum)\\n cosim = cos_acum/math.sqrt(ginorm_acum*gavg_norm_acum)\\n #pdb.set_trace()\\n cos_acums.append(cosim)\\n variances.append(var_acum)\\n\\n variance = sum(variances)/len(variances)\\n\\n print(\\\"mean cosine: {}\\\".format(sum(cos_acums)/len(cos_acums)))\\n\\n #pdb.set_trace()\\n\\n with open('stats/{}fastdiagnostics_epoch{}.pkl'.format(self.test_name, self.epoch), 'wb') as output:\\n pickle.dump({\\n 'train_loss': train_loss,\\n 'train_err': train_err,\\n 'test_loss': test_loss,\\n 'test_err': test_err,\\n 'epoch': self.epoch,\\n #'layer_gradient_norm_sqs': layer_gradient_norm_sqs,\\n #'gradient_norm_sqs': gradient_norm_sqs,\\n #'vr_step_variance': vr_step_variance,\\n #'cosine_distances': cos_acums,\\n #'variances': variances,\\n 'variance': variance,\\n #'gavg_norm': gavg_norm_acum,\\n #'gavg': gavg_acum,\\n #'iterate_distances': self.inrun_iterate_distances,\\n #'grad_distances': self.inrun_grad_distances,\\n }, output)\\n print(\\\"Epoch diagnostics saved\\\")\\n #pdb.set_trace()\\n\\n self.inrun_iterate_distances = []\\n self.inrun_grad_distances = []\",\n \"def run_validation(self):\\n stats = {'loss': 0,\\n 'accuracy': 0,\\n 'time_error': 0,\\n 'location_error': np.zeros(3),\\n 'total_pts': 0,\\n 'scatter': []}\\n run_variables = [self.loss, self.conf, self.occ, self.occ_t, self.occ_loc, self.output['time'],\\n self.output['location']]\\n\\n self.session.run(self.val_init)\\n while True:\\n try:\\n (loss, confidences, occurrences, times,\\n locations, time_output, location_output) = self.session.run(run_variables)\\n n_pts = confidences.shape[0]\\n stats['loss'] += loss * n_pts\\n stats['accuracy'] += np.sum(np.round(confidences) == occurrences)\\n stats['time_error'] += np.sum(np.abs(times-time_output))\\n stats['location_error'] += np.sum(np.abs(times - time_output), axis=0)\\n stats['scatter'].append(location_output - locations)\\n stats['total_pts'] += n_pts\\n except tf.errors.OutOfRangeError:\\n stats['loss'] /= stats['total_pts']\\n stats['accuracy'] /= stats['total_pts']\\n stats['time_error'] /= stats['total_pts']\\n stats['location_error'] /= stats['total_pts']\\n stats['scatter'] = np.concatenate(stats['scatter'], axis=0)\\n return stats\",\n \"def on_epoch_end(self):\\n self.epoch += 1\\n metric = self.metric_fn()\\n if metric < self.best:\\n self.best = metric\\n self.count = 0\\n else:\\n self.count += 1\\n if self.count > self.patience:\\n self.model.stop_training()\\n if self.verbose:\\n print(self.name+' after '+str(self.epoch)+' epochs')\",\n \"def _train_epoch(self, epoch):\\n self.model.train()\\n\\n\\n total_loss = 0\\n total_metrics = np.zeros(len(self.metrics))\\n length = len(self.data_loader)\\n total_pm25_loss = 0\\n total_pm10_loss = 0\\n pm25_loss = 0\\n pm10_loss = 0\\n\\n for batch_idx, (data, target) in enumerate(self.data_loader):\\n data, target = data.to(self.device), target.to(self.device)\\n\\n self.optimizer.zero_grad()\\n output = self.model(data)\\n # print(output.shape, target.shape)\\n target = target.squeeze()\\n model_loss = self.loss(output, target)\\n\\n # print(output.shape, target.shape)\\n # pm25_predict, pm10_predict = torch.chunk(output, 2, dim=1)\\n # pm25_target, pm10_target = torch.chunk(target, 2, dim=1)\\n # pm25_loss = self.loss(pm25_predict, pm25_target)\\n # pm10_loss = self.loss(pm10_predict, pm10_target)\\n # total_pm25_loss += pm25_loss.item()\\n # total_pm10_loss += pm10_loss.item()\\n\\n l2_reg = torch.tensor(0.0).to(self.device)\\n if self.config['trainer']['l2_regularization']:\\n for param in self.model.parameters():\\n l2_reg += torch.norm(param, p=2)\\n loss = model_loss + self.config['trainer']['l2_lambda'] * l2_reg\\n else:\\n loss = model_loss\\n\\n loss.backward()\\n # torch.nn.utils.clip_grad_norm(self.model.parameters(), 1)\\n self.optimizer.step()\\n\\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\\n self.writer.add_scalar('loss', loss.item())\\n total_loss += loss.item()\\n # total_metrics += self._eval_metrics(output, target)\\n\\n if batch_idx % self.log_step == 0:\\n self.logger.debug('Train Epoch: {} {} Loss: {:.6f} model_loss: {:.6f} pm25_loss {:.6f} pm10_loss {:.6f} l2_loss: {:.6f}'.format(\\n epoch,\\n self._progress(batch_idx),\\n loss.item(),\\n model_loss.item(),\\n pm25_loss,\\n pm10_loss,\\n l2_reg.item()))\\n\\n if batch_idx == self.len_epoch:\\n break\\n\\n log = {\\n 'loss': total_loss / length,\\n 'rmse_pm25_loss': np.sqrt(total_pm25_loss / length),\\n 'rmse_pm10_loss': np.sqrt(total_pm10_loss / length)\\n }\\n\\n\\n val_log = self._valid_epoch(epoch)\\n log.update(val_log)\\n\\n if self.lr_scheduler is not None:\\n self.lr_scheduler.step(val_log['val_loss'])\\n\\n return log\",\n \"def get_output_stats(self, output):\\n\\t\\ttype_dict = {}\\n\\t\\ttype_full_dict = {}\\n\\t\\ttotal = 0\\n\\t\\tfor key in output.keys():\\n\\t\\t\\tif output[key]['deleted'] == \\\"0\\\":\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\ttype_dict[output[key]['type']] += 1\\n\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\ttype_dict[output[key]['type']] = 1\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\ttype_full_dict[output[key]['type_full']] += 1\\n\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\ttype_full_dict[output[key]['type_full']] = 1\\n\\t\\t\\t\\ttotal += 1\\n\\t\\tfinal_stats = {}\\n\\t\\tfor key in type_dict.keys():\\n\\t\\t\\tfinal_stats[key + \\\"(\\\" + str(type_dict[key]) + \\\"/\\\" + str(int(np.rint((type_dict[key]/total)*100))) + \\\"%)\\\"] = {'count': type_dict[key], 'percent_of_total': (type_dict[key]/total)*100}\\n\\t\\t\\tfor k in type_full_dict.keys():\\n\\t\\t\\t\\tif k == None:\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\telif k.startswith(key):\\n\\t\\t\\t\\t\\tfinal_stats[key + \\\"(\\\" + str(type_dict[key]) + \\\"/\\\" + str(int(np.rint((type_dict[key]/total)*100))) + \\\"%)\\\"][k + \\\"(\\\" + str(type_full_dict[k]) + \\\"/\\\" + str(int(np.rint((type_full_dict[k]/total)*100))) + \\\"%)\\\"] = {'count': type_full_dict[k], 'percent_of_total': (type_full_dict[k]/total)*100, 'percent_of_' + key + '(s)': (type_full_dict[k]/type_dict[key])*100}\\n\\t\\treturn (final_stats, total)\",\n \"def _collect_stats(self, trainer: pl.Trainer, pl_module: AnomalyModule) -> None:\\n predictions = Trainer(accelerator=trainer.accelerator, devices=trainer.num_devices).predict(\\n model=self._create_inference_model(pl_module), dataloaders=trainer.datamodule.train_dataloader()\\n )\\n pl_module.normalization_metrics.reset()\\n for batch in predictions:\\n if \\\"pred_scores\\\" in batch.keys():\\n pl_module.normalization_metrics.update(anomaly_scores=batch[\\\"pred_scores\\\"])\\n if \\\"anomaly_maps\\\" in batch.keys():\\n pl_module.normalization_metrics.update(anomaly_maps=batch[\\\"anomaly_maps\\\"])\\n pl_module.normalization_metrics.compute()\",\n \"def train_epoch(self, epoch, evaluator, optimizer, perf_path, perf_trace, state_fpath, writer_tensorboard):\\n\\n # Train an epoch\\n self.model.train()\\n print('Start epoch', epoch)\\n train_itr = iter(self.loader_train)\\n total_err = 0\\n total_acc = 0\\n\\n for index, (data_pixel, data_labels) in enumerate(train_itr):\\n\\n # compute\\n input_data = data_pixel.float().cuda()\\n data_labels = data_labels.cuda()\\n\\n # Use the model the produce the classification\\n grapheme_logits, vowel_logits, consonant_logits = self.model(input_data)\\n\\n # produce evaluator results\\n eval_result = evaluator(grapheme_logits, vowel_logits, consonant_logits, data_labels)\\n\\n # set optimizer to zero.\\n optimizer.zero_grad()\\n\\n # back propogate the evaluation results.\\n eval_result['loss'].backward()\\n\\n # optimizer take step forward.\\n optimizer.step()\\n\\n # tabulate the steps from the evaluation\\n eval_result = {k: eval_result[k].item() for k in eval_result}\\n\\n # update every hundreds' of\\n if index % 100 == 0:\\n print(index, eval_result['loss'], eval_result['acc'])\\n train_result = evaluator.evalulate_on_cache()\\n train_total_err = train_result['loss']\\n writer_tensorboard.add_scalar('Loss/Train', train_total_err, global_step=epoch)\\n # log_metric('loss', train_total_err)\\n train_total_acc = train_result['acc']\\n writer_tensorboard.add_scalar('Accuracy/Train', train_total_acc, global_step=epoch)\\n # log_metric('acc', train_total_acc)\\n train_kaggle_score = train_result['kaggle_score']\\n writer_tensorboard.add_scalar('Kaggle_Score/Train', train_kaggle_score, global_step=epoch)\\n # log_metric('kaggle_score', train_kaggle_score)\\n dict_metrics_train = {\\n 'Loss/Train': train_total_err,\\n 'Accuracy/Train': train_total_acc,\\n 'Kaggle_Score/Train': train_kaggle_score,\\n }\\n log_metrics(dict_metrics_train, step=epoch)\\n print(f\\\"Epoch {epoch} Training, Loss {train_total_err}, Acc {train_total_acc}\\\")\\n evaluator.clear_cache()\\n # compute validation error\\n self.model.eval()\\n val_itr = iter(self.loader_val)\\n with torch.no_grad():\\n for index, (data_pixel, data_labels) in enumerate(val_itr):\\n input_data = data_pixel.float().cuda()\\n data_labels = data_labels.cuda()\\n grapheme_logits, vowel_logits, consonant_logits = self.model(input_data)\\n eval_result = evaluator(grapheme_logits, vowel_logits, consonant_logits, data_labels)\\n eval_result = {k: eval_result[k].item() for k in eval_result}\\n total_err += eval_result['loss']\\n total_acc += eval_result['acc']\\n # print(total_err / (1 + input_index), total_acc / (1 + input_index))\\n val_result = evaluator.evalulate_on_cache()\\n val_total_err = val_result['loss']\\n writer_tensorboard.add_scalar('Loss/Val', val_total_err, global_step=epoch)\\n val_total_acc = val_result['acc']\\n writer_tensorboard.add_scalar('Accuracy/Val', val_total_acc, global_step=epoch)\\n val_kaggle_score = val_result['kaggle_score']\\n writer_tensorboard.add_scalar('Kaggle_Score/Val', val_kaggle_score, global_step=epoch)\\n dict_metrics_val = {\\n 'Loss/Validation': val_total_err,\\n 'Accuracy/Validation': val_total_acc,\\n 'Kaggle_Score/Validation': val_kaggle_score,\\n }\\n log_metrics(dict_metrics_val, step=epoch)\\n # Write to disk.\\n writer_tensorboard.flush()\\n print(f\\\"Epoch {epoch} Eval, Loss {val_total_err}, Acc {val_total_acc}\\\")\\n evaluator.clear_cache()\\n print(\\\"Saving the model (epoch %d)\\\" % epoch)\\n torch.save({\\n \\\"epoch\\\": epoch + 1,\\n \\\"model_state\\\": self.model.state_dict(),\\n \\\"optimizer_state\\\": optimizer.state_dict(),\\n }, state_fpath)\\n print(f\\\"Making a backup (step {epoch})\\\")\\n backup_fpath = os.path.join(self.backup_dir, f\\\"model_bak_{epoch}.pt\\\")\\n torch.save({\\n \\\"epoch\\\": epoch + 1,\\n \\\"model_state\\\": self.model.state_dict(),\\n \\\"optimizer_state\\\": optimizer.state_dict(),\\n }, backup_fpath)\\n # Dump the traces\\n perf_trace.append(\\n {\\n 'epoch': epoch,\\n 'train_err': train_total_err,\\n 'train_acc': train_total_acc,\\n 'train_kaggle_score': train_kaggle_score,\\n 'val_err': val_total_err,\\n 'val_acc': val_total_acc,\\n 'val_kaggle_score': val_kaggle_score\\n }\\n )\\n pickle.dump(perf_trace, open(perf_path, 'wb'))\\n # store epoch full result separately\\n epoch_result = {\\n 'epoch': epoch,\\n 'train_result': train_result,\\n 'val_result': val_result\\n }\\n pickle.dump(epoch_result, open(os.path.join(self.results_dir, 'result_epoch_{0}.p'.format(epoch)), 'wb'))\",\n \"def on_epoch_end(self):\\n if self.shuffle:\\n np.random.shuffle(self.statistics)\\n self.mapping = self.__build_mapping()\",\n \"def epoch_end(self, run_context):\\n cb_params = run_context.original_args()\\n result = self.model.eval(self.ds_eval)\\n print(\\\"result:\\\", result)\\n if result['top_1_accuracy'] > self.top1:\\n self.top1 = result['top_1_accuracy']\\n file_name = 'attention_cluster_{}_{}.ckpt'.format(self.config.fc, self.config.natt)\\n save_checkpoint(save_obj=cb_params.train_network,\\n ckpt_file_name=os.path.join(self.config.result_dir, file_name))\\n print(\\\"Best checkpoint saved!\\\")\",\n \"def on_validation_epoch_end(self) -> None:\\n self.log_dict(self.val_metrics.compute())\\n self.val_metrics.reset()\",\n \"def evaluate_epoch(eval_dl, model, criterion, epoch, writer):\\n print('\\\\neval epoch {}'.format(epoch))\\n device = next(model.parameters()).device\\n\\n model.eval()\\n recall = Recall(lambda x: (x[0], x[1]))\\n precision = Precision(lambda x: (x[0], x[1]))\\n mean_recall = []\\n mean_precision = []\\n mean_loss = []\\n with torch.no_grad():\\n for idx, (inputs, targets) in enumerate(eval_dl):\\n inputs, targets = inputs.to(device), targets.to(device)\\n outputs = model(inputs)\\n loss = criterion(outputs, targets)\\n\\n preds = outputs.argmax(1)\\n\\n precision.update((preds, targets))\\n recall.update((preds, targets))\\n mean_loss.append(loss.item())\\n mean_recall.append(recall.compute().item())\\n mean_precision.append(precision.compute().item())\\n\\n # print('val-epoch:{} [{}/{}], loss: {:5.3}'.format(epoch, idx + 1, len(dataloader), loss.item()))\\n writer.add_scalar('test/loss', loss.item(), len(eval_dl) * epoch + idx)\\n\\n mean_precision, mean_recall = np.array(mean_precision).mean(), np.array(mean_recall).mean()\\n f1 = mean_precision * mean_recall * 2 / (mean_precision + mean_recall + 1e-20)\\n\\n print('precision: {:07.5}, recall: {:07.5}, f1: {:07.5}\\\\n'.format(mean_precision, mean_recall, f1))\\n writer.add_scalar('test/epoch-loss', np.array(mean_loss).mean(), epoch)\\n writer.add_scalar('test/f1', f1, epoch)\\n writer.add_scalar('test/precision', mean_precision, epoch)\\n writer.add_scalar('test/recall', mean_recall, epoch)\",\n \"def train_visualization(output_path): \\n log_path = output_path + 'output.log'\\n Train_Cost, Valid_Cost, Test_Cost, Train_Acc, Valid_Acc, Test_Acc = log_reader(log_path)\\n n_epoch = len(Train_Cost)\\n\\n x1 = range(n_epoch)\\n x2 = range(n_epoch)\\n y1 = Train_Cost\\n y2 = Valid_Cost\\n y3 = Test_Cost\\n y4 = Train_Acc\\n y5 = Valid_Acc\\n y6 = Test_Acc\\n plt.subplot(2, 1, 1)\\n plt.plot(x1, y1, label=\\\"Train_Cost\\\", linewidth=2)\\n plt.plot(x1, y2, label=\\\"Valid_Cost\\\", linewidth=2)\\n plt.plot(x1, y3, label=\\\"Test_Cost\\\", linewidth=2)\\n\\n plt.title('binary cross entropy vs. epoches')\\n plt.ylabel('binary cross entropy')\\n plt.legend(loc='best')\\n plt.subplot(2, 1, 2)\\n plt.plot(x2, y4, label=\\\"Train_Acc\\\", linewidth=2)\\n plt.plot(x2, y5, label=\\\"Valid_Acc\\\", linewidth=2)\\n plt.plot(x2, y6, label=\\\"Test_Acc\\\", linewidth=2)\\n plt.xlabel('Accuracy@20 vs. epoches')\\n plt.ylabel('Accuracy@20')\\n plt.legend(loc='best')\\n plt.savefig(output_path + 'loss_fig.png')\\n # plt.show()\",\n \"def evaluate_epoch(\\n axes,\\n tr_loader,\\n val_loader,\\n te_loader,\\n model,\\n criterion,\\n epoch,\\n stats,\\n include_test=False,\\n update_plot=True,\\n multiclass=False,\\n):\\n\\n def _get_metrics(loader):\\n y_true, y_pred = [], []\\n # correct, total = 0, 0\\n\\n running_loss = []\\n\\n # for X, y in loader:\\n for i, batch in enumerate(loader):\\n with torch.no_grad():\\n print(\\\"evaluating... batch number\\\", i)\\n # X = torch.Tensor(batch[\\\"image\\\"]).to(\\\"cuda\\\")\\n # y = torch.Tensor(batch[\\\"depth\\\"]).to(device=\\\"cuda\\\")\\n X = torch.Tensor(batch[\\\"image\\\"])\\n y = torch.Tensor(batch[\\\"depth\\\"])\\n\\n output = model(X)\\n predicted = predictions(output.data)\\n y_true.append(y)\\n y_pred.append(predicted)\\n\\n # total += y.size(0)\\n\\n # correct += (predicted == y).sum().item()\\n\\n # Calculate the net loss of this batch\\n loss = criterion(predicted, y)\\n # gradient_loss = gradient_criterion(predicted, y, device=\\\"cuda\\\")\\n # running_loss.append(criterion(output, y).item())\\n running_loss.append(loss)\\n\\n y_true = torch.cat(y_true)\\n y_pred = torch.cat(y_pred)\\n\\n loss = np.mean(running_loss)\\n\\n acc = 0.9\\n auroc = 0.9\\n\\n return acc, loss, auroc\\n\\n print(\\\"evaluating training set...\\\")\\n train_acc, train_loss, train_auc = _get_metrics(tr_loader)\\n print(\\\"evaluating validation set\\\")\\n val_acc, val_loss, val_auc = _get_metrics(val_loader)\\n\\n stats_at_epoch = [\\n val_acc,\\n val_loss,\\n val_auc,\\n train_acc,\\n train_loss,\\n train_auc,\\n ]\\n if include_test:\\n print(\\\"evaluating testing set...\\\")\\n stats_at_epoch += list(_get_metrics(te_loader))\\n\\n stats.append(stats_at_epoch)\\n # utils.log_training(epoch, stats)\\n # if update_plot:\\n # utils.update_training_plot(axes, epoch, stats)\",\n \"def on_epoch_end(self, epoch, logs=None):\\n loss = None\\n acc = None\\n if self.x is not None and self.y is not None:\\n loss, acc = self.model.evaluate(x=self.x, y=self.y, batch_size=self.batch_size)\\n elif self.x is not None and self.y is None:\\n loss, acc = self.model.evaluate(x=self.x, steps=self.steps)\\n if logs:\\n self.epoch_iter += 1\\n f = open(self.log_file_path, \\\"a\\\")\\n f.write(\\\"ep {} - \\\"\\n \\\"rl : {} ;\\\"\\n \\\"racc : {} ;\\\"\\n \\\"l: {} ; \\\"\\n \\\"acc : {} ; \\\"\\n \\\"vl : {} ; \\\"\\n \\\"vacc : {}\\\\n\\\"\\n .format(self.epoch_iter, loss, acc, logs['loss'], logs['sparse_categorical_accuracy'] if self.acc_loss != \\\"std\\\" else logs['categorical_accuracy'],\\n logs['val_loss'],\\n logs['val_sparse_categorical_accuracy'] if self.acc_loss != \\\"std\\\" else logs['val_categorical_accuracy'])\\n )\\n f.close()\",\n \"def run_epoch( self ):\\n # --- Init Epoch ----\\n total_epoch_loss = 0.0\\n epoch_batches = self.dataset.dataloader( self.config.neuron.epoch_length )\\n progress_bar = qqdm(enumerate(epoch_batches), total=len(epoch_batches), desc=format_str('blue', f'Epoch Progress'))\\n for iteration, (inputs) in progress_bar:\\n\\n # ---- Forward / Backward ----\\n prev_mechanism_weights = self.mechanism_weights.tolist()\\n output = self.train ( batch = { 'inputs': inputs } )\\n next_mechanism_weights = self.mechanism_weights.tolist()\\n total_epoch_loss += output.local_target_loss.item()\\n\\n # ---- Logs ----\\n self.epoch_logs (\\n progress_bar,\\n iteration = iteration,\\n output = output,\\n prev_mechanism_weights = prev_mechanism_weights,\\n next_mechanism_weights = next_mechanism_weights\\n )\\n self.global_step += 1\\n\\n self.epoch_loss = total_epoch_loss / self.config.neuron.epoch_length\\n self.epoch += 1\",\n \"def valid_epoch(self, epoch):\\n device_mapper = self.device_mapper\\n self.model.eval()\\n self.valid_metrics.reset()\\n targets = []\\n outputs = []\\n with torch.no_grad():\\n for batch_idx, data in enumerate(self.valid_data_loader):\\n data = device_mapper.map_modules(data, non_blocking=True)\\n\\n output = self.model(data)\\n loss = self.loss(output, data)\\n\\n self.writer.set_step((epoch - 1) * len(self.valid_data_loader) + batch_idx, 'valid')\\n self.valid_metrics.update('loss', loss.item(), batch_size=output.size(0))\\n for met in self.metrics:\\n self.valid_metrics.update(met.name(), met(output, data), batch_size=output.size(0))\\n\\n if self.add_roc_auc:\\n if not self.softmax:\\n outputs.append(torch.sigmoid(output).cpu().numpy().reshape(-1))\\n else:\\n outputs.append(torch.nn.functional.softmax(output, dim=1)[:, 1].cpu().numpy().reshape(-1))\\n targets.append(data['target'].cpu().numpy().reshape(-1))\\n\\n if self.add_roc_auc:\\n outputs = np.concatenate(outputs)\\n targets = np.concatenate(targets)\\n score = roc_auc_score(targets, outputs)\\n # size doesn't matter here, it's a global metric not per batch\\n self.valid_metrics.update('roc_auc', score, batch_size=1)\\n\\n return self.valid_metrics.result()\",\n \"def see_evaluation(epoch, training_acc, test_acc):\\n print (\\\"Epoch \\\", epoch, \\\"Training acc: \\\", training_acc*100, \\\"Test acc: \\\", test_acc*100)\",\n \"def on_predict_batch_end(\\n self,\\n trainer: pl.Trainer,\\n pl_module: AnomalyModule,\\n outputs: dict,\\n batch: Any,\\n batch_idx: int,\\n dataloader_idx: int,\\n ) -> None:\\n del trainer, batch, batch_idx, dataloader_idx # These variables are not used.\\n\\n self._standardize_batch(outputs, pl_module)\\n self._normalize_batch(outputs, pl_module)\\n outputs[\\\"pred_labels\\\"] = outputs[\\\"pred_scores\\\"] >= 0.5\",\n \"def run_epoch(self, epoch, data_loader, training=False):\\n if training:\\n self.model.train()\\n else:\\n self.model.eval()\\n\\n epoch_metrics = {\\\"loss\\\": 0.0}\\n overall_parsing_counts = {\\\"correct\\\": 0, \\\"predicted\\\": 0, \\\"gold\\\": 0}\\n num_evaluated_batches = 0\\n\\n with torch.set_grad_enabled(training):\\n for sentences, target in data_loader:\\n # Run model\\n target = self._to_device(target)\\n output, parsing_counts = self.parser.evaluate_batch(sentences)\\n\\n # Compute loss\\n output, target = self._unroll_sequence_batch(output), self._unroll_sequence_batch(target)\\n loss = self.criterion(output, target)\\n\\n # Add metrics to overall total\\n epoch_metrics[\\\"loss\\\"] += loss.item()\\n for count in \\\"gold\\\", \\\"predicted\\\", \\\"correct\\\":\\n overall_parsing_counts[count] += parsing_counts[count]\\n\\n # Perform backpropagation (when training)\\n if training:\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # Print progress\\n num_evaluated_batches += 1\\n self.logger.debug('{} Epoch: {} {} Loss: {:.6f}'.format(\\n \\\"Training\\\" if training else \\\"Validation\\\",\\n epoch,\\n self._progress(num_evaluated_batches, data_loader),\\n loss.item()))\\n\\n epoch_metrics.update(self.compute_prf(overall_parsing_counts))\\n\\n return epoch_metrics\",\n \"def after_pred(self):\\n # If training then skip\\n if self.training:\\n return\\n\\n # Get ground truths in epoch 0 i.e. start of training\\n if self.epoch == 0:\\n self.y_true.extend(self.y.cpu().flatten().numpy())\\n\\n # Get predictions from each batch and add them to prediction container\\n y_pred = self.pred.detach().cpu()\\n \\n self.y_pred.extend(y_pred.flatten().numpy())\",\n \"def _evaluate_epoch(X_train, y_train, X_val, y_val, model, criterion, epoch):\\n\\n #this function is inspired by an EECS 445 project done by Justin Weilbach\\n\\n print('evaluating epoch')\\n correct, total = 0, 0\\n running_loss = []\\n for i, image in enumerate(X_train):\\n with torch.no_grad():\\n label = y_train[i]\\n label = torch.from_numpy(np.asarray(label))\\n label = label.type(torch.LongTensor)\\n label = torch.tensor([label])\\n\\n image = torch.from_numpy(image)\\n image = image.type(torch.FloatTensor)\\n image = image.unsqueeze(0)\\n\\n output = model(image)\\n total += label.size(0)\\n\\n label = label.float()\\n correct_output = np.argmax(output)\\n if float(label) == float(correct_output):\\n correct += 1\\n\\n label = label.long()\\n running_loss.append(criterion(output, label).item())\\n\\n train_loss = np.mean(running_loss)\\n train_acc = correct / total\\n print('training loss: ' + str(train_loss))\\n print('train acc: ' + str(train_acc))\\n correct, total = 0, 0\\n running_loss = []\\n for i, image in enumerate(X_val):\\n with torch.no_grad():\\n label = y_val[i]\\n label = torch.from_numpy(np.asarray(label))\\n label = label.type(torch.LongTensor)\\n label = torch.tensor([label])\\n\\n image = torch.from_numpy(image)\\n image = image.type(torch.FloatTensor)\\n image = image.unsqueeze(0)\\n\\n output = model(image)\\n total += label.size(0)\\n\\n label = label.float()\\n correct_output = np.argmax(output)\\n if float(label) == float(correct_output):\\n correct += 1\\n\\n label = label.long()\\n running_loss.append(criterion(output, label).item())\\n\\n val_loss = np.mean(running_loss)\\n val_acc = correct / total\\n print('val loss: ' + str(val_loss))\\n print('val acc: ' + str(val_acc))\\n \\n return val_loss, train_loss, val_acc, train_acc\",\n \"def on_epoch_end(self, epoch: int, logs: dict):\\n loss = logs[\\\"loss\\\"]\\n original = logs[\\\"original\\\"]\\n reconstructed = logs[\\\"reconstructed\\\"]\\n\\n col_count = min(original.shape[0], 10)\\n figure, axes = plt.subplots(3, col_count, figsize=(15, 5))\\n\\n # these are the layers to show histograms\\n for bins_col in range(len(self.layer_names)):\\n\\n # get the layer\\n layer = self.model.get_layer(self.layer_names[bins_col])\\n\\n # set the title for the plot\\n axes[0][bins_col].set_title(layer.name)\\n\\n # extract the kernels weights\\n kernel_weights = [\\n kernel\\n for kernel in layer.trainable_variables\\n if \\\"kernel\\\" in kernel.name\\n ][0]\\n\\n axes[0][bins_col].hist(kernel_weights.numpy().reshape(-1))\\n\\n quantiles = [0.05, 0.95]\\n for n in range(col_count):\\n q_test = np.quantile(original[n], quantiles)\\n axes[1][n].imshow(original[n], cmap=\\\"gray\\\", vmin=q_test[0], vmax=q_test[1])\\n\\n reshape_test_image = np.reshape(reconstructed[n], (64, 64))\\n reshape_test_image = resize(\\n reshape_test_image, (256, 256), order=3, anti_aliasing=True\\n )\\n\\n q_re = np.quantile(reshape_test_image, quantiles)\\n\\n if self.filter_test_image:\\n reshape_test_image -= q_re[0]\\n reshape_test_image /= q_re[1] - q_re[0]\\n\\n filtered_test_image = anisotropic_diffusion_(\\n reshape_test_image, niter=20, kappa=0.1, option=3, gradient_scale=8\\n )\\n axes[2][n].imshow(filtered_test_image, cmap=\\\"gray\\\", vmin=0.0, vmax=1.0)\\n else:\\n axes[2][n].imshow(\\n reshape_test_image, cmap=\\\"gray\\\", vmin=q_re[0], vmax=q_re[1]\\n )\\n\\n figure.suptitle(f\\\"Epoch {epoch}: loss={loss:0.2f}\\\")\\n\\n # make the save path, if needed\\n self.path.mkdir(parents=True, exist_ok=True)\\n\\n # save and close\\n figure.savefig(self.path / f\\\"{epoch}-figure.png\\\")\\n plt.close(figure)\",\n \"def _train_epoch(self, epoch):\\n self.model.train()\\n total_loss = 0\\n\\n self.logger.info('Train Epoch: {}'.format(epoch))\\n\\n for batch_idx, (data) in enumerate(self.train_loader):\\n start_it = time()\\n data = data.to(self.device)\\n\\n self.optimizer.zero_grad()\\n output = self.model(data)\\n if isinstance(output, tuple):\\n loss = self.model.loss(data, *output)\\n else:\\n loss = self.model.loss(data, output)\\n loss.backward()\\n self.optimizer.step()\\n\\n step = epoch * len(self.train_loader) + batch_idx\\n self.tb_writer.add_scalar('train/loss', loss.item(), step)\\n # self.comet_writer.log_metric('loss', loss.item(), step)\\n\\n total_loss += loss.item()\\n\\n end_it = time()\\n time_it = end_it - start_it\\n if batch_idx % self.log_step == 0:\\n self.logger.info(\\n ' > [{}/{} ({:.0f}%), {:.2f}s] Loss: {:.6f} '.format(\\n batch_idx * self.train_loader.batch_size + data.size(\\n 0),\\n len(self.train_loader.dataset),\\n 100.0 * batch_idx / len(self.train_loader),\\n time_it * (len(self.train_loader) - batch_idx),\\n loss.item()))\\n # grid = make_grid(data.cpu(), nrow=8, normalize=True)\\n # self.tb_writer.add_image('input', grid, step)\\n\\n self.logger.info(' > Total loss: {:.6f}'.format(\\n total_loss / len(self.train_loader)\\n ))\\n\\n return total_loss / len(self.train_loader)\",\n \"def process_outputs(self, data, output, save=True):\\n\\n pred_spline = output['pred_polys']\\n\\n # preds = self.spline.sample_point(pred_spline)\\n preds = pred_spline\\n torch.cuda.synchronize()\\n preds = preds.cpu().numpy()\\n\\n pred_spline = pred_spline.cpu()\\n pred_spline = pred_spline.numpy()\\n\\n instances = data['instance']\\n polys = []\\n results = []\\n for i, instance in enumerate(instances):\\n detection = defaultdict(float)\\n poly = preds[i]\\n poly = poly * data['patch_w'][i]\\n poly[:, 0] += data['starting_point'][i][0]\\n poly[:, 1] += data['starting_point'][i][1]\\n detection['image_id'] = instance['image_path']\\n img_h, img_w = instance['height'], instance['width']\\n\\n detection['poly'] = poly\\n detection['image_size'] = [img_w, img_h]\\n # pred_sp = pred_spline[i]\\n # pred_sp = pred_sp * data['patch_w'][i]\\n # pred_sp[:, 0] += data['starting_point'][i][0]\\n # pred_sp[:, 1] += data['starting_point'][i][1]\\n #\\n # instance['spline_pos'] = pred_sp.tolist()\\n\\n polys.append(poly)\\n\\n results.append(detection)\\n\\n\\n # if save:\\n\\n # predicted_poly = []\\n\\n\\n\\n # pred_mask = np.zeros((img_h, img_w), dtype=np.uint8)\\n # utils.draw_poly(pred_mask, poly.astype(np.int))\\n # predicted_poly.append(poly.tolist())\\n #\\n # # gt_mask = utils.get_full_mask_from_instance(\\n # # self.min_area,\\n # # instance)\\n #\\n # instance['my_predicted_poly'] = predicted_poly\\n # # instance_id = instance['instance_id']\\n # image_id = instance['image_id']\\n #\\n # pred_mask_fname = os.path.join(self.output_dir, '{}_pred.png'.format(image_id))\\n # instance['pred_mask_fname'] = os.path.relpath(pred_mask_fname, self.output_dir)\\n #\\n # # gt_mask_fname = os.path.join(self.output_dir, '{}_gt.png'.format(instance_id))\\n # # instance['gt_mask_fname'] = os.path.relpath(gt_mask_fname, self.output_dir)\\n #\\n # instance['n_corrections'] = 0\\n #\\n # info_fname = os.path.join(self.output_dir, '{}_info.json'.format(image_id))\\n #\\n # with warnings.catch_warnings():\\n # warnings.simplefilter(\\\"ignore\\\")\\n # sio.imsave(pred_mask_fname, pred_mask)\\n # # sio.imsave(gt_mask_fname, gt_mask)\\n #\\n # # print '==> dumping json'\\n # with open(info_fname, 'w') as f:\\n # json.dump(instance, f, indent=2)\\n\\n return results, polys\",\n \"def on_epoch_end(self):\\n self.current_params = self.model.posterior_mean(self.params)\\n self.current_epoch += 1\\n self.parameter_values += [self.current_params]\\n self.epochs += [self.current_epoch]\",\n \"def run_epoch_test(session, model, verbose=False):\\n # fetches = {\\\"ms\\\": model.dynamic_eval.global_ms()}\\n # vals = session.run(fetches)\\n # ms = vals[\\\"ms\\\"]\\n # s = np.sum(np.sqrt([x for x in ms]))\\n # print(s)\\n\\n\\n\\n start_time = time.time()\\n losses = 0.0\\n iters = 0\\n\\n # zeros initial state for all devices\\n state = []\\n for k in range(model.gpu_num):\\n state.append(session.run(model.initial_state(k)))\\n\\n # evaluate loss and final state for all devices\\n fetches = {\\\"loss\\\": model.loss}\\n\\n if config.dynamic_eval:\\n fetches[\\\"update_op\\\"] = model.dynamic_eval.update_op()\\n\\n\\n for k in range(model.gpu_num):\\n fetches[\\\"final_state%d\\\" % k] = model.final_state(k)\\n\\n for step in range(model.input.epoch_size):\\n # pass states between time batches\\n feed_dict = {}\\n for i in range(model.gpu_num):\\n gpu_state = model.initial_state(i)\\n for j, (c, h) in enumerate(gpu_state):\\n feed_dict[c] = state[i][j].c\\n feed_dict[h] = state[i][j].h\\n\\n vals = session.run(fetches, feed_dict)\\n\\n loss = vals[\\\"loss\\\"]\\n\\n for k in range(model.gpu_num):\\n state[k] = vals[\\\"final_state%d\\\" % k]\\n\\n losses += loss\\n iters += model.input.time_steps\\n\\n if verbose and step % (model.input.epoch_size // 10) == 0:\\n print(\\\"%.3f perplexity: %.3f bits: %.3f speed: %.0f wps\\\" %\\n (step * 1.0 / model.input.epoch_size, np.exp(losses / iters), np.log2(np.exp(losses / iters)),\\n iters * model.input.batch_size / (time.time() - start_time)))\\n\\n return np.exp(losses / iters)\",\n \"def on_epoch_begin(self, epoch, logs=None):\",\n \"def on_epoch_begin(self, epoch, logs=None):\",\n \"def run_epoch(session,\\n model,\\n dataset,\\n is_train=False,\\n plot_attention_weights=False):\\n assert dataset is not None\\n n_words = len([word for sample in dataset for word in sample if word > 0])\\n epoch_size = int(math.ceil(len(dataset) / model.batch_size))\\n # producer = lm_data_producer(dataset, model.batch_size, model.num_steps)\\n\\n fetches = {\\\"step_cost\\\": model.batch_loss, \\\"niters\\\": model.nwords}\\n if is_train:\\n fetches[\\\"eval_op\\\"] = model.train_op\\n if plot_attention_weights:\\n fetches[\\\"weights\\\"] = model.attention_weights\\n\\n costs = 0.0\\n iters = 0\\n start_time = time.time()\\n # for step, (x, y) in enumerate(producer):\\n for step in range(epoch_size):\\n step_time = time.time()\\n vals = session.run(fetches, {})\\n step_cost = vals[\\\"step_cost\\\"]\\n costs += step_cost\\n # iters += np.sum(x > 0)\\n iters += vals[\\\"niters\\\"]\\n\\n # print information regarding the current training process\\n if is_train:\\n if step % (epoch_size // 20) == 10:\\n print(\\\"{:.3f} - aprox. loss {:.8f} - approx. speed: {:.0f} wps\\\".format(\\n step * 1.0 / epoch_size, costs / (step + 1),\\n iters / (time.time() - start_time)))\\n # print information regarding the current training process\\n else:\\n if step % (epoch_size // 10) == 5:\\n print(\\\"{:.3f} - approx. speed: {:.0f} wps\\\".format(\\n step * 1.0 / epoch_size, iters / (time.time() - start_time)))\\n\\n return np.exp(costs / n_words)\",\n \"def after_train_iter(self,\\n runner: Runner,\\n batch_idx: int,\\n data_batch: DATA_BATCH = None,\\n outputs: Optional[dict] = None) -> None:\\n\\n if not self.every_n_iters(runner, self.interval):\\n return\\n\\n model = runner.model.module if is_model_wrapper(\\n runner.model) else runner.model\\n\\n for key in self.module_keys:\\n # get current ema states\\n ema_net = getattr(model, key)\\n states_ema = ema_net.state_dict(keep_vars=False)\\n # get currently original states\\n net = getattr(model, key[:-4])\\n states_orig = net.state_dict(keep_vars=True)\\n\\n for k, v in states_orig.items():\\n if runner.iter < self.start_iter:\\n states_ema[k].data.copy_(v.data)\\n else:\\n states_ema[k] = self.interp_func(\\n v, states_ema[k], trainable=v.requires_grad).detach()\\n ema_net.load_state_dict(states_ema, strict=True)\",\n \"def eval(epoch):\\n global best_acc\\n\\n net.eval()\\n test_loss_accumulator = 0\\n correct = 0\\n total = 0\\n test_accuracy = None\\n test_loss = None\\n for batch_idx, (inputs, targets) in enumerate(trainloader):\\n\\n if use_cuda:\\n inputs, targets = inputs.cuda(), targets.cuda()\\n inputs, targets = Variable(inputs, volatile=True), Variable(targets)\\n outputs = net(inputs)\\n loss = criterion(outputs, targets)\\n\\n test_loss_accumulator += loss.data[0]\\n _, predicted = torch.max(outputs.data, 1)\\n total += targets.size(0)\\n correct += predicted.eq(targets.data).cpu().sum()\\n\\n test_accuracy = 100. * correct / total\\n test_loss = test_loss_accumulator / (batch_idx + 1)\\n progress_bar(batch_idx, len(trainloader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)'\\n % (test_loss, test_accuracy, correct, total))\\n\\n if ((batch_idx + 1) * mini_batch_size) > max_training_examples:\\n break\\n print()\\n\\n\\n\\n return EvalPerf(test_loss, test_accuracy)\",\n \"def test(self):\\r\\n \\r\\n args = self.args\\r\\n model = self.model\\r\\n dataset = self.dataset\\r\\n \\r\\n dataset.set_split('test')\\r\\n batch_generator = generate_nmt_batches(dataset, \\r\\n batch_size=len(dataset), \\r\\n device=args.device)\\r\\n\\r\\n acc_sum = 0.0\\r\\n model.eval()\\r\\n \\r\\n for batch_index, batch_dict in enumerate(batch_generator):\\r\\n # step 1. compute the output\\r\\n if isinstance(model,NMTModelWithMLTM):\\r\\n y_pred = model(batch_dict['x_source'], \\r\\n batch_dict['x_source_mltm_vector'],\\r\\n batch_dict['x_source_length'], \\r\\n batch_dict['x_target'])\\r\\n else:\\r\\n y_pred = model(batch_dict['x_source'], \\r\\n batch_dict['x_source_length'], \\r\\n batch_dict['x_target'])\\r\\n\\r\\n acc_t = compute_accuracy(y_pred, batch_dict['y_target'], self.mask_index)\\r\\n acc_sum += acc_t\\r\\n \\r\\n return acc_sum / (batch_index+1)\",\n \"def on_epoch_end(self, epoch, logs={}):\\n for (k, v) in logs.items():\\n l = self.H.get(k, [])\\n l.append(v)\\n self.H[k] = l \\n # check to see if the training history should be serialized to file\\n if self.jsonPath is not None:\\n f = open(self.jsonPath, \\\"w\\\")\\n # Encodes a Python object as a JSON string.\\n f.write(json.dumps(self.H))\\n f.close() \\n # ensure at least two epochs have passed before plotting\\n # (epoch starts at zero)\\n if len(self.H[\\\"loss\\\"]) > 1:\\n N = np.arange(0, len(self.H[\\\"loss\\\"]))\\n plt.style.use(\\\"ggplot\\\")\\n plt.figure()\\n plt.plot(N, self.H[\\\"loss\\\"], label=\\\"train_loss\\\")\\n plt.plot(N, self.H[\\\"val_loss\\\"], label=\\\"val_loss\\\")\\n plt.plot(N, self.H[\\\"acc\\\"], label=\\\"train_acc\\\")\\n plt.plot(N, self.H[\\\"val_acc\\\"], label=\\\"val_acc\\\")\\n plt.title(\\\"Training Loss and Acc [Epoch {}]\\\".format(\\n len(self.H[\\\"loss\\\"])))\\n plt.xlabel(\\\"Epoch #\\\")\\n plt.ylabel(\\\"Loss/Acc\\\")\\n plt.legend()\\n plt.savefig(self.figPath)\\n plt.close()\",\n \"def train_epoch(self, epoch):\\n device_mapper = self.device_mapper\\n self.model.train()\\n self.train_metrics.reset()\\n for batch_idx, data in enumerate(self.data_loader):\\n data = device_mapper.map_modules(data, non_blocking=True)\\n\\n self.optimizer.zero_grad()\\n output = self.model(data)\\n loss = self.loss(output, data)\\n loss.backward()\\n self.optimizer.step()\\n\\n self.writer.set_step((epoch - 1) * self.len_epoch + batch_idx)\\n self.train_metrics.update('loss', loss.item(), batch_size=output.size(0))\\n for met in self.metrics:\\n self.train_metrics.update(met.name(), met(output, data), batch_size=output.size(0))\\n\\n if batch_idx % self.log_step == 0:\\n self.logger.debug('Train Epoch: %d %s Loss: %.6f', epoch, self._progress(batch_idx), loss.item())\\n\\n if batch_idx == self.len_epoch:\\n break\\n log = self.train_metrics.result()\\n\\n if self.do_validation:\\n val_log = self.valid_epoch(epoch)\\n log.update(**{'val_' + k: v for k, v in val_log.items()})\\n\\n if self.lr_scheduler is not None:\\n if isinstance(self.lr_scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau):\\n self.lr_scheduler.step(log[\\\"val_roc_auc\\\"])\\n else:\\n self.lr_scheduler.step()\\n return log\",\n \"def on_epoch_end(self, epoch, logs=None):\\r\\n step = epoch if self.update_freq == 'epoch' else self._samples_seen\\r\\n self._log_metrics(logs, prefix='epoch_', step=step)\\r\\n\\r\\n if self.histogram_freq and epoch % self.histogram_freq == 0:\\r\\n self._log_weights(epoch)\\r\\n\\r\\n if self.embeddings_freq and epoch % self.embeddings_freq == 0:\\r\\n self._log_embeddings(epoch)\",\n \"def process_evaluation_epoch(aggregates):\\n if 'losses' in aggregates:\\n eloss = torch.mean(torch.stack(aggregates['losses'])).item()\\n else:\\n eloss = None\\n\\n hypotheses = aggregates['preds']\\n references = aggregates['txts']\\n\\n wer, scores, num_words = word_error_rate(hypotheses, references)\\n multi_gpu = dist.is_initialized()\\n if multi_gpu:\\n if eloss is not None:\\n eloss /= dist.get_world_size()\\n eloss_tensor = torch.tensor(eloss).cuda()\\n dist.all_reduce(eloss_tensor)\\n eloss = eloss_tensor.item()\\n\\n scores_tensor = torch.tensor(scores).cuda()\\n dist.all_reduce(scores_tensor)\\n scores = scores_tensor.item()\\n num_words_tensor = torch.tensor(num_words).cuda()\\n dist.all_reduce(num_words_tensor)\\n num_words = num_words_tensor.item()\\n wer = scores * 1.0 / num_words\\n return wer, eloss\",\n \"def train_epoch(model, train_dataloader, optimizer, loss_fn):\\n model.train()\\n total_training_loss = 0\\n for batch_index, batch in enumerate(train_dataloader):\\n batch = batch[0].view(-1,1,28,28).float()\\n output_batch = model(batch)\\n loss = loss_fn(batch, output_batch, model.prev_means, model.prev_vars)\\n optimizer.zero_grad()\\n loss.backward()\\n optimizer.step()\\n total_training_loss += loss\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7093068","0.6828395","0.6732253","0.669807","0.669807","0.6676033","0.6524682","0.64946216","0.6488606","0.6488606","0.63934577","0.6391537","0.63756627","0.6371239","0.63657916","0.63108504","0.62925154","0.6290336","0.62839675","0.6260386","0.6257214","0.6255917","0.62222195","0.6221388","0.6218443","0.6192814","0.61585236","0.6129413","0.6112944","0.6112673","0.60972375","0.6085735","0.6081631","0.6074879","0.6043715","0.60425496","0.6040355","0.6036486","0.6030812","0.6025712","0.6024426","0.60127425","0.59857243","0.598136","0.5979127","0.597401","0.59704304","0.59649676","0.59588397","0.595537","0.59530824","0.5947301","0.59456915","0.5935979","0.59166044","0.59145224","0.59130603","0.59124434","0.59124434","0.591113","0.59108526","0.59107786","0.5904996","0.5899601","0.58840203","0.5883785","0.5858991","0.585488","0.58547854","0.5851126","0.58472437","0.58416134","0.58412796","0.5831721","0.5830614","0.58299124","0.582946","0.5825102","0.58222985","0.5819073","0.5814064","0.58119595","0.5811075","0.58062446","0.58024114","0.5798089","0.5788547","0.5787718","0.57759017","0.57654744","0.57654744","0.5761637","0.576141","0.575968","0.57554007","0.5739695","0.57343936","0.5730885","0.5723587","0.57215196"],"string":"[\n \"0.7093068\",\n \"0.6828395\",\n \"0.6732253\",\n \"0.669807\",\n \"0.669807\",\n \"0.6676033\",\n \"0.6524682\",\n \"0.64946216\",\n \"0.6488606\",\n \"0.6488606\",\n \"0.63934577\",\n \"0.6391537\",\n \"0.63756627\",\n \"0.6371239\",\n \"0.63657916\",\n \"0.63108504\",\n \"0.62925154\",\n \"0.6290336\",\n \"0.62839675\",\n \"0.6260386\",\n \"0.6257214\",\n \"0.6255917\",\n \"0.62222195\",\n \"0.6221388\",\n \"0.6218443\",\n \"0.6192814\",\n \"0.61585236\",\n \"0.6129413\",\n \"0.6112944\",\n \"0.6112673\",\n \"0.60972375\",\n \"0.6085735\",\n \"0.6081631\",\n \"0.6074879\",\n \"0.6043715\",\n \"0.60425496\",\n \"0.6040355\",\n \"0.6036486\",\n \"0.6030812\",\n \"0.6025712\",\n \"0.6024426\",\n \"0.60127425\",\n \"0.59857243\",\n \"0.598136\",\n \"0.5979127\",\n \"0.597401\",\n \"0.59704304\",\n \"0.59649676\",\n \"0.59588397\",\n \"0.595537\",\n \"0.59530824\",\n \"0.5947301\",\n \"0.59456915\",\n \"0.5935979\",\n \"0.59166044\",\n \"0.59145224\",\n \"0.59130603\",\n \"0.59124434\",\n \"0.59124434\",\n \"0.591113\",\n \"0.59108526\",\n \"0.59107786\",\n \"0.5904996\",\n \"0.5899601\",\n \"0.58840203\",\n \"0.5883785\",\n \"0.5858991\",\n \"0.585488\",\n \"0.58547854\",\n \"0.5851126\",\n \"0.58472437\",\n \"0.58416134\",\n \"0.58412796\",\n \"0.5831721\",\n \"0.5830614\",\n \"0.58299124\",\n \"0.582946\",\n \"0.5825102\",\n \"0.58222985\",\n \"0.5819073\",\n \"0.5814064\",\n \"0.58119595\",\n \"0.5811075\",\n \"0.58062446\",\n \"0.58024114\",\n \"0.5798089\",\n \"0.5788547\",\n \"0.5787718\",\n \"0.57759017\",\n \"0.57654744\",\n \"0.57654744\",\n \"0.5761637\",\n \"0.576141\",\n \"0.575968\",\n \"0.57554007\",\n \"0.5739695\",\n \"0.57343936\",\n \"0.5730885\",\n \"0.5723587\",\n \"0.57215196\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.82542735"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":914,"numItemsPerPage":100,"numTotalItems":95772,"offset":91400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTYzMzA4NCwianRpIjoiMGI1NjU1OGQtMWIyMy00MzU0LWEwNDctYTBjOTRmZjVhY2Y4Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU2MzY2ODQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ._YU3nCTouMPpNdozXdCYhuW4mJOk9oFpMMh8urTDq8NjnwiUC4BvbRcUnCoXwV7ZzZnhq8097anWXm3KLOOYAw","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 |
|---|---|---|---|---|---|---|
Scans the given hosts with nmap. | def nmap_scan():
# Create the search and config objects
hs = HostSearch()
config = Config()
# Static options to be able to figure out what options to use depending on the input the user gives.
nmap_types = ['top10', 'top100', 'custom', 'top1000', 'all']
options = {'top10':'--top-ports 10', 'top... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(args):\n if '-' in args['-p']:\n tmp = args['-p'].split('-')\n tgtPorts = [str(i) for i in xrange(int(tmp[0]), int(tmp[1])+1)]\n else:\n tgtPorts = [args['-p']]\n tgtHost = args['-H']\n for tgtPort in tgtPorts:\n nmapScan(tgtHost, tgtPort)",
"def nmap_discover():\... | [
"0.7025049",
"0.6521409",
"0.6378542",
"0.62963414",
"0.6219195",
"0.6097285",
"0.60449445",
"0.5851369",
"0.5845113",
"0.5843361",
"0.5717884",
"0.5716023",
"0.5675595",
"0.5556713",
"0.5540878",
"0.54813397",
"0.5472343",
"0.54518175",
"0.54498523",
"0.54407346",
"0.5436073... | 0.75665087 | 0 |
Scans available smb services in the database for smb signing and ms17010. | def nmap_smb_vulnscan():
service_search = ServiceSearch()
services = service_search.get_services(ports=['445'], tags=['!smb_vulnscan'], up=True)
services = [service for service in services]
service_dict = {}
for service in services:
service.add_tag('smb_vulnscan')
service_dict[str(se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_samba_clients(self):\n # TODO preferably use a library, don't assume localhost.\n logging.debug(\"inspecting samba...\")\n command = 'sudo smbstatus -p | sed -n 5p | tr -s \" \" | cut -d\" \" -f4'\n output = utils.run_os_command(command)\n return output.strip().split(\"\... | [
"0.62371737",
"0.5669815",
"0.53696716",
"0.53552085",
"0.53151625",
"0.5273359",
"0.5259361",
"0.5240157",
"0.51579183",
"0.51324147",
"0.5113975",
"0.5078871",
"0.5054602",
"0.5043952",
"0.5043248",
"0.5041043",
"0.503842",
"0.5036707",
"0.50204873",
"0.5011913",
"0.5010239... | 0.6513238 | 0 |
Performs os (and domain) discovery of smb hosts. | def os_discovery():
hs = HostSearch()
hosts = hs.get_hosts(ports=[445], tags=['!nmap_os'])
# TODO fix filter for emtpy fields.
hosts = [host for host in hosts if not host.os]
host_dict = {}
for host in hosts:
host_dict[str(host.address)] = host
arguments = "--script smb-os-discov... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nslookup(self):\n if len(self.hostnames) == 0:\n st, out = commands.getstatusoutput('get_instance_by_service %s' % self.bns)\n assert st == 0, \"Failure:'get_instance_by_service %s', errno=%d\" % (self.bns, st)\n self.hostnames = out.split('\\n')\n assert self.hos... | [
"0.57663345",
"0.5488624",
"0.53603756",
"0.5260246",
"0.52439183",
"0.5241199",
"0.52410096",
"0.5170347",
"0.51309216",
"0.5104058",
"0.50928646",
"0.50926536",
"0.5088061",
"0.5071322",
"0.50709414",
"0.5067245",
"0.5057643",
"0.50443965",
"0.50281113",
"0.5010868",
"0.500... | 0.6300907 | 0 |
Get number of nodes in an evaluator tree | def nodeCount(eval):
if not isEvaluator(eval):
return 0
return eval.ReferencedNodes().Size() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(self):\n return self.__tree.node_count",
"def countNodes(epr):\n result = 1\n argLst = epr.args\n for arg in argLst:\n result += countNodes(arg)\n return result",
"def uniqueNodeCount(eval):\n if not isEvaluator(eval):\n return 0\n return eva... | [
"0.75622797",
"0.7529294",
"0.7479575",
"0.7247177",
"0.72267604",
"0.7162352",
"0.7160398",
"0.70068026",
"0.69996077",
"0.6992341",
"0.6980684",
"0.695798",
"0.69542134",
"0.69283307",
"0.6926007",
"0.6905633",
"0.6887969",
"0.68765336",
"0.68759674",
"0.68656826",
"0.68631... | 0.83393586 | 0 |
Get number of unique nodes in an evaluator tree | def uniqueNodeCount(eval):
if not isEvaluator(eval):
return 0
return eval.ReferencedUniqueNodes().Size() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nodeCount(eval):\n if not isEvaluator(eval):\n return 0\n return eval.ReferencedNodes().Size()",
"def countNodes(epr):\n result = 1\n argLst = epr.args\n for arg in argLst:\n result += countNodes(arg)\n return result",
"def count_unique(self) -> int:\n ... | [
"0.7576809",
"0.7254298",
"0.71891284",
"0.71155745",
"0.70935607",
"0.70214313",
"0.6912688",
"0.6897794",
"0.6867565",
"0.6790366",
"0.67900467",
"0.6774255",
"0.6749377",
"0.6732378",
"0.672201",
"0.67205966",
"0.6686232",
"0.66795933",
"0.66662836",
"0.66526145",
"0.66101... | 0.84147877 | 0 |
Get number of evaluators dependant of an evaluator, ie parents | def doDependentCount(eval, log):
if not isEvaluator(eval):
return 0
dependents = eval.Dependents()
count = 0
if log:
skippedMsgs = []
print ('***************************')
print ('Input: ' + str(eval))
for dep in dependents:
if hasattr(dep, "IsKindOf"... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nodeCount(eval):\n if not isEvaluator(eval):\n return 0\n return eval.ReferencedNodes().Size()",
"def get_number_of_evaluation(self):\n return self.n_eval",
"def countNodes(epr):\n result = 1\n argLst = epr.args\n for arg in argLst:\n result += countNodes... | [
"0.6929427",
"0.6591238",
"0.6296858",
"0.62552387",
"0.60923344",
"0.6016347",
"0.59949905",
"0.59949905",
"0.59826666",
"0.59242123",
"0.58922696",
"0.5888797",
"0.58361304",
"0.5833104",
"0.58175397",
"0.5810677",
"0.57730937",
"0.574246",
"0.5709555",
"0.5677782",
"0.5672... | 0.6347132 | 2 |
Get average profiling time for an evaluator | def avg(ev):
profData = getProfilingData(ev)
if profData is not None:
return profData.Tavg()
return "" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def avg_inference_time(self):\n return self._avg_inference_time",
"def mean_run_time(self) -> float:\n return float(self.result_array.sum(axis=0).mean())",
"def get_average_execution_time_value(execution_time):\n if all_results_are_merged:\n # There will be multiple branch cover... | [
"0.6653341",
"0.6610705",
"0.6419527",
"0.63969165",
"0.6383479",
"0.63042825",
"0.6289734",
"0.62701607",
"0.6252877",
"0.6204559",
"0.6181674",
"0.6152221",
"0.6139389",
"0.6118519",
"0.6111415",
"0.6096281",
"0.6076748",
"0.6076074",
"0.6073837",
"0.6021519",
"0.60152686",... | 0.6432693 | 2 |
Get accumulated profiling time for an evaluator | def acc(ev):
profData = getProfilingData(ev)
if profData is not None:
return profData.Tacc()
return "" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_time(self):\n return self.compute_time_without_gc() + self.gc_time",
"def timings(self):\r\n return self._timings",
"def perf_timer():\n start_time = datetime.now()\n yield\n end_time = datetime.now()\n log.info(end_time - start_time)",
"def GetCpuTimestamp(self):\n return {'... | [
"0.6357354",
"0.6236055",
"0.6222545",
"0.61795944",
"0.6170181",
"0.607339",
"0.6047909",
"0.6019864",
"0.59656215",
"0.5904349",
"0.58972514",
"0.5896824",
"0.5888479",
"0.5883879",
"0.5877799",
"0.5868603",
"0.58448243",
"0.5841196",
"0.583563",
"0.58150375",
"0.58019006",... | 0.0 | -1 |
Get max profiling time for an evaluator | def max(ev):
profData = getProfilingData(ev)
if profData is not None:
return profData.Tmax()
return "" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max_time(self) -> float:\r\n if(len(self.operations_by_name) == 0):\r\n return -1\r\n return max(map(lambda x: x[\"time_step\"], self.operations_by_name.values()))",
"def max(self):\n\n return time_stat(self, stat=\"max\")",
"def getMaxSimTime(self):\n return self.max_sim... | [
"0.6709669",
"0.62209153",
"0.6059053",
"0.6050143",
"0.6025128",
"0.60107434",
"0.5955151",
"0.5945843",
"0.5939467",
"0.59079236",
"0.5812572",
"0.5812572",
"0.57888734",
"0.57609487",
"0.57224643",
"0.57156175",
"0.5695369",
"0.56885415",
"0.5660657",
"0.56372124",
"0.5609... | 0.64209914 | 1 |
Get min profiling time for an evaluator | def min(ev):
profData = getProfilingData(ev)
if profData is not None:
return profData.Tmin()
return "" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def min_time(self):\n #{{{ function to return time of first sample\n\n return self.mintime",
"def min(self):\n\n return time_stat(self, stat=\"min\")",
"def get_min_tim(self):\n return self.get_shortest_mode().tim",
"def min_time(self):\n return self._ll_tree_sequence.get_min_time(... | [
"0.65390086",
"0.6491748",
"0.6374993",
"0.62546337",
"0.62226903",
"0.61515844",
"0.5921736",
"0.5845982",
"0.5836962",
"0.58335114",
"0.5820608",
"0.5797174",
"0.57750994",
"0.5770553",
"0.57538813",
"0.57335234",
"0.57052904",
"0.57025284",
"0.56895",
"0.5687751",
"0.56761... | 0.68451685 | 0 |
Get propagated cost profiling time for an evaluator | def cost(ev):
profData = getProfilingData(ev)
if profData is not None:
return profData.PropagatedCost()
return "" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_time(self):\n return self.compute_time_without_gc() + self.gc_time",
"def computation_time(self) -> float:\r\n if self._computation_times is None:\r\n return None\r\n else:\r\n return self._computation_times[0]",
"def perf_timer():\n start_time = datetime.n... | [
"0.6636906",
"0.6144508",
"0.61103594",
"0.6105323",
"0.6021323",
"0.59983486",
"0.5941204",
"0.592668",
"0.59159535",
"0.59084445",
"0.5887483",
"0.5884865",
"0.58274376",
"0.5812681",
"0.57631546",
"0.5761986",
"0.5759631",
"0.57565475",
"0.57422686",
"0.57337075",
"0.57311... | 0.64273757 | 1 |
Get profiling call count for an evaluator | def count(ev):
profData = getProfilingData(ev)
if profData is not None:
return profData.Count()
return "" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def op_callcount(self):\r\n # timing is stored by node, we compute timing by Op on demand\r\n rval = {}\r\n for node, count in self.apply_callcount.items():\r\n rval.setdefault(node.op, 0)\r\n rval[node.op] += count\r\n return rval",
"def class_callcount(self):\r... | [
"0.645071",
"0.6406745",
"0.63925785",
"0.63677806",
"0.63302857",
"0.6281262",
"0.6211619",
"0.6148319",
"0.6045033",
"0.60330534",
"0.6007769",
"0.60064745",
"0.5980804",
"0.59685713",
"0.5929456",
"0.58637774",
"0.5863227",
"0.5843919",
"0.58364314",
"0.5831876",
"0.582873... | 0.6478726 | 0 |
Get profiling total call count for evaluator descendants | def dcount(ev):
profData = getProfilingData(ev)
if profData is not None:
a = profData.Descendants().AsArray()
if len(a) > 0:
return profData.DescendantCount(a[0])
return "" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def class_callcount(self):\r\n # timing is stored by node, we compute timing by class on demand\r\n rval = {}\r\n for node, count in self.apply_callcount.items():\r\n typ = type(node.op)\r\n rval.setdefault(typ, 0)\r\n rval[typ] += count\r\n return rval"... | [
"0.6942295",
"0.6894825",
"0.6448754",
"0.6368588",
"0.6336088",
"0.6323855",
"0.62947893",
"0.62349457",
"0.62281996",
"0.6223465",
"0.61490244",
"0.6130873",
"0.6120092",
"0.61115897",
"0.60901487",
"0.604145",
"0.60308754",
"0.60130274",
"0.5990126",
"0.58869624",
"0.58549... | 0.60667473 | 15 |
a tuple containing the device and the autosave strings | def generate_device_specific(
device, device_number: int, ip_asyn_port: str, sector
) -> typing.Tuple[str, str]:
res = ""
_as = ""
prefix = device.prefix
serial_address = device.serial_address
channels = device.channels
for i in range(4):
if channels[i] is None:
# @todo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getLatestAutosave():\n nukeAutoSavePath = nuke.toNode(\"preferences\").knob('AutoSaveName').evaluate()\n if os.path.exists(nukeAutoSavePath):\n latestAutosave = cmd.getstatusoutput('ls -1tr '+nukeAutoSavePath+' | tail -1')[1]\n latestAutosavePy = latestAutosave.split('.')[0]+'.nk'\n ... | [
"0.58341247",
"0.57714856",
"0.5669109",
"0.5427801",
"0.53116256",
"0.5254177",
"0.52220273",
"0.52175",
"0.5199559",
"0.51973975",
"0.5164707",
"0.5159505",
"0.51471555",
"0.513835",
"0.5134263",
"0.5087733",
"0.5082035",
"0.50702757",
"0.50481826",
"0.5037174",
"0.50205785... | 0.0 | -1 |
Van Der Pol oscilator rewritten as a system of two first order ODE's | def van_der_pol(pos):
epsilon = 0.1
def x_dot(x, y):
return (1 / epsilon) * (y - ((1/3)*(x**3) - x))
def y_dot(x, y):
return -epsilon * x
return np.array([x_dot(pos[0], pos[1]), y_dot(pos[0], pos[1])]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def van_der_pol_oscillator_deriv(x, t):\n \n x1 = x[1]\n y = -nu * (x[0] ** 2.0 - 1.0) * x[1] - x[0]\n result = np.array([x1, y])\n return result",
"def ode(self, **kwargs):\n pass",
"def get_ode(self, d):\n C1 = np.array([[-1./self.Q, -1.], [1., 0.]])\n C2 = np.array([[1.],... | [
"0.67783046",
"0.6365935",
"0.6167238",
"0.6111346",
"0.60931164",
"0.6071298",
"0.6022355",
"0.5944856",
"0.59336215",
"0.5882533",
"0.5867107",
"0.58559364",
"0.5838924",
"0.58322763",
"0.581218",
"0.57877517",
"0.5785348",
"0.5784892",
"0.57654876",
"0.57618225",
"0.575517... | 0.0 | -1 |
Model of a pendulum | def pendulum(pos):
def x_dot(x, y):
return y
def y_dot(x, y):
return -np.sin(x)
return np.array([x_dot(pos[0], pos[1]), y_dot(pos[0], pos[1])]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, pendulum, name=\"Pendulum\", dt=0.01):\n super().__init__(name=name)\n self.pendulum = pendulum\n self.dt = dt",
"def damped_pendulum(pos):\n\n def x_dot(x, y):\n return y\n\n def y_dot(x, y):\n return -0.1*y - np.sin(x)\n\n return np.array([x_dot(po... | [
"0.68147796",
"0.6339868",
"0.6296034",
"0.60743606",
"0.5980977",
"0.5754878",
"0.5716205",
"0.56013805",
"0.5563842",
"0.54992867",
"0.54514074",
"0.5432418",
"0.543091",
"0.54245365",
"0.54043674",
"0.54034466",
"0.5398115",
"0.53881854",
"0.5375106",
"0.5373626",
"0.53723... | 0.6975272 | 0 |
Model of a damped pendulum | def damped_pendulum(pos):
def x_dot(x, y):
return y
def y_dot(x, y):
return -0.1*y - np.sin(x)
return np.array([x_dot(pos[0], pos[1]), y_dot(pos[0], pos[1])]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, pendulum, name=\"Pendulum\", dt=0.01):\n super().__init__(name=name)\n self.pendulum = pendulum\n self.dt = dt",
"def _model(self, t, theta, period, tmpid):\n template = self.templates[tmpid]\n phase = (t / period - theta[2]) % 1\n return theta[0] + th... | [
"0.6389757",
"0.62570584",
"0.6251534",
"0.6018877",
"0.5953172",
"0.58293605",
"0.58160734",
"0.5796524",
"0.57523537",
"0.56851745",
"0.56645703",
"0.5663768",
"0.56319314",
"0.562755",
"0.55919474",
"0.55872536",
"0.5567067",
"0.55479765",
"0.5503377",
"0.54973847",
"0.549... | 0.6742539 | 0 |
Model of a pendulum | def strange_attractor(pos):
P = 10
R = 350
B = 8/3
#P = 10
#R = 35
#B = 5
def x_dot(x, y, z):
return P * (y - x)
def y_dot(x, y, z):
return R*x - y - x*z
def z_dot(x, y, z):
return x*y - B*z
return np.array([x_dot(pos[0], pos[1], pos[2]),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pendulum(pos):\n\n def x_dot(x, y):\n return y\n\n def y_dot(x, y):\n return -np.sin(x)\n\n return np.array([x_dot(pos[0], pos[1]), y_dot(pos[0], pos[1])])",
"def __init__(self, pendulum, name=\"Pendulum\", dt=0.01):\n super().__init__(name=name)\n self.pendulum = pendulu... | [
"0.6975272",
"0.68147796",
"0.6339868",
"0.6296034",
"0.60743606",
"0.5980977",
"0.5754878",
"0.5716205",
"0.56013805",
"0.5563842",
"0.54992867",
"0.54514074",
"0.5432418",
"0.543091",
"0.54245365",
"0.54043674",
"0.54034466",
"0.5398115",
"0.53881854",
"0.5375106",
"0.53736... | 0.0 | -1 |
Model of a pendulum | def rossler_attractor(pos):
A = 0.2
B = 0.2
C = 5.7
def x_dot(x, y, z):
return -(y + z)
def y_dot(x, y, z):
return x + A*y
def z_dot(x, y, z):
return B + x*z - C*z
return np.array([x_dot(pos[0], pos[1], pos[2]),
y_dot(pos[0], pos[1], pos[2]),... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pendulum(pos):\n\n def x_dot(x, y):\n return y\n\n def y_dot(x, y):\n return -np.sin(x)\n\n return np.array([x_dot(pos[0], pos[1]), y_dot(pos[0], pos[1])])",
"def __init__(self, pendulum, name=\"Pendulum\", dt=0.01):\n super().__init__(name=name)\n self.pendulum = pendulu... | [
"0.6975272",
"0.68147796",
"0.6339868",
"0.6296034",
"0.60743606",
"0.5980977",
"0.5754878",
"0.5716205",
"0.56013805",
"0.5563842",
"0.54992867",
"0.54514074",
"0.5432418",
"0.543091",
"0.54245365",
"0.54043674",
"0.54034466",
"0.5398115",
"0.53881854",
"0.5375106",
"0.53736... | 0.0 | -1 |
Hard sigmoid function For a given value u as input, it gives hard sigmoid of u as output. | def hard_sigmoid(u):
if u > 1:
ro = 1
elif u < 0:
ro = 0
else:
ro = u
return ro | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hard_sigmoid_derivative(u):\r\n if u > 1:\r\n ro = 0\r\n elif u < 0:\r\n ro = 0\r\n else:\r\n ro = 1\r\n return ro",
"def sigmoid(x):\n return 1 / (1 - (power(e,-x)))",
"def sigmoid(z):\r\n \r\n return vSigmoid(z);",
"def sigmoid(x):\n return 1 / (1 + exp(-x)... | [
"0.8340554",
"0.7792559",
"0.77599376",
"0.7747133",
"0.7747133",
"0.76981646",
"0.7667149",
"0.7664956",
"0.7651496",
"0.76462394",
"0.76462394",
"0.76407063",
"0.7631713",
"0.76259273",
"0.76033205",
"0.76024806",
"0.7595583",
"0.7590885",
"0.7590708",
"0.7586715",
"0.75819... | 0.83319825 | 1 |
Hard sigmoid function for an array of values For a given array u as input, it gives hard sigmoid of u as output. | def hard_sigmoid_array(u):
ro = np.zeros(len(u))
for i in np.arange(len(u)):
ro[i] = hard_sigmoid(u[i])
return ro | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sigmoid(t):\n return np.exp(t)/(1+np.exp(t))",
"def sigmoid(x: np.ndarray \n ) -> np.ndarray:\n return 1/(1+np.exp(-x))",
"def sigmoid(values, gain, shift):\n import numpy as np\n\n tiny = 0.000000001\n\n # Make sure argument is a numpy array\n if type(values) != np.ndarr... | [
"0.7557232",
"0.75521666",
"0.7530991",
"0.75062776",
"0.74866426",
"0.7473698",
"0.74650526",
"0.7455005",
"0.7455005",
"0.7455005",
"0.7455005",
"0.7455005",
"0.7455005",
"0.74319494",
"0.7427566",
"0.7409621",
"0.74043214",
"0.7399037",
"0.7392596",
"0.7390544",
"0.7388159... | 0.8358422 | 0 |
Derivative of hard sigmoid function For a given value u as input, it gives hard sigmoid derivative of u as output. | def hard_sigmoid_derivative(u):
if u > 1:
ro = 0
elif u < 0:
ro = 0
else:
ro = 1
return ro | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def derivative_sigmoid(x):\n return x * (1 - x)",
"def derivative_sigmoid(x):\n return x * (1 - x)",
"def sigmoid_derivative(x):\n return x * (1-x)",
"def sigmoid_derivative(x):\n return x * (1.0 - x)",
"def sigmoid_derivative(x):\n\n return sigmoid(x) * (1 - sigmoid(x))",
"def sigmoid_der... | [
"0.7970959",
"0.7970959",
"0.79495186",
"0.7897426",
"0.7845998",
"0.7710246",
"0.7476678",
"0.7226657",
"0.7202913",
"0.71984",
"0.70288426",
"0.69358486",
"0.6927546",
"0.69059795",
"0.6862626",
"0.6840817",
"0.6803506",
"0.6792324",
"0.6756603",
"0.67067933",
"0.6668996",
... | 0.8027031 | 0 |
Free phase function This function determines states dynamics and their final values, and the convergence time as output according to the free phase. | def free_phase(w, b, v, n_iter, eps, fan_in, fan_hidden, fan_out):
start_time = time.time()
s = np.asarray(
np.random.RandomState().uniform(low=-np.sqrt(6. / (fan_in + fan_out)), high=np.sqrt(6. / (fan_in + fan_out)),
size=(fan_hidden + fan_out,)))
u = np... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __update_if_required(self, time, phase):\n if (not self.__force_update) and (time, phase) == self.__last_params:\n return\n self.__last_params = (time, phase)\n self.__sin = np.sin(self.__rabi_mod * 0.5 * time)\n self.__cos = np.cos(self.__rabi_mod * 0.5 * time)\n ... | [
"0.58598506",
"0.57560414",
"0.5753303",
"0.5736742",
"0.5542678",
"0.5542645",
"0.55395633",
"0.553148",
"0.5518612",
"0.5518064",
"0.54858553",
"0.5479553",
"0.5467217",
"0.5458112",
"0.5453849",
"0.541411",
"0.5410637",
"0.54043305",
"0.5385624",
"0.5383069",
"0.5352124",
... | 0.5824797 | 1 |
Weakly clamped phase function This function determines states dynamics and their final values, and the convergence time as output according to the weakly clamped phase. | def weaklyClamped_phase(w, b, v, y_onehot, epoch, beta, n_iter, eps, fan_in, fan_hidden, fan_out):
start_time = time.time()
s = np.asarray(
np.random.RandomState().uniform(low=-np.sqrt(6. / (fan_in + fan_out)), high=np.sqrt(6. / (fan_in + fan_out)),
size=(fan_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def phasefold(t, P, t0, starting_phase=-0.5):\n t = np.array(t)\n dt = t0shft( np.array(t), P, t0)\n tshift = t + dt\n t_phasefold = np.mod(tshift - starting_phase*P, P) + starting_phase * P\n phase = t_phasefold / P\n cycle = np.floor(tshift/P - starting_phase).astype(int)\n return t_phasefol... | [
"0.57427216",
"0.5517094",
"0.531438",
"0.5293937",
"0.52501124",
"0.5207172",
"0.5200721",
"0.51790994",
"0.5178072",
"0.5168876",
"0.5124565",
"0.5105001",
"0.50900114",
"0.50700676",
"0.50423545",
"0.50392187",
"0.5019811",
"0.50197685",
"0.5018847",
"0.5014742",
"0.500329... | 0.59560907 | 0 |
Weight update function This function updates the weights. | def weight_update(u_ff, u_wc, alpha, beta, w, fan_all):
mult_wc = np.matmul(np.reshape(hard_sigmoid_array(u_wc), (fan_all, 1)),
np.reshape(hard_sigmoid_array(u_wc), (1, fan_all)))
mult_ff = np.matmul(np.reshape(hard_sigmoid_array(u_ff), (fan_all, 1)),
np.resha... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_weights(self):\n\t\tpass",
"def update_weights(self):\n self._weights = self._weights + self.update_weights_value",
"def update_weights(self):\n self._weights = self._weights + self.update_weights_value\n self.weights_clipping()",
"def updateWeights(self,weightUpdate):\n\t\n\t... | [
"0.87812054",
"0.86967194",
"0.84079665",
"0.823003",
"0.7969475",
"0.79565686",
"0.79220754",
"0.7916582",
"0.7887394",
"0.771643",
"0.76431197",
"0.7587686",
"0.7503989",
"0.74916613",
"0.73891324",
"0.7367587",
"0.7352369",
"0.7352369",
"0.7352369",
"0.7352369",
"0.7291205... | 0.73871416 | 15 |
This method is intended to create a new group element after the initial installation is complete. It will create a file containing the group and job selection/matchin criteria. This can then be manually merged into the existing frontend configuration file. | def get_new_config_group(self):
filename = "%(config_dir)s/%(group)s.%(time)s" % \
{ "config_dir": self.config_dir(),
"group": self.group_name(),
"time": common.time_suffix(),}
common.write_file("w", 0o644, filename, self.get_match_criteria()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createMainGroup(self):\n\t\tmc.group( n = self.grp.name, em = True )",
"def createGroup(self, name):\n new_group = ET.SubElement(self._root,'group')\n group_name = ET.SubElement(new_group, 'name')\n group_name.text = name\n # update the document's groups\n self._groups = self._root.findall('gr... | [
"0.64204746",
"0.6273165",
"0.609973",
"0.58930635",
"0.58930635",
"0.585004",
"0.58285666",
"0.5814239",
"0.58060133",
"0.57745683",
"0.5757875",
"0.575727",
"0.5730281",
"0.5723413",
"0.5714178",
"0.5712287",
"0.56967247",
"0.5644694",
"0.56357884",
"0.5604819",
"0.5562929"... | 0.67966115 | 0 |
This method attempts to clean up all directories so a fresh install can be accomplished successfully. It is consoldiated in a single check so as to only ask once and not for each directory. | def verify_directories_empty(self):
if self.install_type == "rpm":
return # For RPM install we don't want to clean anything
instance_dir = "frontend_%(service)s-%(instance)s" % \
{ "service": self.service_name(),
"instance": self.glidein.instance_name(), }
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def try_clean(self):\n for f in self.FILES_TO_CLEAN:\n if not os.path.exists(f):\n continue\n\n if os.path.isdir(f):\n # don't care on error\n shutil.rmtree(f, onerror=lambda *x, **y: None)\n else:\n self.safe_delet... | [
"0.74447376",
"0.73241925",
"0.71441674",
"0.7128869",
"0.7061443",
"0.7038404",
"0.7005379",
"0.69962335",
"0.69664586",
"0.6964546",
"0.6936114",
"0.69127035",
"0.68968123",
"0.6844384",
"0.6836401",
"0.6826492",
"0.6820406",
"0.6812501",
"0.68029016",
"0.6763443",
"0.67616... | 0.6714952 | 23 |
The VOFrontend service can share the same instance of Condor with the UserCollector and/or Schedd services. So we want to check and see if this is the case. We will skip the installation of Condor and just perform the configuration of the condor_config file. | def determine_colocated_services(self):
if self.install_type() == "rpm":
return # Not needed for RPM install
services = ""
# -- if not on same node, we don't have any co-located
if self.hostname() == self.usercollector.hostname():
if self.condor_location() == self.usercollector.c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_config(self):",
"def check_configs(self):\n\n pass",
"def configure(self, conf):\n return False",
"def handleCondorStatusService(self):\n procScript = \"cmssw_handle_condor_status_service.py\"\n cmd = \"%s --input_pkl %s --output_pkl %s --name %s\" % (\n proc... | [
"0.5896995",
"0.5661055",
"0.5633242",
"0.5532198",
"0.5482386",
"0.5431263",
"0.542196",
"0.53726244",
"0.5362765",
"0.5343296",
"0.5337556",
"0.53289133",
"0.53210413",
"0.52994794",
"0.529925",
"0.52943397",
"0.5285092",
"0.528452",
"0.5275828",
"0.5275431",
"0.5272948",
... | 0.50878876 | 30 |
Determine the job constraints/matching criteria for submitting jobs. | def get_match_criteria(self):
#-- factory attributes ----
print("""
What glidein/factory attributres are you using in the match expression?
I have computed my best estimate for your match string,
please verify and correct if needed.
""")
default_factory_attributes = string.join(self.extract_factory_attrs(), '... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def criteria(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Criterion]:",
"def get_data_reqs(self):\n reqs = {\n \"requires_partial_lc\": True,\n \"metric\": self.metric,\n \"requires_hyperparameters\": False,\n \"hyperpara... | [
"0.57358813",
"0.5659757",
"0.5569344",
"0.55406904",
"0.55322236",
"0.55069834",
"0.54394615",
"0.5389639",
"0.5385479",
"0.53590983",
"0.5272351",
"0.52676505",
"0.5258483",
"0.52503854",
"0.5246914",
"0.5218388",
"0.5214789",
"0.51990587",
"0.5188233",
"0.5180952",
"0.5178... | 0.4942156 | 71 |
Parses the file given to this object and stores the data obtained as the object's fields. | def parse(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse(self, infile):\n raise NotImplementedError()",
"def __init__(self, file):\n self.data = []\n parse_mode = 'unknown'\n for line in open(file, 'r'):\n # Figure out if we should change our parse mode\n if line == '':\n continue\n ... | [
"0.6832204",
"0.68077624",
"0.67919856",
"0.67727983",
"0.6633941",
"0.65920854",
"0.6585272",
"0.6563904",
"0.6557574",
"0.65152675",
"0.6491245",
"0.6470125",
"0.64425564",
"0.64315665",
"0.6416702",
"0.6415605",
"0.6415176",
"0.6395",
"0.63931954",
"0.6372315",
"0.636632",... | 0.0 | -1 |
calculate the attention scores of each word | def score(self, hidden, encoder_outputs):
# after cat: [B, T, 2/3*H]
# after attn: [B, T, H]
# energy: [B, T, H]
energy = F.relu(self.attn(torch.cat([hidden, encoder_outputs], dim=2))) # [B, T, H]
energy = energy.transpose(1, 2) # [B, H, T]
v = self.v.repeat(encod... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def analyze(self, text):\n\n score = 0.0;\n\n words = text.split(' ')\n # match each word in either the positives or negatives list adding or subtracting 1 from the score if present\n for word in words:\n for w in self.positives:\n if w == word.lower():\n ... | [
"0.69037485",
"0.6777465",
"0.669691",
"0.66638595",
"0.6655352",
"0.6629472",
"0.66284233",
"0.6620621",
"0.65981007",
"0.6594562",
"0.6559582",
"0.6534421",
"0.6527756",
"0.6516296",
"0.64836556",
"0.6481548",
"0.64703435",
"0.64680326",
"0.6458587",
"0.64560616",
"0.644371... | 0.0 | -1 |
Return the value for a given MC sample, energy or year, and information type If information is stored for both an energy and a year, the value for the given energy will be preferentially returned. If strict checking is turned on the function will raise an error if a given dictionary or piece of information isn't found.... | def get_value(self, name, energy, year, key, strict=False):
fields = [self.__key_field_map[key][0]+"_"+energy,self.__key_field_map[key][0]+"_"+year]
if not name in self.__values_dict:
raise KeyError("ERROR MCSampleValuesHelper::Unknown process \"" + str(name) + "\"")
if not key in se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def value(self,pt,eta,mode):\n\n self._eta_range= get_eta_key(eta)+'_2012B'\n self._pt_range= get_pt_key(pt)\n\n if mode == '0' :\n return self._map['DoubleMu17Mu8_Mu8_Tight'][self._eta_range][self._pt_range]['data']['efficiency'] \n elif mode == '+1' :\n return self._map['DoubleMu1... | [
"0.54123473",
"0.5368775",
"0.5330085",
"0.50552213",
"0.50486755",
"0.5037508",
"0.49840373",
"0.4980758",
"0.4962545",
"0.49597347",
"0.4958092",
"0.49424076",
"0.49341348",
"0.49290487",
"0.49097136",
"0.48970246",
"0.48856208",
"0.48642394",
"0.4853736",
"0.48443174",
"0.... | 0.6362816 | 0 |
Execute some commands (python scripts) using a scheduler. If the script contains a '__hopla__' list of parameter names to keep trace on, all the specified parameters values are stored in the execution status. | def scheduler(commands, name="job", outputdir=None, cpus=1,
use_subprocess=False, delay_upto=0,
logfile=None, cluster=False, cluster_logdir=None,
cluster_queue=None, cluster_memory=1, cluster_walltime=24,
cluster_nb_threads=1, python_cmd="python", verbose=1):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def call_script_on_staging(name, args=[]):\n def fn(): lib.call([os.path.join(env.staging_path, \"scripts\", name)] + args)\n time_duration(fn)",
"def beginExecution(self):\n self.setup = self.am_getOption(\"Setup\", self.setup)\n self.enabled = self.am_getOption(\"EnableFlag\", self.enabled)\n self.r... | [
"0.5874737",
"0.5848745",
"0.58409274",
"0.5711282",
"0.5694308",
"0.56838024",
"0.56369233",
"0.56181896",
"0.56100684",
"0.5592848",
"0.55839664",
"0.55704004",
"0.55532855",
"0.5543302",
"0.5541781",
"0.5539037",
"0.5522676",
"0.5521089",
"0.5520722",
"0.54800516",
"0.5479... | 0.56198955 | 7 |
Returns a random approximate maximum independent set. | def generate_mis(G, sample_size, nodes=None):
# list of maximal independent sets
max_ind_set_list=[]
# iterates from 0 to the number of samples chosen
for i in range(sample_size):
# for each iteration generates a random maximal independent set that contains
# UnitedHealth and Amazon
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_max_sampled_bandit(self)->Bandit:\n estimates = []\n for bandit in self.bandits:\n estimates.append(np.random.normal(loc =self.mu[bandit.id], scale = self.var[bandit.id]))\n return self.bandits[np.argmax(estimates)]",
"def argmax(values):\n\tvalues = np.array(values)\n\tm... | [
"0.6385899",
"0.6373035",
"0.6325812",
"0.6071461",
"0.6059322",
"0.60403305",
"0.6027513",
"0.5994413",
"0.5994413",
"0.5994413",
"0.5994413",
"0.5976374",
"0.59618556",
"0.59598696",
"0.59598696",
"0.59598696",
"0.59382355",
"0.5938174",
"0.5854442",
"0.5819924",
"0.5764114... | 0.6168583 | 3 |
Returns a dictionary of portfolio weights. | def centrality_to_portfolio_weights(weights):
# iterates over the key, value pairs in the weights dict
for key, value in weights.items():
# takes the inverse of the communicability betweeness centrality of each asset
weights[key] = 1/value
# normalization parameter for all weights to add ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def current_portfolio_weights(self) -> 'pd.Series[float]':\n position_values = pd.Series({\n asset: (\n position.last_sale_price *\n position.amount *\n asset.price_multiplier\n )\n for asset, position in self.position... | [
"0.7302032",
"0.688067",
"0.6818489",
"0.67349046",
"0.6629948",
"0.65233266",
"0.6515393",
"0.6515393",
"0.6515393",
"0.6515393",
"0.6513552",
"0.6513552",
"0.6500232",
"0.6500232",
"0.6455062",
"0.6455062",
"0.6455062",
"0.6455062",
"0.6455062",
"0.64438415",
"0.64048874",
... | 0.698716 | 1 |
Returns the cumulative returns of a portfolio. | def cumulative_returns(shares_allocation, capital, test_data):
# list of DataFrames of cumulative returns for each stock
daily_returns = []
# iterates over every stock in the portfolio
for stock in shares_allocation.index:
# multiples shares by share prices in the validation dataset
d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cumulative_returns(self):\n return (1 + self.pct_change).cumprod()",
"def calculate_cumulative_returns_by_group(quantile_ret_ts: pd.DataFrame):\n # 1_period_return 5_period_return 10_period_return\n # factor_quantile Date\n # 1 2010-06-17 0.... | [
"0.80346304",
"0.7117688",
"0.7020555",
"0.68004584",
"0.6599235",
"0.65987766",
"0.65317065",
"0.6378568",
"0.6267627",
"0.61863387",
"0.6161118",
"0.61232454",
"0.61232454",
"0.6069886",
"0.60389215",
"0.6008858",
"0.5964947",
"0.5934377",
"0.591715",
"0.5849632",
"0.582511... | 0.76559335 | 1 |
Returns the daily return on investment. | def portfolio_daily_roi(shares_allocation, capital, test_data):
# computes the cumulative returns
cumulative_daily_returns = cumulative_returns(
shares_allocation,
capital,
test_data
)
# calculates daily return on investment
daily_roi = cumulative_daily_returns.apply(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_daily(self, dname, *args, **kwargs):\n if dname != 'returnsN':\n return super(QuoteFetcher, self).fetch_daily(dname, *args, **kwargs)\n\n N, date = args[:2]\n if 'offset' in kwargs:\n offset = kwargs.pop('offset')\n else:\n offset = args[-1] i... | [
"0.6251522",
"0.62175494",
"0.6184673",
"0.6074017",
"0.60315067",
"0.5999271",
"0.59204483",
"0.58649945",
"0.58231676",
"0.5821116",
"0.58064353",
"0.57915264",
"0.5759449",
"0.5746898",
"0.5705196",
"0.5705196",
"0.56715834",
"0.5593716",
"0.5593335",
"0.55523324",
"0.5540... | 0.56852764 | 16 |
Returns the end of year returns of a portfolio. | def end_of_year_returns(model_roi, return_type, start, end):
# converts index of datetimes to a list of strings
dates = model_roi.index.astype('str').tolist()
# list comprehension of a string of dates between the
# start and end dates
years = [str(x) for x in range(start, end + 1)]
# generate... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def end_year(self) -> float:\n\n end_year = -np.inf\n for td_table in list(self.tdve.values()) + self.transfers + self.interpops:\n if len(td_table.tvec) and np.amax(td_table.tvec) > end_year:\n end_year = np.amax(td_table.tvec)\n return end_year",
"def model_end_ye... | [
"0.66694117",
"0.6252978",
"0.5982185",
"0.5906132",
"0.59023",
"0.5769457",
"0.5755498",
"0.5709566",
"0.56960356",
"0.56714946",
"0.5662829",
"0.563564",
"0.55554664",
"0.5549461",
"0.5539725",
"0.5533944",
"0.54835814",
"0.5468832",
"0.5411401",
"0.5375918",
"0.536325",
... | 0.6676339 | 0 |
Returns average annual returns. | def avg_annual_returns(end_of_year_returns, mstat):
# imports mean stats
from scipy.stats import mstats
# converts returns dict to an array (in decimal fmt)
returns_arr = np.array(list(end_of_year_returns.values()))/100
if mstat == 'geometric':
# calculates the geometric mean
gme... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def annual_return(returns, period=DAILY):\n\n if returns.size < 1:\n return np.nan\n\n try:\n ann_factor = ANNUALIZATION_FACTORS[period]\n except KeyError:\n raise ValueError(\n \"period cannot be '{}'. \"\n \"Must be '{}', '{}', or '{}'\".format(\n ... | [
"0.7513993",
"0.7327938",
"0.7215449",
"0.6849367",
"0.6817595",
"0.68023896",
"0.66719836",
"0.66230255",
"0.6608608",
"0.6540497",
"0.64067215",
"0.6393488",
"0.6343028",
"0.6321957",
"0.63070506",
"0.62917763",
"0.6256154",
"0.6240215",
"0.61818576",
"0.60735667",
"0.60480... | 0.8158878 | 0 |
Returns annualized portfolio volatility. | def portfolio_std(weights, test_data):
# computes daily change in returns from 2015-2017
daily_ret_delta = test_data.pct_change()
# computes the covariance matrix of the above
cov_matrix = daily_ret_delta.cov()
# initializes weights
weights_list = []
# iterates over weights dict and appe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def annualized_volatility(self):\n return self.daily_std() * math.sqrt(252)",
"def calc_volatility(self):\n volatility = std(self._returns)\n self._volatility = volatility\n return volatility",
"def annual_volatility(returns, period=DAILY):\n\n if returns.size < 2:\n retur... | [
"0.8074476",
"0.7391112",
"0.7350425",
"0.7104371",
"0.6744522",
"0.6657975",
"0.66555136",
"0.66555136",
"0.6492553",
"0.6439596",
"0.6372493",
"0.6310216",
"0.61207324",
"0.61000425",
"0.60233104",
"0.59982216",
"0.5941567",
"0.5931666",
"0.59143764",
"0.5911077",
"0.588697... | 0.564987 | 26 |
Returns annualized portfolio volatility. | def mis_portfolio_std(weights, test_data, maximum_independent_set):
# computes daily change in returns from 2015-2017
daily_ret_delta = test_data[maximum_independent_set].pct_change()
# computes the covariance matrix
cov_matrix = daily_ret_delta.cov()
# initializes weights list
weights_list =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def annualized_volatility(self):\n return self.daily_std() * math.sqrt(252)",
"def calc_volatility(self):\n volatility = std(self._returns)\n self._volatility = volatility\n return volatility",
"def annual_volatility(returns, period=DAILY):\n\n if returns.size < 2:\n retur... | [
"0.8074476",
"0.7391112",
"0.7350425",
"0.7104371",
"0.6744522",
"0.6657975",
"0.66555136",
"0.66555136",
"0.6492553",
"0.6439596",
"0.6372493",
"0.6310216",
"0.61207324",
"0.61000425",
"0.60233104",
"0.59982216",
"0.5941567",
"0.5931666",
"0.59143764",
"0.5911077",
"0.588697... | 0.0 | -1 |
Returns the daily running 252day maximum. | def daily_rolling_max(cumulative_returns, window=252, min_periods=1):
return cumulative_returns.rolling(
window=window,
min_periods=min_periods
).max() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def obtain_daily_maximum(data=pd.DataFrame()):\n return data.resample(\"D\").max()",
"def _max_days(self):\n # type: (...) -> Union[int, Tuple[int]]\n\n return self.value.max_days",
"def max_days(self):\n # This can be refined, as there are at max 2 consecutive months with 31\n #... | [
"0.73749036",
"0.7217937",
"0.70836467",
"0.667602",
"0.6598183",
"0.6598183",
"0.6532576",
"0.64994997",
"0.6396165",
"0.6396148",
"0.62458897",
"0.6223828",
"0.61432564",
"0.6141461",
"0.6097955",
"0.60674804",
"0.58854157",
"0.58501315",
"0.5818336",
"0.5808526",
"0.575486... | 0.6340012 | 10 |
Returns the daily running 252day drawdown. | def daily_rolling_drawdown(cumulative_returns, rolling_max):
return (cumulative_returns / rolling_max) - 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lifetime_max_drawdown(daily_drawdown):\n\n return round(daily_drawdown.min()*100, 2)",
"def _get_daily_drawing_prompt(self) -> str:\n\n site = urllib.request.urlopen(\n urllib.request.Request(\"https://reddit.com/r/SketchDaily/new\", headers={'User-Agent': 'Mozilla/5.0'}))\n site_... | [
"0.6324104",
"0.60545033",
"0.6035098",
"0.59931993",
"0.5970094",
"0.5958163",
"0.59536815",
"0.591748",
"0.5884653",
"0.5840686",
"0.57922554",
"0.56973386",
"0.5680856",
"0.5680856",
"0.5662309",
"0.56341743",
"0.5618964",
"0.5577764",
"0.55763453",
"0.55734617",
"0.556395... | 0.6346399 | 0 |
Returns the daily running 252day maximum daily drawdown. | def max_daily_rolling_drawdown(daily_drawdown, window=252, min_periods=1):
return daily_drawdown.rolling(
window=window,
min_periods=min_periods
).min() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lifetime_max_drawdown(daily_drawdown):\n\n return round(daily_drawdown.min()*100, 2)",
"def max_drawdown_date(self) -> dt.date:\n mdd_date = (self.tsdf / self.tsdf.expanding(min_periods=1).max()).idxmin().values[0].astype(dt.datetime)\n return dt.datetime.fromtimestamp(mdd_date / 1e9).date()... | [
"0.8053372",
"0.7309904",
"0.7136397",
"0.6945596",
"0.66620314",
"0.65847397",
"0.65381736",
"0.6391821",
"0.623571",
"0.61597496",
"0.59037566",
"0.5875009",
"0.5865871",
"0.58287054",
"0.5795373",
"0.5767846",
"0.57399833",
"0.56995285",
"0.5673958",
"0.56637424",
"0.56529... | 0.7519542 | 1 |
Returns the lifetime maximum drawdown. | def lifetime_max_drawdown(daily_drawdown):
return round(daily_drawdown.min()*100, 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def MaxLifetime(self):\r\n\t\treturn self._get_attribute('maxLifetime')",
"def max_age(self):\n return 120 if self.realtime else 1800",
"def max(self):\n\n return time_stat(self, stat=\"max\")",
"def max_frame_age(self) -> float:\n return self._max_frame_age",
"def max_time(self):\n ... | [
"0.70438933",
"0.6749617",
"0.6718662",
"0.6696578",
"0.6525013",
"0.64177185",
"0.6395959",
"0.63215995",
"0.6261537",
"0.6258824",
"0.6245386",
"0.61703086",
"0.6164336",
"0.6164336",
"0.6155133",
"0.6142087",
"0.6137692",
"0.6115013",
"0.60518104",
"0.60164064",
"0.5985856... | 0.7830443 | 0 |
Returns the lifetime maximum drawdown. | def returns_over_max_drawdown(tot_returns_dict, year, lifetime_maximum_drawdown):
return round(tot_returns_dict[year] / abs(lifetime_maximum_drawdown), 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lifetime_max_drawdown(daily_drawdown):\n\n return round(daily_drawdown.min()*100, 2)",
"def MaxLifetime(self):\r\n\t\treturn self._get_attribute('maxLifetime')",
"def max_age(self):\n return 120 if self.realtime else 1800",
"def max(self):\n\n return time_stat(self, stat=\"max\")",
"def ma... | [
"0.7830443",
"0.70438933",
"0.6749617",
"0.6718662",
"0.6696578",
"0.6525013",
"0.64177185",
"0.6395959",
"0.63215995",
"0.6261537",
"0.6258824",
"0.6245386",
"0.61703086",
"0.6164336",
"0.6164336",
"0.6155133",
"0.6142087",
"0.6115013",
"0.60518104",
"0.60164064",
"0.5985856... | 0.6137692 | 17 |
Returns the growthrisk ratio. | def portfolio_growth_risk(avg_annual_returns, max_daily_rolling_drawdown):
return round(avg_annual_returns / abs(max_daily_rolling_drawdown.mean()*100), 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def golden_ratio():\n return 1.61803398875",
"def bw_ratio(self):\r\n bw = self.bwstats.mean\r\n if bw == 0.0: return 0\r\n else: return self.bw/(1024.*bw)",
"def adv_ratio(self): # XXX\r\n bw = StatsRouter.global_bw_mean\r\n if bw == 0.0: return 0\r\n else: return self.bw/bw",
"def span... | [
"0.68468666",
"0.6782805",
"0.6716115",
"0.67120725",
"0.66483486",
"0.663469",
"0.6482645",
"0.6453428",
"0.6384429",
"0.63716984",
"0.6366324",
"0.6349121",
"0.6314736",
"0.6272553",
"0.62707216",
"0.6267296",
"0.6262057",
"0.62570226",
"0.6190915",
"0.6126322",
"0.60882515... | 0.0 | -1 |
Construct an ESL Receipt. | def __init__(self, db: DB, values: list, user_id: int) -> None:
super(ESLReceipt, self).__init__()
self.db = db
self.transaction_number = values[0]
self.date = format_date(values[1])
self.description = values[2]
self.memo = values[3]
self.amount_debit = values[4]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def work_order_receipt_create(self, work_order_id, worker_id,\n worker_service_id,\n requester_id,\n receipt_create_status,\n work_order_request_hash,\n id=None):\n pass",
"def _generate_cybersource_sa_payload(*, order, receipt_url, cancel_url, ip_address):\n # http:/... | [
"0.6053351",
"0.60198313",
"0.5788419",
"0.57612604",
"0.57396764",
"0.56825536",
"0.5476821",
"0.54742515",
"0.54360664",
"0.5352504",
"0.5342289",
"0.53357846",
"0.53357846",
"0.53352183",
"0.5319554",
"0.5299511",
"0.52830905",
"0.52596617",
"0.52482724",
"0.52446",
"0.519... | 0.6187345 | 0 |
Create a list representation of this object. | def to_list(self) -> list:
return [self.transaction_number, self.date, self.description, self.memo, self.amount_debit,
self.amount_credit, self.balance, self.check_number, self.fees, self.card_type,
self.is_payment, self.is_transaction, self.user_id] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_list(cls, *args):\n return _create_list(cls, *args)",
"def create_list(cls, *args):\n return _create_list(cls, *args)",
"def list(self):\r\n return List(self)",
"def list(self):\r\n return List(self)",
"def list(self):\r\n return List(self)",
"def list(self) ... | [
"0.78831285",
"0.78831285",
"0.7854843",
"0.7854843",
"0.7854843",
"0.7659452",
"0.75172836",
"0.71234053",
"0.68021625",
"0.67077607",
"0.66552454",
"0.6617766",
"0.659643",
"0.6589745",
"0.6534543",
"0.65066326",
"0.6503789",
"0.64903694",
"0.6399522",
"0.6393055",
"0.63908... | 0.617411 | 38 |
Create a tuple representation of this object. | def to_tuple(self) -> tuple:
return (self.transaction_number, self.date, self.description, self.memo, self.amount_debit,
self.amount_credit, self.balance, self.check_number, self.fees, self.card_type,
self.is_payment, self.is_transaction, self.user_id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tuple(self) -> tuple:\n return tuple(self)",
"def as_tuple(self):\n return (self.oid, self.type, self.value)",
"def to_tuple(self):\n return tuple(self.to_list())",
"def as_tuple(self):\n return self.value, self.name",
"def to_tuple(self) -> Tuple[Any, Iterable[Tuple]]:\n ... | [
"0.8206062",
"0.77906114",
"0.77413464",
"0.7683825",
"0.7492797",
"0.73772067",
"0.73772067",
"0.7250236",
"0.7248604",
"0.71830124",
"0.71419895",
"0.70949525",
"0.70850444",
"0.70850444",
"0.7023691",
"0.702011",
"0.6996008",
"0.6961932",
"0.69082046",
"0.6898514",
"0.6879... | 0.6833079 | 24 |
Create a dictionary representation of this object. | def to_dictionary(self) -> dict:
return {
'transaction_number': self.transaction_number,
'date': self.date,
'description': self.description,
'memo': self.memo,
'amount_debit': self.amount_debit,
'amount_credit': self.amount_credit,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_obj(self):\n return dict()",
"def to_dict(self):\n return dict(self)",
"def asdict(self) -> dict:\n return self.__asdict(self)",
"def as_dict(self):\n return dict(self.as_OD())",
"def to_dict(self):\n return {}",
"def to_dict(self):\n return to_dict(self._... | [
"0.81933457",
"0.8123329",
"0.80411434",
"0.8013342",
"0.7980575",
"0.7973111",
"0.7956117",
"0.79091156",
"0.7891545",
"0.7891143",
"0.7881474",
"0.7878525",
"0.7847243",
"0.783445",
"0.783445",
"0.78194517",
"0.7805945",
"0.78007174",
"0.77890986",
"0.7784457",
"0.7773048",... | 0.0 | -1 |
Remove a negative sign from the string. | def format_amount(self) -> str:
if self.amount_debit != '':
return self.amount_debit.replace('-', '')
return self.amount_credit.replace('-', '') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_dash(string):\n\tif string[-1]=='-':\n\t\treturn string[:-1]\n\telse:\n\t\treturn string",
"def remove_plus_minus(x):\n x = strip_stoich_wrapper(x)\n REPLACE_GROUP = r'([LSRD])[ -](\\([+-]\\))'\n # Adding in the r'\\1' ensures that we keep the L component, sub the rest\n ne... | [
"0.761538",
"0.69173324",
"0.67643726",
"0.670503",
"0.66739273",
"0.655915",
"0.64809096",
"0.64616877",
"0.6396145",
"0.6362044",
"0.62969035",
"0.6272038",
"0.6264692",
"0.6227543",
"0.62183565",
"0.61224294",
"0.61101955",
"0.60865664",
"0.6086379",
"0.60761386",
"0.60593... | 0.0 | -1 |
Insert this receipt into the database as well as inserting it into the transactions table, if a transaction. | def insert_to_db(self) -> None:
query = '''INSERT INTO ESLReceipts(Transaction_Number, Date, Description, Memo,
Amount_Debit, Amount_Credit, Balance, Check_Number,
Fees, Card_Type, Is_Payment, Is_Transaction, User_id)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insert(self):\n self.getDbRecord().insert()\n\n return",
"def send_to_db(ck_transactions):\n db = DDDB()\n\n db.add_orders(ck_transactions)",
"def insert(self, sql):\n try:\n # Execute the SQL command\n self.cursor.execute(sql)\n # Commit your cha... | [
"0.6211693",
"0.6090155",
"0.59534514",
"0.5747204",
"0.5717745",
"0.57042015",
"0.57042015",
"0.57042015",
"0.56759435",
"0.5658691",
"0.5618459",
"0.56082004",
"0.5607029",
"0.56063724",
"0.5585733",
"0.5573718",
"0.55546314",
"0.5539944",
"0.5531392",
"0.5496173",
"0.54764... | 0.8284341 | 0 |
May not work with duplicate transactions on same dates, may want to figure out better query. Check to see if this object exists within the db. | def exists_in_db(self) -> bool:
query = '''SELECT *
FROM ESLReceipts
WHERE Transaction_Number=? AND Date=? AND Description=?
AND Memo=? AND Amount_Debit=?
AND Amount_Credit=? AND... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_duplicate_trans(self):\n transactions_set = set(self._transactions)\n return len(transactions_set) == len(self._transactions)",
"def alreadyStored(self, date_):\r\n for day in self._repo:\r\n if day.date == date_:\r\n return True\r\n return False",... | [
"0.63032657",
"0.6060435",
"0.59728163",
"0.5909144",
"0.5890913",
"0.5875711",
"0.5871815",
"0.57318866",
"0.5668111",
"0.5658965",
"0.56536156",
"0.56436634",
"0.5630893",
"0.5628744",
"0.5618186",
"0.5599592",
"0.5577646",
"0.55707943",
"0.55545235",
"0.5551597",
"0.551997... | 0.597987 | 2 |
Retrieve the id of this object from the database. | def get_id(self) -> int:
query = '''SELECT id
FROM ESLReceipts
WHERE Transaction_Number=? AND Date=? AND Description=?
AND Memo=? AND Amount_Debit=?
AND Amount_Credit=? AND Balan... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_id(self):\n return self.id",
"def get_id(self):\n return self.id",
"def get_id(self):\n return self.id",
"def get_id(self):\n return self.id",
"def get_id(self):\n return self.id",
"def get_id(self):\n return self.id",
"def get_id(self):\n return... | [
"0.8268289",
"0.8268289",
"0.8268289",
"0.8268289",
"0.8268289",
"0.8268289",
"0.8268289",
"0.8268289",
"0.8268289",
"0.8268289",
"0.8268289",
"0.8268289",
"0.8268289",
"0.8268289",
"0.8268289",
"0.8268289",
"0.8268289",
"0.82324207",
"0.82324207",
"0.8194997",
"0.81552595",
... | 0.0 | -1 |
Retrieve the string representation of this objects' type. | def get_type(self) -> str:
return Tables.ESL.name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def type_as_string(self):\n return self.properties.get('TypeAsString', None)",
"def type_name(self) -> str: # pragma: no cover\n return repr_type(self.type_obj)",
"def getTypeString(self):\n return '_'.join(self.types)",
"def type(self) -> str:\n return self._type",
"def type(s... | [
"0.8733057",
"0.8553197",
"0.85377437",
"0.8325933",
"0.8325933",
"0.8325933",
"0.8290743",
"0.8279878",
"0.82764584",
"0.82569075",
"0.82285696",
"0.82285696",
"0.8195347",
"0.81576073",
"0.8149313",
"0.8138784",
"0.8124178",
"0.81017655",
"0.8085337",
"0.8024441",
"0.792285... | 0.0 | -1 |
Returns root endpoint HTML | def hello_world():
keyword_query = 'Gamestop' # Change it to something you're interested in!
article_data = get_article_data(keyword_query)
return render_template(
"index.html",
topic=keyword_query,
headlines=article_data['headlines'],
snippets=article_data['snippets'],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_root():\r\n return render_template(\"index.html\"), 200",
"def root(self):\n return self.app.get('/',headers=self.headers)",
"def root():\n return render_template('index.html')",
"def root():\n return render_template('index.html')",
"def root():\n return render_template('index.ht... | [
"0.7781494",
"0.7524314",
"0.7460347",
"0.7460347",
"0.7460347",
"0.73451215",
"0.73225725",
"0.7263215",
"0.72324246",
"0.7196254",
"0.71309966",
"0.7130514",
"0.70534015",
"0.6958472",
"0.695357",
"0.6901402",
"0.6869037",
"0.68371344",
"0.68197304",
"0.6809037",
"0.6803652... | 0.0 | -1 |
Set a Source class from the input | def _set_source(source, context):
if isinstance(source, (str, list, dict, Dataset)):
return Source(source, context)
elif isinstance(source, Source):
return source
else:
raise ValueError('Wrong source') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, source):\n self._source = source",
"def SphinxDummySourceClass(source: Any, *args: Any, **kwargs: Any) -> Any:\n return source",
"def __init__(self, source):\r\n self.source = source",
"def __init__(self, source):\n self.source = source",
"def __init__(self, sourc... | [
"0.67583483",
"0.67401874",
"0.66732496",
"0.6669555",
"0.6669555",
"0.65352905",
"0.65030694",
"0.63952017",
"0.6294075",
"0.6294075",
"0.6294075",
"0.6294075",
"0.6294075",
"0.6294075",
"0.6294075",
"0.62846047",
"0.62708694",
"0.6204473",
"0.61683613",
"0.61246663",
"0.608... | 0.72986305 | 0 |
Set a Style class from the input | def _set_style(style):
if isinstance(style, (str, dict)):
return Style(style)
elif isinstance(style, Style):
return style
else:
return Style() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_style(self):",
"def set_style(self, style):\n if isinstance(style, string_types):\n style = get_style_by_name(style)\n self._style = style\n self._clear_caches()",
"def style(self, style):\n\n self.container['style'] = style",
"def update_css_class(kwargs, class... | [
"0.654943",
"0.63310474",
"0.6265196",
"0.6194581",
"0.61655325",
"0.61655325",
"0.61425185",
"0.6124288",
"0.6023133",
"0.60221726",
"0.6001759",
"0.59781164",
"0.59699464",
"0.5902382",
"0.58698934",
"0.58513117",
"0.5782348",
"0.57525957",
"0.57379335",
"0.573579",
"0.5732... | 0.6732158 | 0 |
Set a Popup class from the input | def _set_popup(popup):
if isinstance(popup, dict):
return Popup(popup)
elif isinstance(popup, Popup):
return popup
else:
return Popup() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_popup(self):\n self.popup = Popup(Point(0, 2), self, \"\", \"\")\n self.popup.set_highlight_color(self.graphics.HIGHLIGHT)\n self.popup.set_secondary_color(self.graphics.DIM)\n title_color = self.graphics.BRIGHT | self.graphics.UNDERLINE\n self.popup.set_title_color(titl... | [
"0.63107663",
"0.6060422",
"0.5535878",
"0.52886254",
"0.52468014",
"0.52125245",
"0.51682144",
"0.5146479",
"0.5079666",
"0.50717413",
"0.50559866",
"0.5050433",
"0.49416202",
"0.4940349",
"0.48901185",
"0.4874202",
"0.48704216",
"0.48458034",
"0.4833469",
"0.47811547",
"0.4... | 0.6512138 | 0 |
Set a Legend class from the input | def _set_legend(legend):
if isinstance(legend, dict):
return Legend(legend)
elif isinstance(legend, Legend):
return legend
else:
return Legend() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def legend(self, legend):\n\n self.container['legend'] = legend",
"def legend(self, legend):\n\n self._legend = legend",
"def legend (self, **kwargs):\n axes = self.twin_axes or self.axes\n self.mpl_legend = axes.legend (self.mpl_lines, self.labels, **kwargs)",
"def finish (self, ... | [
"0.6538302",
"0.64451087",
"0.63078874",
"0.60143113",
"0.5830607",
"0.5821305",
"0.5782544",
"0.5664723",
"0.5637923",
"0.55676806",
"0.5538643",
"0.55200446",
"0.5487594",
"0.54669875",
"0.54185116",
"0.54073274",
"0.5400403",
"0.53886503",
"0.53818643",
"0.53346527",
"0.53... | 0.67842346 | 0 |
generates a list of dice values into the class attribute dice. Increments throw number attribute. | def throw_dice(self):
self.dice = []
for i in range (6):
die = random.randint(1, 6)
self.dice.append(die)
self.num_throws += 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def roll_dice():\n rolled_number = []\n for number in range(0,4):\n rolled_number.append(random.randint(1, 6))\n \n rol\n \n \n class Dog():\n def __init__(self, name, age):\n self.name = name",
"def rollDices():\n for i in range(5):\n dices[i] = randint(1,... | [
"0.7211979",
"0.6997264",
"0.6851038",
"0.6751333",
"0.6729713",
"0.668519",
"0.6677819",
"0.66247433",
"0.65643424",
"0.6544101",
"0.6543014",
"0.6510373",
"0.6505515",
"0.6487591",
"0.6461432",
"0.6459857",
"0.64389354",
"0.6434398",
"0.64102566",
"0.6345126",
"0.63131344",... | 0.73881346 | 0 |
Calculates points from current dice roll. | def get_points(self):
self.round_points = 0
for die in self.dice:
if die == 1:
self.round_points += 100
elif die == 5:
self.round_points += 50
return self.round_points | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assign_points(self, dice):\n if not self.assigned:\n self._assigned = True\n self._points = self._calculate_points(dice)",
"def calculate_points(self):\n points = 0\n for power in self.stats['powers']:\n points += self.stats['powers'][power]\n retu... | [
"0.66966766",
"0.66681296",
"0.6637562",
"0.65762514",
"0.6406548",
"0.62852454",
"0.6266145",
"0.6250244",
"0.62489074",
"0.6243738",
"0.615768",
"0.6100919",
"0.60981864",
"0.60895824",
"0.608306",
"0.6028972",
"0.59434074",
"0.5937676",
"0.5882016",
"0.5868866",
"0.5841612... | 0.7415062 | 0 |
Determines if another throw is valid. | def can_throw(self):
if self.round_points == 0:
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def WrapNonExceptionThrows(self) -> bool:",
"def check_for_raise_condition(self, first_arg):\n for key, val in self.query_return_values.items():\n for sa_class, attr in [(DeclarativeMeta, '__table__'),\n (InstrumentedAttribute, 'property')]:\n if... | [
"0.5762478",
"0.5735585",
"0.5678639",
"0.56598675",
"0.56276846",
"0.56141746",
"0.55751085",
"0.5548169",
"0.55279744",
"0.5496751",
"0.54638016",
"0.54616606",
"0.54095435",
"0.5398751",
"0.539429",
"0.5393722",
"0.53783095",
"0.53757596",
"0.5365019",
"0.5364991",
"0.5339... | 0.52178335 | 38 |
Show all data sets in one folder. Shortcut for 'demo.py show file1 e file2 ....' | def all(folder, mt=False):
handles = []
experiments = get_experiment_series(folder, mT=mt)
for ex in experiments:
if mt:
handles.append(
plt.plot(
ex.distance,
ex.weight,
label='{}mm {}mT'.format(ex.height, ex.ma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_data_files(self):\n for idx in self.plot_data:\n self.plot_data[idx].show()",
"def show ( self, **show_kw ):\n for package in self._subdirs.values():\n package.show ( **show_kw )",
"def show_dataset(folder, n=10):\n volumes = volume_paths(folder)\n for i, v in enum... | [
"0.7206528",
"0.6704359",
"0.6531897",
"0.62452567",
"0.62223077",
"0.6216129",
"0.615565",
"0.6036854",
"0.5980537",
"0.59479564",
"0.59352255",
"0.58796173",
"0.58701545",
"0.5865497",
"0.586405",
"0.58427453",
"0.5840055",
"0.5772605",
"0.57498944",
"0.57193184",
"0.569840... | 0.5747747 | 19 |
Render data in provided input file using row 2 and 3. | def show(infile, zero=False):
assert len(infile) > 0, "At least one inputfile must be provided"
experiments = []
for f in infile:
experiments.append(Experiment(f))
plt.xlabel(r'Distance in $mm$')
plt.ylabel(r'Weight in $g$')
handles = []
for e in experiments:
if zero:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def csvdata():\n return render_template(\"data.html\")",
"def get_file_data(self):\n self.switch_row(self.PATTERN_INFO_ROW)\n\n # get background image file path\n if self.row[0] != 'No image':\n # set path to background image, and get/set screen size\n self.bg_img_pat... | [
"0.54804945",
"0.5446267",
"0.53765386",
"0.53220177",
"0.528258",
"0.5273371",
"0.5207391",
"0.5203178",
"0.5175294",
"0.51712817",
"0.5171099",
"0.517103",
"0.51068914",
"0.510211",
"0.5092412",
"0.5082377",
"0.5069564",
"0.50449073",
"0.50380313",
"0.5024925",
"0.5022232",... | 0.0 | -1 |
Find max value of every file in the provided folder. | def max(folder):
experiments = get_experiment_series(folder)
plt.plot([ex.height for ex in experiments], [ex.maxWeight() for ex in experiments])
plt.show() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_latest_file(folder):\n if not os.path.exists(folder):\n raise AppException(\"Folder does not exists!\")\n return max(glob.iglob(folder + \"/*\"), key=os.path.getctime)",
"def get_latest(dir_list):\n int_list = []\n for directory in dir_list:\n try:\n int_l... | [
"0.70181876",
"0.68163276",
"0.65994817",
"0.6551173",
"0.6296109",
"0.6280196",
"0.6130655",
"0.61263907",
"0.60991913",
"0.605896",
"0.6038931",
"0.6019283",
"0.6011168",
"0.5990008",
"0.5971479",
"0.5960095",
"0.5925378",
"0.5911864",
"0.5896931",
"0.5863172",
"0.5847859",... | 0.57354146 | 23 |
Find the breaking point of the provided graph | def find_breaks(infile, dx, minval, plot, fwmh):
ex = Experiment(infile)
ex.find_breaks(minval=minval, dx=dx, plot=plot) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_breaking_point(x, y):\n # select threshold where curve break\n slope = (y[-1] - y[0]) / len(y)\n y_grad = np.gradient(y)\n m = list(y_grad >= slope)\n j = m.index(False)\n m = m[j:]\n x = x[j:]\n y = y[j:]\n if True in m:\n i = m.index(True)\n else:\n i = -1\n ... | [
"0.69425875",
"0.6751981",
"0.62985086",
"0.56206095",
"0.56047994",
"0.552724",
"0.5449823",
"0.53517556",
"0.5321847",
"0.5278051",
"0.5276969",
"0.5265826",
"0.5265269",
"0.52511835",
"0.5230468",
"0.5227905",
"0.5221146",
"0.52105725",
"0.51963985",
"0.51860183",
"0.51475... | 0.0 | -1 |
kw ==>> function(file_path=file_path,save_path=save_path,kw) ex. conversion='s2t' | def CallF_DirFile_save(dir_path,function,file_head_name='new_',replace_old=False,file_filter_=None,regular=False,**kw):
file_list = Get_dir_file_list(dir_path=dir_path,file_filter_=file_filter_,regular=regular,distinguish=True)
file_list = file_list[0]
for file_name in file_list:
file_path = os.path... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(file):\n\n # Get the current working directory.\n here = os.getcwd()\n #Need the file_name to set globe, so that other functions can access to it.\n global file_name\n # Spite the Input into file_path and file_name.\n file_path = spilt_path(file)[0]\n file_name = spilt_path(file)[1]\n... | [
"0.5469621",
"0.5448147",
"0.5395161",
"0.5394721",
"0.52756107",
"0.5140342",
"0.509505",
"0.50910085",
"0.50839645",
"0.50631875",
"0.50515723",
"0.50288105",
"0.5018318",
"0.5012531",
"0.49956027",
"0.49208355",
"0.49167103",
"0.48899543",
"0.48839748",
"0.48737064",
"0.48... | 0.0 | -1 |
return list kw ==>> function(file_path=file_path,save_path=save_path,kw) ex. conversion='s2t' | def CallF_DirFile(dir_path,function,file_filter_=None,regular=False,**kw):
file_list = Get_dir_file_list(dir_path=dir_path,file_filter_=file_filter_,regular=regular,distinguish=True)
file_list = file_list[0]
save_list = []
for file_name in file_list:
file_path = os.path.join(dir_path,file_name)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _convert(self, filepath):\n raise NotImplementedError()",
"def convert_txt_to_data():\n pass",
"def convert_01(filename,ext_out=\".json\"):\n summary=[]\n try:\n ext_in = os.path.splitext(filename)[1]\n if (ext_in == ext_out):\n print(\"\\tError input extention matc... | [
"0.56361085",
"0.5504672",
"0.54413015",
"0.539796",
"0.53592116",
"0.53004533",
"0.5227658",
"0.52184165",
"0.5096168",
"0.502128",
"0.49623695",
"0.49120712",
"0.48973635",
"0.48932657",
"0.48899108",
"0.48844537",
"0.48754358",
"0.4872553",
"0.4862515",
"0.48617154",
"0.48... | 0.45459044 | 69 |
Filter out longer of line than max_word_num | def Filter_file_wlen(file_path,save_path,max_word_num,replace_old=False,encoding='utf-8',
word_split=' ',row_split='\n',padding=None):
with open(file_path,'r',encoding=encoding) as f:
with open(save_path, 'w',encoding=encoding) as f_wrtie:
if padding == None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_long_words():\n f = open('session09/words.txt')\n \n for line in f:\n word = line.strip()\n if len(word) > 20:\n print(word, len(word))",
"def remove_longer_words(text):\n return \" \".join([word for word in str(text).split() if len(word) <= 12])",
"def filter_te... | [
"0.6970572",
"0.6750624",
"0.6748221",
"0.6604386",
"0.6440132",
"0.63298947",
"0.63013774",
"0.6236585",
"0.61541104",
"0.6127007",
"0.6068392",
"0.5990749",
"0.59631073",
"0.5956658",
"0.5945256",
"0.59395516",
"0.5923759",
"0.5896358",
"0.58945507",
"0.58920485",
"0.587292... | 0.65711075 | 4 |
The number of words in the line does not exceed max_word_num, run padding. | def Padding_file_lword(file_path,save_path,max_word_num,replace_old=False,encoding='utf-8',
padding='my_padding_str',word_split=' ',row_split='\n'):
with open(file_path,'r',encoding=encoding) as f:
with open(save_path, 'w',encoding=encoding) as f_wrtie:
for line in f:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cut_in_words(self,linea):\n length = 0\n res = ''\n limit_screen = 30\n for word in linea.split(' '):\n if length + len(word) <= limit_screen:\n new_word = word + ' '\n length += len(new_word)\n else:\n new_word = '\... | [
"0.6321368",
"0.62552446",
"0.62552446",
"0.62552446",
"0.6224735",
"0.62228525",
"0.60601604",
"0.60480917",
"0.60226417",
"0.59796304",
"0.59780484",
"0.5938737",
"0.5922524",
"0.59193945",
"0.591625",
"0.58862084",
"0.58735347",
"0.5864799",
"0.58254963",
"0.5813321",
"0.5... | 0.6182837 | 6 |
batch using dir_file_call_function() close log using "logging.disable(lvl)" | def Jieba_file_segmentation(file_path,save_path,replace_old=False,word_delimiter=' ',
file_delimiter='\n',stopword_path=None,encoding='utf-8'):
import jieba
#設置log格式，以及print的log等級
logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
# ji... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setLogFileOff(self):\n self.edLogging.setLogFileOff()",
"def clean_up_logging_decorator(func):\n filename = filename_regexp.match(inspect.getmodule(inspect.stack()[1][0]).__file__).group(1)\n\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n logger.info('{}: Start cleaning up'... | [
"0.62549573",
"0.6227667",
"0.62244844",
"0.6010256",
"0.58438027",
"0.57851404",
"0.57381016",
"0.57026744",
"0.5680886",
"0.565489",
"0.56436425",
"0.5627239",
"0.5612014",
"0.5611865",
"0.560305",
"0.55806977",
"0.55713636",
"0.557088",
"0.5515398",
"0.55111116",
"0.550829... | 0.0 | -1 |
batch using dir_file_call_function() close log using "logging.disable(lvl)" | def Opencc_file(file_path,save_path,replace_old=False,conversion='s2t',encoding='utf-8'):
from opencc import OpenCC
logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
cc = OpenCC(conversion)
string = ''
with open(file_path,'r',encoding=encoding) as read_f:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setLogFileOff(self):\n self.edLogging.setLogFileOff()",
"def clean_up_logging_decorator(func):\n filename = filename_regexp.match(inspect.getmodule(inspect.stack()[1][0]).__file__).group(1)\n\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n logger.info('{}: Start cleaning up'... | [
"0.6256523",
"0.62290466",
"0.622886",
"0.60116386",
"0.5846248",
"0.5788501",
"0.57395935",
"0.57019794",
"0.5679706",
"0.56533265",
"0.5642139",
"0.5629246",
"0.56152624",
"0.5612089",
"0.56046575",
"0.55847603",
"0.55710196",
"0.55698",
"0.5516899",
"0.5510668",
"0.5508379... | 0.0 | -1 |
Run migrations in 'offline' mode. This configures the context with just a URL and not an Engine, though an Engine is acceptable here as well. By skipping the Engine creation we don't even need a DBAPI to be available. Calls to context.execute() here emit the given string to the script output. | def run_migrations_offline():
url = alembic_config.get_main_option("sqlalchemy.url")
context.configure(
url=url,
target_metadata=target_metadata,
literal_binds=True
)
with context.begin_transaction():
context.run_migrations() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_migrations_offline():\n url = get_url()\n context.configure(\n url=url,\n target_metadata=target_metadata,\n literal_binds=True,\n compare_type=True,\n version_table_schema=POSTGRES_SCHEMA,\n )\n\n with context.begin_transaction():\n context.run_migrati... | [
"0.80311227",
"0.8030696",
"0.803014",
"0.7821831",
"0.7810445",
"0.7810445",
"0.7810445",
"0.78074014",
"0.78074014",
"0.78003657",
"0.7758784",
"0.7664535",
"0.75625294",
"0.72418004",
"0.683509",
"0.6713637",
"0.6491039",
"0.64804435",
"0.64549184",
"0.6450837",
"0.6417197... | 0.77403295 | 11 |
Run migrations in 'online' mode. In this scenario we need to create an Engine and associate a connection with the context. | def run_migrations_online():
connectable = engine_from_config(
alembic_config.get_section(alembic_config.config_ini_section),
prefix='sqlalchemy.',
poolclass=pool.NullPool)
with connectable.connect() as connection:
context.configure(
connection=connection,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_migrations_online():\n # specify here how the engine is acquired\n engine = create_engine(db_url)\n if isinstance(engine, Engine):\n connection = engine.connect()\n else:\n raise Exception(\n 'Expected engine instance got %s instead' % type(engine)\n )\n # pyl... | [
"0.83303607",
"0.80863214",
"0.8021978",
"0.7952788",
"0.78426266",
"0.78426266",
"0.7835564",
"0.7816424",
"0.7793565",
"0.77598333",
"0.7744341",
"0.7678985",
"0.75311255",
"0.74458575",
"0.7393637",
"0.72782445",
"0.72048295",
"0.72048295",
"0.72048295",
"0.7193927",
"0.71... | 0.77268213 | 11 |
A concordancer for Tregex queries over trees or regexes over plain text | def conc(corpus, query,
n = 100,
random = False,
window = 40,
trees = False,
plaintext = 'guess'):
import os
import re
import pandas as pd
from pandas import DataFrame
from time import localtime, strftime
try:
from IPython.display import d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def slow_tregex(sents, **dummy_args):\n speakr = dummy_args.get('speaker', '')\n import os\n from corpkit.process import tregex_engine\n # first, put the relevant trees into temp file\n to_open = '\\n'.join(sent.parse_string.strip() for sent in sents \\\n ... | [
"0.6346311",
"0.63272005",
"0.61945575",
"0.5999631",
"0.57411695",
"0.57234347",
"0.5704001",
"0.5676995",
"0.56152594",
"0.5605837",
"0.55126595",
"0.5373799",
"0.5355118",
"0.53242844",
"0.53140885",
"0.5293481",
"0.5287096",
"0.52824426",
"0.52277535",
"0.5182872",
"0.515... | 0.0 | -1 |
Generate Call number by Library of Congress Classification | def gen_call_number(self, serializer):
data = serializer.validated_data
original_data = self.request.data
subject = data['subject']
author_id = original_data['authors'][0]
publication_date = data['publication_date'].year
code = Constant.BOOK_SUBJECT_CODE[subject]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_cnv(self):\r\n\r\n self.cnv = random.sample(range(1, 25), 4)\r\n self.c_array = random.sample(self.c_array, len(self.c_array))\r\n score = float(0)\r\n common = [i for i in self.cnv[1:] if i in self.c_array]\r\n if self.cnv[0] in self.c0_array:\r\n score += 0.... | [
"0.54599875",
"0.5346699",
"0.5329161",
"0.5242474",
"0.52265507",
"0.52088416",
"0.5199471",
"0.5125358",
"0.51210237",
"0.50600225",
"0.50577676",
"0.5043906",
"0.5036982",
"0.5026152",
"0.5023245",
"0.50229776",
"0.5021118",
"0.50144714",
"0.5008166",
"0.50016636",
"0.4993... | 0.52430516 | 3 |
Initialize your data structure here. | def __init__(self, values=1000000):
self.size = int(sqrt(values))
self.buckets = [None] * self.size | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_empty(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__... | [
"0.7765608",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7595176",
"0.75853467",
"0.7558298",
"0.7530608",
"0.7530608",
"0.7530608",
"0.7530608",
"0.7530608",
"0.74971247",
"0.74971247",
"0.7478105",
"0.7477832",
"0.7477832",
"0.7477832",
... | 0.0 | -1 |
Returns true if this set contains the specified element | def contains(self, key: int) -> bool:
hash1, hash2 = self._hash(key)
if not self.buckets[hash1]:
return False
return self.buckets[hash1][hash2] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _contains(self, element):\n if not isinstance(element, Tuple) or len(element) != 2:\n return S.false\n\n if not element[1].is_Integer:\n return S.false\n\n if element[1] >= len(self.sets) or element[1] < 0:\n return S.false\n\n return self.sets[eleme... | [
"0.8238365",
"0.81394833",
"0.8021257",
"0.7981039",
"0.76247203",
"0.7380103",
"0.7340669",
"0.73250914",
"0.73250914",
"0.729173",
"0.72639936",
"0.7257722",
"0.7257722",
"0.72303694",
"0.719921",
"0.7197546",
"0.7190269",
"0.7190217",
"0.7183452",
"0.7173034",
"0.7150846",... | 0.0 | -1 |
Check a translationonly field on one or more axes, different image orientations. | def test_itk_h5(tmp_path, testdata_path):
os.chdir(str(tmp_path))
img_fname = testdata_path / "T1w_scanner.nii.gz"
xfm_fname = (
testdata_path
/ "ds-005_sub-01_from-T1w_to-MNI152NLin2009cAsym_mode-image_xfm.h5"
)
xfm = _load(xfm_fname)
assert len(xfm) == 2
ref_fname = tmp_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_transformations(*args):\n assert args[0].shape == (21,21)\n assert args[0].dtype == np.float64\n if len(args) == 2:\n assert args[1].shape == (2,2)\n assert args[1].dtype == np.float64",
"def checkField(fieldset, text=True):\n if text:\n print \"\\nFieldset contains the... | [
"0.58493704",
"0.5795946",
"0.55515265",
"0.55038935",
"0.5467156",
"0.5446259",
"0.5384152",
"0.5367525",
"0.5367525",
"0.53530484",
"0.53415245",
"0.52947795",
"0.52947795",
"0.5200388",
"0.5127027",
"0.5111068",
"0.5102852",
"0.50853443",
"0.50678736",
"0.5057223",
"0.5017... | 0.0 | -1 |
Check whether affines are correctly collapsed. | def test_collapse_affines(tmp_path, data_path, ext0, ext1, ext2):
chain = TransformChain(
[
Affine.from_filename(
data_path
/ "regressions"
/ f"from-fsnative_to-scanner_mode-image.{ext0}",
fmt=f"{FMT[ext0]}",
),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collapsed(blk):\n if blk is not None and blk.name in COLLAPSIBLE and\\\n len(blk.values) == 1 and blk.values[0] != 0:\n return True\n return False",
"def collapsed(self) -> None:",
"def check_done(grid):\r\n for row in grid:\r\n for el in row:\r\n if not el.collapsed... | [
"0.6648625",
"0.64990586",
"0.6319578",
"0.6291907",
"0.6267607",
"0.6213155",
"0.6111619",
"0.5948826",
"0.57925594",
"0.5738614",
"0.56732744",
"0.53091776",
"0.53027165",
"0.52979547",
"0.5263411",
"0.52244925",
"0.51575667",
"0.51398015",
"0.5111023",
"0.5051264",
"0.5032... | 0.48665687 | 29 |
Calcualtes the name of the currency using the initials. | def currency_name(self, init):
c2 = CurrencyCodes()
c_name = c2.get_currency_name(init)
return c_name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def currency_word(self):\n result = \" \"\n for cr in self:\n if cr.currency_id.name == 'USD':\n result = \" Dollar\"\n elif cr.currency_id.name == 'EUR':\n result = \" Euro\"\n elif cr.currency_id.name == 'JPY':\n result =... | [
"0.6545595",
"0.65187955",
"0.6400594",
"0.61858106",
"0.6183995",
"0.5940923",
"0.5884641",
"0.58576405",
"0.57543",
"0.5593448",
"0.55822915",
"0.5562207",
"0.55397344",
"0.5527879",
"0.5522243",
"0.55098426",
"0.54883844",
"0.54776466",
"0.54487824",
"0.54059935",
"0.53924... | 0.73644185 | 0 |
Calculates the latest rate for the currency at hand. | def currency_rate(self, init):
curr = CurrencyRates()
curr_rate = curr.get_rates(init)
return curr_rate | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exchange_rate(self):\n res = r.get(self.url + self.current_rate)\n return self.execute(res)",
"def get_current_rate(self):\n pass",
"def update(self):\n self.rate = self.exchange.latest()",
"def api_call(cls, currency):\n headers = {\"x-accept-version\": \"2.0.0\", \"Ac... | [
"0.7194681",
"0.7087124",
"0.7015733",
"0.6857771",
"0.6801177",
"0.6785793",
"0.66941553",
"0.66645527",
"0.66415185",
"0.6638817",
"0.6485171",
"0.6424446",
"0.6401379",
"0.63694507",
"0.63674176",
"0.633374",
"0.6300826",
"0.628026",
"0.62679833",
"0.62639594",
"0.62147737... | 0.713497 | 1 |
Calculates the latest conversion rate for the currency at hand. | def conversion_rate(self, init, new_currency):
curr = CurrencyRates()
curr_conv_rate = curr.get_rate(init, new_currency)
return curr_conv_rate | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def currency_rate(self, init):\r\n\r\n curr = CurrencyRates()\r\n curr_rate = curr.get_rates(init)\r\n return curr_rate",
"def get_currency_exchange_rate(self, from_currency, to_currency):\n _FUNCTION_KEY = 'CURRENCY_EXCHANGE_RATE'\n return _FUNCTION_KEY, 'Realtime Currency Exc... | [
"0.6993551",
"0.69812477",
"0.6692026",
"0.666445",
"0.6645402",
"0.6555873",
"0.6546272",
"0.6487058",
"0.64221525",
"0.6406838",
"0.64052564",
"0.6369392",
"0.6346241",
"0.63396156",
"0.63319975",
"0.6328635",
"0.6302605",
"0.6302515",
"0.618671",
"0.61817455",
"0.60828835"... | 0.74947244 | 0 |
Converts an amount from the currency at hand to a new currency. | def convert_amount(self, init, new_currency, amount):
curr = CurrencyRates()
curr_conversion = curr.convert(init, new_currency, amount)
return curr_conversion | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _convert(self, from_amount, to_currency, company, date, round=True):\n self, to_currency = self or to_currency, to_currency or self\n assert self, \"convert amount from unknown currency\"\n assert to_currency, \"convert amount to unknown currency\"\n assert company, \"convert amount... | [
"0.73006153",
"0.72782034",
"0.71290565",
"0.70164573",
"0.6842994",
"0.6626046",
"0.6571269",
"0.65345883",
"0.6460881",
"0.64539254",
"0.6389461",
"0.6372568",
"0.6338758",
"0.6223571",
"0.6182157",
"0.6140729",
"0.6137326",
"0.6085868",
"0.6061959",
"0.6049651",
"0.5981646... | 0.77393734 | 0 |
Calculates the relative symbol for the currency at hand. | def currency_symbol(self, init):
c2 = CurrencyCodes()
c_symbol = c2.get_symbol(init)
return c_symbol | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getCurrencySymbol():",
"def monetary_base(self, symbol):\n pass",
"def local_price(amount, currency):\n amt = convert(amount, currency)\n sym = symbol(currency)\n return f'{sym}{amt}'",
"def getBaseCurrency():",
"def getCurrencySymbol(id=None):",
"def create_symbol(self, base_ccy, ass... | [
"0.7532425",
"0.61583894",
"0.6051573",
"0.6010398",
"0.6007663",
"0.57941693",
"0.5785363",
"0.5702698",
"0.568727",
"0.5658896",
"0.5622147",
"0.5558757",
"0.5514153",
"0.5434841",
"0.5427567",
"0.54007",
"0.53848547",
"0.5369845",
"0.53468686",
"0.53214556",
"0.5318823",
... | 0.62263805 | 1 |
Checks whether or not an entered currency is valid. | def check_currency_validity(self, init):
currencies = open("supported_curr.txt", "r")
alert = "Not a valid currency. Please try again!"
if init in currencies:
return init
else:
return alert | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validateCurrency(self, currency_code):\n if currency_code in self.travel_db.currencies:\n return True\n else:\n return False",
"def validate_currency(currency_code):\n try:\n rate = rates.get_rates(currency_code)\n return 0\n except:\n flash(f'Er... | [
"0.73480386",
"0.7288969",
"0.670163",
"0.65683585",
"0.6326081",
"0.6306544",
"0.6249831",
"0.6232125",
"0.6184508",
"0.6178256",
"0.6126641",
"0.6100734",
"0.60888636",
"0.60436463",
"0.60396165",
"0.6022093",
"0.60103476",
"0.60070944",
"0.5970834",
"0.59520406",
"0.595190... | 0.68851346 | 2 |
Checks whether or not an entered amount is valid. | def check_amount_validity(self, amount):
alert = "Not a valid amount. Please try again!"
if type(amount) == int or type(amount) == float:
return amount
else:
return alert | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_amount_valid(self):\n\t\tamount = self.entry_amount.get()\n\n\t\ttry:\n\t\t\tfloat(amount)\n\t\texcept ValueError:\n\t\t\tmessagebox.showerror(\"Invalid Amount\", \"Amount must be a positive number\")\n\t\t\treturn False\n\n\t\tif float(amount) < 0:\n\t\t\tmessagebox.showerror(\"Invalid Amount\", \"Amount ... | [
"0.82144606",
"0.7673015",
"0.75659555",
"0.6944316",
"0.6673183",
"0.65760684",
"0.6559131",
"0.6552635",
"0.6488286",
"0.64840955",
"0.6429893",
"0.6422951",
"0.6412067",
"0.6382808",
"0.63355726",
"0.63257205",
"0.6321893",
"0.63069206",
"0.626406",
"0.62407017",
"0.621087... | 0.78239405 | 1 |
featuresn least square method impletement Use sum of square error function which aroses in the maximum likehood to get liner regression param set w for supervised learning. To control overfitting, use lmd for regularization. | def least_square(features, values, w, lmd=None, regularizer=2):
if lmd == None:
lmd = 0
size = len(values)
R = lmd * eye(len(features[0, :]))
# solve the equation features'*features*w=features'b
w = linalg.solve(R+dot(features.T, features), dot(features.T, values))
return w | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def learn(self, Xtrain, ytrain):\n pass\n self.weights = np.zeros(Xtrain.shape[1],)\n\n ### YOUR CODE HERE\n \n lmbd = self.params['lamb']\n \n numsamples = Xtrain.shape[0]\n # Xless = Xtrain[:,self.params['features']]\n Xless = Xtrain\n self.we... | [
"0.59811664",
"0.59792453",
"0.5977199",
"0.5910014",
"0.57902515",
"0.57429147",
"0.5736021",
"0.5726675",
"0.5687944",
"0.55737907",
"0.55421764",
"0.55418295",
"0.5539954",
"0.5535652",
"0.5524679",
"0.5473309",
"0.5462243",
"0.54486495",
"0.5445677",
"0.54421",
"0.5438471... | 0.63457775 | 0 |
linear Regression use bayesian approach | def bayesian(features, values, w, alpha=None, beta=None, steps=None):
#alpha and beta can be init by user
if alpha == None:
alpha = .1
if beta == None:
beta = 10
#iterate time control to fix alpha beta
if steps == None:
steps = 100
size = len(values)
R = alpha * eye(l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nnRegression(data):",
"def linear_model(inp, w1, b1):\n y = inp @ w1 + b1\n centered_y = y - y.mean()\n return centered_y.sum()",
"def linear_regression(features, values):\n clf = SGDRegressor(n_iter=100)\n clf.fit(features,values)\n print(clf.score(features,values))\n intercept ... | [
"0.74872494",
"0.673163",
"0.66392136",
"0.6557477",
"0.65192616",
"0.6501405",
"0.63697916",
"0.6348934",
"0.6335981",
"0.63249224",
"0.63204587",
"0.6319576",
"0.6310046",
"0.62668383",
"0.62358856",
"0.6211634",
"0.6155481",
"0.6148775",
"0.6139724",
"0.6126958",
"0.607768... | 0.0 | -1 |
create_settings root_directory root directory of program"path/to/root" files files to be observed[files,...] variables variables to be observed[Variable,...] main_file main file of program"relative/path/from/root/to/main" output where to store PEL output "path/to/store/output" | def create_settings(root_directory, files, variables, main_file, output):
files = [format_path(f) for f in files]
variables = format_variables(variables)
settings = {
SETTINGS_ROOTDIR : root_directory if root_directory.endswith('/') else root_directory+'/',
SETTINGS_FILES : files,
SETTINGS_VARIABLES : variable... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_files(args):\n postfix = 'reinforce'\n has_value_model = False\n if args.baseline:\n postfix = \"reinforce-baseline\"\n has_value_model = True\n elif args.actor_critic:\n postfix = \"actor-critic\"\n has_value_model = True\n elif args.a2c:\n postfix = \"a... | [
"0.61745477",
"0.61673695",
"0.6149942",
"0.6126735",
"0.59460837",
"0.59423786",
"0.5937718",
"0.5911535",
"0.58622587",
"0.5852425",
"0.5816493",
"0.5807516",
"0.57808864",
"0.5754789",
"0.5721028",
"0.5715072",
"0.57069653",
"0.5706456",
"0.5699024",
"0.56912315",
"0.56876... | 0.7556358 | 0 |
run settings takes a settings dictionary, can be correctly formatted by calling create_settings with valid parameters | def run(settings):
print settings
print "Loading operations.py..."
ol = OperationsLoader(currrent_path+OPERATIONS_PATH)
settings[SETTINGS_OPERATIONS] = ol.load(settings[SETTINGS_OUTPUT],settings[SETTINGS_VARIABLES])
print "Loading Transformers (parsers)..."
settings[SETTINGS_TRANSFORMERS] = [PassTransformer(TRA... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_settings(self, settings_file):\n int_keys = [ 'first_base_to_keep', 'last_base_to_keep', 'max_reads_to_split', 'minimum_reads_for_inclusion',\n 'pool_5trim', 'pool_3trim', 'min_post_adaptor_length']\n #float_keys = []\n str_keys = ['adaptor_sequence', 'rrna_inde... | [
"0.7012952",
"0.6709503",
"0.6628244",
"0.63827366",
"0.6283154",
"0.6199137",
"0.6153022",
"0.61143154",
"0.61040217",
"0.60619944",
"0.60534656",
"0.6021595",
"0.5980613",
"0.5956128",
"0.590959",
"0.58843094",
"0.58827704",
"0.5880984",
"0.5863066",
"0.58467436",
"0.584559... | 0.58851045 | 15 |
Method that converts data and labels to instances of class torch.utils.data.Dataset | def init_datasets(self, data_dict, label_dict, **kwargs):
return {
key: TensorDataset(
torch.FloatTensor(data_dict[key]), torch.LongTensor(label_dict[key])
)
for key in data_dict.keys()
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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 labels_to_dataset(labels, label_mode, num_classes):\n label_ds = dataset_ops.Dataset.from_tensor_slices(l... | [
"0.7115415",
"0.694991",
"0.6914352",
"0.6845197",
"0.67110246",
"0.66670096",
"0.66645527",
"0.66255164",
"0.65189576",
"0.6509893",
"0.64952195",
"0.64838934",
"0.6474416",
"0.64262444",
"0.6405279",
"0.6367776",
"0.6365836",
"0.63566065",
"0.6337854",
"0.6322987",
"0.63042... | 0.65559363 | 8 |
Method that converts data and labels to instances of class torch.utils.data.DataLoader | def init_loaders(self, *args, **kwargs):
# Convert the data to Dataset
dataset_dict = self.init_datasets(*args, **kwargs)
# If the Dataset implements collate_fn, that is used. Otherwise, default_collate is used
if hasattr(dataset_dict["train"], "collate_fn") and callable(
g... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dataloaders():\n # train data path\n data_train = '../dataset/train/'\n # set transformations\n train_transforms = transforms.Compose([\n transforms.Resize((224, 224)),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406],\n ... | [
"0.74957144",
"0.74059236",
"0.73900753",
"0.73697627",
"0.7280223",
"0.7249118",
"0.7240241",
"0.71756315",
"0.70918363",
"0.7086592",
"0.7085246",
"0.7044244",
"0.7007126",
"0.6970048",
"0.69508225",
"0.6943519",
"0.69286335",
"0.6925529",
"0.6924148",
"0.6876771",
"0.68674... | 0.6935648 | 16 |
Creates data loaders from inputs for use at prediction time | def init_loaders_predict(self, data_dict, label_dict):
return self.init_loaders(data_dict, label_dict) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data_loaders(args, tokenizer):\n personachat = get_dataset(tokenizer, args.dataset_path, args.dataset_cache, args.train_lang)\n _ = personachat.pop(\"test\", None)\n logger.info(\"Build inputs and labels\")\n datasets = {\"train\": [], \"valid\": []}\n\n if args.train_lang in [\"En\", \"Fr\"... | [
"0.74005574",
"0.7197881",
"0.7158881",
"0.6972034",
"0.6917558",
"0.68405676",
"0.6837874",
"0.678532",
"0.6781111",
"0.6738349",
"0.67170435",
"0.67128015",
"0.66842",
"0.6673706",
"0.6673443",
"0.6654735",
"0.6637798",
"0.659848",
"0.65955985",
"0.6593302",
"0.6554777",
... | 0.6874065 | 5 |
Initialize a dict of metrics | def init_metric_dict(self, metrics=[""], phases=["train", "val"]):
metric_dict = {phase: {metric: [] for metric in metrics} for phase in phases}
return metric_dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_metrics():\n metrics = {\n 'cd_losses': [],\n 'cd_corrects': [],\n 'cd_precisions': [],\n 'cd_recalls': [],\n 'cd_f1scores': [],\n }\n\n return metrics",
"def init_metrics():\n metrics = defaultdict(list)\n metrics['best_acc'] = 0.0\n metrics['b... | [
"0.8447349",
"0.8055454",
"0.7887387",
"0.7674845",
"0.7393849",
"0.7364651",
"0.7242206",
"0.7189611",
"0.7178743",
"0.7161504",
"0.71576923",
"0.6911986",
"0.68280876",
"0.6823303",
"0.6809899",
"0.6747972",
"0.67374635",
"0.6736809",
"0.67120516",
"0.66915673",
"0.6668668"... | 0.78341216 | 3 |
Updates a metric dict with metrics from an epoch | def update_metric_dict(self, metric_dict, update_dict):
for key in update_dict.keys():
metric_dict[key].append(update_dict[key])
return metric_dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_epoch_metrics(self, val_metrics=False):\n metric_names = self.tracked_metrics()\n\n for metric in metric_names:\n if val_metrics:\n mean_val = np.array(self.metrics_history[f\"val_{metric}\"][\"batch_vals\"]).mean()\n self.metrics_history[f\"val_... | [
"0.653285",
"0.6474349",
"0.64158195",
"0.63220245",
"0.6176943",
"0.6079535",
"0.6050288",
"0.6017538",
"0.5881254",
"0.58689195",
"0.5808414",
"0.5795073",
"0.5788146",
"0.5759678",
"0.5751611",
"0.5738101",
"0.573619",
"0.57162505",
"0.56976926",
"0.5689485",
"0.5674656",
... | 0.5343309 | 64 |
Initialize the output dict | def init_output_dict(self):
return {
"outputs": torch.FloatTensor(),
"pred_probs": torch.FloatTensor(),
"labels": torch.LongTensor(),
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _populate_output(self):\n pass",
"def initialize_output_dict(self, label: Optional[str] = None):\n if label is not None or not self._does_output_dict_contain_info():\n for species in self.species_list:\n if label is None or species.label == label:\n ... | [
"0.7403707",
"0.7319638",
"0.719789",
"0.718091",
"0.6895616",
"0.6818378",
"0.6713962",
"0.66572535",
"0.6627214",
"0.6627214",
"0.6626906",
"0.6612285",
"0.6525927",
"0.651021",
"0.6355464",
"0.6314832",
"0.63007283",
"0.6230506",
"0.62086916",
"0.61997986",
"0.61873674",
... | 0.7332433 | 1 |
Compute epoch statistics after an epoch of training using an output_dict. | def compute_epoch_statistics(self, output_dict):
epoch_statistics = {
"auc": roc_auc_score(
output_dict["labels"].cpu().numpy(),
output_dict["pred_probs"][:, 1].cpu().numpy(),
),
"auprc": average_precision_score(
output_dict["la... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def training_epoch_end(self, outputs: Any) -> None:\n self.log_dict(self.train_metrics.compute())\n self.train_metrics.reset()",
"def validation_epoch_end(self, outputs):\n avg_loss = torch.stack([x['val_loss'] for x in outputs]).mean()\n val_acc = sum([x['n_correct_pred'] for x in ou... | [
"0.7093068",
"0.6828395",
"0.6732253",
"0.669807",
"0.669807",
"0.6676033",
"0.6524682",
"0.64946216",
"0.6488606",
"0.6488606",
"0.63934577",
"0.6391537",
"0.63756627",
"0.6371239",
"0.63657916",
"0.63108504",
"0.62925154",
"0.6290336",
"0.62839675",
"0.6260386",
"0.6257214"... | 0.82542735 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.