model.add(Activation('relu'))
model.add(MaxPooling3D(pool_size=(nb_pool[2], nb_pool[2], nb_pool[2])))
model.add(Flatten())
# TODO(rbharath): If we change away from axis-size 32, this code will break.
# Eventually figure out a more general rule that works for all axis sizes.
model.add(Dense(16, init='normal'))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(1, init='normal'))
sgd = RMSprop(lr=learning_rate, decay=1e-6, momentum=0.9, nesterov=True)
print("About to compile model")
model.compile(loss=loss_function, optimizer=sgd)
self.raw_model = model
def fit_on_batch(self, X, y, w):
X = shuffle_data(X)
loss = self.raw_model.train_on_batch(X, y)
print("Loss: %f" % loss)
def predict_on_batch(self, X):
if len(np.shape(X)) != 5:
raise ValueError(
"Tensorial datatype must be of shape (n_samples, N, N, N, n_channels).")
X = shuffle_data(X)
y_pred = self.raw_model.predict_on_batch(X)
y_pred = np.squeeze(y_pred)
return y_pred
Model.register_model_type("convolutional_3D_regressor", DockingDNN)
nb_tasks = len(sorted_tasks)
y_pred = np.zeros((nb_samples, nb_tasks))
for ind, task in enumerate(sorted_tasks):
task_type = self.task_types[task]
taskname = "task%d" % ind
if task_type == "classification":
# Class probabilities are predicted for classification outputs. Instead,
# output the most likely class.
y_pred_task = np.squeeze(np.argmax(y_pred_dict[taskname], axis=1))
else:
y_pred_task = np.squeeze(y_pred_dict[taskname])
y_pred[:, ind] = y_pred_task
y_pred = np.squeeze(y_pred)
return y_pred
Model.register_model_type("multitask_deep_regressor", MultiTaskDNN)
Model.register_model_type("multitask_deep_classifier", MultiTaskDNN)
class SingleTaskDNN(MultiTaskDNN):
"""
Abstract base class for different ML models.
"""
def __init__(self, model_type, task_types, model_params, initialize_raw_model=True):
super(SingleTaskDNN, self).__init__(model_type, task_types, model_params,
initialize_raw_model)
Model.register_model_type("singletask_deep_regressor", SingleTaskDNN)
Model.register_model_type("singletask_deep_classifier", SingleTaskDNN)
def to_one_hot(y):
"""Transforms label vector into one-hot encoding.
for (X, y, _, _) in numpy_dataset.itershards():
Xs.append(X)
ys.append(y)
X = np.concatenate(Xs)
y = np.concatenate(ys).ravel()
self.raw_model.fit(X, y)
def predict_on_batch(self, X):
"""
Makes predictions on given batch of new data.
"""
return self.raw_model.predict(X)
def save(self, out_dir):
"""Saves sklearn model to disk using joblib."""
super(SklearnModel, self).save(out_dir)
save_to_disk(self.raw_model, self.get_model_filename(out_dir))
def load(self, model_dir):
"""Loads sklearn model from joblib file on disk."""
self.raw_model = load_from_disk(Model.get_model_filename(model_dir))
Model.register_model_type("logistic", SklearnModel)
Model.register_model_type("rf_classifier", SklearnModel)
Model.register_model_type("rf_regressor", SklearnModel)
Model.register_model_type("linear", SklearnModel)
Model.register_model_type("ridge", SklearnModel)
Model.register_model_type("lasso", SklearnModel)
Model.register_model_type("lasso_lars", SklearnModel)
Model.register_model_type("elastic_net", SklearnModel)
Makes predictions on dataset.
"""
# Sets batch_size which the default impl in Model expects
#TODO(enf/rbharath): This is kludgy. Fix later.
if "batch_size" not in self.model_params.keys():
self.model_params["batch_size"] = 32
return super(SklearnModel, self).predict(X)
def save(self, out_dir):
"""Saves sklearn model to disk using joblib."""
super(SklearnModel, self).save(out_dir)
save_to_disk(self.raw_model, self.get_model_filename(out_dir))
def load(self, model_dir):
"""Loads sklearn model from joblib file on disk."""
self.raw_model = load_from_disk(Model.get_model_filename(model_dir))
Model.register_model_type(SklearnModel)
#TODO(enf/rbharath): deprecate the following if __init__.py functions as planned.
'''
Model.register_model_type("logistic", SklearnModel)
Model.register_model_type("rf_classifier", SklearnModel)
Model.register_model_type("rf_regressor", SklearnModel)
Model.register_model_type("linear", SklearnModel)
Model.register_model_type("ridge", SklearnModel)
Model.register_model_type("lasso", SklearnModel)
Model.register_model_type("lasso_lars", SklearnModel)
Model.register_model_type("elastic_net", SklearnModel)
'''
"""
Makes predictions on dataset.
"""
# Sets batch_size which the default impl in Model expects
#TODO(enf/rbharath): This is kludgy. Fix later.
if "batch_size" not in self.model_params.keys():
self.model_params["batch_size"] = 32
return super(SklearnModel, self).predict(X)
def save(self, out_dir):
"""Saves sklearn model to disk using joblib."""
super(SklearnModel, self).save(out_dir)
save_to_disk(self.raw_model, self.get_model_filename(out_dir))
def load(self, model_dir):
"""Loads sklearn model from joblib file on disk."""
self.raw_model = load_from_disk(Model.get_model_filename(model_dir))
Model.register_model_type(SklearnModel)
#TODO(enf/rbharath): deprecate the following if __init__.py functions as planned.
'''
Model.register_model_type("logistic", SklearnModel)
Model.register_model_type("rf_classifier", SklearnModel)
Model.register_model_type("rf_regressor", SklearnModel)
Model.register_model_type("linear", SklearnModel)
Model.register_model_type("ridge", SklearnModel)
Model.register_model_type("lasso", SklearnModel)
Model.register_model_type("lasso_lars", SklearnModel)
Model.register_model_type("elastic_net", SklearnModel)
'''
nb_tasks = len(sorted_tasks)
y_pred = np.zeros((nb_samples, nb_tasks))
for ind, task in enumerate(sorted_tasks):
task_type = self.task_types[task]
taskname = "task%d" % ind
if task_type == "classification":
# Class probabilities are predicted for classification outputs. Instead,
# output the most likely class.
y_pred_task = np.squeeze(np.argmax(y_pred_dict[taskname], axis=1))
else:
y_pred_task = np.squeeze(y_pred_dict[taskname])
y_pred[:, ind] = y_pred_task
y_pred = np.squeeze(y_pred)
return y_pred
Model.register_model_type(MultiTaskDNN)
class SingleTaskDNN(MultiTaskDNN):
"""
Abstract base class for different ML models.
"""
def __init__(self, task_types, model_params, initialize_raw_model=True):
super(SingleTaskDNN, self).__init__(task_types, model_params,
initialize_raw_model=initialize_raw_model)
Model.register_model_type(SingleTaskDNN)
def to_one_hot(y):
"""Transforms label vector into one-hot encoding.
Turns y into vector of shape [n_samples, 2] (assuming binary labels).
for ind, task in enumerate(sorted_tasks):
task_type = self.task_types[task]
taskname = "task%d" % ind
if task_type == "classification":
# Class probabilities are predicted for classification outputs. Instead,
# output the most likely class.
y_pred_task = np.squeeze(
np.argmax(y_pred_dict[taskname], axis=1))
else:
y_pred_task = np.squeeze(y_pred_dict[taskname])
y_pred[:, ind] = y_pred_task
y_pred = np.squeeze(y_pred)
return y_pred
Model.register_model_type(MultiTaskDNN)
class SingleTaskDNN(MultiTaskDNN):
"""
Abstract base class for different ML models.
"""
def __init__(self, task_types, model_params, initialize_raw_model=True):
super(SingleTaskDNN,
self).__init__(task_types,
model_params,
initialize_raw_model=initialize_raw_model)
Model.register_model_type(SingleTaskDNN)
