fixed failing tests

    for epoch in range(self.model_params["nb_epoch"]):

      print("Starting epoch %s" % str(epoch+1))

      for i, (X, y, w, _) in enumerate(dataset.itershards()):

        print("Training on batch-%s/epoch-%s" % (str(i+1), str(epoch+1)))

        print("Training on shard-%s/epoch-%s" % (str(i+1), str(epoch+1)))

        nb_sample = np.shape(X)[0]

        interval_points = np.linspace(

            0, nb_sample, np.ceil(float(nb_sample)/batch_size)+1, dtype=int)

        for j in range(len(interval_points)-1):

          print("Training on batch-%s/shard-%s/epoch-%s" % (str(j+1), str(i+1), str(epoch+1)))

          indices = range(interval_points[j], interval_points[j+1])

          X_batch = X[indices, :]

          y_batch = y[indices]

    """

    data = self.get_data_dict(X)

    y_pred_dict = self.raw_model.predict_on_batch(data)

    print("y_pred_dict.keys()")

    print(y_pred_dict.keys())

    sorted_tasks = sorted(self.task_types.keys())

    nb_samples = np.shape(X)[0]

    nb_tasks = len(sorted_tasks)

    for ind, task in enumerate(sorted_tasks):

      task_type = self.task_types[task]

      taskname = "task%d" % ind

      print("taskname")

      print(taskname)

      if task_type == "classification":

        # Class probabilities are predicted for classification outputs. Instead,

        # output the most likely class.

  featurize_group.add_argument(

      "--ligand-mol2-field", type=str, default=None,

      help="Name of field holding ligand mol2.")

  featurize_group.add_argument(

      "--parallel", type=float, default=None,

      help="Use multiprocessing will be used to parallelize featurization.")

def add_transforms_group(cmd):

  """Adds flags for data transforms."""

        feature_dir, data_dir, args.input_files, args.user_specified_features,

        args.tasks, args.smiles_field, args.split_field, args.id_field,

        args.threshold, args.protein_pdb_field,

        args.ligand_pdb_field, args.ligand_mol2_field, args.parallel)

        args.ligand_pdb_field, args.ligand_mol2_field)

  if args.generate_dataset:

    print("+++++++++++++++++++++++++++++++++")

def featurize_inputs(feature_dir, data_dir, input_files,

                     user_specified_features, tasks, smiles_field,

                     split_field, id_field, threshold, protein_pdb_field, 

                     ligand_pdb_field, ligand_mol2_field, parallel):

                     ligand_pdb_field, ligand_mol2_field):

  """Allows for parallel data featurization."""

  featurize_input_partial = partial(featurize_input,

                                    ligand_pdb_field=ligand_pdb_field,

                                    ligand_mol2_field=ligand_mol2_field)

  if parallel:

    pool = mp.Pool(int(mp.cpu_count()/2))

    pool.map(featurize_input_partial, input_files)

    pool.terminate()

  else:

  for input_file in input_files:

    featurize_input_partial(input_file)

def _df_to_numpy(df, feature_types):

  """Transforms a featurized dataset df into standard set of numpy arrays"""

  if not set(feature_types).issubset(df.keys()):

    print("feature_types")

    print(feature_types)

    print("df.keys()")

    print(df.keys())

    raise ValueError(

        "Featurized data does not support requested feature_types.")

  # perform common train/test split across all tasks

  sorted_ids = df["mol_id"]

  # Set missing data to have weight zero

  missing = (y == "")

  print("missing")

  print(missing)

  missing = (y.astype(object) == "")

  y[missing] = 0.

  w[missing] = 0.

  print("len(sorted_ids)")

  print(len(sorted_ids))

  print("np.shape(x) np.shape(y) np.shape(w)")

  print(np.shape(x))

  print(np.shape(y))

  print(np.shape(w))

  return sorted_ids, x.astype(float), y.astype(float), w.astype(float)