# deepchem.models.tensorgraph.tests package¶

## deepchem.models.tensorgraph.tests.test_gan module¶

class deepchem.models.tensorgraph.tests.test_gan.ExampleGAN(n_generators=1, n_discriminators=1, **kwargs)[source]
add_output(layer)
build()
create_discriminator(data_inputs, conditional_inputs)[source]
create_discriminator_loss(discrim_output_train, discrim_output_gen)

Create the loss function for the discriminator.

The default implementation is appropriate for most cases. Subclasses can override this if the need to customize it.

Parameters: discrim_output_train (Layer) – the output from the discriminator on a batch of generated data. This is its estimate of the probability that each sample is training data. discrim_output_gen (Layer) – the output from the discriminator on a batch of training data. This is its estimate of the probability that each sample is training data. A Layer object that outputs the loss function to use for optimizing the discriminator.
create_generator(noise_input, conditional_inputs)[source]
create_generator_loss(discrim_output)

Create the loss function for the generator.

The default implementation is appropriate for most cases. Subclasses can override this if the need to customize it.

Parameters: discrim_output (Layer) – the output from the discriminator on a batch of generated data. This is its estimate of the probability that each sample is training data. A Layer object that outputs the loss function to use for optimizing the generator.
create_submodel(layers=None, loss=None, optimizer=None)

Create an alternate objective for training one piece of a TensorGraph.

A TensorGraph consists of a set of layers, and specifies a loss function and optimizer to use for training those layers. Usually this is sufficient, but there are cases where you want to train different parts of a model separately. For example, a GAN consists of a generator and a discriminator. They are trained separately, and they use different loss functions.

A submodel defines an alternate objective to use in cases like this. It may optionally specify any of the following: a subset of layers in the model to train; a different loss function; and a different optimizer to use. This method creates a submodel, which you can then pass to fit() to use it for training.

Parameters: layers (list) – the list of layers to train. If None, all layers in the model will be trained. loss (Layer) – the loss function to optimize. If None, the model’s main loss function will be used. optimizer (Optimizer) – the optimizer to use for training. If None, the model’s main optimizer will be used. the newly created submodel, which can be passed to any of the fitting methods.
default_generator(dataset, epochs=1, predict=False, deterministic=True, pad_batches=True)
evaluate(dataset, metrics, transformers=[], per_task_metrics=False)

Evaluates the performance of this model on specified dataset.

Parameters: dataset (dc.data.Dataset) – Dataset object. metric (deepchem.metrics.Metric) – Evaluation metric transformers (list) – List of deepchem.transformers.Transformer per_task_metrics (bool) – If True, return per-task scores. Maps tasks to scores under metric. dict
evaluate_generator(feed_dict_generator, metrics, transformers=[], labels=None, outputs=None, weights=[], per_task_metrics=False)
fit(dataset, nb_epoch=10, max_checkpoints_to_keep=5, checkpoint_interval=1000, deterministic=False, restore=False, submodel=None, **kwargs)

Train this model on a dataset.

Parameters: dataset (Dataset) – the Dataset to train on nb_epoch (int) – the number of epochs to train for max_checkpoints_to_keep (int) – the maximum number of checkpoints to keep. Older checkpoints are discarded. checkpoint_interval (int) – the frequency at which to write checkpoints, measured in training steps. Set this to 0 to disable automatic checkpointing. deterministic (bool) – if True, the samples are processed in order. If False, a different random order is used for each epoch. restore (bool) – if True, restore the model from the most recent checkpoint and continue training from there. If False, retrain the model from scratch. submodel (Submodel) – an alternate training objective to use. This should have been created by calling create_submodel().
fit_gan(batches, generator_steps=1.0, max_checkpoints_to_keep=5, checkpoint_interval=1000, restore=False)

Train this model on data.

Parameters: batches (iterable) – batches of data to train the discriminator on, each represented as a dict that maps Layers to values. It should specify values for all members of data_inputs and conditional_inputs. generator_steps (float) – the number of training steps to perform for the generator for each batch. This can be used to adjust the ratio of training steps for the generator and discriminator. For example, 2.0 will perform two training steps for every batch, while 0.5 will only perform one training step for every two batches. max_checkpoints_to_keep (int) – the maximum number of checkpoints to keep. Older checkpoints are discarded. checkpoint_interval (int) – the frequency at which to write checkpoints, measured in batches. Set this to 0 to disable automatic checkpointing. restore (bool) – if True, restore the model from the most recent checkpoint before training it.
fit_generator(feed_dict_generator, max_checkpoints_to_keep=5, checkpoint_interval=1000, restore=False, submodel=None)

Train this model on data from a generator.

Parameters: feed_dict_generator (generator) – this should generate batches, each represented as a dict that maps Layers to values. max_checkpoints_to_keep (int) – the maximum number of checkpoints to keep. Older checkpoints are discarded. checkpoint_interval (int) – the frequency at which to write checkpoints, measured in training steps. Set this to 0 to disable automatic checkpointing. restore (bool) – if True, restore the model from the most recent checkpoint and continue training from there. If False, retrain the model from scratch. submodel (Submodel) – an alternate training objective to use. This should have been created by calling create_submodel(). the average loss over the most recent checkpoint interval
fit_on_batch(X, y, w, submodel=None)
get_checkpoints()

Get a list of all available checkpoint files.

get_conditional_input_shapes()[source]
get_data_input_shapes()[source]
get_global_step()
get_layer_variables(layer)

Get the list of trainable variables in a layer of the graph.

get_model_filename(model_dir)

Given model directory, obtain filename for the model itself.

get_noise_batch(batch_size)

Get a batch of random noise to pass to the generator.

This should return a NumPy array whose shape matches the one returned by get_noise_input_shape(). The default implementation returns normally distributed values. Subclasses can override this to implement a different distribution.

get_noise_input_shape()[source]
get_num_tasks()
get_params(deep=True)

Get parameters for this estimator.

Parameters: deep (boolean, optional) – If True, will return the parameters for this estimator and contained subobjects that are estimators. params – Parameter names mapped to their values. mapping of string to any
get_params_filename(model_dir)

Given model directory, obtain filename for the model itself.

get_pickling_errors(obj, seen=None)
get_pre_q_input(input_layer)
get_task_type()

Currently models can only be classifiers or regressors.

load_from_dir(model_dir, restore=True)
predict(dataset, transformers=[], outputs=None)

Uses self to make predictions on provided Dataset object.

Parameters: dataset (dc.data.Dataset) – Dataset to make prediction on transformers (list) – List of dc.trans.Transformers. outputs (object) – If outputs is None, then will assume outputs = self.outputs[0] (single output). If outputs is a Layer/Tensor, then will evaluate and return as a single ndarray. If outputs is a list of Layers/Tensors, will return a list of ndarrays. results numpy ndarray or list of numpy ndarrays
predict_gan_generator(batch_size=1, noise_input=None, conditional_inputs=[], generator_index=0)

Use the GAN to generate a batch of samples.

Parameters: batch_size (int) – the number of samples to generate. If either noise_input or conditional_inputs is specified, this argument is ignored since the batch size is then determined by the size of that argument. noise_input (array) – the value to use for the generator’s noise input. If None (the default), get_noise_batch() is called to generate a random input, so each call will produce a new set of samples. conditional_inputs (list of arrays) – the values to use for all conditional inputs. This must be specified if the GAN has any conditional inputs. generator_index (int) – the index of the generator (between 0 and n_generators-1) to use for generating the samples. An array (if the generator has only one output) or list of arrays (if it has multiple outputs) containing the generated samples.
predict_on_batch(X, transformers=[], outputs=None)

Generates predictions for input samples, processing samples in a batch.

Parameters: X (ndarray) – the input data, as a Numpy array. transformers (List) – List of dc.trans.Transformers A Numpy array of predictions.
predict_on_generator(generator, transformers=[], outputs=None)
Parameters: generator (Generator) – Generator that constructs feed dictionaries for TensorGraph. transformers (list) – List of dc.trans.Transformers. outputs (object) – If outputs is None, then will assume outputs = self.outputs. If outputs is a Layer/Tensor, then will evaluate and return as a single ndarray. If outputs is a list of Layers/Tensors, will return a list of ndarrays. Returns – y_pred: numpy ndarray of shape (n_samples, n_classes*n_tasks)
predict_proba(dataset, transformers=[], outputs=None)
Parameters: dataset (dc.data.Dataset) – Dataset to make prediction on transformers (list) – List of dc.trans.Transformers. outputs (object) – If outputs is None, then will assume outputs = self.outputs[0] (single output). If outputs is a Layer/Tensor, then will evaluate and return as a single ndarray. If outputs is a list of Layers/Tensors, will return a list of ndarrays. y_pred numpy ndarray or list of numpy ndarrays
predict_proba_on_batch(X, transformers=[], outputs=None)

Generates predictions for input samples, processing samples in a batch.

Parameters: X (ndarray) – the input data, as a Numpy array. transformers (List) – List of dc.trans.Transformers A Numpy array of predictions.
predict_proba_on_generator(generator, transformers=[], outputs=None)
Returns: numpy ndarray of shape (n_samples, n_classes*n_tasks) y_pred
reload()

restore(checkpoint=None)

Reload the values of all variables from a checkpoint file.

Parameters: checkpoint (str) – the path to the checkpoint file to load. If this is None, the most recent checkpoint will be chosen automatically. Call get_checkpoints() to get a list of all available checkpoints.
save()
save_checkpoint(max_checkpoints_to_keep=5)

Save a checkpoint to disk.

Usually you do not need to call this method, since fit() saves checkpoints automatically. If you have disabled automatic checkpointing during fitting, this can be called to manually write checkpoints.

Parameters: max_checkpoints_to_keep (int) – the maximum number of checkpoints to keep. Older checkpoints are discarded.
set_loss(layer)
set_optimizer(optimizer)

Set the optimizer to use for fitting.

set_params(**params)

Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects (such as pipelines). The latter have parameters of the form <component>__<parameter> so that it’s possible to update each component of a nested object.

Returns: self
topsort()
class deepchem.models.tensorgraph.tests.test_gan.TestGAN(methodName='runTest')[source]

Bases: unittest.case.TestCase

addCleanup(function, *args, **kwargs)

Add a function, with arguments, to be called when the test is completed. Functions added are called on a LIFO basis and are called after tearDown on test failure or success.

Cleanup items are called even if setUp fails (unlike tearDown).

addTypeEqualityFunc(typeobj, function)

Add a type specific assertEqual style function to compare a type.

This method is for use by TestCase subclasses that need to register their own type equality functions to provide nicer error messages.

Parameters: typeobj – The data type to call this function on when both values are of the same type in assertEqual(). function – The callable taking two arguments and an optional msg= argument that raises self.failureException with a useful error message when the two arguments are not equal.
assertAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is more than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

If the two objects compare equal then they will automatically compare almost equal.

assertAlmostEquals(*args, **kwargs)
assertCountEqual(first, second, msg=None)

An unordered sequence comparison asserting that the same elements, regardless of order. If the same element occurs more than once, it verifies that the elements occur the same number of times.

self.assertEqual(Counter(list(first)),
Counter(list(second)))
Example:
• [0, 1, 1] and [1, 0, 1] compare equal.
• [0, 0, 1] and [0, 1] compare unequal.
assertDictContainsSubset(subset, dictionary, msg=None)

Checks whether dictionary is a superset of subset.

assertDictEqual(d1, d2, msg=None)
assertEqual(first, second, msg=None)

Fail if the two objects are unequal as determined by the ‘==’ operator.

assertEquals(*args, **kwargs)
assertFalse(expr, msg=None)

Check that the expression is false.

assertGreater(a, b, msg=None)

Just like self.assertTrue(a > b), but with a nicer default message.

assertGreaterEqual(a, b, msg=None)

Just like self.assertTrue(a >= b), but with a nicer default message.

assertIn(member, container, msg=None)

Just like self.assertTrue(a in b), but with a nicer default message.

assertIs(expr1, expr2, msg=None)

Just like self.assertTrue(a is b), but with a nicer default message.

assertIsInstance(obj, cls, msg=None)

Same as self.assertTrue(isinstance(obj, cls)), with a nicer default message.

assertIsNone(obj, msg=None)

Same as self.assertTrue(obj is None), with a nicer default message.

assertIsNot(expr1, expr2, msg=None)

Just like self.assertTrue(a is not b), but with a nicer default message.

assertIsNotNone(obj, msg=None)

Included for symmetry with assertIsNone.

assertLess(a, b, msg=None)

Just like self.assertTrue(a < b), but with a nicer default message.

assertLessEqual(a, b, msg=None)

Just like self.assertTrue(a <= b), but with a nicer default message.

assertListEqual(list1, list2, msg=None)

A list-specific equality assertion.

Parameters: list1 – The first list to compare. list2 – The second list to compare. msg – Optional message to use on failure instead of a list of differences.
assertLogs(logger=None, level=None)

Fail unless a log message of level level or higher is emitted on logger_name or its children. If omitted, level defaults to INFO and logger defaults to the root logger.

This method must be used as a context manager, and will yield a recording object with two attributes: output and records. At the end of the context manager, the output attribute will be a list of the matching formatted log messages and the records attribute will be a list of the corresponding LogRecord objects.

Example:

with self.assertLogs('foo', level='INFO') as cm:
logging.getLogger('foo').info('first message')
logging.getLogger('foo.bar').error('second message')
self.assertEqual(cm.output, ['INFO:foo:first message',
'ERROR:foo.bar:second message'])

assertMultiLineEqual(first, second, msg=None)

Assert that two multi-line strings are equal.

assertNotAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is less than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

Objects that are equal automatically fail.

assertNotAlmostEquals(*args, **kwargs)
assertNotEqual(first, second, msg=None)

Fail if the two objects are equal as determined by the ‘!=’ operator.

assertNotEquals(*args, **kwargs)
assertNotIn(member, container, msg=None)

Just like self.assertTrue(a not in b), but with a nicer default message.

assertNotIsInstance(obj, cls, msg=None)

Included for symmetry with assertIsInstance.

assertNotRegex(text, unexpected_regex, msg=None)

Fail the test if the text matches the regular expression.

assertNotRegexpMatches(*args, **kwargs)
assertRaises(expected_exception, *args, **kwargs)

Fail unless an exception of class expected_exception is raised by the callable when invoked with specified positional and keyword arguments. If a different type of exception is raised, it will not be caught, and the test case will be deemed to have suffered an error, exactly as for an unexpected exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertRaises(SomeException):
do_something()


An optional keyword argument ‘msg’ can be provided when assertRaises is used as a context object.

The context manager keeps a reference to the exception as the ‘exception’ attribute. This allows you to inspect the exception after the assertion:

with self.assertRaises(SomeException) as cm:
do_something()
the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

