def train(self):
# train conv stack layer by layer
for i, stack in enumerate(self.conv_stack):
if self.checkpoint_file != '':
model = load(self.checkpoint_file)
self.net = FastNet(self.learning_rate, self.image_shape, self.n_out, initModel=model)
# delete softmax layer
self.net.del_layer()
self.net.del_layer()
# for i in range(len(self.fc_params)):
# self.net.del_layer()
self.net.disable_bprop()
layerParam = stack + [self.fakefc_param, self.softmax_param]
self.net.append_layers_from_dict(layerParam)
self.init_data_provider()
self.scheduler.reset()
self.scheduler.set_level(i)
self.test_outputs = []
self.train_output = []
AutoStopTrainer.train(self)
# train fc layer
for i, stack in enumerate(self.fc_stack):
model = load(self.checkpoint_file)
self.net = FastNet(self.learning_rate, self.image_shape, self.n_out, initModel=model)
self.net.del_layer()
self.net.del_layer()
self.net.disable_bprop()
if i == len(self.fc_stack) - 1:
layerParam = stack + [self.softmax_param]
else:
layerParam = stack + [self.fakefc_param, self.softmax_param]
self.net.append_layers_from_dict(layerParam)
self.init_data_provider()
self.scheduler.reset()
self.scheduler.set_level(i)
self.test_outputs = []
self.train_output = []
AutoStopTrainer.train(self)
model = load(self.checkpoint_file)
self.test_id += 1
self.net = FastNet(self.learning_rate, self.image_shape, self.n_out, initModel=model)
self.test_range = self.origin_test_range
self.init_data_provider()
self.scheduler = Scheduler(self)
self.num_epoch /= 2
AutoStopTrainer.train(self)
def train(self):
MiniBatchTrainer.train(self)
for i, group in enumerate(self.num_group_list):
self.set_num_group(group)
self.curr_batch = self.curr_epoch = 0
self.num_batch = self.num_batch_list[i]
model = self.checkpoint_dumper.get_checkpoint()
layers = model['model_state']['layers']
fc = layers[-2]
fc['outputSize'] = group
fc['weight'] = None
fc['bias'] = None
fc['weightIncr'] = None
fc['biasIncr'] = None
self.learning_rate = self.learning_rate_list[i]
self.net = FastNet(self.learning_rate,
self.image_shape,
init_model=model)
self.net.clear_weight_incr()
MiniBatchTrainer.train(self)
def train(self):
MiniBatchTrainer.train(self)
for i, cate in enumerate(self.num_caterange_list):
self.set_category_range(cate)
self.curr_batch = self.curr_epoch = 0
self.num_batch = self.num_batch_list[i]
model = self.checkpoint_dumper.get_checkpoint()
layers = model['model_state']['layers']
fc = layers[-2]
fc['weight'] = None
fc['bias'] = None
fc['weightIncr'] = None
fc['biasIncr'] = None
#for l in layers:
# if l['type'] == 'fc':
# l['weight'] = None
# l['bias'] = None
# l['weightIncr'] = None
# l['biasIncr'] = None
#fc = layers[-2]
fc['outputSize'] = cate
self.learning_rate = self.learning_rate_list[i]
self.net = FastNet(self.learning_rate,
self.image_shape,
init_model=model)
self.net.clear_weight_incr()
MiniBatchTrainer.train(self)
def get_trainer_by_name(name, param_dict):
net = FastNet(param_dict['learning_rate'],
param_dict['image_shape'],
init_model=None)
param_dict['net'] = net
if name == 'layerwise':
return ImageNetLayerwisedTrainer(**param_dict)
if name == 'catewise':
return ImageNetCatewisedTrainer(**param_dict)
if name == 'categroup':
return ImageNetCateGroupTrainer(**param_dict)
net = FastNet(param_dict['learning_rate'], param_dict['image_shape'],
param_dict['init_model'])
param_dict['net'] = net
if name == 'normal':
return Trainer(**param_dict)
if name == 'minibatch':
return MiniBatchTrainer(**param_dict)
raise Exception, 'No trainer found for name: %s' % name
def _finish_init(self):
self.num_batch_list = self.num_batch[1:]
self.num_batch = self.num_batch[0]
self.learning_rate_list = self.learning_rate[1:]
self.learning_rate = self.learning_rate[0]
layers = self.init_model
fc = layers[-2]
fc['outputSize'] = self.num_group_list[0]
self.num_group_list = self.num_group_list[1:]
self.set_num_group(fc['outputSize'])
self.net = FastNet(self.learning_rate,
self.image_shape,
init_model=self.init_model)
MiniBatchTrainer._finish_init(self)
def __init__(self, test_id, data_dir, data_provider, checkpoint_dir, train_range, test_range, test_freq, save_freq, batch_size, num_epoch, image_size,
image_color, learning_rate, auto_init=False, init_model=None, adjust_freq=1, factor=1.0):
self.test_id = test_id
self.data_dir = data_dir
self.data_provider = data_provider
self.checkpoint_dir = checkpoint_dir
self.train_range = train_range
self.test_range = test_range
self.test_freq = test_freq
self.save_freq = save_freq
self.batch_size = batch_size
self.num_epoch = num_epoch
self.image_size = image_size
self.image_color = image_color
self.learning_rate = learning_rate
# doesn't matter anymore
self.n_out = 10
self.factor = factor
self.adjust_freq = adjust_freq
self.regex = re.compile('^test%d-(\d+)\.(\d+)$' % self.test_id)
self.init_data_provider()
self.image_shape = (self.batch_size, self.image_color, self.image_size, self.image_size)
if init_model is not None and 'model_state' in init_model:
self.train_outputs = init_model['model_state']['train_outputs']
self.test_outputs = init_model['model_state']['test_outputs']
else:
self.train_outputs = []
self.test_outputs = []
self.curr_minibatch = self.num_batch = self.curr_epoch = self.curr_batch = 0
self.net = FastNet(self.learning_rate, self.image_shape, self.n_out, init_model=init_model)
self.train_data = None
self.test_data = None
self.num_train_minibatch = 0
self.num_test_minibatch = 0
self.checkpoint_file = ''
self.train_dumper = None #DataDumper('/scratch1/imagenet-pickle/train-data.pickle')
self.test_dumper = None #DataDumper('/scratch1/imagenet-pickle/test-data.pickle')
self.input = None
def train(self):
AutoStopTrainer.train(self)
if self.layerwised:
for i in range(len(self.n_filters) - 1):
next_n_filter = [self.n_filters[i + 1]]
next_size_filter = [self.size_filters[i + 1]]
model = load(self.checkpoint_file)
self.net = FastNet(self.learning_rate, self.image_shape, 0, initModel=model)
self.net.del_layer()
self.net.del_layer()
self.net.disable_bprop()
self.net.add_parameterized_layers(next_n_filter, next_size_filter, self.fc_nouts)
self.init_data_provider()
self.scheduler = Scheduler(self)
self.test_outputs = []
self.train_outputs = []
AutoStopTrainer.train(self)
def _finish_init(self):
assert len(self.num_caterange_list) == len(
self.num_batch) and self.num_caterange_list[-1] == 1000
self.num_batch_list = self.num_batch[1:]
self.num_batch = self.num_batch[0]
init_output = self.num_caterange_list[0]
self.num_caterange_list = self.num_caterange_list[1:]
fc = self.init_model[-2]
fc['outputSize'] = init_output
self.learning_rate_list = self.learning_rate[1:]
self.learning_rate = self.learning_rate[0]
self.set_category_range(init_output)
self.net = FastNet(self.learning_rate,
self.image_shape,
init_model=self.init_model)
MiniBatchTrainer._finish_init(self)
def _finish_init(self):
self.curr_model = []
self.complete_model = self.init_model
self.fc_params = []
self.conv_params = []
self.final_num_epoch = self.num_epoch
conv = True
for ld in self.init_model:
if ld['type'] in ['conv', 'rnorm', 'pool', 'neuron'] and conv:
#self.conv_params.append(ld)
self.curr_model.append(ld)
elif ld['type'] == 'fc' or (not conv and ld['type'] == 'neuron'):
self.fc_params.append(ld)
conv = False
else:
self.softmax_param = ld
#self.conv_stack = FastNet.split_conv_to_stack(self.conv_params)
#for i in range(3):
# self.curr_model.extend(self.conv_stack[i])
self.fc_stack = FastNet.split_fc_to_stack(self.fc_params)
#tmp = self.conv_stack[3:]
#tmp.extend(self.fc_stack)
#self.stack = tmp
self.stack = self.fc_stack
self.curr_model.append(self.stack[-1][0])
self.curr_model.append(self.softmax_param)
del self.stack[-1]
pprint.pprint(self.stack)
self.layerwised = True
self.num_epoch = 1
self.net = FastNet(self.learning_rate, self.image_shape,
self.curr_model)
def train(self):
Trainer.train(self)
for i, stack in enumerate(self.stack):
pprint.pprint(stack)
self.curr_model = self.checkpoint_dumper.get_checkpoint()
self.curr_batch = self.curr_epoch = 0
l = self.curr_model['model_state']['layers'][-2]
assert l['type'] == 'fc'
l['weight'] = None
l['bias'] = None
l['weightIncr'] = None
l['biasIncr'] = None
if i == len(self.stack) - 1:
self.num_epoch = self.final_num_epoch
layers = self.curr_model['model_state']['layers']
stack[0]['epsW'] *= self.learning_rate
stack[0]['epsB'] *= self.learning_rate
model = [stack[0], stack[1], layers[-2], layers[-1]]
train_dp_old = self.train_dp
test_dp_old = self.test_dp
self.init_subnet_data_provider()
self.train_dumper = None
self.test_dumper = None
image_shape_old = self.image_shape
shape = self.curr_model['model_state']['layers'][-3]['outputShape']
size = shape[0] * shape[1] * shape[2]
self.image_shape = (size, 1, 1, self.batch_size)
self.net = FastNet(1.0, self.image_shape, init_model=model)
old_num_epoch = self.num_epoch
self.num_epoch = 1
Trainer.train(self)
self.curr_batch = self.curr_epoch = 0
self.num_epoch = old_num_epoch
self.image_shape = image_shape_old
del layers[-1], layers[-1]
layers.extend(self.net.get_dumped_layers())
self.train_dp = train_dp_old
self.test_dp = test_dp_old
#for layer in self.curr_model['model_state']['layers'][:-2]:
# layer['disableBprop'] = True
#stack[0]['epsW'] *= self.learning_rate
#stack[0]['epsB'] *= self.learning_rate
#self.curr_model['model_state']['layers'].insert(-2, stack[0])
#self.curr_model['model_state']['layers'].insert(-2, stack[1])
self.init_output_dumper()
self.init_data_provider()
self.net = FastNet(self.learning_rate,
self.image_shape,
init_model=self.curr_model)
Trainer.train(self)
