Begin adding type annotations

- pip install yapf==0.22.0

- pip install coveralls

- python setup.py install

- conda install mypy

script:

- pytest -m "not slow" --cov=deepchem deepchem

- if [ $TRAVIS_PYTHON_VERSION == '3.7' ]; then find ./deepchem | grep .py$ |xargs

  python -m doctest -v; fi

- bash devtools/travis-ci/test_format_code.sh

- mypy -p deepchem --ignore-missing-imports

after_success:

- echo $TRAVIS_SECURE_ENV_VARS

- coveralls

    """

    raise NotImplementedError

  def fit(self, dataset, nb_epoch=10, batch_size=50, **kwargs):

  def fit(self, dataset, nb_epoch=10, **kwargs):

    """

    Fits a model on data in a Dataset object.

    """

    for epoch in range(nb_epoch):

      log("Starting epoch %s" % str(epoch + 1), self.verbose)

      losses = []

      for (X_batch, y_batch, w_batch,

           ids_batch) in dataset.iterbatches(batch_size):

      for (X_batch, y_batch, w_batch, ids_batch) in dataset.iterbatches():

        losses.append(self.fit_on_batch(X_batch, y_batch, w_batch))

      log("Avg loss for epoch %d: %f" % (epoch + 1, np.array(losses).mean()),

          self.verbose)

  def predict(self, dataset, transformers=[], batch_size=None):

  def predict(self, dataset, transformers=[]):

    """

    Uses self to make predictions on provided Dataset object.

    n_tasks = self.get_num_tasks()

    ind = 0

    for (X_batch, _, _, ids_batch) in dataset.iterbatches(

        batch_size, deterministic=True):

    for (X_batch, _, _, ids_batch) in dataset.iterbatches(deterministic=True):

      n_samples = len(X_batch)

      y_pred_batch = self.predict_on_batch(X_batch)

      # Discard any padded predictions

    nb_epoch = None

    # Building scikit logistic regression model

    def model_builder(model_dir_logreg):

    def model_builder(model_dir):

      sklearn_model = LogisticRegression(

          penalty=penalty_type,

          C=1. / penalty,

    nb_epoch = None

    # Building scikit random forest model

    def model_builder(model_dir_rf):

    def model_builder(model_dir):

      sklearn_model = RandomForestClassifier(

          class_weight="balanced", n_estimators=n_estimators, n_jobs=-1)

      return deepchem.models.sklearn_models.SklearnModel(

    nb_epoch = None

    # Building scikit learn Kernel SVM model

    def model_builder(model_dir_kernelsvm):

    def model_builder(model_dir):

      sklearn_model = SVC(

          C=C, gamma=gamma, class_weight="balanced", probability=True)

      return deepchem.models.SklearnModel(sklearn_model, model_dir_kernelsvm)

    esr = {'early_stopping_rounds': early_stopping_rounds}

    # Building xgboost classification model

    def model_builder(model_dir_xgb):

    def model_builder(model_dir):

      import xgboost

      xgboost_model = xgboost.XGBClassifier(

          max_depth=max_depth,

    nb_epoch = None

    # Building scikit random forest model

    def model_builder(model_dir_rf_regression):

    def model_builder(model_dir):

      sklearn_model = RandomForestRegressor(

          n_estimators=n_estimators, n_jobs=-1)

      return deepchem.models.sklearn_models.SklearnModel(

    nb_epoch = None

    # Building scikit learn Kernel Ridge Regression model

    def model_builder(model_dir_krr):

    def model_builder(model_dir):

      sklearn_model = KernelRidge(kernel="rbf", alpha=alpha)

      return deepchem.models.SklearnModel(sklearn_model, model_dir_krr)

    test_dataset = ft_transformer.transform(test_dataset)

    # Building scikit learn Kernel Ridge Regression model

    def model_builder(model_dir_krr):

    def model_builder(model_dir):

      sklearn_model = KernelRidge(kernel="rbf", alpha=alpha)

      return deepchem.models.SklearnModel(sklearn_model, model_dir_krr)

    esr = {'early_stopping_rounds': early_stopping_rounds}

    # Building xgboost regression model

    def model_builder(model_dir_xgb):

    def model_builder(model_dir):

      xgboost_model = xgboost.XGBRegressor(

          max_depth=max_depth,

          learning_rate=learning_rate,

      assert np.count_nonzero(y_present[:split_index, task]) == int(

          task_actives / 2)

  def test_singletask_stratified_split(self):

  def test_random_stratified_split(self):

    """

    Test RandomStratifiedSplitter on a singletask split.

    """