adding torch env

import unittest

import os

import numpy as np

import pytest

import deepchem as dc

try:

  assert i == 19

@pytest.mark.torch

def _validate_pytorch_dataset(dataset):

  X = dataset.X

  y = dataset.y

      batch_sizes.append(len(X))

    self.assertEqual([3, 3, 3, 1, 3, 3, 3, 1], batch_sizes)

  @unittest.skipIf(PYTORCH_IMPORT_FAILED, 'PyTorch is not installed')

  @pytest.mark.torch

  def test_make_pytorch_dataset_from_numpy(self):

    """Test creating a PyTorch Dataset from a NumpyDataset."""

    X = np.random.random((100, 5))

    dataset = dc.data.NumpyDataset(X, y, ids=ids)

    _validate_pytorch_dataset(dataset)

  @unittest.skipIf(PYTORCH_IMPORT_FAILED, 'PyTorch is not installed')

  @pytest.mark.torch

  def test_make_pytorch_dataset_from_images(self):

    """Test creating a PyTorch Dataset from an ImageDataset."""

    path = os.path.join(os.path.dirname(__file__), 'images')

    dataset = dc.data.ImageDataset(files, y, ids=ids)

    _validate_pytorch_dataset(dataset)

  @unittest.skipIf(PYTORCH_IMPORT_FAILED, 'PyTorch is not installed')

  @pytest.mark.torch

  def test_make_pytorch_dataset_from_disk(self):

    """Test creating a PyTorch Dataset from a DiskDataset."""

    dataset = load_solubility_data()

import unittest

import pytest

import numpy as np

from deepchem.feat.graph_data import GraphData, BatchGraphData

class TestGraph(unittest.TestCase):

  @pytest.mark.torch

  def test_graph_data(self):

    num_nodes, num_node_features = 5, 32

    num_edges, num_edge_features = 6, 32

    from dgl import DGLGraph

    assert isinstance(dgl_graph, DGLGraph)

  @pytest.mark.torch

  def test_invalid_graph_data(self):

    with self.assertRaises(ValueError):

      invalid_node_features_type = list(np.random.random_sample((5, 32)))

      node_features = np.random.random_sample((5, 32))

      _ = GraphData(node_features=node_features)

  @pytest.mark.torch

  def test_batch_graph_data(self):

    num_nodes_list, num_edge_list = [3, 4, 5], [2, 4, 5]

    num_node_features, num_edge_features = 32, 32

import deepchem.models.optimizers as optimizers

import unittest

import pytest

try:

  import tensorflow as tf

    tfopt = opt._create_tf_optimizer(global_step)

    assert isinstance(tfopt, tf.keras.optimizers.Adam)

  @unittest.skipIf(not has_pytorch, 'PyTorch is not installed')

  @pytest.mark.torch

  def test_adam_pytorch(self):

    """Test creating an Adam optimizer."""

    opt = optimizers.Adam(learning_rate=0.01)

    tfopt = opt._create_tf_optimizer(global_step)

    assert isinstance(tfopt, tfa.optimizers.AdamW)

  @unittest.skipIf(not has_pytorch, 'PyTorch is not installed')

  @pytest.mark.torch

  def test_adamw_pytorch(self):

    """Test creating an AdamW optimizer."""

    opt = optimizers.AdamW(learning_rate=0.01)

    tfopt = opt._create_tf_optimizer(global_step)

    assert isinstance(tfopt, tfa.optimizers.LazyAdam)

  @unittest.skipIf(not has_pytorch, 'PyTorch is not installed')

  @pytest.mark.torch

  def test_sparseadam_pytorch(self):

    """Test creating a SparseAdam optimizer."""

    opt = optimizers.SparseAdam(learning_rate=0.01)

    tfopt = opt._create_tf_optimizer(global_step)

    assert isinstance(tfopt, tf.keras.optimizers.Adagrad)

  @unittest.skipIf(not has_pytorch, 'PyTorch is not installed')

  @pytest.mark.torch

  def test_adagrad_pytorch(self):

    """Test creating an AdaGrad optimizer."""

    opt = optimizers.AdaGrad(learning_rate=0.01)

    tfopt = opt._create_tf_optimizer(global_step)

    assert isinstance(tfopt, tf.keras.optimizers.RMSprop)

  @unittest.skipIf(not has_pytorch, 'PyTorch is not installed')

  @pytest.mark.torch

  def test_rmsprop_pytorch(self):

    """Test creating an RMSProp Optimizer."""

    opt = optimizers.RMSProp(learning_rate=0.01)

    tfopt = opt._create_tf_optimizer(global_step)

    assert isinstance(tfopt, tf.keras.optimizers.SGD)

  @unittest.skipIf(not has_pytorch, 'PyTorch is not installed')

  @pytest.mark.torch

  def test_gradient_descent_pytorch(self):

    """Test creating a Gradient Descent optimizer."""

    opt = optimizers.GradientDescent(learning_rate=0.01)

    global_step = tf.Variable(0)

    tfopt = opt._create_tf_optimizer(global_step)

  @unittest.skipIf(not has_pytorch, 'PyTorch is not installed')

  @pytest.mark.torch

  def test_exponential_decay_pytorch(self):

    """Test creating an optimizer with an exponentially decaying learning rate."""

    rate = optimizers.ExponentialDecay(

    global_step = tf.Variable(0)

    tfopt = opt._create_tf_optimizer(global_step)

  @unittest.skipIf(not has_pytorch, 'PyTorch is not installed')

  @pytest.mark.torch

  def test_polynomial_decay_pytorch(self):

    """Test creating an optimizer with a polynomially decaying learning rate."""

    rate = optimizers.PolynomialDecay(

    global_step = tf.Variable(0)

    tfopt = opt._create_tf_optimizer(global_step)

  @unittest.skipIf(not has_pytorch, 'PyTorch is not installed')

  @pytest.mark.torch

  def test_linearCosine_decay_pytorch(self):

    """test creating an optimizer with a linear cosine decay to the learning rate"""

    rate = optimizers.LinearCosineDecay(initial_rate=0.1, decay_steps=10000)

  assert scores[regression_metric.name] < .1

@pytest.mark.torch

def test_classification_overfit():

  """Test that MultitaskClassifier can overfit simple classification datasets."""

  n_samples = 10

  assert scores[classification_metric.name] > .9

@pytest.mark.torch

def test_residual_classification_overfit():

  """Test that a residual network can overfit simple classification datasets."""

  n_samples = 10

  assert scores[regression_metric.name] < .1

@pytest.mark.torch

def test_skewed_classification_overfit():

  """Test MultitaskClassifier can overfit 0/1 datasets with few actives."""

  # n_samples = 100

  assert scores[classification_metric.name] > .75

@pytest.mark.torch

def test_skewed_missing_classification_overfit():

  """MultitaskClassifier, skewed data, few actives