Fixes to get MUV models to run to completion. Bad results though.

      for hyperparam, hyperparam_val in zip(hyperparams, hyperparameter_tuple):

        model_params[hyperparam] = hyperparam_val

      if logdir is not None:

        model_dir = logdir

      else:

        model_dir = tempfile.mkdtemp()

      if logdir is not None:

        model = self.model_class(self.task_types, model_params, logdir=logdir)

        model = self.model_class(self.task_types, model_params, model_dir,

                                 verbosity=self.verbosity)

      else:

        model = self.model_class(self.task_types, model_params)

        model = self.model_class(self.task_types, model_params,

                                 verbosity=self.verbosity)

      model.fit(train_dataset)

      model.save(model_dir)

        valid_score = scores_df.iloc[0][metric.name]

      else:

        valid_score = multitask_scores[metric.name]

      print("hyperparameters.compute")

      print("valid_score")

      print(valid_score)

      print("hyperparameter_tuple")

      print(hyperparameter_tuple)

      all_scores[hyperparameter_tuple] = valid_score

      if (use_max and valid_score >= best_validation_score) or (

      log("\tbest_validation_score so far: %f" % best_validation_score,

          self.verbosity)

    if best_model is None:

      log("No models trained correctly.", self.verbosity)

      return best_model, best_hyperparams, all_scores

    train_csv_out = tempfile.NamedTemporaryFile()

    train_stats_out = tempfile.NamedTemporaryFile()

    train_evaluator = Evaluator(best_model, train_dataset, output_transformers)

from deepchem.utils.evaluate import from_one_hot

from deepchem.models.tensorflow_models import model_ops

from deepchem.models.tensorflow_models import utils as tf_utils

from deepchem.utils.save import log

class TensorflowGraph(object):

  """Thin wrapper holding a tensorflow graph and a few vars.

    logdir: Directory for output files.

  """

  def __init__(self, model_params, logdir, task_types, train=True):

  def __init__(self, model_params, logdir, task_types, train=True,

               verbosity=None):

    """Constructs the computational graph.

    Args:

    self.logdir = logdir

    self.task_types = task_types

    self.num_tasks = len(task_types)

    self.verbosity = verbosity

    # Lazily created by _get_shared_session().

    self._shared_session = None

  def fit(self,

          dataset,

          max_steps=None,

          summaries=False,

          save_model_secs=60,

          max_checkpoints_to_keep=5):

    """Fit the model.

    Args:

      dataset: Dataset object that represents data on disk.

      max_steps: Maximum number of training steps. If not provided, will

        train indefinitely.

      summaries: If True, add summaries for model parameters.

      save_model_secs: Integer. Saves a checkpoint at this interval in seconds.

      max_checkpoints_to_keep: Integer. Maximum number of checkpoints to keep;

        older checkpoints will be deleted.

    Raises:

      AssertionError: If model is not in training mode.

    """

    num_datapoints = len(dataset)

    batch_size = self.model_params["batch_size"]

    step_per_epoch = np.ceil(float(num_datapoints)/batch_size)

    nb_epoch = self.model_params["nb_epoch"]

    log("Training for %d epochs" % nb_epoch, self.verbosity)

    with self.graph.as_default():

      assert model_ops.is_training()

      self.require_attributes(['loss', 'global_step', 'updates'])

      no_op = tf.no_op()

      tf.train.write_graph(

          tf.get_default_graph().as_graph_def(), self.logdir, 'train.pbtxt')

      last_checkpoint_time = time.time()

      with self._get_shared_session() as sess:

        sess.run(tf.initialize_all_variables())

        saver = tf.train.Saver(max_to_keep=max_checkpoints_to_keep)

        # Save an initial checkpoint.

        saver.save(sess, self._save_path, global_step=self.global_step)

        for (X_b, y_b, w_b, ids_b) in dataset.iterbatches(self.model_params["batch_size"]):

        for epoch in range(nb_epoch):

          for (X_b, y_b, w_b, ids_b) in dataset.iterbatches(batch_size):

            # Run training op and compute summaries.

            feed_dict = self.construct_feed_dict(X_b, y_b, w_b, ids_b)

            step, loss, _ = sess.run(

                [train_op.values()[0], self.loss, self.updates],

                feed_dict=feed_dict)

          # Save model checkpoints.

          secs_since_checkpoint = time.time() - last_checkpoint_time

          if secs_since_checkpoint > save_model_secs:

            logging.info('step %d: %g', step, loss)

          # Save model checkpoints at end of epoch

          saver.save(sess, self._save_path, global_step=self.global_step)

            last_checkpoint_time = time.time()

          # Quit when we reach max_steps.

          if max_steps is not None and step >= max_steps:

            break

          log('Ending epoch %d: loss %g' % (epoch, loss), self.verbosity)

        # Always save a final checkpoint when complete.

        saver.save(sess, self._save_path, global_step=self.global_step)

        logging.info('Eval batch took %g seconds', time.time() - start)

        labels = np.array(from_one_hot(np.squeeze(np.concatenate(labels))))

        labels = np.array(from_one_hot(

            np.squeeze(np.concatenate(labels)), axis=2))

    return np.copy(labels)

      tf_class = TensorflowGraph

    self.model_params = model_params

    self.task_types = task_types

    self.train_model = tf_class(model_params, logdir, task_types, train=True)

    self.eval_model = tf_class(model_params, logdir, task_types, train=False)

    self.train_model = tf_class(model_params, logdir, task_types, train=True,

                                verbosity=verbosity)

    self.eval_model = tf_class(model_params, logdir, task_types, train=False,

                               verbosity=verbosity)

    self.num_tasks = len(task_types)

  def fit(self, dataset):

    """

    if logdir != self.train_model.logdir:

      raise ValueError("Cannot save to directory "

                       "that was not specifed during initialization")

                       "that was not specified during initialization")

  def load(self, model_dir):

    """

    #shutil.rmtree(self.model_dir)

  def _hyperparam_opt(self, model_builder, params_dict, train_dataset,

                      valid_dataset, output_transformers, task_types, metric):

                      valid_dataset, output_transformers, task_types, metric,

                      logdir=None):

    optimizer = HyperparamOpt(model_builder, task_types, verbosity="low")

    best_model, best_hyperparams, all_results = optimizer.hyperparam_search(

      params_dict, train_dataset, valid_dataset, output_transformers,

      metric)

      metric, logdir=logdir)

  def _create_model(self, train_dataset, test_dataset, model, transformers,

                    metrics):

      y_hot[index] = np.array([0, 1])

  return y_hot

def from_one_hot(y):

def from_one_hot(y, axis=1):

  """Transorms label vector from one-hot encoding.

  y: np.ndarray

    A vector of shape [n_samples, num_classes]

  """

  return np.argmax(y, axis=1)

  return np.argmax(y, axis=axis)

def threshold_predictions(y, threshold):

  y_out = np.zeros_like(y)