def __init__(self, n_inputs, n_outputs, n_tasks, args):
super(Net, self).__init__()
nl, nh = args.n_layers, args.n_hiddens
if 'mnist' in args.data_file:
self.net = MLP([n_inputs] + [nh] * nl + [n_outputs])
else:
if args.finetune == 'None':
self.net = ResNet18(n_outputs, bias=args.bias)
else:
self.net = pretrained_cifar.cifar_resnet20(
pretrained=args.finetune, num_classes=n_outputs)
self.distance_measure = args.distance
self.ce = nn.CrossEntropyLoss()
self.n_outputs = n_outputs
self.opt = optim.SGD(self.parameters(), args.lr)
self.n_memories = args.n_memories # number of memories per task
self.n_sampled_memories = args.n_sampled_memories # number of sampled memories per task
self.n_constraints = args.n_constraints
self.gpu = args.cuda
self.batch_size = args.batch_size
self.n_iter = args.n_iter
self.alpha = args.alpha
# allocate ring buffer
self.memory_data = torch.FloatTensor(self.n_memories, n_inputs)
self.memory_labs = torch.LongTensor(self.n_memories)
if args.cuda:
self.memory_data = self.memory_data.cuda()
self.memory_labs = self.memory_labs.cuda()
# we allocate buffer for each class, not each task
self.sampled_class_data = {}
self.sampled_class_labs = {}
self.sampled_class_features = {}
# allocate counters
self.observed_tasks = []
self.old_task = -1
self.mem_cnt = 0
self.n_task = 0
self.n_old_task = 0
self.sample_size_list = []
self.class_buffer_size = 0
self.n_class = 0
self.n_old_class = 0
self.total_task = args.total_task
self.class_per_task = args.class_per_task
# initialized for MOF
self.mean_features = [
0 for i in range(self.total_task * self.class_per_task)
]
self.class_nums = [
0 for i in range(self.total_task * self.class_per_task)
]
self.normalize = args.normalize
def __init__(self, n_inputs, n_outputs, n_tasks, args):
super(Net, self).__init__()
nl, nh = args.n_layers, args.n_hiddens
if 'mnist' in args.data_file:
self.net = MLP([n_inputs] + [nh] * nl + [n_outputs])
else:
if args.finetune == 'None':
self.net = ResNet18(n_outputs, bias=args.bias)
else:
self.net = pretrained_cifar.cifar_resnet20(
pretrained=args.finetune, num_classes=n_outputs)
# The selecton of the loss function seems not good.
# But I think we can still compare various selection approaches.
self.ce = nn.CrossEntropyLoss()
self.n_outputs = n_outputs
self.n_inputs = n_inputs
self.opt = optim.SGD(self.parameters(), args.lr)
self.n_memories = args.n_memories
self.n_sampled_memories = args.n_sampled_memories
self.n_constraints = args.n_constraints
self.gpu = args.cuda
self.batch_size = args.batch_size
self.n_iter = args.n_iter
self.alpha = args.alpha
self.loss = args.loss
self.feature_update = args.feature_update
self.memory_update = args.memory_update
self.initialize_criterion(args)
# allocate counters
self.observed_tasks = []
self.old_task = -1
self.mem_cnt = 0
self.n_task = 0
self.n_old_task = 0
self.sample_size_list = []
self.class_buffer_size = 0
self.n_class = 0
self.n_old_class = 0
self.total_task = args.total_task
self.class_per_task = args.class_per_task
self.total_class = self.total_task * self.class_per_task
self.class_nums = [0 for i in range(self.total_class)]
self.initialize_memory_buffer()
# initialized for MOF
self.mean_features = [
0 for i in range(self.total_task * self.class_per_task)
]
self.normalize = args.normalize
def __init__(self, n_inputs, n_outputs, n_tasks, args):
super(Net, self).__init__()
nl, nh = args.n_layers, args.n_hiddens
self.rn = args.memory_strength # n the number of gradient vectors to estimate new samples similarity, line 5 in alg.2
if 'mnist' in args.data_file:
self.net = MLP([n_inputs] + [nh] * nl + [n_outputs])
else:
if args.finetune == 'None':
self.net = ResNet18(n_outputs, bias=args.bias)
else:
self.net = pretrained_cifar.cifar_resnet20(
pretrained=args.finetune, num_classes=n_outputs)
self.ce = nn.CrossEntropyLoss()
self.n_outputs = n_outputs
self.opt = optim.SGD(self.parameters(), args.lr)
self.n_memories = args.n_memories # auxiliary storage before deciding samples to the buffer,
# if this is equal to the batch size, then every batch the method decides which samples to add to the buffer.
self.n_sampled_memories = args.n_sampled_memories #buffer size, M
self.n_constraints = args.n_constraints #n_samples to be replayed from the buffer at each time a new batch is recieved, default equal to batch size
self.gpu = args.cuda
self.batch_size = args.batch_size
self.n_iter = args.n_iter #number of iteraions (update steps) for each recieved batch
self.sim_th = args.change_th
self.memory_data = torch.FloatTensor(self.n_memories, n_inputs)
self.memory_labs = torch.LongTensor(self.n_memories)
self.added_index = self.n_sampled_memories
self.sampled_memory_data = None
self.sampled_memory_labs = None
self.sampled_memory_cos = None # buffer cosine similarity score
# old grads to measure changes
if args.cuda:
self.memory_data = self.memory_data.cuda()
self.memory_labs = self.memory_labs.cuda()
# allocate temporary synaptic memory
self.grad_dims = []
for param in self.parameters():
self.grad_dims.append(param.data.numel())
# allocate counters
self.observed_tasks = []
self.old_task = -1
self.mem_cnt = 0
def __init__(self, n_inputs, n_outputs, n_tasks, args):
super(Net, self).__init__()
nl, nh = args.n_layers, args.n_hiddens
if 'mnist' in args.data_file:
self.net = MLP([n_inputs] + [nh] * nl + [n_outputs])
else:
if args.finetune == 'None':
self.net = ResNet18(n_outputs, bias=args.bias)
else:
self.net = pretrained_cifar.cifar_resnet20(
pretrained=args.finetune)
self.opt = torch.optim.SGD(self.parameters(), lr=args.lr)
self.ce = torch.nn.CrossEntropyLoss()
self.n_outputs = n_outputs
self.n_iter = args.n_iter
def __init__(self, n_inputs, n_outputs, n_tasks, args):
super(Net, self).__init__()
nl, nh = args.n_layers, args.n_hiddens
self.margin = args.memory_strength
self.is_cifar = ('cifar10' in args.data_file)
if 'mnist' in args.data_file:
self.net = MLP([n_inputs] + [nh] * nl + [n_outputs])
else:
if args.finetune == 'None':
self.net = ResNet18(n_outputs, bias=args.bias)
else:
self.net = pretrained_cifar.cifar_resnet20(
pretrained=args.finetune, num_classes=n_outputs)
self.ce = nn.CrossEntropyLoss()
self.n_outputs = n_outputs
self.opt = optim.SGD(self.parameters(), args.lr)
self.n_iter = args.n_iter
self.n_memories = args.n_memories
self.gpu = args.cuda
# allocate episodic memory
self.memory_data = torch.FloatTensor(n_tasks, self.n_memories,
n_inputs)
self.memory_labs = torch.LongTensor(n_tasks, self.n_memories)
if args.cuda:
self.memory_data = self.memory_data.cuda()
self.memory_labs = self.memory_labs.cuda()
# allocate temporary synaptic memory
self.grad_dims = []
for param in self.parameters():
self.grad_dims.append(param.data.numel())
self.grads = torch.Tensor(sum(self.grad_dims), n_tasks)
if args.cuda:
self.grads = self.grads.cuda()
# allocate counters
self.observed_tasks = []
self.old_task = -1
self.mem_cnt = 0
self.nc_per_task = args.class_per_task
def __init__(self,
n_inputs,
n_outputs,
n_tasks,
args):
super(Net, self).__init__()
nl, nh = args.n_layers, args.n_hiddens
if 'mnist' in args.data_file:
self.net = MLP([n_inputs] + [nh] * nl + [n_outputs])
else:
if args.finetune=='None':
self.net = ResNet18(n_outputs, bias=args.bias)
else:
self.net = pretrained_cifar.cifar_resnet20(pretrained=args.finetune,num_classes=n_outputs)
self.ce = nn.CrossEntropyLoss()
self.n_outputs = n_outputs
self.n_inputs = n_inputs
self.opt = optim.SGD(self.parameters(), args.lr)
self.n_memories = args.n_memories
self.n_sampled_memories = args.n_sampled_memories
self.n_constraints = args.n_constraints
self.gpu = args.cuda
self.batch_size=args.batch_size
self.n_iter = args.n_iter
self.mode=args.mode
# allocate counters
self.observed_tasks = []
self.old_task = -1
self.mem_cnt = 0
self.n_task=0
self.n_old_task=0
self.sample_size_list=[]
self.class_buffer_size=0
self.n_class=0
self.n_old_class=0
self.total_task = args.total_task
self.class_per_task=args.class_per_task
self.total_class=self.total_task*self.class_per_task
self.class_nums = [0 for i in range(self.total_class)]
self.initialize_memory_buffer()
