class ImageNetLayerwisedTrainer(Trainer):
def divide_layers_to_stack(self):
self.fc_params = []
self.conv_params = []
conv = True
for ld in self.init_model:
if ld['type'] in ['conv', 'rnorm', 'pool', 'neuron'] and conv:
# self.conv_params.append(ld)
self.conv_params.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
def initialize_model(self):
self.curr_model.extend(self.conv_stack['conv1'])
self.curr_model.extend(self.conv_stack['conv2'])
self.curr_model.extend(self.conv_stack['conv3'])
self.curr_model.extend(self.conv_stack['conv4'])
self.curr_model.extend(self.conv_stack['conv5'])
self.curr_model.extend(self.fc_tmp)
def _finish_init(self):
self.final_num_epoch = self.num_epoch
self.curr_model = []
self.divide_layers_to_stack()
self.conv_stack = FastNet.split_conv_to_stack(self.conv_params)
self.fc_stack = FastNet.split_fc_to_stack(self.fc_params)
self.fc_tmp = [self.fc_stack['fc8'][0], self.softmax_param]
del self.fc_stack['fc8']
self.stack = self.fc_stack
self.initialize_model()
pprint.pprint(self.stack)
self.num_epoch = self.frag_epoch
self.net = FastNet(self.learning_rate, self.image_shape, self.curr_model)
self.container = deque()
def report(self):
pass
def should_continue_training(self):
return self.curr_epoch <= self.num_epoch
def init_replaynet_data_provider(self):
if self.output_method == 'disk':
dp = data.get_by_name('intermediate')
count = self.layer_output_dumper.get_count()
self.train_dp = dp(self.layer_output_path, range(0, count), 'fc')
elif self.output_method == 'memory':
dp = data.get_by_name('memory')
self.train_dp = dp(self.layer_output_dumper)
def train_replaynet(self, stack):
self.container.append(self.save_freq)
self.container.append(self.test_freq)
self.container.append(self.train_dp)
self.container.append(self.test_dp)
self.container.append(self.layer_output_dumper)
self.container.append(self.net)
self.save_freq = self.curr_batch + 100
self.test_freq = self.curr_batch + 100
self.curr_batch = self.curr_epoch = 0
self.init_replaynet_data_provider()
model = []
model.extend(stack)
model.extend(self.fc_tmp)
self.layer_output_dumper = None
size = self.net['fc8'].get_input_size()
image_shape = (size, 1, 1, self.batch_size)
self.net = FastNet(self.learning_rate, image_shape, model)
self.replaynet = self.net
self.num_epoch = self.replaynet_epoch
Trainer.train(self)
self.net = self.container.pop()
self.layer_output_dumper = self.container.pop()
self.layer_output_dumper.reset()
self.test_dp = self.container.pop()
self.train_dp = self.container.pop()
self.test_freq = self.container.pop()
self.save_freq = self.container.pop()
def reset_trainer(self, i):
if i == len(self.stack) - 1:
self.num_epoch = self.final_num_epoch
else:
self.num_epoch = self.frag_epoch
self.curr_batch = self.curr_epoch = 0
self.init_data_provider()
def train(self):
Trainer.train(self)
for i, stack in enumerate(self.stack.values()):
self.train_replaynet(stack)
self.reset_trainer(i)
self.net.drop_layer_from('fc8')
for layer in self.replaynet:
if layer.type != 'data':
self.net.append_layer(layer)
Trainer.train(self)
class ImageNetLayerwisedTrainer(Trainer):
def divide_layers_to_stack(self):
self.fc_params = []
self.conv_params = []
conv = True
for ld in self.init_model:
if ld['type'] in ['conv', 'rnorm', 'pool', 'neuron'] and conv:
# self.conv_params.append(ld)
self.conv_params.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
def initialize_model(self):
self.curr_model.extend(self.conv_stack['conv1'])
self.curr_model.extend(self.conv_stack['conv2'])
self.curr_model.extend(self.conv_stack['conv3'])
self.curr_model.extend(self.conv_stack['conv4'])
self.curr_model.extend(self.conv_stack['conv5'])
self.curr_model.extend(self.fc_tmp)
def _finish_init(self):
self.final_num_epoch = self.num_epoch
self.curr_model = []
self.divide_layers_to_stack()
self.conv_stack = FastNet.split_conv_to_stack(self.conv_params)
self.fc_stack = FastNet.split_fc_to_stack(self.fc_params)
self.fc_tmp = [self.fc_stack['fc8'][0], self.softmax_param]
del self.fc_stack['fc8']
self.stack = self.fc_stack
self.initialize_model()
pprint.pprint(self.stack)
self.num_epoch = self.frag_epoch
self.net = FastNet(self.learning_rate, self.image_shape, self.curr_model)
self.container = deque()
def report(self):
pass
def should_continue_training(self):
return self.curr_epoch <= self.num_epoch
def init_replaynet_data_provider(self):
if self.output_method == 'disk':
dp = data.get_by_name('intermediate')
count = self.train_layer_output_dumper.get_count()
self.train_dp = dp(self.train_layer_output_path, range(0, count), 'fc')
count = self.test_layer_output_dumper.get_count()
self.test_dp = dp(self.test_layer_output_path, range(count), 'fc')
elif self.output_method == 'memory':
dp = data.get_by_name('memory')
self.train_dp = dp(self.train_layer_output_dumper)
self.test_dp = dp(self.test_layer_output_dumper)
def train_replaynet(self, stack):
self.container.append(self.save_freq)
self.container.append(self.test_freq)
self.container.append(self.train_dp)
self.container.append(self.test_dp)
self.container.append(self.train_layer_output_dumper)
self.container.append(self.test_layer_output_dumper)
self.container.append(self.net)
self.save_freq = self.curr_batch + 100
self.test_freq = self.curr_batch + 100
self.curr_batch = self.curr_epoch = 0
self.init_replaynet_data_provider()
model = []
model.extend(stack)
model.extend(self.fc_tmp)
self.train_layer_output_dumper = None
self.test_layer_output_dumper = None
size = self.net['fc8'].get_input_size()
image_shape = (size, 1, 1, self.batch_size)
self.net = FastNet(self.learning_rate, image_shape, model)
self.replaynet = self.net
self.num_epoch = self.replaynet_epoch
Trainer.train(self)
self.net = self.container.pop()
self.test_layer_output_dumper = self.container.pop()
self.test_layer_output_dumper.reset()
self.train_layer_output_dumper = self.container.pop()
self.train_layer_output_dumper.reset()
self.test_dp = self.container.pop()
self.train_dp = self.container.pop()
self.test_freq = self.container.pop()
self.save_freq = self.container.pop()
def reset_trainer(self, i):
if i == len(self.stack) - 1:
self.num_epoch = self.final_num_epoch
else:
self.num_epoch = self.frag_epoch
self.curr_batch = self.curr_epoch = 0
self.init_data_provider()
def train(self):
Trainer.train(self)
for i, stack in enumerate(self.stack.values()):
self.train_replaynet(stack)
self.reset_trainer(i)
self.net.drop_layer_from('fc8')
for layer in self.replaynet:
if layer.type != 'data':
self.net.append_layer(layer)
Trainer.train(self)
