コード例 #1
0
ファイル: deep3d.py プロジェクト: evanfeinberg/deepchem
      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)
コード例 #2
0
ファイル: deep.py プロジェクト: evanfeinberg/deepchem
    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.
コード例 #3
0
ファイル: standard.py プロジェクト: evanfeinberg/deepchem
    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)
コード例 #4
0
    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)
'''
コード例 #5
0
ファイル: standard.py プロジェクト: arose/deepchem
    """
    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)
'''
コード例 #6
0
ファイル: deep.py プロジェクト: arose/deepchem
    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).
コード例 #7
0
ファイル: deep.py プロジェクト: hainm/deepchem
        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)