class ImageNetLayerwisedTrainer(AutoStopTrainer):
def __init__(self, test_id, data_dir, provider, checkpoint_dir, train_range, test_range, test_freq,
save_freq, batch_size, num_epoch, image_size, image_color, learning_rate, params):
self.origin_test_range = test_range
if len(test_range) != 1:
test_range = [test_range[0]]
AutoStopTrainer.__init__(self, test_id, data_dir, provider, checkpoint_dir, train_range, test_range, test_freq,
save_freq, batch_size, num_epoch, image_size, image_color, learning_rate, False)
self.conv_params = []
self.fc_params = []
self.softmax_param = None
self.params = params
conv = True
for ld in self.params:
if ld['type'] in ['conv', 'rnorm', 'pool', 'neuron'] and conv:
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
self.conv_stack = FastNet.split_conv_to_stack(self.conv_params)
self.fc_stack = FastNet.split_fc_to_stack(self.fc_params)
pprint.pprint(self.conv_stack)
pprint.pprint(self.fc_stack)
self.fakefc_param = self.fc_stack[-1][0]
def report(self):
pass
def init_data_provider(self):
self.train_dp = ImageNetDataProvider(self.data_dir, self.train_range)
self.test_dp = ImageNetDataProvider(self.data_dir, self.test_range)
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)
class LayerwisedTrainer(AutoStopTrainer):
def __init__(self, test_id, data_dir, provider, checkpoint_dir, train_range, test_range, test_freq,
save_freq, batch_size, num_epoch, image_size, image_color, learning_rate, n_filters,
size_filters, fc_nouts):
AutoStopTrainer.__init__(self, test_id, data_dir,provider, checkpoint_dir, train_range, test_range, test_freq,
save_freq, batch_size, num_epoch, image_size, image_color, learning_rate, 0, False)
if len(n_filters) == 1:
self.layerwised = False
else:
self.layerwised = True
self.n_filters = n_filters
self.size_filters = size_filters
self.fc_nouts = fc_nouts
init_n_filter = [self.n_filters[0]]
init_size_filter = [self.size_filters[0]]
self.net.add_parameterized_layers(init_n_filter, init_size_filter, self.fc_nouts)
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 add_parameterized_layers(self, net, n_filters=None, size_filters=None, fc_nout=[10]):
for i in range(len(n_filters)):
prev = n_filters[i - 1] if i > 0 else net.imgShapes[-1][1]
filter_shape = (n_filters[i], prev, size_filters[i], size_filters[i])
conv = layer.ConvLayer('conv' + str(net.numConv), filter_shape, net.imgShapes[-1])
net.append_layer(conv)
neuron = layer.NeuronLayer('neuron' + str(net.numConv), net.imgShapes[-1], type='tanh')
net.append_layer(neuron)
pool = layer.MaxPoolLayer('pool' + str(net.numConv), net.imgShapes[-1])
net.append_layer(pool)
rnorm = layer.ResponseNormLayer('rnorm' + str(net.numConv), net.imgShapes[-1])
net.append_layer(rnorm)
for i in range(len(fc_nout)):
fc = layer.FCLayer('fc' + str(i + 1), net.inputShapes[-1], fc_nout[-1])
net.append_layer(fc)
net.append_layer(layer.SoftmaxLayer('softmax', net.inputShapes[-1]))
