def test_node_consistency():
graph = CnnGenerator(10, (32, 32, 3)).generate()
assert graph.layer_list[6].output.shape == (16, 16, 64)
for layer in graph.layer_list:
assert layer.output.shape == layer.output_shape
graph.to_wider_model(5, 64)
assert graph.layer_list[5].output.shape == (16, 16, 128)
for layer in graph.layer_list:
assert layer.output.shape == layer.output_shape
graph.to_conv_deeper_model(5, 3)
assert graph.layer_list[19].output.shape == (16, 16, 128)
for layer in graph.layer_list:
assert layer.output.shape == layer.output_shape
graph.to_add_skip_model(5, 18)
assert graph.layer_list[23].output.shape == (16, 16, 128)
for layer in graph.layer_list:
assert layer.output.shape == layer.output_shape
graph.to_concat_skip_model(5, 18)
assert graph.layer_list[25].output.shape == (16, 16, 256)
for layer in graph.layer_list:
assert layer.output.shape == layer.output_shape
def test_long_transform():
graph = CnnGenerator(10, (32, 32, 3)).generate()
history = [('to_wider_model', 1, 256), ('to_conv_deeper_model', 1, 3),
('to_concat_skip_model', 5, 9)]
for args in history:
getattr(graph, args[0])(*list(args[1:]))
graph.produce_model()
assert legal_graph(graph)
def test_wider_dense():
graph = CnnGenerator(10, (32, 32, 3)).generate()
graph.produce_model().set_weight_to_graph()
history = [('to_wider_model', 14, 64)]
for args in history:
getattr(graph, args[0])(*list(args[1:]))
graph.produce_model()
assert legal_graph(graph)
def test_wider_dense():
graph = CnnGenerator(10, (32, 32, 3)).generate()
graph.produce_model().set_weight_to_graph()
history = [('to_wider_model', 14, 64)]
for args in history:
getattr(graph, args[0])(*list(args[1:]))
graph.produce_model()
assert graph.layer_list[14].output.shape[-1] == 128
def test_wider_conv():
model = CnnGenerator(10, (28, 28, 3)).generate().produce_model()
model.set_weight_to_graph()
graph = model.graph
assert isinstance(wider_pre_conv(graph.layer_list[1], 3), StubConv)
assert isinstance(wider_bn(graph.layer_list[2], 3, 3, 3),
StubBatchNormalization)
assert isinstance(wider_next_conv(graph.layer_list[5], 3, 3, 3), StubConv)
def test_model_trainer_regression():
model = CnnGenerator(1, (28, 28, 3)).generate().produce_model()
train_data, test_data = get_regression_data_loaders()
ModelTrainer(model,
train_data=train_data,
test_data=test_data,
metric=MSE,
loss_function=regression_loss,
verbose=False).train_model(max_iter_num=3)
def test_model_trainer_classification():
model = CnnGenerator(3, (28, 28, 3)).generate().produce_model()
train_data, test_data = get_classification_data_loaders()
ModelTrainer(model,
train_data=train_data,
test_data=test_data,
metric=Accuracy,
loss_function=classification_loss,
verbose=True).train_model(max_iter_num=3)
def test_model_trainer_regression():
model = CnnGenerator(1, (28, 28, 3)).generate().produce_model()
train_data, test_data = get_regression_data_loaders()
ModelTrainer(model,
train_data=train_data,
test_data=test_data,
metric=MSE,
loss_function=Backend.regression_loss,
verbose=False,
path=TEST_TEMP_DIR).train_model(max_iter_num=3)
clean_dir(TEST_TEMP_DIR)
def test_node_consistency():
graph = CnnGenerator(10, (32, 32, 3)).generate()
assert graph.layer_list[6].output.shape == (16, 16, 64)
for layer in graph.layer_list:
assert layer.output.shape == layer.output_shape
graph.to_wider_model(6, 64)
assert graph.layer_list[6].output.shape == (16, 16, 128)
for layer in graph.layer_list:
assert layer.output.shape == layer.output_shape
def test_model_trainer_timout():
model = CnnGenerator(3, (28, 28, 3)).generate().produce_model()
timeout = 1
train_data, test_data = get_classification_data_loaders()
with pytest.raises(TimeoutError):
ModelTrainer(model,
train_data=train_data,
test_data=test_data,
metric=Accuracy,
loss_function=classification_loss,
verbose=True,
path=TEST_TEMP_DIR).train_model(max_iter_num=300, timeout=timeout)
clean_dir(TEST_TEMP_DIR)
def test_model_trainer_classification():
Backend.backend = tensorflow
model = CnnGenerator(3, (28, 28, 3)).generate().produce_model()
train_data, test_data = get_classification_data_loaders()
ModelTrainer(model,
train_data=train_data,
test_data=test_data,
metric=Accuracy,
loss_function=Backend.classification_loss,
verbose=True,
path=TEST_TEMP_DIR).train_model(max_iter_num=3)
Backend.backend = torch
clean_dir(TEST_TEMP_DIR)
def init_search(self):
if self.verbose:
print('\nInitializing search.')
graph = CnnGenerator(self.n_classes, self.input_shape).generate(
self.default_model_len, self.default_model_width)
model_id = self.model_count
self.model_count += 1
self.training_queue.append((graph, -1, model_id))
self.descriptors.append(graph.extract_descriptor())
for child_graph in default_transform(graph):
child_id = self.model_count
self.model_count += 1
self.training_queue.append((child_graph, model_id, child_id))
self.descriptors.append(child_graph.extract_descriptor())
if self.verbose:
print('Initialization finished.')
def final_fit(self,
x_train,
y_train,
x_test,
y_test,
trainer_args=None,
retrain=True):
x_train = self.preprocess(x_train)
x_test = self.preprocess(x_test)
self.encoder.fit(y_train)
y_train = self.encoder.transform(y_train)
y_test = self.encoder.transform(y_test)
self.data_transformer = ImageDataTransformer(x_train,
augment=self.augment)
train_data = self.data_transformer.transform_train(x_train,
y_train,
batch_size=1)
test_data = self.data_transformer.transform_test(x_test,
y_test,
batch_size=1)
self.net = CnnGenerator(self.encoder.n_classes, x_train.shape[1:]) \
.generate(model_len=self.Length, model_width=self.Width).produce_model()
pickle_to_file(self, os.path.join(self.path, 'classifier'))
self.model_trainer = ModelTrainer(self.net,
path=self.path,
loss_function=classification_loss,
metric=Accuracy,
train_data=train_data,
test_data=test_data,
verbose=True)
self.model_trainer.train_model(self.Epochs, 3)
print('Finished Final Fit')
def test_default_transform():
graphs = default_transform(CnnGenerator(10, (32, 32, 3)).generate())
model = graphs[0].produce_model()
model(torch.Tensor(get_conv_data()))
assert len(graphs) == 1
assert len(graphs[0].layer_list) == 43
def fit(self, x_train=None, y_train=None, time_limit=60 * 60 * 6):
end_time = time.time() + time_limit
x_train = self.preprocess(x_train)
x_train, x_valid, y_train, y_valid = train_test_split(x_train,
y_train,
test_size=0.25,
shuffle=True)
x_train, y_train = np.array(x_train), np.array(y_train)
x_valid, y_valid = np.array(x_valid), np.array(y_valid)
self.encoder.fit(y_train)
y_train = self.encoder.transform(y_train)
y_valid = self.encoder.transform(y_valid)
self.data_transformer = ImageDataTransformer(x_train,
augment=self.augment)
train_data = self.data_transformer.transform_train(x_train,
y_train,
batch_size=1)
test_data = self.data_transformer.transform_test(x_valid,
y_valid,
batch_size=1)
y_valid = self.encoder.inverse_transform(y_valid)
visited = set()
pq = []
trainingQ = [(self.Length, self.Width, self.Epochs)]
accuracy = 0.0
while trainingQ:
for len, width, epoch in trainingQ:
if time.time() < end_time and (len, width,
epoch) not in visited:
visited.add((len, width, epoch))
try:
net = CnnGenerator(self.encoder.n_classes, x_train.shape[1:])\
.generate(model_len=len, model_width=width).produce_model()
model_trainer = ModelTrainer(
net,
path=self.path,
loss_function=classification_loss,
metric=Accuracy,
train_data=train_data,
test_data=test_data,
verbose=True)
model_trainer.train_model(epoch, 3)
outputs = []
with torch.no_grad():
for index, (inputs, _) in enumerate(test_data):
outputs.append(net(inputs).numpy())
output = reduce(lambda x, y: np.concatenate((x, y)),
outputs)
pred_valid = self.encoder.inverse_transform(output)
accu = self.metric().evaluate(y_valid, pred_valid)
print("Accuracy: ", accu, " Parameters: ", len, width,
epoch)
pq.append((-accu, (len, width, epoch)))
if pq.__len__() > self.capacity:
heapq.heapify(pq)
pq.remove(heapq.nlargest(1, pq)[0])
if accu > accuracy:
self.Epochs = epoch
self.Length = len
self.Width = width
accuracy = accu
except Exception as e:
print(e)
if not pq:
break
heapq.heapify(pq)
_, (nexlen, nexwidth, nexepoch) = heapq.heappop(pq)
# Create children
trainingQ = []
trainingQ.append((nexlen + 1, nexwidth, nexepoch))
trainingQ.append((nexlen, nexwidth * 2, nexepoch))
trainingQ.append((nexlen, nexwidth, nexepoch + 5))
trainingQ.append((nexlen + 2, nexwidth, nexepoch + 3))
trainingQ.append((nexlen, nexwidth * 2, nexepoch + 2))
trainingQ.append((nexlen + 1, nexwidth, nexepoch + 3))
print('Finished Fit')
print("Optimal Conv3D Network Parameters:")
print("Number of Layers (Length):", self.Length)
print("Number of Filters (Width):", self.Width)
print("Number of Epochs", self.Epochs)
print()
def test_deeper_conv_block():
graph = CnnGenerator(10, (28, 28, 3)).generate()
layers = deeper_conv_block(graph.layer_list[1], 3)
assert len(layers) == Constant.CONV_BLOCK_DISTANCE + 1
def test_long_transform2():
graph = CnnGenerator(10, (28, 28, 1)).generate()
graph.to_add_skip_model(2, 3)
graph.to_concat_skip_model(2, 3)
model = graph.produce_model()
model(torch.Tensor(np.random.random((10, 1, 28, 28))))
def test_graph_size():
graph = CnnGenerator(10, (32, 32, 3)).generate()
assert graph.size() == 7254