Merge branch 'master' into specified-id-splitter

python:

- '2.7'

- '3.5'

- '3.6'

sudo: required

dist: trusty

install:

RUN export LANG=en_US.UTF-8 && \

    git clone https://github.com/deepchem/deepchem.git && \

    cd deepchem && \

    git checkout 2.0.0 && \

    git checkout 2.1.0 && \

    sed -i -- 's/tensorflow$/tensorflow-gpu/g' scripts/install_deepchem_conda.sh && \

    bash scripts/install_deepchem_conda.sh && \

    python setup.py develop

### Easy Install via Conda

```bash

conda install -c deepchem -c rdkit -c conda-forge -c omnia deepchem=2.0.0

conda install -c deepchem -c rdkit -c conda-forge -c omnia deepchem=2.1.0

```

**Note:** `Easy Install` installs the latest stable version of `deepchem` and _does not install from source_. If you need to install from source make sure you follow the steps [here](#using-a-conda-environment).

## Version

2.0.0

2.1.0

        for deg in range(self.min_deg, self.max_deg + 1)

    ]

    self.degree_list = []

    for i, deg in enumerate(range(self.min_deg, self.max_deg + 1)):

      self.degree_list.extend([deg] * deg_size[i])

    # Get the the start indices for items in each block

    self.deg_start = cumulative_sum(deg_size)

    num_mols = len(mols)

    atoms_per_mol = [mol.get_num_atoms() for mol in mols]

    # Get atoms by degree

    atoms_by_deg = [

        mol.get_atoms_with_deg(deg)

        for deg in range(min_deg, max_deg + 1)

        for mol in mols

    ]

    # stack the atoms

    all_atoms = np.vstack(atoms_by_deg)

    # Results should be sorted by (atom_degree, mol_index)

    atoms_by_deg = np.concatenate([x.atom_features for x in mols])

    degree_vector = np.concatenate([x.degree_list for x in mols], axis=0)

    # Mergesort is a "stable" sort, so the array maintains it's secondary sort of mol_index

    all_atoms = atoms_by_deg[degree_vector.argsort(kind='mergesort')]

    # Sort all atoms by degree.

    # Get the size of each atom list separated by molecule id, then by degree

    # Determines the membership (atom i belongs to membership[i] molecule)

    membership = [

        k

        for deg in range(min_deg, max_deg + 1) for k in range(num_mols)

        k for deg in range(min_deg, max_deg + 1) for k in range(num_mols)

        for i in range(mol_deg_sz[deg][k])

    ]

  """

  def __init__(self, nodes, deg_adj_lists, deg_slice, membership, num_mols):

    self.nodes = nodes

    self.deg_adj_lists = deg_adj_lists

    self.deg_slice = deg_slice

  """

  def __init__(self, nodes, pairs):

    self.nodes = nodes

    self.pairs = pairs

    self.num_atoms = self.nodes.shape[0]

from unittest import TestCase

import numpy as np

from deepchem.feat import ConvMolFeaturizer

from deepchem.feat.mol_graphs import ConvMol

from deepchem.molnet import load_bace_classification

class TestConvMol(TestCase):

  def get_molecules(self):

    tasks, all_dataset, transformers = load_bace_classification(

        featurizer="Raw")

    return all_dataset[0].X

  def test_mol_ordering(self):

    mols = self.get_molecules()

    featurizer = ConvMolFeaturizer()

    featurized_mols = featurizer.featurize(mols)

    for i in range(len(featurized_mols)):

      atom_features = featurized_mols[i].atom_features

      degree_list = np.expand_dims(featurized_mols[i].degree_list, axis=1)

      atom_features = np.concatenate([degree_list, atom_features], axis=1)

      featurized_mols[i].atom_features = atom_features

    conv_mol = ConvMol.agglomerate_mols(featurized_mols)

    for start, end in conv_mol.deg_slice.tolist():

      members = conv_mol.membership[start:end]

      sorted_members = np.array(sorted(members))

      members = np.array(members)

      self.assertTrue(np.all(sorted_members == members))

    conv_mol_atom_features = conv_mol.get_atom_features()

    adj_number = 0

    for start, end in conv_mol.deg_slice.tolist():

      deg_features = conv_mol_atom_features[start:end]

      adj_number_array = deg_features[:, 0]

      self.assertTrue(np.all(adj_number_array == adj_number))

      adj_number += 1