assertRaisesRegex(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters: expected_exception – Exception class expected to be raised. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.
assertRaisesRegexp(*args, **kwargs)
assertRegex(text, expected_regex, msg=None)

Fail the test unless the text matches the regular expression.

assertRegexpMatches(*args, **kwargs)
assertSequenceEqual(seq1, seq2, msg=None, seq_type=None)

An equality assertion for ordered sequences (like lists and tuples).

For the purposes of this function, a valid ordered sequence type is one which can be indexed, has a length, and has an equality operator.

Parameters: seq1 – The first sequence to compare. seq2 – The second sequence to compare. seq_type – The expected datatype of the sequences, or None if no datatype should be enforced. msg – Optional message to use on failure instead of a list of differences.
assertSetEqual(set1, set2, msg=None)

A set-specific equality assertion.

Parameters: set1 – The first set to compare. set2 – The second set to compare. msg – Optional message to use on failure instead of a list of differences.

assertSetEqual uses ducktyping to support different types of sets, and is optimized for sets specifically (parameters must support a difference method).

assertTrue(expr, msg=None)

Check that the expression is true.

assertTupleEqual(tuple1, tuple2, msg=None)

A tuple-specific equality assertion.

Parameters: tuple1 – The first tuple to compare. tuple2 – The second tuple to compare. msg – Optional message to use on failure instead of a list of differences.
assertWarns(expected_warning, *args, **kwargs)

Fail unless a warning of class warnClass is triggered by the callable when invoked with specified positional and keyword arguments. If a different type of warning is triggered, it will not be handled: depending on the other warning filtering rules in effect, it might be silenced, printed out, or raised as an exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertWarns(SomeWarning):
do_something()


An optional keyword argument ‘msg’ can be provided when assertWarns is used as a context object.

The context manager keeps a reference to the first matching warning as the ‘warning’ attribute; similarly, the ‘filename’ and ‘lineno’ attributes give you information about the line of Python code from which the warning was triggered. This allows you to inspect the warning after the assertion:

with self.assertWarns(SomeWarning) as cm:
do_something()
the_warning = cm.warning
self.assertEqual(the_warning.some_attribute, 147)

assertWarnsRegex(expected_warning, expected_regex, *args, **kwargs)

Asserts that the message in a triggered warning matches a regexp. Basic functioning is similar to assertWarns() with the addition that only warnings whose messages also match the regular expression are considered successful matches.

Parameters: expected_warning – Warning class expected to be triggered. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertWarnsRegex is used as a context manager.
assert_(*args, **kwargs)
countTestCases()
debug()

Run the test without collecting errors in a TestResult

defaultTestResult()
doCleanups()

Execute all cleanup functions. Normally called for you after tearDown.

fail(msg=None)

Fail immediately, with the given message.

failIf(*args, **kwargs)
failIfAlmostEqual(*args, **kwargs)
failIfEqual(*args, **kwargs)
failUnless(*args, **kwargs)
failUnlessAlmostEqual(*args, **kwargs)
failUnlessEqual(*args, **kwargs)
failUnlessRaises(*args, **kwargs)
failureException

alias of AssertionError

id()
longMessage = True
maxDiff = 640
run(result=None)
setUp()

Hook method for setting up the test fixture before exercising it.

setUpClass()

Hook method for setting up class fixture before running tests in the class.

shortDescription()

Returns a one-line description of the test, or None if no description has been provided.

The default implementation of this method returns the first line of the specified test method’s docstring.

skipTest(reason)

Skip this test.

subTest(msg=<object object>, **params)

Return a context manager that will return the enclosed block of code in a subtest identified by the optional message and keyword parameters. A failure in the subtest marks the test case as failed but resumes execution at the end of the enclosed block, allowing further test code to be executed.

tearDown()

Hook method for deconstructing the test fixture after testing it.

tearDownClass()

Hook method for deconstructing the class fixture after running all tests in the class.

test_cgan()[source]

Test fitting a conditional GAN.

test_mix_gan()[source]

Test a GAN with multiple generators and discriminators.

test_wgan()[source]

Test fitting a conditional WGAN.

deepchem.models.tensorgraph.tests.test_gan.generate_batch(batch_size)[source]

Draw training data from a Gaussian distribution, where the mean is a conditional input.

deepchem.models.tensorgraph.tests.test_gan.generate_data(gan, batches, batch_size)[source]

## deepchem.models.tensorgraph.tests.test_layers module¶

class deepchem.models.tensorgraph.tests.test_layers.TestLayers(methodName='runTest')[source]

Bases: tensorflow.python.framework.test_util.TensorFlowTestCase

Test that layers function as intended.

addCleanup(function, *args, **kwargs)

Add a function, with arguments, to be called when the test is completed. Functions added are called on a LIFO basis and are called after tearDown on test failure or success.

Cleanup items are called even if setUp fails (unlike tearDown).

addTypeEqualityFunc(typeobj, function)

Add a type specific assertEqual style function to compare a type.

This method is for use by TestCase subclasses that need to register their own type equality functions to provide nicer error messages.

Parameters: typeobj – The data type to call this function on when both values are of the same type in assertEqual(). function – The callable taking two arguments and an optional msg= argument that raises self.failureException with a useful error message when the two arguments are not equal.
assertAllClose(a, b, rtol=1e-06, atol=1e-06)

Asserts that two numpy arrays, or dicts of same, have near values.

This does not support nested dicts.

Parameters: a – The expected numpy ndarray (or anything can be converted to one), or dict of same. Must be a dict iff b is a dict. b – The actual numpy ndarray (or anything can be converted to one), or dict of same. Must be a dict iff a is a dict. rtol – relative tolerance. atol – absolute tolerance. ValueError – if only one of a and b is a dict.
assertAllCloseAccordingToType(a, b, rtol=1e-06, atol=1e-06, float_rtol=1e-06, float_atol=1e-06, half_rtol=0.001, half_atol=0.001, bfloat16_rtol=0.01, bfloat16_atol=0.01)

Like assertAllClose, but also suitable for comparing fp16 arrays.

In particular, the tolerance is reduced to 1e-3 if at least one of the arguments is of type float16.

Parameters: a – the expected numpy ndarray or anything can be converted to one. b – the actual numpy ndarray or anything can be converted to one. rtol – relative tolerance. atol – absolute tolerance. float_rtol – relative tolerance for float32. float_atol – absolute tolerance for float32. half_rtol – relative tolerance for float16. half_atol – absolute tolerance for float16. bfloat16_rtol – relative tolerance for bfloat16. bfloat16_atol – absolute tolerance for bfloat16.
assertAllEqual(a, b)

Asserts that two numpy arrays have the same values.

Parameters: a – the expected numpy ndarray or anything can be converted to one. b – the actual numpy ndarray or anything can be converted to one.
assertAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is more than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

If the two objects compare equal then they will automatically compare almost equal.

assertAlmostEquals(*args, **kwargs)
assertArrayNear(farray1, farray2, err)

Asserts that two float arrays are near each other.

Checks that for all elements of farray1 and farray2 |f1 - f2| < err. Asserts a test failure if not.

Parameters: farray1 – a list of float values. farray2 – a list of float values. err – a float value.
assertCountEqual(first, second, msg=None)

An unordered sequence comparison asserting that the same elements, regardless of order. If the same element occurs more than once, it verifies that the elements occur the same number of times.

self.assertEqual(Counter(list(first)),
Counter(list(second)))
Example:
• [0, 1, 1] and [1, 0, 1] compare equal.
• [0, 0, 1] and [0, 1] compare unequal.
assertDeviceEqual(device1, device2)

Asserts that the two given devices are the same.

Parameters: device1 – A string device name or TensorFlow DeviceSpec object. device2 – A string device name or TensorFlow DeviceSpec object.
assertDictContainsSubset(subset, dictionary, msg=None)

Checks whether dictionary is a superset of subset.

assertDictEqual(d1, d2, msg=None)
assertEqual(first, second, msg=None)

Fail if the two objects are unequal as determined by the ‘==’ operator.

assertEquals(*args, **kwargs)
assertFalse(expr, msg=None)

Check that the expression is false.

assertGreater(a, b, msg=None)

Just like self.assertTrue(a > b), but with a nicer default message.

assertGreaterEqual(a, b, msg=None)

Just like self.assertTrue(a >= b), but with a nicer default message.

assertIn(member, container, msg=None)

Just like self.assertTrue(a in b), but with a nicer default message.

assertIs(expr1, expr2, msg=None)

Just like self.assertTrue(a is b), but with a nicer default message.

assertIsInstance(obj, cls, msg=None)

Same as self.assertTrue(isinstance(obj, cls)), with a nicer default message.

assertIsNone(obj, msg=None)

Same as self.assertTrue(obj is None), with a nicer default message.

assertIsNot(expr1, expr2, msg=None)

Just like self.assertTrue(a is not b), but with a nicer default message.

assertIsNotNone(obj, msg=None)

Included for symmetry with assertIsNone.

assertItemsEqual(first, second, msg=None)

An unordered sequence comparison asserting that the same elements, regardless of order. If the same element occurs more than once, it verifies that the elements occur the same number of times.

self.assertEqual(Counter(list(first)),
Counter(list(second)))
Example:
• [0, 1, 1] and [1, 0, 1] compare equal.
• [0, 0, 1] and [0, 1] compare unequal.
assertLess(a, b, msg=None)

Just like self.assertTrue(a < b), but with a nicer default message.

assertLessEqual(a, b, msg=None)

Just like self.assertTrue(a <= b), but with a nicer default message.

assertListEqual(list1, list2, msg=None)

A list-specific equality assertion.

Parameters: list1 – The first list to compare. list2 – The second list to compare. msg – Optional message to use on failure instead of a list of differences.
assertLogs(logger=None, level=None)

Fail unless a log message of level level or higher is emitted on logger_name or its children. If omitted, level defaults to INFO and logger defaults to the root logger.

This method must be used as a context manager, and will yield a recording object with two attributes: output and records. At the end of the context manager, the output attribute will be a list of the matching formatted log messages and the records attribute will be a list of the corresponding LogRecord objects.

Example:

with self.assertLogs('foo', level='INFO') as cm:
logging.getLogger('foo').info('first message')
logging.getLogger('foo.bar').error('second message')
self.assertEqual(cm.output, ['INFO:foo:first message',
'ERROR:foo.bar:second message'])

assertMultiLineEqual(first, second, msg=None)

Assert that two multi-line strings are equal.

assertNDArrayNear(ndarray1, ndarray2, err)

Asserts that two numpy arrays have near values.

Parameters: ndarray1 – a numpy ndarray. ndarray2 – a numpy ndarray. err – a float. The maximum absolute difference allowed.
assertNear(f1, f2, err, msg=None)

Asserts that two floats are near each other.

Checks that |f1 - f2| < err and asserts a test failure if not.

Parameters: f1 – A float value. f2 – A float value. err – A float value. msg – An optional string message to append to the failure message.
assertNotAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is less than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

Objects that are equal automatically fail.

assertNotAlmostEquals(*args, **kwargs)
assertNotEqual(first, second, msg=None)

Fail if the two objects are equal as determined by the ‘!=’ operator.

assertNotEquals(*args, **kwargs)
assertNotIn(member, container, msg=None)

Just like self.assertTrue(a not in b), but with a nicer default message.

assertNotIsInstance(obj, cls, msg=None)

Included for symmetry with assertIsInstance.

assertNotRegex(text, unexpected_regex, msg=None)

Fail the test if the text matches the regular expression.

assertNotRegexpMatches(*args, **kwargs)
assertProtoEquals(expected_message_maybe_ascii, message)

Asserts that message is same as parsed expected_message_ascii.

Creates another prototype of message, reads the ascii message into it and then compares them using self._AssertProtoEqual().

Parameters: expected_message_maybe_ascii – proto message in original or ascii form. message – the message to validate.
assertProtoEqualsVersion(expected, actual, producer=24, min_consumer=0)
assertRaises(expected_exception, *args, **kwargs)

Fail unless an exception of class expected_exception is raised by the callable when invoked with specified positional and keyword arguments. If a different type of exception is raised, it will not be caught, and the test case will be deemed to have suffered an error, exactly as for an unexpected exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertRaises(SomeException):
do_something()


An optional keyword argument ‘msg’ can be provided when assertRaises is used as a context object.

The context manager keeps a reference to the exception as the ‘exception’ attribute. This allows you to inspect the exception after the assertion:

with self.assertRaises(SomeException) as cm:
do_something()
the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

assertRaisesOpError(expected_err_re_or_predicate)
assertRaisesRegex(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters: expected_exception – Exception class expected to be raised. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.
assertRaisesRegexp(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters: expected_exception – Exception class expected to be raised. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.
assertRaisesWithPredicateMatch(exception_type, expected_err_re_or_predicate)

Returns a context manager to enclose code expected to raise an exception.

If the exception is an OpError, the op stack is also included in the message predicate search.

Parameters: exception_type – The expected type of exception that should be raised. expected_err_re_or_predicate – If this is callable, it should be a function of one argument that inspects the passed-in exception and returns True (success) or False (please fail the test). Otherwise, the error message is expected to match this regular expression partially. A context manager to surround code that is expected to raise an exception.
assertRegex(text, expected_regex, msg=None)

Fail the test unless the text matches the regular expression.

assertRegexpMatches(*args, **kwargs)
assertSequenceEqual(seq1, seq2, msg=None, seq_type=None)

An equality assertion for ordered sequences (like lists and tuples).

For the purposes of this function, a valid ordered sequence type is one which can be indexed, has a length, and has an equality operator.

Parameters: seq1 – The first sequence to compare. seq2 – The second sequence to compare. seq_type – The expected datatype of the sequences, or None if no datatype should be enforced. msg – Optional message to use on failure instead of a list of differences.
assertSetEqual(set1, set2, msg=None)

A set-specific equality assertion.

Parameters: set1 – The first set to compare. set2 – The second set to compare. msg – Optional message to use on failure instead of a list of differences.

assertSetEqual uses ducktyping to support different types of sets, and is optimized for sets specifically (parameters must support a difference method).

assertShapeEqual(np_array, tf_tensor)

Asserts that a Numpy ndarray and a TensorFlow tensor have the same shape.

Parameters: np_array – A Numpy ndarray or Numpy scalar. tf_tensor – A Tensor. TypeError – If the arguments have the wrong type.
assertStartsWith(actual, expected_start, msg=None)

Assert that actual.startswith(expected_start) is True.

Parameters: actual – str expected_start – str msg – Optional message to report on failure.
assertTrue(expr, msg=None)

Check that the expression is true.

assertTupleEqual(tuple1, tuple2, msg=None)

A tuple-specific equality assertion.

Parameters: tuple1 – The first tuple to compare. tuple2 – The second tuple to compare. msg – Optional message to use on failure instead of a list of differences.
assertWarns(expected_warning, *args, **kwargs)

Fail unless a warning of class warnClass is triggered by the callable when invoked with specified positional and keyword arguments. If a different type of warning is triggered, it will not be handled: depending on the other warning filtering rules in effect, it might be silenced, printed out, or raised as an exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertWarns(SomeWarning):
do_something()


An optional keyword argument ‘msg’ can be provided when assertWarns is used as a context object.

The context manager keeps a reference to the first matching warning as the ‘warning’ attribute; similarly, the ‘filename’ and ‘lineno’ attributes give you information about the line of Python code from which the warning was triggered. This allows you to inspect the warning after the assertion:

with self.assertWarns(SomeWarning) as cm:
do_something()
the_warning = cm.warning
self.assertEqual(the_warning.some_attribute, 147)

assertWarnsRegex(expected_warning, expected_regex, *args, **kwargs)

Asserts that the message in a triggered warning matches a regexp. Basic functioning is similar to assertWarns() with the addition that only warnings whose messages also match the regular expression are considered successful matches.

Parameters: expected_warning – Warning class expected to be triggered. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertWarnsRegex is used as a context manager.
assert_(*args, **kwargs)
checkedThread(target, args=None, kwargs=None)

Returns a Thread wrapper that asserts ‘target’ completes successfully.

This method should be used to create all threads in test cases, as otherwise there is a risk that a thread will silently fail, and/or assertions made in the thread will not be respected.

Parameters: target – A callable object to be executed in the thread. args – The argument tuple for the target invocation. Defaults to (). kwargs – A dictionary of keyword arguments for the target invocation. Defaults to {}. A wrapper for threading.Thread that supports start() and join() methods.
countTestCases()
debug()

Run the test without collecting errors in a TestResult

defaultTestResult()
doCleanups()

Execute all cleanup functions. Normally called for you after tearDown.

evaluate(tensors)

Evaluates tensors and returns numpy values.

Parameters: tensors – A Tensor or a nested list/tuple of Tensors. tensors numpy values.
fail(msg=None)

Fail immediately, with the given message.

failIf(*args, **kwargs)
failIfAlmostEqual(*args, **kwargs)
failIfEqual(*args, **kwargs)
failUnless(*args, **kwargs)
failUnlessAlmostEqual(*args, **kwargs)
failUnlessEqual(*args, **kwargs)
failUnlessRaises(*args, **kwargs)
failureException

alias of AssertionError

get_temp_dir()

Returns a unique temporary directory for the test to use.

If you call this method multiple times during in a test, it will return the same folder. However, across different runs the directories will be different. This will ensure that across different runs tests will not be able to pollute each others environment. If you need multiple unique directories within a single test, you should use tempfile.mkdtemp as follows:

tempfile.mkdtemp(dir=self.get_temp_dir()):
Returns: string, the path to the unique temporary directory created for this test.
id()
longMessage = True
maxDiff = 640
run(result=None)
setUp()
setUpClass()

Hook method for setting up class fixture before running tests in the class.

shortDescription()

Returns a one-line description of the test, or None if no description has been provided.

The default implementation of this method returns the first line of the specified test method’s docstring.

skipTest(reason)

Skip this test.

subTest(msg=<object object>, **params)

Return a context manager that will return the enclosed block of code in a subtest identified by the optional message and keyword parameters. A failure in the subtest marks the test case as failed but resumes execution at the end of the enclosed block, allowing further test code to be executed.

tearDown()
tearDownClass()

Hook method for deconstructing the class fixture after running all tests in the class.

test_IRV()[source]

Test that IRVLayer and IRVRegularize can be invoked.

test_add()[source]

Test that Add can be invoked.

test_alpha_share_layer()[source]

Test that alpha share works correctly

test_attn_lstm_embedding()[source]

Test that attention LSTM computation works properly.

test_batch_norm()[source]

Test that BatchNorm can be invoked.

test_beta_share()[source]

Test that beta share works correctly

test_cast()[source]

Test that layers can automatically reshape inconsistent inputs.

test_combine_mean_std()[source]

Test that Transpose can be invoked.

test_concat()[source]

Test that Concat can be invoked.

test_constant()[source]

Test that Constant can be invoked.

test_conv_1D()[source]

Test that Conv1D can be invoked.

test_conv_2D()[source]

Test that Conv2D can be invoked.

test_conv_2D_transpose()[source]

Test that Conv2DTranspose can be invoked.

test_conv_3D()[source]

Test that Conv3D can be invoked.

test_conv_3D_transpose()[source]

Test that Conv3DTranspose can be invoked.

test_convert_to_tensor()[source]

Test implicit conversion of Layers to Tensors.

test_dense()[source]

Test that Dense can be invoked.

test_exp()[source]

Test that Exp can be invoked.

test_flatten()[source]

Test that Flatten can be invoked.

test_gather()[source]

Test that Gather can be invoked.

test_graph_conv()[source]

Test that GraphConv can be invoked.

test_graph_gather()[source]

Test that GraphGather can be invoked.

test_graphcnn()[source]

Test GraphCNN Layer From https://arxiv.org/abs/1703.00792

test_graphcnnpool()[source]

Test GraphCNNPool Layer From https://arxiv.org/abs/1703.00792

test_gru()[source]

Test that GRU can be invoked.

test_input()[source]

Test that Input can be invoked.

test_input_fifo_queue()[source]

Test InputFifoQueue can be invoked.

test_interatomic_distances()[source]

Test that the interatomic distance calculation works.

test_iter_ref_lstm_embedding()[source]

Test that IterRef LSTM computation works properly.

test_l2_loss()[source]

Test that L2Loss can be invoked.

test_log()[source]

Test that Log can be invoked.

test_lstm()[source]

Test that LSTM can be invoked.

test_lstm_step()[source]

Test that LSTMStep computation works properly.

test_max_pool_3D()[source]

Test that MaxPool3D can be invoked.

test_maxpool2D()[source]

Test that MaxPool2D can be invoked.

test_multiply()[source]

Test that Multiply can be invoked.

test_reduce_mean()[source]

Test that ReduceMean can be invoked.

test_reduce_square_difference()[source]

Test that ReduceSquareDifference can be invoked.

test_reduce_sum()[source]

Test that ReduceSum can be invoked.

test_relu()[source]

Test that Sigmoid can be invoked.

test_repeat()[source]

Test that Repeat can be invoked.

test_reshape()[source]

Test that Reshape can be invoked.

test_reshape_inputs()[source]

Test that layers can automatically reshape inconsistent inputs.

test_session(graph=None, config=None, use_gpu=False, force_gpu=False)

Returns a TensorFlow Session for use in executing tests.

This method should be used for all functional tests.

This method behaves different than session.Session: for performance reasons test_session will by default (if graph is None) reuse the same session across tests. This means you may want to either call the function reset_default_graph() before tests, or if creating an explicit new graph, pass it here (simply setting it with as_default() won’t do it), which will trigger the creation of a new session.

Use the use_gpu and force_gpu options to control where ops are run. If force_gpu is True, all ops are pinned to /device:GPU:0. Otherwise, if use_gpu is True, TensorFlow tries to run as many ops on the GPU as possible. If both force_gpu and use_gpu are False, all ops are pinned to the CPU.

Example: python class MyOperatorTest(test_util.TensorFlowTestCase):

def testMyOperator(self):
with self.test_session(use_gpu=True):

valid_input = [1.0, 2.0, 3.0, 4.0, 5.0] result = MyOperator(valid_input).eval() self.assertEqual(result, [1.0, 2.0, 3.0, 5.0, 8.0] invalid_input = [-1.0, 2.0, 7.0] with self.assertRaisesOpError(“negative input not supported”):

MyOperator(invalid_input).eval()
Parameters: graph – Optional graph to use during the returned session. config – An optional config_pb2.ConfigProto to use to configure the session. use_gpu – If True, attempt to run as many ops as possible on GPU. force_gpu – If True, pin all ops to /device:GPU:0. A Session object that should be used as a context manager to surround the graph building and execution code in a test case.
test_sigmoid()[source]

Test that Sigmoid can be invoked.

test_sigmoid_cross_entropy()[source]

Test that SigmoidCrossEntropy can be invoked.

test_slice()[source]

Test that Slice can be invoked.

test_sluice_loss()[source]

Test the sluice loss function

test_softmax()[source]

Test that Softmax can be invoked.

test_softmax_cross_entropy()[source]

Test that SoftMaxCrossEntropy can be invoked.

test_squeeze_inputs()[source]

Test that layers can automatically reshape inconsistent inputs.

test_stop_gradient()[source]

Test that StopGradient can be invoked.

test_time_series_dense()[source]

Test that TimeSeriesDense can be invoked.

test_to_float()[source]

Test that ToFloat can be invoked.

test_transpose()[source]

Test that Transpose can be invoked.

test_variable()[source]

Test that Variable can be invoked.

test_vina_free_energy()[source]

Test that VinaFreeEnergy can be invoked.

test_weighted_error()[source]

Test that WeightedError can be invoked.

test_weighted_linear_combo()[source]

Test that WeightedLinearCombo can be invoked.

## deepchem.models.tensorgraph.tests.test_layers_pickle module¶

deepchem.models.tensorgraph.tests.test_layers_pickle.testGraphCNNPoolLayer_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.testGraphCNN_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.testInteratomicL2Distances()[source]

TODO(LESWING) what is ndim here? :return:

deepchem.models.tensorgraph.tests.test_layers_pickle.test_AtomicDifferentialDense_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_AttnLSTM_pickle()[source]

Tests that AttnLSTM can be pickled.

deepchem.models.tensorgraph.tests.test_layers_pickle.test_BatchNorm_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Cast_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_CombineMeanStd_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Concat_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Constant_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Conv1D_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Conv2DTranspose_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Conv2D_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Conv3DTranspose_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Conv3D_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_DAGGather_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_DAGLayer_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_DTNNEmbedding_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_DTNNExtract_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_DTNNGather_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_DTNNStep_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Dense_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Exp_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Flatten_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_GRU_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Gather_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_GraphConv_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_GraphGather_Pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_GraphPool_Pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_IRVLayer_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_IterRefLSTM_pickle()[source]

Tests that IterRefLSTM can be pickled.

deepchem.models.tensorgraph.tests.test_layers_pickle.test_L2loss_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_LSTMStep_pickle()[source]

Tests that LSTMStep can be pickled.

deepchem.models.tensorgraph.tests.test_layers_pickle.test_LSTM_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Log_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_MP_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_MaxPool2D_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_MaxPool3D_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_ReLU_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_ReduceMean_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_ReduceSquareDifference_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_ReduceSum_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Repeat_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Reshape_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_SetGather_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_SigmoidCrossEntropy_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Sigmoid_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Slice_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_SoftmaxCrossEntropy_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Softmax_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Squeeze_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_StopGradient_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_ToFloat_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Transpose_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Variable_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_WeaveGather_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_Weave_pickle()[source]
deepchem.models.tensorgraph.tests.test_layers_pickle.test_WeightedError_pickle()[source]

## deepchem.models.tensorgraph.tests.test_model_ops module¶

Test ops for graph construction.

class deepchem.models.tensorgraph.tests.test_model_ops.TestModelOps(methodName='runTest')[source]

Bases: tensorflow.python.framework.test_util.TensorFlowTestCase

addCleanup(function, *args, **kwargs)

Add a function, with arguments, to be called when the test is completed. Functions added are called on a LIFO basis and are called after tearDown on test failure or success.

Cleanup items are called even if setUp fails (unlike tearDown).

addTypeEqualityFunc(typeobj, function)

Add a type specific assertEqual style function to compare a type.

This method is for use by TestCase subclasses that need to register their own type equality functions to provide nicer error messages.

Parameters: typeobj – The data type to call this function on when both values are of the same type in assertEqual(). function – The callable taking two arguments and an optional msg= argument that raises self.failureException with a useful error message when the two arguments are not equal.
assertAllClose(a, b, rtol=1e-06, atol=1e-06)

Asserts that two numpy arrays, or dicts of same, have near values.

This does not support nested dicts.

Parameters: a – The expected numpy ndarray (or anything can be converted to one), or dict of same. Must be a dict iff b is a dict. b – The actual numpy ndarray (or anything can be converted to one), or dict of same. Must be a dict iff a is a dict. rtol – relative tolerance. atol – absolute tolerance. ValueError – if only one of a and b is a dict.
assertAllCloseAccordingToType(a, b, rtol=1e-06, atol=1e-06, float_rtol=1e-06, float_atol=1e-06, half_rtol=0.001, half_atol=0.001, bfloat16_rtol=0.01, bfloat16_atol=0.01)

Like assertAllClose, but also suitable for comparing fp16 arrays.

In particular, the tolerance is reduced to 1e-3 if at least one of the arguments is of type float16.

Parameters: a – the expected numpy ndarray or anything can be converted to one. b – the actual numpy ndarray or anything can be converted to one. rtol – relative tolerance. atol – absolute tolerance. float_rtol – relative tolerance for float32. float_atol – absolute tolerance for float32. half_rtol – relative tolerance for float16. half_atol – absolute tolerance for float16. bfloat16_rtol – relative tolerance for bfloat16. bfloat16_atol – absolute tolerance for bfloat16.
assertAllEqual(a, b)

Asserts that two numpy arrays have the same values.

Parameters: a – the expected numpy ndarray or anything can be converted to one. b – the actual numpy ndarray or anything can be converted to one.
assertAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is more than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

If the two objects compare equal then they will automatically compare almost equal.

assertAlmostEquals(*args, **kwargs)
assertArrayNear(farray1, farray2, err)

Asserts that two float arrays are near each other.

Checks that for all elements of farray1 and farray2 |f1 - f2| < err. Asserts a test failure if not.

Parameters: farray1 – a list of float values. farray2 – a list of float values. err – a float value.
assertCountEqual(first, second, msg=None)

An unordered sequence comparison asserting that the same elements, regardless of order. If the same element occurs more than once, it verifies that the elements occur the same number of times.

self.assertEqual(Counter(list(first)),
Counter(list(second)))
Example:
• [0, 1, 1] and [1, 0, 1] compare equal.
• [0, 0, 1] and [0, 1] compare unequal.
assertDeviceEqual(device1, device2)

Asserts that the two given devices are the same.

Parameters: device1 – A string device name or TensorFlow DeviceSpec object. device2 – A string device name or TensorFlow DeviceSpec object.
assertDictContainsSubset(subset, dictionary, msg=None)

Checks whether dictionary is a superset of subset.

assertDictEqual(d1, d2, msg=None)
assertEqual(first, second, msg=None)

Fail if the two objects are unequal as determined by the ‘==’ operator.

assertEquals(*args, **kwargs)
assertFalse(expr, msg=None)

Check that the expression is false.

assertGreater(a, b, msg=None)

Just like self.assertTrue(a > b), but with a nicer default message.

assertGreaterEqual(a, b, msg=None)

Just like self.assertTrue(a >= b), but with a nicer default message.

assertIn(member, container, msg=None)

Just like self.assertTrue(a in b), but with a nicer default message.

assertIs(expr1, expr2, msg=None)

Just like self.assertTrue(a is b), but with a nicer default message.

assertIsInstance(obj, cls, msg=None)

Same as self.assertTrue(isinstance(obj, cls)), with a nicer default message.

assertIsNone(obj, msg=None)

Same as self.assertTrue(obj is None), with a nicer default message.

assertIsNot(expr1, expr2, msg=None)

Just like self.assertTrue(a is not b), but with a nicer default message.

assertIsNotNone(obj, msg=None)

Included for symmetry with assertIsNone.

assertItemsEqual(first, second, msg=None)

An unordered sequence comparison asserting that the same elements, regardless of order. If the same element occurs more than once, it verifies that the elements occur the same number of times.

self.assertEqual(Counter(list(first)),
Counter(list(second)))
Example:
• [0, 1, 1] and [1, 0, 1] compare equal.
• [0, 0, 1] and [0, 1] compare unequal.
assertLess(a, b, msg=None)

Just like self.assertTrue(a < b), but with a nicer default message.

assertLessEqual(a, b, msg=None)

Just like self.assertTrue(a <= b), but with a nicer default message.

assertListEqual(list1, list2, msg=None)

A list-specific equality assertion.

Parameters: list1 – The first list to compare. list2 – The second list to compare. msg – Optional message to use on failure instead of a list of differences.
assertLogs(logger=None, level=None)

Fail unless a log message of level level or higher is emitted on logger_name or its children. If omitted, level defaults to INFO and logger defaults to the root logger.

This method must be used as a context manager, and will yield a recording object with two attributes: output and records. At the end of the context manager, the output attribute will be a list of the matching formatted log messages and the records attribute will be a list of the corresponding LogRecord objects.

Example:

with self.assertLogs('foo', level='INFO') as cm:
logging.getLogger('foo').info('first message')
logging.getLogger('foo.bar').error('second message')
self.assertEqual(cm.output, ['INFO:foo:first message',
'ERROR:foo.bar:second message'])

assertMultiLineEqual(first, second, msg=None)

Assert that two multi-line strings are equal.

assertNDArrayNear(ndarray1, ndarray2, err)

Asserts that two numpy arrays have near values.

Parameters: ndarray1 – a numpy ndarray. ndarray2 – a numpy ndarray. err – a float. The maximum absolute difference allowed.
assertNear(f1, f2, err, msg=None)

Asserts that two floats are near each other.

Checks that |f1 - f2| < err and asserts a test failure if not.

Parameters: f1 – A float value. f2 – A float value. err – A float value. msg – An optional string message to append to the failure message.
assertNotAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is less than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

Objects that are equal automatically fail.

assertNotAlmostEquals(*args, **kwargs)
assertNotEqual(first, second, msg=None)

Fail if the two objects are equal as determined by the ‘!=’ operator.

assertNotEquals(*args, **kwargs)
assertNotIn(member, container, msg=None)

Just like self.assertTrue(a not in b), but with a nicer default message.

assertNotIsInstance(obj, cls, msg=None)

Included for symmetry with assertIsInstance.

assertNotRegex(text, unexpected_regex, msg=None)

Fail the test if the text matches the regular expression.

assertNotRegexpMatches(*args, **kwargs)
assertProtoEquals(expected_message_maybe_ascii, message)

Asserts that message is same as parsed expected_message_ascii.

Creates another prototype of message, reads the ascii message into it and then compares them using self._AssertProtoEqual().

Parameters: expected_message_maybe_ascii – proto message in original or ascii form. message – the message to validate.
assertProtoEqualsVersion(expected, actual, producer=24, min_consumer=0)
assertRaises(expected_exception, *args, **kwargs)

Fail unless an exception of class expected_exception is raised by the callable when invoked with specified positional and keyword arguments. If a different type of exception is raised, it will not be caught, and the test case will be deemed to have suffered an error, exactly as for an unexpected exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertRaises(SomeException):
do_something()


An optional keyword argument ‘msg’ can be provided when assertRaises is used as a context object.

The context manager keeps a reference to the exception as the ‘exception’ attribute. This allows you to inspect the exception after the assertion:

with self.assertRaises(SomeException) as cm:
do_something()
the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

assertRaisesOpError(expected_err_re_or_predicate)
assertRaisesRegex(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters: expected_exception – Exception class expected to be raised. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.
assertRaisesRegexp(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters: expected_exception – Exception class expected to be raised. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.
assertRaisesWithPredicateMatch(exception_type, expected_err_re_or_predicate)

Returns a context manager to enclose code expected to raise an exception.

If the exception is an OpError, the op stack is also included in the message predicate search.

Parameters: exception_type – The expected type of exception that should be raised. expected_err_re_or_predicate – If this is callable, it should be a function of one argument that inspects the passed-in exception and returns True (success) or False (please fail the test). Otherwise, the error message is expected to match this regular expression partially. A context manager to surround code that is expected to raise an exception.
assertRegex(text, expected_regex, msg=None)

Fail the test unless the text matches the regular expression.

assertRegexpMatches(*args, **kwargs)
assertSequenceEqual(seq1, seq2, msg=None, seq_type=None)

An equality assertion for ordered sequences (like lists and tuples).

For the purposes of this function, a valid ordered sequence type is one which can be indexed, has a length, and has an equality operator.

Parameters: seq1 – The first sequence to compare. seq2 – The second sequence to compare. seq_type – The expected datatype of the sequences, or None if no datatype should be enforced. msg – Optional message to use on failure instead of a list of differences.
assertSetEqual(set1, set2, msg=None)

A set-specific equality assertion.

Parameters: set1 – The first set to compare. set2 – The second set to compare. msg – Optional message to use on failure instead of a list of differences.

assertSetEqual uses ducktyping to support different types of sets, and is optimized for sets specifically (parameters must support a difference method).

assertShapeEqual(np_array, tf_tensor)

Asserts that a Numpy ndarray and a TensorFlow tensor have the same shape.

Parameters: np_array – A Numpy ndarray or Numpy scalar. tf_tensor – A Tensor. TypeError – If the arguments have the wrong type.
assertStartsWith(actual, expected_start, msg=None)

Assert that actual.startswith(expected_start) is True.

Parameters: actual – str expected_start – str msg – Optional message to report on failure.
assertTrue(expr, msg=None)

Check that the expression is true.

assertTupleEqual(tuple1, tuple2, msg=None)

A tuple-specific equality assertion.

Parameters: tuple1 – The first tuple to compare. tuple2 – The second tuple to compare. msg – Optional message to use on failure instead of a list of differences.
assertWarns(expected_warning, *args, **kwargs)

Fail unless a warning of class warnClass is triggered by the callable when invoked with specified positional and keyword arguments. If a different type of warning is triggered, it will not be handled: depending on the other warning filtering rules in effect, it might be silenced, printed out, or raised as an exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertWarns(SomeWarning):
do_something()


An optional keyword argument ‘msg’ can be provided when assertWarns is used as a context object.

The context manager keeps a reference to the first matching warning as the ‘warning’ attribute; similarly, the ‘filename’ and ‘lineno’ attributes give you information about the line of Python code from which the warning was triggered. This allows you to inspect the warning after the assertion:

with self.assertWarns(SomeWarning) as cm:
do_something()
the_warning = cm.warning
self.assertEqual(the_warning.some_attribute, 147)

assertWarnsRegex(expected_warning, expected_regex, *args, **kwargs)

Asserts that the message in a triggered warning matches a regexp. Basic functioning is similar to assertWarns() with the addition that only warnings whose messages also match the regular expression are considered successful matches.

Parameters: expected_warning – Warning class expected to be triggered. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertWarnsRegex is used as a context manager.
assert_(*args, **kwargs)
checkedThread(target, args=None, kwargs=None)

Returns a Thread wrapper that asserts ‘target’ completes successfully.

This method should be used to create all threads in test cases, as otherwise there is a risk that a thread will silently fail, and/or assertions made in the thread will not be respected.

Parameters: target – A callable object to be executed in the thread. args – The argument tuple for the target invocation. Defaults to (). kwargs – A dictionary of keyword arguments for the target invocation. Defaults to {}. A wrapper for threading.Thread that supports start() and join() methods.
countTestCases()
debug()

Run the test without collecting errors in a TestResult

defaultTestResult()
doCleanups()

Execute all cleanup functions. Normally called for you after tearDown.

evaluate(tensors)

Evaluates tensors and returns numpy values.

Parameters: tensors – A Tensor or a nested list/tuple of Tensors. tensors numpy values.
fail(msg=None)

Fail immediately, with the given message.

failIf(*args, **kwargs)
failIfAlmostEqual(*args, **kwargs)
failIfEqual(*args, **kwargs)
failUnless(*args, **kwargs)
failUnlessAlmostEqual(*args, **kwargs)
failUnlessEqual(*args, **kwargs)
failUnlessRaises(*args, **kwargs)
failureException

alias of AssertionError

get_temp_dir()

Returns a unique temporary directory for the test to use.

If you call this method multiple times during in a test, it will return the same folder. However, across different runs the directories will be different. This will ensure that across different runs tests will not be able to pollute each others environment. If you need multiple unique directories within a single test, you should use tempfile.mkdtemp as follows:

tempfile.mkdtemp(dir=self.get_temp_dir()):
Returns: string, the path to the unique temporary directory created for this test.
id()
longMessage = True
maxDiff = 640
run(result=None)
setUp()[source]
setUpClass()

Hook method for setting up class fixture before running tests in the class.

shortDescription()

Returns a one-line description of the test, or None if no description has been provided.

The default implementation of this method returns the first line of the specified test method’s docstring.

skipTest(reason)

Skip this test.

subTest(msg=<object object>, **params)

Return a context manager that will return the enclosed block of code in a subtest identified by the optional message and keyword parameters. A failure in the subtest marks the test case as failed but resumes execution at the end of the enclosed block, allowing further test code to be executed.

tearDown()
tearDownClass()

Hook method for deconstructing the class fixture after running all tests in the class.

test_add_bias()[source]
test_fully_connected_layer()[source]
test_multitask_logits()[source]
test_session(graph=None, config=None, use_gpu=False, force_gpu=False)

Returns a TensorFlow Session for use in executing tests.

This method should be used for all functional tests.

This method behaves different than session.Session: for performance reasons test_session will by default (if graph is None) reuse the same session across tests. This means you may want to either call the function reset_default_graph() before tests, or if creating an explicit new graph, pass it here (simply setting it with as_default() won’t do it), which will trigger the creation of a new session.

Use the use_gpu and force_gpu options to control where ops are run. If force_gpu is True, all ops are pinned to /device:GPU:0. Otherwise, if use_gpu is True, TensorFlow tries to run as many ops on the GPU as possible. If both force_gpu and use_gpu are False, all ops are pinned to the CPU.

Example: python class MyOperatorTest(test_util.TensorFlowTestCase):

def testMyOperator(self):
with self.test_session(use_gpu=True):

valid_input = [1.0, 2.0, 3.0, 4.0, 5.0] result = MyOperator(valid_input).eval() self.assertEqual(result, [1.0, 2.0, 3.0, 5.0, 8.0] invalid_input = [-1.0, 2.0, 7.0] with self.assertRaisesOpError(“negative input not supported”):

MyOperator(invalid_input).eval()
Parameters: graph – Optional graph to use during the returned session. config – An optional config_pb2.ConfigProto to use to configure the session. use_gpu – If True, attempt to run as many ops as possible on GPU. force_gpu – If True, pin all ops to /device:GPU:0. A Session object that should be used as a context manager to surround the graph building and execution code in a test case.
test_softmax_N()[source]
test_softmax_N_with_numpy()[source]

## deepchem.models.tensorgraph.tests.test_nbr_list module¶

class deepchem.models.tensorgraph.tests.test_nbr_list.TestNbrList(methodName='runTest')[source]

Bases: tensorflow.python.framework.test_util.TensorFlowTestCase

Test that tensorgraph neighbor-list works.

addCleanup(function, *args, **kwargs)

Add a function, with arguments, to be called when the test is completed. Functions added are called on a LIFO basis and are called after tearDown on test failure or success.

Cleanup items are called even if setUp fails (unlike tearDown).

addTypeEqualityFunc(typeobj, function)

Add a type specific assertEqual style function to compare a type.

This method is for use by TestCase subclasses that need to register their own type equality functions to provide nicer error messages.

Parameters: typeobj – The data type to call this function on when both values are of the same type in assertEqual(). function – The callable taking two arguments and an optional msg= argument that raises self.failureException with a useful error message when the two arguments are not equal.
assertAllClose(a, b, rtol=1e-06, atol=1e-06)

Asserts that two numpy arrays, or dicts of same, have near values.

This does not support nested dicts.

Parameters: a – The expected numpy ndarray (or anything can be converted to one), or dict of same. Must be a dict iff b is a dict. b – The actual numpy ndarray (or anything can be converted to one), or dict of same. Must be a dict iff a is a dict. rtol – relative tolerance. atol – absolute tolerance. ValueError – if only one of a and b is a dict.
assertAllCloseAccordingToType(a, b, rtol=1e-06, atol=1e-06, float_rtol=1e-06, float_atol=1e-06, half_rtol=0.001, half_atol=0.001, bfloat16_rtol=0.01, bfloat16_atol=0.01)

Like assertAllClose, but also suitable for comparing fp16 arrays.

In particular, the tolerance is reduced to 1e-3 if at least one of the arguments is of type float16.

Parameters: a – the expected numpy ndarray or anything can be converted to one. b – the actual numpy ndarray or anything can be converted to one. rtol – relative tolerance. atol – absolute tolerance. float_rtol – relative tolerance for float32. float_atol – absolute tolerance for float32. half_rtol – relative tolerance for float16. half_atol – absolute tolerance for float16. bfloat16_rtol – relative tolerance for bfloat16. bfloat16_atol – absolute tolerance for bfloat16.
assertAllEqual(a, b)

Asserts that two numpy arrays have the same values.

Parameters: a – the expected numpy ndarray or anything can be converted to one. b – the actual numpy ndarray or anything can be converted to one.
assertAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is more than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

If the two objects compare equal then they will automatically compare almost equal.

assertAlmostEquals(*args, **kwargs)
assertArrayNear(farray1, farray2, err)

Asserts that two float arrays are near each other.

Checks that for all elements of farray1 and farray2 |f1 - f2| < err. Asserts a test failure if not.

Parameters: farray1 – a list of float values. farray2 – a list of float values. err – a float value.
assertCountEqual(first, second, msg=None)

An unordered sequence comparison asserting that the same elements, regardless of order. If the same element occurs more than once, it verifies that the elements occur the same number of times.

self.assertEqual(Counter(list(first)),
Counter(list(second)))
Example:
• [0, 1, 1] and [1, 0, 1] compare equal.
• [0, 0, 1] and [0, 1] compare unequal.
assertDeviceEqual(device1, device2)

Asserts that the two given devices are the same.

Parameters: device1 – A string device name or TensorFlow DeviceSpec object. device2 – A string device name or TensorFlow DeviceSpec object.
assertDictContainsSubset(subset, dictionary, msg=None)

Checks whether dictionary is a superset of subset.

assertDictEqual(d1, d2, msg=None)
assertEqual(first, second, msg=None)

Fail if the two objects are unequal as determined by the ‘==’ operator.

assertEquals(*args, **kwargs)
assertFalse(expr, msg=None)

Check that the expression is false.

assertGreater(a, b, msg=None)

Just like self.assertTrue(a > b), but with a nicer default message.

assertGreaterEqual(a, b, msg=None)

Just like self.assertTrue(a >= b), but with a nicer default message.

assertIn(member, container, msg=None)

Just like self.assertTrue(a in b), but with a nicer default message.

assertIs(expr1, expr2, msg=None)

Just like self.assertTrue(a is b), but with a nicer default message.

assertIsInstance(obj, cls, msg=None)

Same as self.assertTrue(isinstance(obj, cls)), with a nicer default message.

assertIsNone(obj, msg=None)

Same as self.assertTrue(obj is None), with a nicer default message.

assertIsNot(expr1, expr2, msg=None)

Just like self.assertTrue(a is not b), but with a nicer default message.

assertIsNotNone(obj, msg=None)

Included for symmetry with assertIsNone.

assertItemsEqual(first, second, msg=None)

An unordered sequence comparison asserting that the same elements, regardless of order. If the same element occurs more than once, it verifies that the elements occur the same number of times.

self.assertEqual(Counter(list(first)),
Counter(list(second)))
Example:
• [0, 1, 1] and [1, 0, 1] compare equal.
• [0, 0, 1] and [0, 1] compare unequal.
assertLess(a, b, msg=None)

Just like self.assertTrue(a < b), but with a nicer default message.

assertLessEqual(a, b, msg=None)

Just like self.assertTrue(a <= b), but with a nicer default message.

assertListEqual(list1, list2, msg=None)

A list-specific equality assertion.

Parameters: list1 – The first list to compare. list2 – The second list to compare. msg – Optional message to use on failure instead of a list of differences.
assertLogs(logger=None, level=None)

Fail unless a log message of level level or higher is emitted on logger_name or its children. If omitted, level defaults to INFO and logger defaults to the root logger.

This method must be used as a context manager, and will yield a recording object with two attributes: output and records. At the end of the context manager, the output attribute will be a list of the matching formatted log messages and the records attribute will be a list of the corresponding LogRecord objects.

Example:

with self.assertLogs('foo', level='INFO') as cm:
logging.getLogger('foo').info('first message')
logging.getLogger('foo.bar').error('second message')
self.assertEqual(cm.output, ['INFO:foo:first message',
'ERROR:foo.bar:second message'])

assertMultiLineEqual(first, second, msg=None)

Assert that two multi-line strings are equal.

assertNDArrayNear(ndarray1, ndarray2, err)

Asserts that two numpy arrays have near values.

Parameters: ndarray1 – a numpy ndarray. ndarray2 – a numpy ndarray. err – a float. The maximum absolute difference allowed.
assertNear(f1, f2, err, msg=None)

Asserts that two floats are near each other.

Checks that |f1 - f2| < err and asserts a test failure if not.

Parameters: f1 – A float value. f2 – A float value. err – A float value. msg – An optional string message to append to the failure message.
assertNotAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is less than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

Objects that are equal automatically fail.

assertNotAlmostEquals(*args, **kwargs)
assertNotEqual(first, second, msg=None)

Fail if the two objects are equal as determined by the ‘!=’ operator.

assertNotEquals(*args, **kwargs)
assertNotIn(member, container, msg=None)

Just like self.assertTrue(a not in b), but with a nicer default message.

assertNotIsInstance(obj, cls, msg=None)

Included for symmetry with assertIsInstance.

assertNotRegex(text, unexpected_regex, msg=None)

Fail the test if the text matches the regular expression.

assertNotRegexpMatches(*args, **kwargs)
assertProtoEquals(expected_message_maybe_ascii, message)

Asserts that message is same as parsed expected_message_ascii.

Creates another prototype of message, reads the ascii message into it and then compares them using self._AssertProtoEqual().

Parameters: expected_message_maybe_ascii – proto message in original or ascii form. message – the message to validate.
assertProtoEqualsVersion(expected, actual, producer=24, min_consumer=0)
assertRaises(expected_exception, *args, **kwargs)

Fail unless an exception of class expected_exception is raised by the callable when invoked with specified positional and keyword arguments. If a different type of exception is raised, it will not be caught, and the test case will be deemed to have suffered an error, exactly as for an unexpected exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertRaises(SomeException):
do_something()


An optional keyword argument ‘msg’ can be provided when assertRaises is used as a context object.

The context manager keeps a reference to the exception as the ‘exception’ attribute. This allows you to inspect the exception after the assertion:

with self.assertRaises(SomeException) as cm:
do_something()
the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

assertRaisesOpError(expected_err_re_or_predicate)
assertRaisesRegex(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters: expected_exception – Exception class expected to be raised. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.
assertRaisesRegexp(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters: expected_exception – Exception class expected to be raised. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.
assertRaisesWithPredicateMatch(exception_type, expected_err_re_or_predicate)

Returns a context manager to enclose code expected to raise an exception.

If the exception is an OpError, the op stack is also included in the message predicate search.

Parameters: exception_type – The expected type of exception that should be raised. expected_err_re_or_predicate – If this is callable, it should be a function of one argument that inspects the passed-in exception and returns True (success) or False (please fail the test). Otherwise, the error message is expected to match this regular expression partially. A context manager to surround code that is expected to raise an exception.
assertRegex(text, expected_regex, msg=None)

Fail the test unless the text matches the regular expression.

assertRegexpMatches(*args, **kwargs)
assertSequenceEqual(seq1, seq2, msg=None, seq_type=None)

An equality assertion for ordered sequences (like lists and tuples).

For the purposes of this function, a valid ordered sequence type is one which can be indexed, has a length, and has an equality operator.

Parameters: seq1 – The first sequence to compare. seq2 – The second sequence to compare. seq_type – The expected datatype of the sequences, or None if no datatype should be enforced. msg – Optional message to use on failure instead of a list of differences.
assertSetEqual(set1, set2, msg=None)

A set-specific equality assertion.

Parameters: set1 – The first set to compare. set2 – The second set to compare. msg – Optional message to use on failure instead of a list of differences.

assertSetEqual uses ducktyping to support different types of sets, and is optimized for sets specifically (parameters must support a difference method).

assertShapeEqual(np_array, tf_tensor)

Asserts that a Numpy ndarray and a TensorFlow tensor have the same shape.

Parameters: np_array – A Numpy ndarray or Numpy scalar. tf_tensor – A Tensor. TypeError – If the arguments have the wrong type.
assertStartsWith(actual, expected_start, msg=None)

Assert that actual.startswith(expected_start) is True.

Parameters: actual – str expected_start – str msg – Optional message to report on failure.
assertTrue(expr, msg=None)

Check that the expression is true.

assertTupleEqual(tuple1, tuple2, msg=None)

A tuple-specific equality assertion.

Parameters: tuple1 – The first tuple to compare. tuple2 – The second tuple to compare. msg – Optional message to use on failure instead of a list of differences.
assertWarns(expected_warning, *args, **kwargs)

Fail unless a warning of class warnClass is triggered by the callable when invoked with specified positional and keyword arguments. If a different type of warning is triggered, it will not be handled: depending on the other warning filtering rules in effect, it might be silenced, printed out, or raised as an exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertWarns(SomeWarning):
do_something()


An optional keyword argument ‘msg’ can be provided when assertWarns is used as a context object.

The context manager keeps a reference to the first matching warning as the ‘warning’ attribute; similarly, the ‘filename’ and ‘lineno’ attributes give you information about the line of Python code from which the warning was triggered. This allows you to inspect the warning after the assertion:

with self.assertWarns(SomeWarning) as cm:
do_something()
the_warning = cm.warning
self.assertEqual(the_warning.some_attribute, 147)

assertWarnsRegex(expected_warning, expected_regex, *args, **kwargs)

Asserts that the message in a triggered warning matches a regexp. Basic functioning is similar to assertWarns() with the addition that only warnings whose messages also match the regular expression are considered successful matches.

Parameters: expected_warning – Warning class expected to be triggered. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertWarnsRegex is used as a context manager.
assert_(*args, **kwargs)
checkedThread(target, args=None, kwargs=None)

Returns a Thread wrapper that asserts ‘target’ completes successfully.

This method should be used to create all threads in test cases, as otherwise there is a risk that a thread will silently fail, and/or assertions made in the thread will not be respected.

Parameters: target – A callable object to be executed in the thread. args – The argument tuple for the target invocation. Defaults to (). kwargs – A dictionary of keyword arguments for the target invocation. Defaults to {}. A wrapper for threading.Thread that supports start() and join() methods.
countTestCases()
debug()

Run the test without collecting errors in a TestResult

defaultTestResult()
doCleanups()

Execute all cleanup functions. Normally called for you after tearDown.

evaluate(tensors)

Evaluates tensors and returns numpy values.

Parameters: tensors – A Tensor or a nested list/tuple of Tensors. tensors numpy values.
fail(msg=None)

Fail immediately, with the given message.

failIf(*args, **kwargs)
failIfAlmostEqual(*args, **kwargs)
failIfEqual(*args, **kwargs)
failUnless(*args, **kwargs)
failUnlessAlmostEqual(*args, **kwargs)
failUnlessEqual(*args, **kwargs)
failUnlessRaises(*args, **kwargs)
failureException

alias of AssertionError

get_temp_dir()

Returns a unique temporary directory for the test to use.

If you call this method multiple times during in a test, it will return the same folder. However, across different runs the directories will be different. This will ensure that across different runs tests will not be able to pollute each others environment. If you need multiple unique directories within a single test, you should use tempfile.mkdtemp as follows:

tempfile.mkdtemp(dir=self.get_temp_dir()):
Returns: string, the path to the unique temporary directory created for this test.
id()
longMessage = True
maxDiff = 640
run(result=None)
setUp()
setUpClass()

Hook method for setting up class fixture before running tests in the class.

shortDescription()

Returns a one-line description of the test, or None if no description has been provided.

The default implementation of this method returns the first line of the specified test method’s docstring.

skipTest(reason)

Skip this test.

subTest(msg=<object object>, **params)

Return a context manager that will return the enclosed block of code in a subtest identified by the optional message and keyword parameters. A failure in the subtest marks the test case as failed but resumes execution at the end of the enclosed block, allowing further test code to be executed.

tearDown()
tearDownClass()

Hook method for deconstructing the class fixture after running all tests in the class.

test_get_atoms_in_nbrs_1D()[source]

Test get_atoms_in_brs in 1D

test_get_cells_1D()[source]

Test neighbor-list method get_cells() in 1D

test_get_cells_for_atoms_1D()[source]

Test that get_cells_for_atoms works in 1D

test_get_closest_atoms_1D()[source]

Test get_closest_atoms works correctly in 1D

test_get_neighbor_cells_1D()[source]

Test that get_neighbor_cells works in 1D

test_neighbor_list_1D()[source]

Test neighbor list on 1D example.

test_neighbor_list_2D()[source]

Test neighbor list on 2D example.

test_neighbor_list_3D()[source]

Test neighbor list on 3D example.

test_neighbor_list_3D_empty_cells()[source]

Test neighbor list on 3D example where cells are empty.

Stresses the failure mode where the neighboring cells are empty so top_k will throw a failure.

test_neighbor_list_shape()[source]

Test that NeighborList works.

test_neighbor_list_simple()[source]

Test that neighbor lists can be constructed.

test_neighbor_list_vina()[source]

Test under conditions closer to Vina usage.

test_session(graph=None, config=None, use_gpu=False, force_gpu=False)

Returns a TensorFlow Session for use in executing tests.

This method should be used for all functional tests.

This method behaves different than session.Session: for performance reasons test_session will by default (if graph is None) reuse the same session across tests. This means you may want to either call the function reset_default_graph() before tests, or if creating an explicit new graph, pass it here (simply setting it with as_default() won’t do it), which will trigger the creation of a new session.

Use the use_gpu and force_gpu options to control where ops are run. If force_gpu is True, all ops are pinned to /device:GPU:0. Otherwise, if use_gpu is True, TensorFlow tries to run as many ops on the GPU as possible. If both force_gpu and use_gpu are False, all ops are pinned to the CPU.

Example: python class MyOperatorTest(test_util.TensorFlowTestCase):

def testMyOperator(self):
with self.test_session(use_gpu=True):

valid_input = [1.0, 2.0, 3.0, 4.0, 5.0] result = MyOperator(valid_input).eval() self.assertEqual(result, [1.0, 2.0, 3.0, 5.0, 8.0] invalid_input = [-1.0, 2.0, 7.0] with self.assertRaisesOpError(“negative input not supported”):

MyOperator(invalid_input).eval()
Parameters: graph – Optional graph to use during the returned session. config – An optional config_pb2.ConfigProto to use to configure the session. use_gpu – If True, attempt to run as many ops as possible on GPU. force_gpu – If True, pin all ops to /device:GPU:0. A Session object that should be used as a context manager to surround the graph building and execution code in a test case.
test_weighted_combo()[source]

Tests that weighted linear combinations can be built

## deepchem.models.tensorgraph.tests.test_optimizers module¶

class deepchem.models.tensorgraph.tests.test_optimizers.TestLayers(methodName='runTest')[source]

Bases: tensorflow.python.framework.test_util.TensorFlowTestCase

Test optimizers and related classes.

addCleanup(function, *args, **kwargs)

Add a function, with arguments, to be called when the test is completed. Functions added are called on a LIFO basis and are called after tearDown on test failure or success.

Cleanup items are called even if setUp fails (unlike tearDown).

addTypeEqualityFunc(typeobj, function)

Add a type specific assertEqual style function to compare a type.

This method is for use by TestCase subclasses that need to register their own type equality functions to provide nicer error messages.

Parameters: typeobj – The data type to call this function on when both values are of the same type in assertEqual(). function – The callable taking two arguments and an optional msg= argument that raises self.failureException with a useful error message when the two arguments are not equal.
assertAllClose(a, b, rtol=1e-06, atol=1e-06)

Asserts that two numpy arrays, or dicts of same, have near values.

This does not support nested dicts.

Parameters: a – The expected numpy ndarray (or anything can be converted to one), or dict of same. Must be a dict iff b is a dict. b – The actual numpy ndarray (or anything can be converted to one), or dict of same. Must be a dict iff a is a dict. rtol – relative tolerance. atol – absolute tolerance. ValueError – if only one of a and b is a dict.
assertAllCloseAccordingToType(a, b, rtol=1e-06, atol=1e-06, float_rtol=1e-06, float_atol=1e-06, half_rtol=0.001, half_atol=0.001, bfloat16_rtol=0.01, bfloat16_atol=0.01)

Like assertAllClose, but also suitable for comparing fp16 arrays.

In particular, the tolerance is reduced to 1e-3 if at least one of the arguments is of type float16.

Parameters: a – the expected numpy ndarray or anything can be converted to one. b – the actual numpy ndarray or anything can be converted to one. rtol – relative tolerance. atol – absolute tolerance. float_rtol – relative tolerance for float32. float_atol – absolute tolerance for float32. half_rtol – relative tolerance for float16. half_atol – absolute tolerance for float16. bfloat16_rtol – relative tolerance for bfloat16. bfloat16_atol – absolute tolerance for bfloat16.
assertAllEqual(a, b)

Asserts that two numpy arrays have the same values.

Parameters: a – the expected numpy ndarray or anything can be converted to one. b – the actual numpy ndarray or anything can be converted to one.
assertAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is more than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

If the two objects compare equal then they will automatically compare almost equal.

assertAlmostEquals(*args, **kwargs)
assertArrayNear(farray1, farray2, err)

Asserts that two float arrays are near each other.

Checks that for all elements of farray1 and farray2 |f1 - f2| < err. Asserts a test failure if not.

Parameters: farray1 – a list of float values. farray2 – a list of float values. err – a float value.
assertCountEqual(first, second, msg=None)

An unordered sequence comparison asserting that the same elements, regardless of order. If the same element occurs more than once, it verifies that the elements occur the same number of times.

self.assertEqual(Counter(list(first)),
Counter(list(second)))
Example:
• [0, 1, 1] and [1, 0, 1] compare equal.
• [0, 0, 1] and [0, 1] compare unequal.
assertDeviceEqual(device1, device2)

Asserts that the two given devices are the same.

Parameters: device1 – A string device name or TensorFlow DeviceSpec object. device2 – A string device name or TensorFlow DeviceSpec object.
assertDictContainsSubset(subset, dictionary, msg=None)

Checks whether dictionary is a superset of subset.

assertDictEqual(d1, d2, msg=None)
assertEqual(first, second, msg=None)

Fail if the two objects are unequal as determined by the ‘==’ operator.

assertEquals(*args, **kwargs)
assertFalse(expr, msg=None)

Check that the expression is false.

assertGreater(a, b, msg=None)

Just like self.assertTrue(a > b), but with a nicer default message.

assertGreaterEqual(a, b, msg=None)

Just like self.assertTrue(a >= b), but with a nicer default message.

assertIn(member, container, msg=None)

Just like self.assertTrue(a in b), but with a nicer default message.

assertIs(expr1, expr2, msg=None)

Just like self.assertTrue(a is b), but with a nicer default message.

assertIsInstance(obj, cls, msg=None)

Same as self.assertTrue(isinstance(obj, cls)), with a nicer default message.

assertIsNone(obj, msg=None)

Same as self.assertTrue(obj is None), with a nicer default message.

assertIsNot(expr1, expr2, msg=None)

Just like self.assertTrue(a is not b), but with a nicer default message.

assertIsNotNone(obj, msg=None)

Included for symmetry with assertIsNone.

assertItemsEqual(first, second, msg=None)

An unordered sequence comparison asserting that the same elements, regardless of order. If the same element occurs more than once, it verifies that the elements occur the same number of times.

self.assertEqual(Counter(list(first)),
Counter(list(second)))
Example:
• [0, 1, 1] and [1, 0, 1] compare equal.
• [0, 0, 1] and [0, 1] compare unequal.
assertLess(a, b, msg=None)

Just like self.assertTrue(a < b), but with a nicer default message.

assertLessEqual(a, b, msg=None)

Just like self.assertTrue(a <= b), but with a nicer default message.

assertListEqual(list1, list2, msg=None)

A list-specific equality assertion.

Parameters: list1 – The first list to compare. list2 – The second list to compare. msg – Optional message to use on failure instead of a list of differences.
assertLogs(logger=None, level=None)

Fail unless a log message of level level or higher is emitted on logger_name or its children. If omitted, level defaults to INFO and logger defaults to the root logger.

This method must be used as a context manager, and will yield a recording object with two attributes: output and records. At the end of the context manager, the output attribute will be a list of the matching formatted log messages and the records attribute will be a list of the corresponding LogRecord objects.

Example:

with self.assertLogs('foo', level='INFO') as cm:
logging.getLogger('foo').info('first message')
logging.getLogger('foo.bar').error('second message')
self.assertEqual(cm.output, ['INFO:foo:first message',
'ERROR:foo.bar:second message'])

assertMultiLineEqual(first, second, msg=None)

Assert that two multi-line strings are equal.

assertNDArrayNear(ndarray1, ndarray2, err)

Asserts that two numpy arrays have near values.

Parameters: ndarray1 – a numpy ndarray. ndarray2 – a numpy ndarray. err – a float. The maximum absolute difference allowed.
assertNear(f1, f2, err, msg=None)

Asserts that two floats are near each other.

Checks that |f1 - f2| < err and asserts a test failure if not.

Parameters: f1 – A float value. f2 – A float value. err – A float value. msg – An optional string message to append to the failure message.
assertNotAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is less than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

Objects that are equal automatically fail.

assertNotAlmostEquals(*args, **kwargs)
assertNotEqual(first, second, msg=None)

Fail if the two objects are equal as determined by the ‘!=’ operator.

assertNotEquals(*args, **kwargs)
assertNotIn(member, container, msg=None)

Just like self.assertTrue(a not in b), but with a nicer default message.

assertNotIsInstance(obj, cls, msg=None)

Included for symmetry with assertIsInstance.

assertNotRegex(text, unexpected_regex, msg=None)

Fail the test if the text matches the regular expression.

assertNotRegexpMatches(*args, **kwargs)
assertProtoEquals(expected_message_maybe_ascii, message)

Asserts that message is same as parsed expected_message_ascii.

Creates another prototype of message, reads the ascii message into it and then compares them using self._AssertProtoEqual().

Parameters: expected_message_maybe_ascii – proto message in original or ascii form. message – the message to validate.
assertProtoEqualsVersion(expected, actual, producer=24, min_consumer=0)
assertRaises(expected_exception, *args, **kwargs)

Fail unless an exception of class expected_exception is raised by the callable when invoked with specified positional and keyword arguments. If a different type of exception is raised, it will not be caught, and the test case will be deemed to have suffered an error, exactly as for an unexpected exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertRaises(SomeException):
do_something()


An optional keyword argument ‘msg’ can be provided when assertRaises is used as a context object.

The context manager keeps a reference to the exception as the ‘exception’ attribute. This allows you to inspect the exception after the assertion:

with self.assertRaises(SomeException) as cm:
do_something()
the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

assertRaisesOpError(expected_err_re_or_predicate)
assertRaisesRegex(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters: expected_exception – Exception class expected to be raised. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.
assertRaisesRegexp(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters: expected_exception – Exception class expected to be raised. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.
assertRaisesWithPredicateMatch(exception_type, expected_err_re_or_predicate)

Returns a context manager to enclose code expected to raise an exception.

If the exception is an OpError, the op stack is also included in the message predicate search.

Parameters: exception_type – The expected type of exception that should be raised. expected_err_re_or_predicate – If this is callable, it should be a function of one argument that inspects the passed-in exception and returns True (success) or False (please fail the test). Otherwise, the error message is expected to match this regular expression partially. A context manager to surround code that is expected to raise an exception.
assertRegex(text, expected_regex, msg=None)

Fail the test unless the text matches the regular expression.

assertRegexpMatches(*args, **kwargs)
assertSequenceEqual(seq1, seq2, msg=None, seq_type=None)

An equality assertion for ordered sequences (like lists and tuples).

For the purposes of this function, a valid ordered sequence type is one which can be indexed, has a length, and has an equality operator.

Parameters: seq1 – The first sequence to compare. seq2 – The second sequence to compare. seq_type – The expected datatype of the sequences, or None if no datatype should be enforced. msg – Optional message to use on failure instead of a list of differences.
assertSetEqual(set1, set2, msg=None)

A set-specific equality assertion.

Parameters: set1 – The first set to compare. set2 – The second set to compare. msg – Optional message to use on failure instead of a list of differences.

assertSetEqual uses ducktyping to support different types of sets, and is optimized for sets specifically (parameters must support a difference method).

assertShapeEqual(np_array, tf_tensor)

Asserts that a Numpy ndarray and a TensorFlow tensor have the same shape.

Parameters: np_array – A Numpy ndarray or Numpy scalar. tf_tensor – A Tensor. TypeError – If the arguments have the wrong type.
assertStartsWith(actual, expected_start, msg=None)

Assert that actual.startswith(expected_start) is True.

Parameters: actual – str expected_start – str msg – Optional message to report on failure.
assertTrue(expr, msg=None)

Check that the expression is true.

assertTupleEqual(tuple1, tuple2, msg=None)

A tuple-specific equality assertion.

Parameters: tuple1 – The first tuple to compare. tuple2 – The second tuple to compare. msg – Optional message to use on failure instead of a list of differences.
assertWarns(expected_warning, *args, **kwargs)

Fail unless a warning of class warnClass is triggered by the callable when invoked with specified positional and keyword arguments. If a different type of warning is triggered, it will not be handled: depending on the other warning filtering rules in effect, it might be silenced, printed out, or raised as an exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertWarns(SomeWarning):
do_something()


An optional keyword argument ‘msg’ can be provided when assertWarns is used as a context object.

The context manager keeps a reference to the first matching warning as the ‘warning’ attribute; similarly, the ‘filename’ and ‘lineno’ attributes give you information about the line of Python code from which the warning was triggered. This allows you to inspect the warning after the assertion:

with self.assertWarns(SomeWarning) as cm:
do_something()
the_warning = cm.warning
self.assertEqual(the_warning.some_attribute, 147)

assertWarnsRegex(expected_warning, expected_regex, *args, **kwargs)

Asserts that the message in a triggered warning matches a regexp. Basic functioning is similar to assertWarns() with the addition that only warnings whose messages also match the regular expression are considered successful matches.

Parameters: expected_warning – Warning class expected to be triggered. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertWarnsRegex is used as a context manager.
assert_(*args, **kwargs)
checkedThread(target, args=None, kwargs=None)

Returns a Thread wrapper that asserts ‘target’ completes successfully.

This method should be used to create all threads in test cases, as otherwise there is a risk that a thread will silently fail, and/or assertions made in the thread will not be respected.

Parameters: target – A callable object to be executed in the thread. args – The argument tuple for the target invocation. Defaults to (). kwargs – A dictionary of keyword arguments for the target invocation. Defaults to {}. A wrapper for threading.Thread that supports start() and join() methods.
countTestCases()
debug()

Run the test without collecting errors in a TestResult

defaultTestResult()
doCleanups()

Execute all cleanup functions. Normally called for you after tearDown.

evaluate(tensors)

Evaluates tensors and returns numpy values.

Parameters: tensors – A Tensor or a nested list/tuple of Tensors. tensors numpy values.
fail(msg=None)

Fail immediately, with the given message.

failIf(*args, **kwargs)
failIfAlmostEqual(*args, **kwargs)
failIfEqual(*args, **kwargs)
failUnless(*args, **kwargs)
failUnlessAlmostEqual(*args, **kwargs)
failUnlessEqual(*args, **kwargs)
failUnlessRaises(*args, **kwargs)
failureException

alias of AssertionError

get_temp_dir()

Returns a unique temporary directory for the test to use.

If you call this method multiple times during in a test, it will return the same folder. However, across different runs the directories will be different. This will ensure that across different runs tests will not be able to pollute each others environment. If you need multiple unique directories within a single test, you should use tempfile.mkdtemp as follows:

tempfile.mkdtemp(dir=self.get_temp_dir()):
Returns: string, the path to the unique temporary directory created for this test.
id()
longMessage = True
maxDiff = 640
run(result=None)
setUp()
setUpClass()

Hook method for setting up class fixture before running tests in the class.

shortDescription()

Returns a one-line description of the test, or None if no description has been provided.

The default implementation of this method returns the first line of the specified test method’s docstring.

skipTest(reason)

Skip this test.

subTest(msg=<object object>, **params)

Return a context manager that will return the enclosed block of code in a subtest identified by the optional message and keyword parameters. A failure in the subtest marks the test case as failed but resumes execution at the end of the enclosed block, allowing further test code to be executed.

tearDown()
tearDownClass()

Hook method for deconstructing the class fixture after running all tests in the class.

test_adam()[source]

test_exponential_decay()[source]

Test creating an optimizer with an exponentially decaying learning rate.

test_gradient_descent()[source]

Test creating a Gradient Descent optimizer.

test_polynomial_decay()[source]

Test creating an optimizer with a polynomially decaying learning rate.

test_session(graph=None, config=None, use_gpu=False, force_gpu=False)

Returns a TensorFlow Session for use in executing tests.

This method should be used for all functional tests.

This method behaves different than session.Session: for performance reasons test_session will by default (if graph is None) reuse the same session across tests. This means you may want to either call the function reset_default_graph() before tests, or if creating an explicit new graph, pass it here (simply setting it with as_default() won’t do it), which will trigger the creation of a new session.

Use the use_gpu and force_gpu options to control where ops are run. If force_gpu is True, all ops are pinned to /device:GPU:0. Otherwise, if use_gpu is True, TensorFlow tries to run as many ops on the GPU as possible. If both force_gpu and use_gpu are False, all ops are pinned to the CPU.

Example: python class MyOperatorTest(test_util.TensorFlowTestCase):

def testMyOperator(self):
with self.test_session(use_gpu=True):

valid_input = [1.0, 2.0, 3.0, 4.0, 5.0] result = MyOperator(valid_input).eval() self.assertEqual(result, [1.0, 2.0, 3.0, 5.0, 8.0] invalid_input = [-1.0, 2.0, 7.0] with self.assertRaisesOpError(“negative input not supported”):

MyOperator(invalid_input).eval()
Parameters: graph – Optional graph to use during the returned session. config – An optional config_pb2.ConfigProto to use to configure the session. use_gpu – If True, attempt to run as many ops as possible on GPU. force_gpu – If True, pin all ops to /device:GPU:0. A Session object that should be used as a context manager to surround the graph building and execution code in a test case.

## deepchem.models.tensorgraph.tests.test_seqtoseq module¶

class deepchem.models.tensorgraph.tests.test_seqtoseq.TestSeqToSeq(methodName='runTest')[source]

Bases: unittest.case.TestCase

addCleanup(function, *args, **kwargs)

Add a function, with arguments, to be called when the test is completed. Functions added are called on a LIFO basis and are called after tearDown on test failure or success.

Cleanup items are called even if setUp fails (unlike tearDown).

addTypeEqualityFunc(typeobj, function)

Add a type specific assertEqual style function to compare a type.

This method is for use by TestCase subclasses that need to register their own type equality functions to provide nicer error messages.

Parameters: typeobj – The data type to call this function on when both values are of the same type in assertEqual(). function – The callable taking two arguments and an optional msg= argument that raises self.failureException with a useful error message when the two arguments are not equal.
assertAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is more than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

If the two objects compare equal then they will automatically compare almost equal.

assertAlmostEquals(*args, **kwargs)
assertCountEqual(first, second, msg=None)

An unordered sequence comparison asserting that the same elements, regardless of order. If the same element occurs more than once, it verifies that the elements occur the same number of times.

self.assertEqual(Counter(list(first)),
Counter(list(second)))
Example:
• [0, 1, 1] and [1, 0, 1] compare equal.
• [0, 0, 1] and [0, 1] compare unequal.
assertDictContainsSubset(subset, dictionary, msg=None)

Checks whether dictionary is a superset of subset.

assertDictEqual(d1, d2, msg=None)
assertEqual(first, second, msg=None)

Fail if the two objects are unequal as determined by the ‘==’ operator.

assertEquals(*args, **kwargs)
assertFalse(expr, msg=None)

Check that the expression is false.

assertGreater(a, b, msg=None)

Just like self.assertTrue(a > b), but with a nicer default message.

assertGreaterEqual(a, b, msg=None)

Just like self.assertTrue(a >= b), but with a nicer default message.

assertIn(member, container, msg=None)

Just like self.assertTrue(a in b), but with a nicer default message.

assertIs(expr1, expr2, msg=None)

Just like self.assertTrue(a is b), but with a nicer default message.

assertIsInstance(obj, cls, msg=None)

Same as self.assertTrue(isinstance(obj, cls)), with a nicer default message.

assertIsNone(obj, msg=None)

Same as self.assertTrue(obj is None), with a nicer default message.

assertIsNot(expr1, expr2, msg=None)

Just like self.assertTrue(a is not b), but with a nicer default message.

assertIsNotNone(obj, msg=None)

Included for symmetry with assertIsNone.

assertLess(a, b, msg=None)

Just like self.assertTrue(a < b), but with a nicer default message.

assertLessEqual(a, b, msg=None)

Just like self.assertTrue(a <= b), but with a nicer default message.

assertListEqual(list1, list2, msg=None)

A list-specific equality assertion.

Parameters: list1 – The first list to compare. list2 – The second list to compare. msg – Optional message to use on failure instead of a list of differences.
assertLogs(logger=None, level=None)

Fail unless a log message of level level or higher is emitted on logger_name or its children. If omitted, level defaults to INFO and logger defaults to the root logger.

This method must be used as a context manager, and will yield a recording object with two attributes: output and records. At the end of the context manager, the output attribute will be a list of the matching formatted log messages and the records attribute will be a list of the corresponding LogRecord objects.

Example:

with self.assertLogs('foo', level='INFO') as cm:
logging.getLogger('foo').info('first message')
logging.getLogger('foo.bar').error('second message')
self.assertEqual(cm.output, ['INFO:foo:first message',
'ERROR:foo.bar:second message'])

assertMultiLineEqual(first, second, msg=None)

Assert that two multi-line strings are equal.

assertNotAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is less than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

Objects that are equal automatically fail.

assertNotAlmostEquals(*args, **kwargs)
assertNotEqual(first, second, msg=None)

Fail if the two objects are equal as determined by the ‘!=’ operator.

assertNotEquals(*args, **kwargs)
assertNotIn(member, container, msg=None)

Just like self.assertTrue(a not in b), but with a nicer default message.

assertNotIsInstance(obj, cls, msg=None)

Included for symmetry with assertIsInstance.

assertNotRegex(text, unexpected_regex, msg=None)

Fail the test if the text matches the regular expression.

assertNotRegexpMatches(*args, **kwargs)
assertRaises(expected_exception, *args, **kwargs)

Fail unless an exception of class expected_exception is raised by the callable when invoked with specified positional and keyword arguments. If a different type of exception is raised, it will not be caught, and the test case will be deemed to have suffered an error, exactly as for an unexpected exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertRaises(SomeException):
do_something()


An optional keyword argument ‘msg’ can be provided when assertRaises is used as a context object.

The context manager keeps a reference to the exception as the ‘exception’ attribute. This allows you to inspect the exception after the assertion:

with self.assertRaises(SomeException) as cm:
do_something()
the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

assertRaisesRegex(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters: expected_exception – Exception class expected to be raised. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.
assertRaisesRegexp(*args, **kwargs)
assertRegex(text, expected_regex, msg=None)

Fail the test unless the text matches the regular expression.

assertRegexpMatches(*args, **kwargs)
assertSequenceEqual(seq1, seq2, msg=None, seq_type=None)

An equality assertion for ordered sequences (like lists and tuples).

For the purposes of this function, a valid ordered sequence type is one which can be indexed, has a length, and has an equality operator.

Parameters: seq1 – The first sequence to compare. seq2 – The second sequence to compare. seq_type – The expected datatype of the sequences, or None if no datatype should be enforced. msg – Optional message to use on failure instead of a list of differences.
assertSetEqual(set1, set2, msg=None)

A set-specific equality assertion.

Parameters: set1 – The first set to compare. set2 – The second set to compare. msg – Optional message to use on failure instead of a list of differences.

assertSetEqual uses ducktyping to support different types of sets, and is optimized for sets specifically (parameters must support a difference method).

assertTrue(expr, msg=None)

Check that the expression is true.

assertTupleEqual(tuple1, tuple2, msg=None)

A tuple-specific equality assertion.

Parameters: tuple1 – The first tuple to compare. tuple2 – The second tuple to compare. msg – Optional message to use on failure instead of a list of differences.
assertWarns(expected_warning, *args, **kwargs)

Fail unless a warning of class warnClass is triggered by the callable when invoked with specified positional and keyword arguments. If a different type of warning is triggered, it will not be handled: depending on the other warning filtering rules in effect, it might be silenced, printed out, or raised as an exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertWarns(SomeWarning):
do_something()


An optional keyword argument ‘msg’ can be provided when assertWarns is used as a context object.

The context manager keeps a reference to the first matching warning as the ‘warning’ attribute; similarly, the ‘filename’ and ‘lineno’ attributes give you information about the line of Python code from which the warning was triggered. This allows you to inspect the warning after the assertion:

with self.assertWarns(SomeWarning) as cm:
do_something()
the_warning = cm.warning
self.assertEqual(the_warning.some_attribute, 147)

assertWarnsRegex(expected_warning, expected_regex, *args, **kwargs)

Asserts that the message in a triggered warning matches a regexp. Basic functioning is similar to assertWarns() with the addition that only warnings whose messages also match the regular expression are considered successful matches.

Parameters: expected_warning – Warning class expected to be triggered. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertWarnsRegex is used as a context manager.
assert_(*args, **kwargs)
countTestCases()
debug()

Run the test without collecting errors in a TestResult

defaultTestResult()
doCleanups()

Execute all cleanup functions. Normally called for you after tearDown.

fail(msg=None)

Fail immediately, with the given message.

failIf(*args, **kwargs)
failIfAlmostEqual(*args, **kwargs)
failIfEqual(*args, **kwargs)
failUnless(*args, **kwargs)
failUnlessAlmostEqual(*args, **kwargs)
failUnlessEqual(*args, **kwargs)
failUnlessRaises(*args, **kwargs)
failureException

alias of AssertionError

id()
longMessage = True
maxDiff = 640
run(result=None)
setUp()

Hook method for setting up the test fixture before exercising it.

setUpClass()

Hook method for setting up class fixture before running tests in the class.

shortDescription()

Returns a one-line description of the test, or None if no description has been provided.

The default implementation of this method returns the first line of the specified test method’s docstring.

skipTest(reason)

Skip this test.

subTest(msg=<object object>, **params)

Return a context manager that will return the enclosed block of code in a subtest identified by the optional message and keyword parameters. A failure in the subtest marks the test case as failed but resumes execution at the end of the enclosed block, allowing further test code to be executed.

tearDown()

Hook method for deconstructing the test fixture after testing it.

tearDownClass()

Hook method for deconstructing the class fixture after running all tests in the class.

test_aspuru_guzik()[source]

Test that the aspuru_guzik encoder doesn’t hard error. This model takes too long to fit to do an overfit test

test_int_sequence()[source]

Test learning to reproduce short sequences of integers.

test_variational()[source]

Test using a SeqToSeq model as a variational autoenconder.

deepchem.models.tensorgraph.tests.test_seqtoseq.generate_sequences(sequence_length, num_sequences)[source]

## deepchem.models.tensorgraph.tests.test_sequencednn module¶

class deepchem.models.tensorgraph.tests.test_sequencednn.TestSequenceDNN(methodName='runTest')[source]

Bases: unittest.case.TestCase

addCleanup(function, *args, **kwargs)

Add a function, with arguments, to be called when the test is completed. Functions added are called on a LIFO basis and are called after tearDown on test failure or success.

Cleanup items are called even if setUp fails (unlike tearDown).

addTypeEqualityFunc(typeobj, function)

Add a type specific assertEqual style function to compare a type.

This method is for use by TestCase subclasses that need to register their own type equality functions to provide nicer error messages.

Parameters: typeobj – The data type to call this function on when both values are of the same type in assertEqual(). function – The callable taking two arguments and an optional msg= argument that raises self.failureException with a useful error message when the two arguments are not equal.
assertAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is more than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

If the two objects compare equal then they will automatically compare almost equal.

assertAlmostEquals(*args, **kwargs)
assertCountEqual(first, second, msg=None)

An unordered sequence comparison asserting that the same elements, regardless of order. If the same element occurs more than once, it verifies that the elements occur the same number of times.

self.assertEqual(Counter(list(first)),
Counter(list(second)))
Example:
• [0, 1, 1] and [1, 0, 1] compare equal.
• [0, 0, 1] and [0, 1] compare unequal.
assertDictContainsSubset(subset, dictionary, msg=None)

Checks whether dictionary is a superset of subset.

assertDictEqual(d1, d2, msg=None)
assertEqual(first, second, msg=None)

Fail if the two objects are unequal as determined by the ‘==’ operator.

assertEquals(*args, **kwargs)
assertFalse(expr, msg=None)

Check that the expression is false.

assertGreater(a, b, msg=None)

Just like self.assertTrue(a > b), but with a nicer default message.

assertGreaterEqual(a, b, msg=None)

Just like self.assertTrue(a >= b), but with a nicer default message.

assertIn(member, container, msg=None)

Just like self.assertTrue(a in b), but with a nicer default message.

assertIs(expr1, expr2, msg=None)

Just like self.assertTrue(a is b), but with a nicer default message.

assertIsInstance(obj, cls, msg=None)

Same as self.assertTrue(isinstance(obj, cls)), with a nicer default message.

assertIsNone(obj, msg=None)

Same as self.assertTrue(obj is None), with a nicer default message.

assertIsNot(expr1, expr2, msg=None)

Just like self.assertTrue(a is not b), but with a nicer default message.

assertIsNotNone(obj, msg=None)

Included for symmetry with assertIsNone.

assertLess(a, b, msg=None)

Just like self.assertTrue(a < b), but with a nicer default message.

assertLessEqual(a, b, msg=None)

Just like self.assertTrue(a <= b), but with a nicer default message.

assertListEqual(list1, list2, msg=None)

A list-specific equality assertion.

Parameters: list1 – The first list to compare. list2 – The second list to compare. msg – Optional message to use on failure instead of a list of differences.
assertLogs(logger=None, level=None)

Fail unless a log message of level level or higher is emitted on logger_name or its children. If omitted, level defaults to INFO and logger defaults to the root logger.

This method must be used as a context manager, and will yield a recording object with two attributes: output and records. At the end of the context manager, the output attribute will be a list of the matching formatted log messages and the records attribute will be a list of the corresponding LogRecord objects.

Example:

with self.assertLogs('foo', level='INFO') as cm:
logging.getLogger('foo').info('first message')
logging.getLogger('foo.bar').error('second message')
self.assertEqual(cm.output, ['INFO:foo:first message',
'ERROR:foo.bar:second message'])

assertMultiLineEqual(first, second, msg=None)

Assert that two multi-line strings are equal.

assertNotAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is less than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

Objects that are equal automatically fail.

assertNotAlmostEquals(*args, **kwargs)
assertNotEqual(first, second, msg=None)

Fail if the two objects are equal as determined by the ‘!=’ operator.

assertNotEquals(*args, **kwargs)
assertNotIn(member, container, msg=None)

Just like self.assertTrue(a not in b), but with a nicer default message.

assertNotIsInstance(obj, cls, msg=None)

Included for symmetry with assertIsInstance.

assertNotRegex(text, unexpected_regex, msg=None)

Fail the test if the text matches the regular expression.

assertNotRegexpMatches(*args, **kwargs)
assertRaises(expected_exception, *args, **kwargs)

Fail unless an exception of class expected_exception is raised by the callable when invoked with specified positional and keyword arguments. If a different type of exception is raised, it will not be caught, and the test case will be deemed to have suffered an error, exactly as for an unexpected exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertRaises(SomeException):
do_something()


An optional keyword argument ‘msg’ can be provided when assertRaises is used as a context object.

The context manager keeps a reference to the exception as the ‘exception’ attribute. This allows you to inspect the exception after the assertion:

with self.assertRaises(SomeException) as cm:
do_something()
the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

assertRaisesRegex(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters: expected_exception – Exception class expected to be raised. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.
assertRaisesRegexp(*args, **kwargs)
assertRegex(text, expected_regex, msg=None)

Fail the test unless the text matches the regular expression.

assertRegexpMatches(*args, **kwargs)
assertSequenceEqual(seq1, seq2, msg=None, seq_type=None)

An equality assertion for ordered sequences (like lists and tuples).

For the purposes of this function, a valid ordered sequence type is one which can be indexed, has a length, and has an equality operator.

Parameters: seq1 – The first sequence to compare. seq2 – The second sequence to compare. seq_type – The expected datatype of the sequences, or None if no datatype should be enforced. msg – Optional message to use on failure instead of a list of differences.
assertSetEqual(set1, set2, msg=None)

A set-specific equality assertion.

Parameters: set1 – The first set to compare. set2 – The second set to compare. msg – Optional message to use on failure instead of a list of differences.

assertSetEqual uses ducktyping to support different types of sets, and is optimized for sets specifically (parameters must support a difference method).

assertTrue(expr, msg=None)

Check that the expression is true.

assertTupleEqual(tuple1, tuple2, msg=None)

A tuple-specific equality assertion.

Parameters: tuple1 – The first tuple to compare. tuple2 – The second tuple to compare. msg – Optional message to use on failure instead of a list of differences.
assertWarns(expected_warning, *args, **kwargs)

Fail unless a warning of class warnClass is triggered by the callable when invoked with specified positional and keyword arguments. If a different type of warning is triggered, it will not be handled: depending on the other warning filtering rules in effect, it might be silenced, printed out, or raised as an exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertWarns(SomeWarning):
do_something()


An optional keyword argument ‘msg’ can be provided when assertWarns is used as a context object.

The context manager keeps a reference to the first matching warning as the ‘warning’ attribute; similarly, the ‘filename’ and ‘lineno’ attributes give you information about the line of Python code from which the warning was triggered. This allows you to inspect the warning after the assertion:

with self.assertWarns(SomeWarning) as cm:
do_something()
the_warning = cm.warning
self.assertEqual(the_warning.some_attribute, 147)

assertWarnsRegex(expected_warning, expected_regex, *args, **kwargs)

Asserts that the message in a triggered warning matches a regexp. Basic functioning is similar to assertWarns() with the addition that only warnings whose messages also match the regular expression are considered successful matches.

Parameters: expected_warning – Warning class expected to be triggered. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertWarnsRegex is used as a context manager.
assert_(*args, **kwargs)
countTestCases()
debug()

Run the test without collecting errors in a TestResult

defaultTestResult()
doCleanups()

Execute all cleanup functions. Normally called for you after tearDown.

fail(msg=None)

Fail immediately, with the given message.

failIf(*args, **kwargs)
failIfAlmostEqual(*args, **kwargs)
failIfEqual(*args, **kwargs)
failUnless(*args, **kwargs)
failUnlessAlmostEqual(*args, **kwargs)
failUnlessEqual(*args, **kwargs)
failUnlessRaises(*args, **kwargs)
failureException

alias of AssertionError

id()
longMessage = True
maxDiff = 640
run(result=None)
setUp()

Hook method for setting up the test fixture before exercising it.

setUpClass()

Hook method for setting up class fixture before running tests in the class.

shortDescription()

Returns a one-line description of the test, or None if no description has been provided.

The default implementation of this method returns the first line of the specified test method’s docstring.

skipTest(reason)

Skip this test.

subTest(msg=<object object>, **params)

Return a context manager that will return the enclosed block of code in a subtest identified by the optional message and keyword parameters. A failure in the subtest marks the test case as failed but resumes execution at the end of the enclosed block, allowing further test code to be executed.

tearDown()

Hook method for deconstructing the test fixture after testing it.

tearDownClass()

Hook method for deconstructing the class fixture after running all tests in the class.

test_seq_dnn_init()[source]

Test SequenceDNN can be initialized.

test_seq_dnn_multifilter_train()[source]

Test SequenceDNN training works.

test_seq_dnn_singlefilter_train()[source]

Test SequenceDNN training works.

## deepchem.models.tensorgraph.tests.test_sequential module¶

class deepchem.models.tensorgraph.tests.test_sequential.TestSequential(methodName='runTest')[source]

Bases: unittest.case.TestCase

Test that sequential graphs work correctly.

addCleanup(function, *args, **kwargs)

Add a function, with arguments, to be called when the test is completed. Functions added are called on a LIFO basis and are called after tearDown on test failure or success.

Cleanup items are called even if setUp fails (unlike tearDown).

addTypeEqualityFunc(typeobj, function)

Add a type specific assertEqual style function to compare a type.

This method is for use by TestCase subclasses that need to register their own type equality functions to provide nicer error messages.

Parameters: typeobj – The data type to call this function on when both values are of the same type in assertEqual(). function – The callable taking two arguments and an optional msg= argument that raises self.failureException with a useful error message when the two arguments are not equal.
assertAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is more than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

If the two objects compare equal then they will automatically compare almost equal.

assertAlmostEquals(*args, **kwargs)
assertCountEqual(first, second, msg=None)

An unordered sequence comparison asserting that the same elements, regardless of order. If the same element occurs more than once, it verifies that the elements occur the same number of times.

self.assertEqual(Counter(list(first)),
Counter(list(second)))
Example:
• [0, 1, 1] and [1, 0, 1] compare equal.
• [0, 0, 1] and [0, 1] compare unequal.
assertDictContainsSubset(subset, dictionary, msg=None)

Checks whether dictionary is a superset of subset.

assertDictEqual(d1, d2, msg=None)
assertEqual(first, second, msg=None)

Fail if the two objects are unequal as determined by the ‘==’ operator.

assertEquals(*args, **kwargs)
assertFalse(expr, msg=None)

Check that the expression is false.

assertGreater(a, b, msg=None)

Just like self.assertTrue(a > b), but with a nicer default message.

assertGreaterEqual(a, b, msg=None)

Just like self.assertTrue(a >= b), but with a nicer default message.

assertIn(member, container, msg=None)

Just like self.assertTrue(a in b), but with a nicer default message.

assertIs(expr1, expr2, msg=None)

Just like self.assertTrue(a is b), but with a nicer default message.

assertIsInstance(obj, cls, msg=None)

Same as self.assertTrue(isinstance(obj, cls)), with a nicer default message.

assertIsNone(obj, msg=None)

Same as self.assertTrue(obj is None), with a nicer default message.

assertIsNot(expr1, expr2, msg=None)

Just like self.assertTrue(a is not b), but with a nicer default message.

assertIsNotNone(obj, msg=None)

Included for symmetry with assertIsNone.

assertLess(a, b, msg=None)

Just like self.assertTrue(a < b), but with a nicer default message.

assertLessEqual(a, b, msg=None)

Just like self.assertTrue(a <= b), but with a nicer default message.

assertListEqual(list1, list2, msg=None)

A list-specific equality assertion.

Parameters: list1 – The first list to compare. list2 – The second list to compare. msg – Optional message to use on failure instead of a list of differences.
assertLogs(logger=None, level=None)

Fail unless a log message of level level or higher is emitted on logger_name or its children. If omitted, level defaults to INFO and logger defaults to the root logger.

This method must be used as a context manager, and will yield a recording object with two attributes: output and records. At the end of the context manager, the output attribute will be a list of the matching formatted log messages and the records attribute will be a list of the corresponding LogRecord objects.

Example:

with self.assertLogs('foo', level='INFO') as cm:
logging.getLogger('foo').info('first message')
logging.getLogger('foo.bar').error('second message')
self.assertEqual(cm.output, ['INFO:foo:first message',
'ERROR:foo.bar:second message'])

assertMultiLineEqual(first, second, msg=None)

Assert that two multi-line strings are equal.

assertNotAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is less than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

Objects that are equal automatically fail.

assertNotAlmostEquals(*args, **kwargs)
assertNotEqual(first, second, msg=None)

Fail if the two objects are equal as determined by the ‘!=’ operator.

assertNotEquals(*args, **kwargs)
assertNotIn(member, container, msg=None)

Just like self.assertTrue(a not in b), but with a nicer default message.

assertNotIsInstance(obj, cls, msg=None)

Included for symmetry with assertIsInstance.

assertNotRegex(text, unexpected_regex, msg=None)

Fail the test if the text matches the regular expression.

assertNotRegexpMatches(*args, **kwargs)
assertRaises(expected_exception, *args, **kwargs)

Fail unless an exception of class expected_exception is raised by the callable when invoked with specified positional and keyword arguments. If a different type of exception is raised, it will not be caught, and the test case will be deemed to have suffered an error, exactly as for an unexpected exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertRaises(SomeException):
do_something()


An optional keyword argument ‘msg’ can be provided when assertRaises is used as a context object.

The context manager keeps a reference to the exception as the ‘exception’ attribute. This allows you to inspect the exception after the assertion:

with self.assertRaises(SomeException) as cm:
do_something()
the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

assertRaisesRegex(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters: expected_exception – Exception class expected to be raised. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.
assertRaisesRegexp(*args, **kwargs)
assertRegex(text, expected_regex, msg=None)

Fail the test unless the text matches the regular expression.

assertRegexpMatches(*args, **kwargs)
assertSequenceEqual(seq1, seq2, msg=None, seq_type=None)

An equality assertion for ordered sequences (like lists and tuples).

For the purposes of this function, a valid ordered sequence type is one which can be indexed, has a length, and has an equality operator.

Parameters: seq1 – The first sequence to compare. seq2 – The second sequence to compare. seq_type – The expected datatype of the sequences, or None if no datatype should be enforced. msg – Optional message to use on failure instead of a list of differences.
assertSetEqual(set1, set2, msg=None)

A set-specific equality assertion.

Parameters: set1 – The first set to compare. set2 – The second set to compare. msg – Optional message to use on failure instead of a list of differences.

assertSetEqual uses ducktyping to support different types of sets, and is optimized for sets specifically (parameters must support a difference method).

assertTrue(expr, msg=None)

Check that the expression is true.

assertTupleEqual(tuple1, tuple2, msg=None)

A tuple-specific equality assertion.

Parameters: tuple1 – The first tuple to compare. tuple2 – The second tuple to compare. msg – Optional message to use on failure instead of a list of differences.
assertWarns(expected_warning, *args, **kwargs)

Fail unless a warning of class warnClass is triggered by the callable when invoked with specified positional and keyword arguments. If a different type of warning is triggered, it will not be handled: depending on the other warning filtering rules in effect, it might be silenced, printed out, or raised as an exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertWarns(SomeWarning):
do_something()


An optional keyword argument ‘msg’ can be provided when assertWarns is used as a context object.

The context manager keeps a reference to the first matching warning as the ‘warning’ attribute; similarly, the ‘filename’ and ‘lineno’ attributes give you information about the line of Python code from which the warning was triggered. This allows you to inspect the warning after the assertion:

with self.assertWarns(SomeWarning) as cm:
do_something()
the_warning = cm.warning
self.assertEqual(the_warning.some_attribute, 147)

assertWarnsRegex(expected_warning, expected_regex, *args, **kwargs)

Asserts that the message in a triggered warning matches a regexp. Basic functioning is similar to assertWarns() with the addition that only warnings whose messages also match the regular expression are considered successful matches.

Parameters: expected_warning – Warning class expected to be triggered. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertWarnsRegex is used as a context manager.
assert_(*args, **kwargs)
countTestCases()
debug()

Run the test without collecting errors in a TestResult

defaultTestResult()
doCleanups()

Execute all cleanup functions. Normally called for you after tearDown.

fail(msg=None)

Fail immediately, with the given message.

failIf(*args, **kwargs)
failIfAlmostEqual(*args, **kwargs)
failIfEqual(*args, **kwargs)
failUnless(*args, **kwargs)
failUnlessAlmostEqual(*args, **kwargs)
failUnlessEqual(*args, **kwargs)
failUnlessRaises(*args, **kwargs)
failureException

alias of AssertionError

id()
longMessage = True
maxDiff = 640
run(result=None)
setUp()

Hook method for setting up the test fixture before exercising it.

setUpClass()

Hook method for setting up class fixture before running tests in the class.

shortDescription()

Returns a one-line description of the test, or None if no description has been provided.

The default implementation of this method returns the first line of the specified test method’s docstring.

skipTest(reason)

Skip this test.

subTest(msg=<object object>, **params)

Return a context manager that will return the enclosed block of code in a subtest identified by the optional message and keyword parameters. A failure in the subtest marks the test case as failed but resumes execution at the end of the enclosed block, allowing further test code to be executed.

tearDown()

Hook method for deconstructing the test fixture after testing it.

tearDownClass()

Hook method for deconstructing the class fixture after running all tests in the class.

test_fit_twice()[source]
test_single_task_classifier()[source]
test_single_task_regressor()[source]

## deepchem.models.tensorgraph.tests.test_tensor_graph module¶

class deepchem.models.tensorgraph.tests.test_tensor_graph.TestTensorGraph(methodName='runTest')[source]

Bases: unittest.case.TestCase

Test that graph topologies work correctly.

addCleanup(function, *args, **kwargs)

Add a function, with arguments, to be called when the test is completed. Functions added are called on a LIFO basis and are called after tearDown on test failure or success.

Cleanup items are called even if setUp fails (unlike tearDown).

addTypeEqualityFunc(typeobj, function)

Add a type specific assertEqual style function to compare a type.

This method is for use by TestCase subclasses that need to register their own type equality functions to provide nicer error messages.

Parameters: typeobj – The data type to call this function on when both values are of the same type in assertEqual(). function – The callable taking two arguments and an optional msg= argument that raises self.failureException with a useful error message when the two arguments are not equal.
assertAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is more than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

If the two objects compare equal then they will automatically compare almost equal.

assertAlmostEquals(*args, **kwargs)
assertCountEqual(first, second, msg=None)

An unordered sequence comparison asserting that the same elements, regardless of order. If the same element occurs more than once, it verifies that the elements occur the same number of times.

self.assertEqual(Counter(list(first)),
Counter(list(second)))
Example:
• [0, 1, 1] and [1, 0, 1] compare equal.
• [0, 0, 1] and [0, 1] compare unequal.
assertDictContainsSubset(subset, dictionary, msg=None)

Checks whether dictionary is a superset of subset.

assertDictEqual(d1, d2, msg=None)
assertEqual(first, second, msg=None)

Fail if the two objects are unequal as determined by the ‘==’ operator.

assertEquals(*args, **kwargs)
assertFalse(expr, msg=None)

Check that the expression is false.

assertGreater(a, b, msg=None)

Just like self.assertTrue(a > b), but with a nicer default message.

assertGreaterEqual(a, b, msg=None)

Just like self.assertTrue(a >= b), but with a nicer default message.

assertIn(member, container, msg=None)

Just like self.assertTrue(a in b), but with a nicer default message.

assertIs(expr1, expr2, msg=None)

Just like self.assertTrue(a is b), but with a nicer default message.

assertIsInstance(obj, cls, msg=None)

Same as self.assertTrue(isinstance(obj, cls)), with a nicer default message.

assertIsNone(obj, msg=None)

Same as self.assertTrue(obj is None), with a nicer default message.

assertIsNot(expr1, expr2, msg=None)

Just like self.assertTrue(a is not b), but with a nicer default message.

assertIsNotNone(obj, msg=None)

Included for symmetry with assertIsNone.

assertLess(a, b, msg=None)

Just like self.assertTrue(a < b), but with a nicer default message.

assertLessEqual(a, b, msg=None)

Just like self.assertTrue(a <= b), but with a nicer default message.

assertListEqual(list1, list2, msg=None)

A list-specific equality assertion.

Parameters: list1 – The first list to compare. list2 – The second list to compare. msg – Optional message to use on failure instead of a list of differences.
assertLogs(logger=None, level=None)

Fail unless a log message of level level or higher is emitted on logger_name or its children. If omitted, level defaults to INFO and logger defaults to the root logger.

This method must be used as a context manager, and will yield a recording object with two attributes: output and records. At the end of the context manager, the output attribute will be a list of the matching formatted log messages and the records attribute will be a list of the corresponding LogRecord objects.

Example:

with self.assertLogs('foo', level='INFO') as cm:
logging.getLogger('foo').info('first message')
logging.getLogger('foo.bar').error('second message')
self.assertEqual(cm.output, ['INFO:foo:first message',
'ERROR:foo.bar:second message'])

assertMultiLineEqual(first, second, msg=None)

Assert that two multi-line strings are equal.

assertNotAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the between the two objects is less than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

Objects that are equal automatically fail.

assertNotAlmostEquals(*args, **kwargs)
assertNotEqual(first, second, msg=None)

Fail if the two objects are equal as determined by the ‘!=’ operator.

assertNotEquals(*args, **kwargs)
assertNotIn(member, container, msg=None)

Just like self.assertTrue(a not in b), but with a nicer default message.

assertNotIsInstance(obj, cls, msg=None)

Included for symmetry with assertIsInstance.

assertNotRegex(text, unexpected_regex, msg=None)

Fail the test if the text matches the regular expression.

assertNotRegexpMatches(*args, **kwargs)
assertRaises(expected_exception, *args, **kwargs)

Fail unless an exception of class expected_exception is raised by the callable when invoked with specified positional and keyword arguments. If a different type of exception is raised, it will not be caught, and the test case will be deemed to have suffered an error, exactly as for an unexpected exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertRaises(SomeException):
do_something()


An optional keyword argument ‘msg’ can be provided when assertRaises is used as a context object.

The context manager keeps a reference to the exception as the ‘exception’ attribute. This allows you to inspect the exception after the assertion:

with self.assertRaises(SomeException) as cm:
do_something()
the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

assertRaisesRegex(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters: expected_exception – Exception class expected to be raised. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.
assertRaisesRegexp(*args, **kwargs)
assertRegex(text, expected_regex, msg=None)

Fail the test unless the text matches the regular expression.

assertRegexpMatches(*args, **kwargs)
assertSequenceEqual(seq1, seq2, msg=None, seq_type=None)

An equality assertion for ordered sequences (like lists and tuples).

For the purposes of this function, a valid ordered sequence type is one which can be indexed, has a length, and has an equality operator.

Parameters: seq1 – The first sequence to compare. seq2 – The second sequence to compare. seq_type – The expected datatype of the sequences, or None if no datatype should be enforced. msg – Optional message to use on failure instead of a list of differences.
assertSetEqual(set1, set2, msg=None)

A set-specific equality assertion.

Parameters: set1 – The first set to compare. set2 – The second set to compare. msg – Optional message to use on failure instead of a list of differences.

assertSetEqual uses ducktyping to support different types of sets, and is optimized for sets specifically (parameters must support a difference method).

assertTrue(expr, msg=None)

Check that the expression is true.

assertTupleEqual(tuple1, tuple2, msg=None)

A tuple-specific equality assertion.

Parameters: tuple1 – The first tuple to compare. tuple2 – The second tuple to compare. msg – Optional message to use on failure instead of a list of differences.
assertWarns(expected_warning, *args, **kwargs)

Fail unless a warning of class warnClass is triggered by the callable when invoked with specified positional and keyword arguments. If a different type of warning is triggered, it will not be handled: depending on the other warning filtering rules in effect, it might be silenced, printed out, or raised as an exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertWarns(SomeWarning):
do_something()


An optional keyword argument ‘msg’ can be provided when assertWarns is used as a context object.

The context manager keeps a reference to the first matching warning as the ‘warning’ attribute; similarly, the ‘filename’ and ‘lineno’ attributes give you information about the line of Python code from which the warning was triggered. This allows you to inspect the warning after the assertion:

with self.assertWarns(SomeWarning) as cm:
do_something()
the_warning = cm.warning
self.assertEqual(the_warning.some_attribute, 147)

assertWarnsRegex(expected_warning, expected_regex, *args, **kwargs)

Asserts that the message in a triggered warning matches a regexp. Basic functioning is similar to assertWarns() with the addition that only warnings whose messages also match the regular expression are considered successful matches.

Parameters: expected_warning – Warning class expected to be triggered. expected_regex – Regex (re pattern object or string) expected to be found in error message. args – Function to be called and extra positional args. kwargs – Extra kwargs. msg – Optional message used in case of failure. Can only be used when assertWarnsRegex is used as a context manager.
assert_(*args, **kwargs)
countTestCases()
debug()

Run the test without collecting errors in a TestResult

defaultTestResult()
doCleanups()

Execute all cleanup functions. Normally called for you after tearDown.

fail(msg=None)

Fail immediately, with the given message.

failIf(*args, **kwargs)
failIfAlmostEqual(*args, **kwargs)
failIfEqual(*args, **kwargs)
failUnless(*args, **kwargs)
failUnlessAlmostEqual(*args, **kwargs)
failUnlessEqual(*args, **kwargs)
failUnlessRaises(*args, **kwargs)
failureException

alias of AssertionError

id()
longMessage = True
maxDiff = 640
run(result=None)
setUp()

Hook method for setting up the test fixture before exercising it.

setUpClass()

Hook method for setting up class fixture before running tests in the class.

shortDescription()

Returns a one-line description of the test, or None if no description has been provided.

The default implementation of this method returns the first line of the specified test method’s docstring.

skipTest(reason)

Skip this test.

subTest(msg=<object object>, **params)

Return a context manager that will return the enclosed block of code in a subtest identified by the optional message and keyword parameters. A failure in the subtest marks the test case as failed but resumes execution at the end of the enclosed block, allowing further test code to be executed.

tearDown()

Hook method for deconstructing the test fixture after testing it.

tearDownClass()

Hook method for deconstructing the class fixture after running all tests in the class.

test_copy_layers()[source]

Test copying layers.

test_copy_layers_shared()[source]

Test copying layers with shared variables.

test_initialize_variable()[source]

Test methods for initializing a variable.

test_multi_task_classifier()[source]
test_multi_task_regressor()[source]
test_no_queue()[source]
test_operators()[source]

Test math operators on Layers.

test_save_load()[source]
test_set_optimizer()[source]
test_shared_layer()[source]
test_single_task_classifier()[source]
test_single_task_regressor()[source]
test_submodels()[source]

Test optimizing submodels.

test_tensorboard()[source]