code stringlengths 17 6.64M |
|---|
def get_dataloaders(data_path, tasks, num_frames, batch_size=64, batch_size_val=4, transform={}, num_workers=0, load_to_mem=False, pin_memory=False, remove_last_step_in_traj=True, removed_actions=[]):
if ('rgb_filled' in tasks):
transform['rgb_filled'] = transforms.Compose([transforms.CenterCrop([256, 256... |
def get_dataloaders(data_path, inputs_and_outputs, batch_size=64, batch_size_val=4, transform=None, num_workers=0, load_to_mem=False, pin_memory=False):
dataloaders = {}
dataset = torchvision.datasets.FashionMNIST(root, train=True, transform=transform, target_transform=None, download=True)
dataloader = Da... |
class iCIFAR100(torchvision.datasets.CIFAR100):
def __init__(self, root, class_idxs, train=True, transform=None, target_transform=None, download=False):
super().__init__(root, train, transform, target_transform, download)
self.class_idxs = list(class_idxs)
self.old_targets = self.targets
... |
def get_dataloaders(data_path, targets, sources=None, masks=None, tasks=None, epochlength=20000, epochs_until_cycle=1, batch_size=64, batch_size_val=4, transform=None, num_workers=0, load_to_mem=False, pin_memory=False, imsize=256):
"\n Targets can either be of the form [iterable1, iterable2]\n ... |
def get_limited_dataloaders(data_path, sources, targets, masks, tasks=None, epochlength=20000, batch_size=64, batch_size_val=4, transform=None, num_workers=0, load_to_mem=False, pin_memory=False, imsize=256):
"\n Targets can either be of the form [iterable1, iterable2]\n or of the form 'cifarXX-... |
def get_cifar_dataloaders(data_path, sources, targets, masks, tasks=None, epochlength=20000, batch_size=64, batch_size_val=4, transform=None, num_workers=0, load_to_mem=False, pin_memory=False, imsize=256):
"\n Targets can either be of the form [iterable1, iterable2]\n or of the form 'cifarXX-YY... |
def cycle_dl(dl):
while True:
for element in dl:
(yield element)
|
class CyclingDataLoader(object):
def __init__(self, dls, epoch_length_per_dl=None, start_dl=0, epochs_until_cycle=0, zip_idx=True):
'\n :param dls: list of dataloaders, one for each task\n :param epoch_length_per_dl: number of items to cycle thru dataset\n :param start_dl:\n :... |
class ErrorPassingCyclingDataLoader(CyclingDataLoader):
def __next__(self):
try:
return super().__next__()
except Exception as e:
if isinstance(e, StopIteration):
raise e
else:
warnings.warn('problem with this datapoint, resampli... |
class ConcatenatedDataLoader(object):
def __init__(self, dls, zip_idx=True):
self.dls = dls
self.curr_iter_idx = 0
self.zip_idx = zip_idx
def __iter__(self):
self.curr_iter_idx = 0
self.curr_iter = iter(self.dls[self.curr_iter_idx])
return self
def __next... |
class ErrorPassingConcatenatedDataLoader(ConcatenatedDataLoader):
def __next__(self):
try:
return super().__next__()
except Exception as e:
if isinstance(e, StopIteration):
raise e
else:
warnings.warn('problem with this datapoint... |
class KthDataLoader(object):
def __init__(self, dls, k=0, epochlength=None):
self.dls = dls
self.dl = dls[k]
self.k = k
self.epochlength = epochlength
def __iter__(self):
self.count = 0
if self.epochlength:
self.curr_iter = cycle_dl(self.dl)
... |
def get_splits(split_path):
with open(split_path) as csvfile:
readCSV = csv.reader(csvfile, delimiter=',')
train_list = []
val_list = []
test_list = []
for row in readCSV:
(name, is_train, is_val, is_test) = row
if (name in forbidden_buildings):
... |
class IdentityFn(nn.Module):
def __init__(self, *args, **kwargs):
super().__init__()
def forward(self, x, **kwargs):
return x
def requires_grad_(self, *args, **kwargs):
pass
|
def identity_fn(x):
return x
|
class ZeroFn(nn.Module):
def forward(self, *args, **kwargs):
return 0.0
def requires_grad_(self, *args, **kwargs):
pass
|
def zero_fn(x):
return 0.0
|
class ScaleLayer(nn.Module):
def __init__(self, init_value=0.001):
super().__init__()
self.scale = nn.Parameter(torch.FloatTensor([init_value]))
def forward(self, input):
return (input * self.scale)
|
class LambdaLayer(nn.Module):
def __init__(self, lambd):
super(LambdaLayer, self).__init__()
self.lambd = lambd
def forward(self, x):
return self.lambd(x)
|
class ResidualLayer(nn.Module):
def __init__(self, net: nn.Module):
super().__init__()
self.net = net
def forward(self, x):
return (x + self.net(x))
|
class EvalOnlyModel(nn.Module):
def __init__(self, eval_only=None, train=False, **kwargs):
super().__init__()
if (eval_only is None):
warnings.warn(f'Model eval_only flag is not set for {type(self)}. Defaulting to True')
eval_only = True
if train:
warni... |
class EWC():
def __init__(self, loss_fn, model, coef=0.001, avg_tasks=False, n_samples_fisher=1000, **kwargs):
self.loss_fn = loss_fn
self.model = model
self.coef = coef
self.avg_tasks = avg_tasks
self.weights_anchor_list = []
self.precision_matrices_list = []
... |
class FCN5MidFeedback(FCN5):
def __init__(self, kernel_size=3, *args, **kwargs):
super().__init__(*args, **kwargs)
if (kernel_size == 3):
net_kwargs = {'kernel_size': 3, 'stride': 1, 'padding': 1}
elif (kernel_size == 1):
net_kwargs = {'kernel_size': 1, 'stride': 1... |
class FCN5LateFeedback(FCN5):
def __init__(self, kernel_size=3, *args, **kwargs):
super().__init__(*args, **kwargs)
if (kernel_size == 3):
net_kwargs = {'kernel_size': 3, 'stride': 1, 'padding': 1}
elif (kernel_size == 1):
net_kwargs = {'kernel_size': 1, 'stride': ... |
class LifelongNetwork(nn.Module):
def forward(self, x, task_idx=None):
pass
def start_training(self):
pass
def start_task(self, task_idx, train):
pass
|
class LifelongSidetuneNetwork(LifelongNetwork):
def __init__(self, dataset='taskonomy', use_baked_encoding=False, normalize_pre_transfer=True, base_class=None, base_weights_path=None, base_kwargs={}, transfer_class=None, transfer_weights_path=None, transfer_kwargs={}, side_class=None, side_weights_path=None, sid... |
class MergeOperator(nn.Module):
def __init__(self, dense, task_idx, dataset):
super().__init__()
self.dense = dense
self.task_idx = task_idx
self.dataset = dataset
def __call__(self, base_encoding, side_encoding, additional_encodings=[]) -> torch.Tensor:
pass
@pr... |
class BaseOnly(MergeOperator):
def __call__(self, base_encoding, side_encoding, additional_encodings=[]):
return base_encoding
|
class SideOnly(MergeOperator):
def __call__(self, base_encoding, side_encoding, additional_encodings=[]):
return side_encoding
|
class Summation(MergeOperator):
def __call__(self, base_encoding, side_encoding, additional_encodings=[]):
merged_encoding = ((base_encoding + side_encoding) + sum(additional_encodings))
return merged_encoding
|
class Product(MergeOperator):
def __call__(self, base_encoding, side_encoding, additional_encodings=[]):
merged_encoding = (base_encoding * side_encoding)
for add_encoding in additional_encodings:
merged_encoding *= add_encoding
return merged_encoding
|
class Alpha(MergeOperator):
def __init__(self, dense, task_idx, **kwargs):
super().__init__(dense, task_idx, **kwargs)
if dense:
self.alphas = nn.Parameter(torch.tensor(0.0).repeat((task_idx + 2)))
else:
self.alphas = nn.Parameter(torch.tensor(0.0))
@property
... |
class FiLMNet(nn.Module):
def __init__(self, n_in, n_out, kernel_size=1):
super().__init__()
if (kernel_size == 3):
net_kwargs = {'kernel_size': 3, 'stride': 1, 'padding': 1}
elif (kernel_size == 1):
net_kwargs = {'kernel_size': 1, 'stride': 1, 'padding': 0}
... |
class FiLM(MergeOperator):
def __init__(self, dense, **kwargs):
super().__init__(dense, **kwargs)
assert (not dense)
self.film = FiLMNet(n_in=8, n_out=8, kernel_size=1)
def __call__(self, base_encoding, side_encoding, additional_encodings=[]):
(mult_factor, add_factor) = self... |
class MLP(MergeOperator):
def __init__(self, dense, task_idx, dataset):
super().__init__(dense, task_idx, dataset)
if (dataset == 'icifar'):
self.make_layer = make_linear_layer
elif (dataset == 'taskonomy'):
self.make_layer = make_conv_layer
self.base_net =... |
class MLP2(MLP):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.side_net = self.make_layer()
|
class ResMLP2(MLP):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.side_net = ResidualLayer(self.make_layer())
|
class MLPHidden(MLP):
def __call__(self, base_encoding, side_encoding, additional_encodings=[]):
merged_encoding = (self.base_net(base_encoding) + self.side_net(side_encoding))
if self.dense:
merged_encoding += sum([net(add_encoding) for (net, add_encoding) in zip(self.dense_side_nets... |
def load_submodule(model_class, model_weights_path, model_kwargs, backup_fn=zero_fn):
if (model_class is not None):
model = model_class(**model_kwargs)
if (model_weights_path is not None):
(model, _) = load_state_dict_from_path(model, model_weights_path)
else:
model = backu... |
def _make_layer(in_channels, out_channels, num_groups=2, kernel_size=3, stride=1, padding=0, dilation=1, normalize=True, bsp=False, period=None, debug=False, projected=False, scaling=False, postlinear=False, linear=False):
assert (not (bsp and projected)), 'cannot do bsp and projectedconv'
if linear:
... |
class SampleGroupStackModule(nn.Module):
def __init__(self, *args, **kwargs):
super(SampleGroupStackModule, self).__init__()
def forward(self, *args, **kwargs):
return downsample_group_stack(*args, **kwargs)
def requires_grad_(self, *args, **kwargs):
pass
|
class ConstantModel():
def __init__(self, data):
if isinstance(data, str):
if ('.png' in data):
img = Image.open(data)
self.const = RESCALE_0_1_NEG1_POS1(transforms.ToTensor()(img))
else:
self.const = torch.load(data)
else:
... |
class EnsembleNet(nn.Module):
def __init__(self, n_models, model_class, model_weights_path, **kwargs):
super().__init__()
self.nets = nn.ModuleList([load_submodule(eval(model_class), model_weights_path, kwargs) for _ in range(n_models)])
def forward(self, x):
return sum([net(x) for n... |
class BoostedNetwork(nn.Module):
def __init__(self, use_baked_encoding=False, normalize_pre_transfer=True, encoder_class=None, encoder_weights_path=None, encoder_kwargs={}, transfer_network_class=None, transfer_network_weights_path=None, transfer_network_kwargs={}, sidetuner_network_class=None, sidetuner_network... |
class FCN5(EvalOnlyModel):
def __init__(self, num_groups=2, img_channels=3, use_residual=False, normalize_outputs=False, bsp=False, period=None, projected=False, final_act=True, **kwargs):
super(FCN5, self).__init__(**kwargs)
self.conv1 = _make_layer(img_channels, 64, num_groups=num_groups, kerne... |
class FCN8(EvalOnlyModel):
def __init__(self, img_channels=3, normalize_outputs=False, **kwargs):
super(FCN8, self).__init__(**kwargs)
self.conv1 = _make_layer(img_channels, 64, kernel_size=8, stride=4, padding=2)
self.conv2 = _make_layer(64, 128, kernel_size=3, stride=2, padding=1)
... |
class FCN4(EvalOnlyModel):
def __init__(self, num_groups=2, img_channels=3, use_residual=False, normalize_outputs=False, bsp=False, period=None, debug=False, projected=False, final_act=True, **kwargs):
super(FCN4, self).__init__(**kwargs)
self.conv1 = _make_layer(img_channels, 16, num_groups=num_... |
class FCN4Reshaped(FCN4):
def forward(self, x, cache={}, time_idx: int=(- 1)):
x = super().forward(x, time_idx)
x = F.avg_pool2d(x, x.size()[3]).view(x.shape[0], 64)
return x
|
class FCN3(EvalOnlyModel):
def __init__(self, num_groups=2, img_channels=3, normalize_outputs=False, **kwargs):
super(FCN3, self).__init__(**kwargs)
self.conv1 = _make_layer(img_channels, 64, num_groups=num_groups, kernel_size=8, stride=4, padding=1)
self.conv2 = _make_layer(64, 256, num_... |
def get_output_sizes():
base_path = '/root/tlkit/tlkit/taskonomy_data/'
decoder_paths = [os.path.join(base_path, f'{task}_decoder.dat') for task in LIST_OF_TASKS]
decoder_state_dicts = [torch.load(path) for path in decoder_paths]
output_sizes = [decoder['state_dict']['decoder_output.0.bias'].numpy().s... |
class HiddenPrints():
def __enter__(self):
self._original_stdout = sys.stdout
sys.stdout = open(os.devnull, 'w')
def __exit__(self, exc_type, exc_val, exc_tb):
sys.stdout.close()
sys.stdout = self._original_stdout
|
def update(d, u):
for (k, v) in u.items():
if isinstance(v, collections.Mapping):
d[k] = update(d.get(k, {}), v)
else:
d[k] = v
return d
|
def flatten(d, parent_key='', sep='.'):
items = []
for (k, v) in d.items():
new_key = (((parent_key + sep) + k) if parent_key else k)
if isinstance(v, collections.MutableMapping):
items.extend(flatten(v, new_key, sep=sep).items())
else:
items.append((new_key, v)... |
def var_to_numpy(encoding):
encoding = encoding.detach().cpu().numpy()
return encoding
|
def checkpoint_name(checkpoint_dir, epoch='latest'):
return os.path.join(checkpoint_dir, 'ckpt-{}.dat'.format(epoch))
|
def save_checkpoint(obj, directory, step_num):
os.makedirs(directory, exist_ok=True)
torch.save(obj, checkpoint_name(directory))
subprocess.call('cp {} {} &'.format(checkpoint_name(directory), checkpoint_name(directory, step_num)), shell=True)
|
def get_parent_dirname(path):
return os.path.basename(os.path.dirname(path))
|
def get_subdir(training_directory, subdir_name):
"\n look through all files/directories in training_directory\n return all files/subdirectories whose basename have subdir_name\n if 0, return none\n if 1, return it\n if more, return list of them\n\n e.g. training_directory: '/path/to/exp'\n ... |
def read_pkl(pkl_name):
with open(pkl_name, 'rb') as f:
data = pickle.load(f)
return data
|
def get_number(name):
'\n use regex to get the first integer in the name\n if none exists, return -1\n '
try:
num = int(re.findall('[0-9]+', name)[0])
except:
num = (- 1)
return num
|
def unused_dir_name(output_dir):
"\n Returns a unique (not taken) output_directory name with similar structure to existing one\n Specifically,\n if dir is not taken, return itself\n if dir is taken, return a new name where\n if dir = base + number, then newdir = base + {number+1}\n ow: n... |
def index_to_image(idxs: torch.Tensor, dictionary: np.ndarray, img_size):
imgs = []
for inst_top5 in dictionary[idxs]:
inst_top5 = [w.split(' ', 1)[1] for w in inst_top5]
to_print = ('Top 5 predictions: \n ' + ' '.join([f'''{w}
''' for w in inst_top5]))
img = Image.new('RGB', (img_siz... |
def pil_to_np(img):
img_arr = np.frombuffer(img.tobytes(), dtype=np.uint8)
img_arr = img_arr.reshape((img.size[1], img.size[0], 3))
return img_arr
|
def np_to_pil(img_arr):
return Image.fromarray(img_arr.astype(np.uint8))
|
def count_open():
tensor_count = {}
var_count = {}
np_count = {}
for obj in gc.get_objects():
try:
if isinstance(obj, np.ndarray):
if (obj.shape in np_count):
np_count[obj.shape] += 1
else:
np_count[obj.shape] ... |
def process_batch_tuple(batch_tuple, task_idx, cfg):
batch_tuple = [x.to(device, non_blocking=True) for x in batch_tuple]
if (task_idx is None):
sources = cfg['training']['sources']
targets = cfg['training']['targets']
else:
sources = cfg['training']['sources'][task_idx]
ta... |
def forward_sequential(x, layers, task_idx):
if (isinstance(layers, nn.Sequential) or isinstance(layers, list) or isinstance(layers, nn.ModuleList)):
for layer in layers:
try:
x = layer(x, task_idx)
except TypeError:
x = layer(x)
else:
tr... |
def load_state_dict_from_path(model, path):
checkpoint = torch.load(path)
if ('state_dict' in checkpoint.keys()):
if any([('module' in k) for k in checkpoint['state_dict']]):
state_dict = {k.replace('module.', ''): v for (k, v) in checkpoint['state_dict'].items()}
else:
... |
class Mock(MagicMock):
@classmethod
def __getattr__(cls, name):
return MagicMock()
|
def setup(app):
app.add_stylesheet('css/pytorch_theme.css')
|
def get_iterator(mode):
ds = MNIST(root='./', download=True, train=mode)
data = getattr(ds, ('train_data' if mode else 'test_data'))
labels = getattr(ds, ('train_labels' if mode else 'test_labels'))
tds = tnt.dataset.TensorDataset([data, labels])
return tds.parallel(batch_size=128, num_workers=4, ... |
def conv_init(ni, no, k):
return kaiming_normal(torch.Tensor(no, ni, k, k))
|
def linear_init(ni, no):
return kaiming_normal(torch.Tensor(no, ni))
|
def f(params, inputs, mode):
o = inputs.view(inputs.size(0), 1, 28, 28)
o = F.conv2d(o, params['conv0.weight'], params['conv0.bias'], stride=2)
o = F.relu(o)
o = F.conv2d(o, params['conv1.weight'], params['conv1.bias'], stride=2)
o = F.relu(o)
o = o.view(o.size(0), (- 1))
o = F.linear(o, p... |
def main():
params = {'conv0.weight': conv_init(1, 50, 5), 'conv0.bias': torch.zeros(50), 'conv1.weight': conv_init(50, 50, 5), 'conv1.bias': torch.zeros(50), 'linear2.weight': linear_init(800, 512), 'linear2.bias': torch.zeros(512), 'linear3.weight': linear_init(512, 10), 'linear3.bias': torch.zeros(10)}
par... |
def get_iterator(mode):
ds = MNIST(root='./', download=True, train=mode)
data = getattr(ds, ('train_data' if mode else 'test_data'))
labels = getattr(ds, ('train_labels' if mode else 'test_labels'))
tds = tnt.dataset.TensorDataset([data, labels])
return tds.parallel(batch_size=128, num_workers=4, ... |
def conv_init(ni, no, k):
return kaiming_normal(torch.Tensor(no, ni, k, k))
|
def linear_init(ni, no):
return kaiming_normal(torch.Tensor(no, ni))
|
def f(params, inputs, mode):
o = inputs.view(inputs.size(0), 1, 28, 28)
o = F.conv2d(o, params['conv0.weight'], params['conv0.bias'], stride=2)
o = F.relu(o)
o = F.conv2d(o, params['conv1.weight'], params['conv1.bias'], stride=2)
o = F.relu(o)
o = o.view(o.size(0), (- 1))
o = F.linear(o, p... |
def main():
params = {'conv0.weight': conv_init(1, 50, 5), 'conv0.bias': torch.zeros(50), 'conv1.weight': conv_init(50, 50, 5), 'conv1.bias': torch.zeros(50), 'linear2.weight': linear_init(800, 512), 'linear2.bias': torch.zeros(512), 'linear3.weight': linear_init(512, 10), 'linear3.bias': torch.zeros(10)}
par... |
def get_iterator(mode):
ds = MNIST(root='./', download=True, train=mode)
data = getattr(ds, ('train_data' if mode else 'test_data'))
labels = getattr(ds, ('train_labels' if mode else 'test_labels'))
tds = tnt.dataset.TensorDataset([data, labels])
return tds.parallel(batch_size=128, num_workers=4, ... |
def conv_init(ni, no, k):
return kaiming_normal(torch.Tensor(no, ni, k, k))
|
def linear_init(ni, no):
return kaiming_normal(torch.Tensor(no, ni))
|
def f(params, inputs, mode):
o = inputs.view(inputs.size(0), 1, 28, 28)
o = F.conv2d(o, params['conv0.weight'], params['conv0.bias'], stride=2)
o = F.relu(o)
o = F.conv2d(o, params['conv1.weight'], params['conv1.bias'], stride=2)
o = F.relu(o)
o = o.view(o.size(0), (- 1))
o = F.linear(o, p... |
def main():
params = {'conv0.weight': conv_init(1, 50, 5), 'conv0.bias': torch.zeros(50), 'conv1.weight': conv_init(50, 50, 5), 'conv1.bias': torch.zeros(50), 'linear2.weight': linear_init(800, 512), 'linear2.bias': torch.zeros(512), 'linear3.weight': linear_init(512, 10), 'linear3.bias': torch.zeros(10)}
par... |
class TestDatasets(unittest.TestCase):
def testListDataset(self):
h = [0, 1, 2]
d = dataset.ListDataset(elem_list=h, load=(lambda x: x))
self.assertEqual(len(d), 3)
self.assertEqual(d[0], 0)
t = torch.LongTensor([0, 1, 2])
d = dataset.ListDataset(elem_list=t, load=... |
class TestMeters(unittest.TestCase):
def testAverageValueMeter(self):
m = meter.AverageValueMeter()
for i in range(1, 10):
m.add(i)
(mean, std) = m.value()
self.assertEqual(mean, 5.0)
m.reset()
(mean, std) = m.value()
self.assertTrue(np.isnan(me... |
class TestTransforms(unittest.TestCase):
def testCompose(self):
self.assertEqual(transform.compose([(lambda x: (x + 1)), (lambda x: (x + 2)), (lambda x: (x / 2))])(1), 2)
def testTableMergeKeys(self):
x = {'sample1': {'input': 1, 'target': 'a'}, 'sample2': {'input': 2, 'target': 'b', 'flag':... |
class BatchDataset(Dataset):
'\n Dataset which batches the data from a given dataset.\n\n Given a `dataset`, `BatchDataset` merges samples from this dataset to\n form a new sample which can be interpreted as a batch of size `batchsize`.\n\n The `merge` function controls how the batching is performed. ... |
class ConcatDataset(Dataset):
'\n Dataset to concatenate multiple datasets.\n\n Purpose: useful to assemble different existing datasets, possibly\n large-scale datasets as the concatenation operation is done in an\n on-the-fly manner.\n\n Args:\n datasets (iterable): List of datasets to be c... |
class Dataset(object):
def __init__(self):
pass
def __len__(self):
pass
def __getitem__(self, idx):
if (idx >= len(self)):
raise IndexError('CustomRange index out of range')
pass
def batch(self, *args, **kwargs):
return torchnet.dataset.BatchData... |
class ListDataset(Dataset):
'\n Dataset which loads data from a list using given function.\n\n Considering a `elem_list` (can be an iterable or a `string` ) i-th sample\n of a dataset will be returned by `load(elem_list[i])`, where `load()`\n is a function provided by the user.\n\n If `path` is pro... |
class ResampleDataset(Dataset):
'\n Dataset which resamples a given dataset.\n\n Given a `dataset`, creates a new dataset which will (re-)sample from this\n underlying dataset using the provided `sampler(dataset, idx)` function.\n\n If `size` is provided, then the newly created dataset will have the\n... |
class ShuffleDataset(ResampleDataset):
'\n Dataset which shuffles a given dataset.\n\n `ShuffleDataset` is a sub-class of `ResampleDataset` provided for\n convenience. It samples uniformly from the given `dataset` with, or without\n `replacement`. The chosen partition can be redrawn by calling `resamp... |
class SplitDataset(Dataset):
'\n Dataset to partition a given dataset.\n\n Partition a given `dataset`, according to the specified `partitions`. Use\n the method `select()` to select the current partition in use.\n\n The `partitions` is a dictionary where a key is a user-chosen string\n naming the ... |
class TensorDataset(Dataset):
'\n Dataset from a tensor or array or list or dict.\n\n `TensorDataset` provides a way to create a dataset out of the data that is\n already loaded into memory. It accepts data in the following forms:\n\n tensor or numpy array\n `idx`th sample is `data[idx]`\n\n ... |
class TransformDataset(Dataset):
'\n Dataset which transforms a given dataset with a given function.\n\n Given a function `transform`, and a `dataset`, `TransformDataset` applies\n the function in an on-the-fly manner when querying a sample with\n `__getitem__(idx)` and therefore returning `transform[... |
class Engine(object):
def __init__(self):
self.hooks = {}
def hook(self, name, state):
'Registers a backward hook.\n\n The hook will be called every time a gradient with respect to the\n Tensor is computed. The hook should have the following signature::\n\n hook (gra... |
class FileLogger(object):
"Logs results to a file.\n\n The FileLogger provides a convenient interface for periodically writing\n results to a file. It is designed to capture all information for a given\n experiment, which may have a sequence of distinct tasks. Therefore, it writes\n results in the for... |
class Logger(object):
_fields = None
@property
def fields(self):
assert (self._fields is not None), 'self.fields is not set!'
return self._fields
@fields.setter
def fields(self, value):
self._fields
def __init__(self, fields=None):
" Automatically logs the va... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.