def fit(self, x, y, x_test=None, y_test=None, time_limit=None):
x = np.array(x)
y = np.array(y).flatten()
validate_xy(x, y)
y = self.transform_y(y)
if x_test is None or y_test is None:
# Divide training data into training and testing data.
validation_set_size = int(len(y) * Constant.VALIDATION_SET_SIZE)
validation_set_size = min(validation_set_size, 500)
validation_set_size = max(validation_set_size, 1)
x_train, x_test, y_train, y_test = train_test_split(
x, y, test_size=validation_set_size, random_state=42)
else:
x_train = x
y_train = y
# Transform x_train
if self.data_transformer is None:
self.data_transformer = ImageDataTransformer(x,
augment=self.augment)
# Wrap the data into DataLoaders
train_data = self.data_transformer.transform_train(x_train, y_train)
test_data = self.data_transformer.transform_test(x_test, y_test)
# Save the classifier
pickle.dump(self, open(os.path.join(self.path, 'classifier'), 'wb'))
pickle_to_file(self, os.path.join(self.path, 'classifier'))
if time_limit is None:
time_limit = 24 * 60 * 60
self.cnn.fit(self.get_n_output_node(), x_train.shape, train_data,
test_data, time_limit)
def get_classification_data_loaders():
x_train = np.random.rand(200, 28, 28, 3)
y_train = np.random.rand(200, 3)
x_test = np.random.rand(190, 28, 28, 3)
y_test = np.random.rand(190, 3)
data_transformer = ImageDataTransformer(x_train, augment=True)
train_data = data_transformer.transform_train(x_train, y_train)
test_data = data_transformer.transform_test(x_test, y_test)
return train_data, test_data
def init_transformer(self, x):
"""THIS FUNCTION NEEDS A DESCRIPTION.
Args:
x: DATA TO TRANSFORM
"""
if self.data_transformer is None:
self.data_transformer = ImageDataTransformer(x,
augment=self.augment)
def fit(self, x_train):
""" Train only
Args:
x_train: ndarray contained the training data
Returns:
"""
# input size stay the same, enable cudnn optimization
cudnn.benchmark = True
self.data_transformer = ImageDataTransformer(x_train,
augment=self.augment)
train_dataloader = self.data_transformer.transform_train(x_train)
GANModelTrainer(self.net_g, self.net_d, train_dataloader,
binary_classification_loss, self.verbose,
self.gen_training_result).train_model()
def fit(self, x, y, x_test=None, y_test=None, time_limit=None):
x = np.array(x)
if len(x.shape) != 0 and len(x[0].shape) == 3:
if self.verbose:
print("Preprocessing the images.")
self.resize_height, self.resize_width = compute_image_resize_params(
x)
x = resize_image_data(x, self.resize_height, self.resize_width)
if x_test is not None:
x_test = resize_image_data(x_test, self.resize_height,
self.resize_width)
if self.verbose:
print("Preprocessing finished.")
y = np.array(y).flatten()
validate_xy(x, y)
y = self.transform_y(y)
if x_test is None or y_test is None:
# Divide training data into training and testing data.
validation_set_size = int(len(y) * Constant.VALIDATION_SET_SIZE)
validation_set_size = min(validation_set_size, 500)
validation_set_size = max(validation_set_size, 1)
x_train, x_test, y_train, y_test = train_test_split(
x, y, test_size=validation_set_size, random_state=42)
else:
x_train = x
y_train = y
# Transform x_train
if self.data_transformer is None:
self.data_transformer = ImageDataTransformer(x,
augment=self.augment)
# Wrap the data into DataLoaders
train_data = self.data_transformer.transform_train(x_train, y_train)
test_data = self.data_transformer.transform_test(x_test, y_test)
# Save the classifier
pickle_to_file(self, os.path.join(self.path, 'classifier'))
if time_limit is None:
time_limit = 24 * 60 * 60
self.cnn.fit(self.get_n_output_node(), x_train.shape, train_data,
test_data, time_limit)
def fit(self, x_train, y_train, time_limit=None):
"""Trains the model on the dataset given.
Args:
x_train: A numpy.ndarray instance containing the training data,
or the training data combined with the validation data.
y_train: A numpy.ndarray instance containing the label of the training data,
or the label of the training data combined with the validation label.
time_limit: A dictionary containing the parameters of the ModelTrainer constructor.
"""
validate_xy(x_train, y_train)
self.resize_shape = compute_image_resize_params(x_train)
x_train = self.preprocess(x_train)
self.y_encoder.fit(y_train)
y_train = self.transform_y(y_train)
# Divide training data into training and testing data.
validation_set_size = int(len(y_train) * Constant.VALIDATION_SET_SIZE)
validation_set_size = min(validation_set_size, 500)
validation_set_size = max(validation_set_size, 1)
x_train_new, x_test, y_train_new, y_test = train_test_split(
x_train, y_train, test_size=validation_set_size, random_state=42)
# initialize data_transformer
self.data_transformer = ImageDataTransformer(x_train_new)
# Wrap the data into DataLoaders
train_loader = self.data_transformer.transform_train(
x_train_new, y_train_new)
test_loader = self.data_transformer.transform_test(x_test, y_test)
self.generator = self._init_generator(self.y_encoder.n_classes,
x_train_new.shape[1:])
graph = self.generator.generate()
if time_limit is None:
time_limit = {'max_no_improvement_num': 30}
_, _1, self.graph = train(None, graph, train_loader, test_loader,
time_limit, self.metric, self.loss,
self.verbose, self.path)
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 get_classification_train_data_loaders():
x_train = np.random.rand(200, 32, 32, 3)
data_transformer = ImageDataTransformer(x_train, augment=True)
train_data = data_transformer.transform_train(x_train)
return train_data
def init_transformer(self, x):
if self.data_transformer is None:
self.data_transformer = ImageDataTransformer(x,
augment=self.augment)
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()
y_encoder.fit(y_train)
y_train = y_encoder.transform(y_train)
return y_train, y_encoder
if __name__ == '__main__':
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(x_train.shape + (1, ))
x_test = x_test.reshape(x_test.shape + (1, ))
y_train, y_encoder = transform_y(y_train)
y_test, _ = transform_y(y_test)
cnnModule = CnnModule(loss=classification_loss,
metric=Accuracy,
searcher_args={},
verbose=True)
# specify the fit args
data_transformer = ImageDataTransformer(x_train, augment=True)
train_data = data_transformer.transform_train(x_train, y_train)
test_data = data_transformer.transform_test(x_test, y_test)
fit_args = {
"n_output_node": y_encoder.n_classes,
"input_shape": x_train.shape,
"train_data": train_data,
"test_data": test_data
}
cnnModule.fit(n_output_node=fit_args.get("n_output_node"),
input_shape=fit_args.get("input_shape"),
train_data=fit_args.get("train_data"),
test_data=fit_args.get("test_data"),
time_limit=24 * 60 * 60)