def test_tensorflow_session_function(self):
sess_a = tf_utils.tensorflow_session()
sess_b = tf_utils.tensorflow_session()
self.assertIs(sess_a, sess_b)
sess_b.close()
sess_c = tf_utils.tensorflow_session()
self.assertIsNot(sess_b, sess_c)
def test_setup_parameter_updates(self):
w1 = tf.Variable(np.ones((4, 3)))
b1 = tf.Variable(np.zeros((3, )))
w2 = tf.Variable(np.ones((3, 2)))
tf_utils.initialize_uninitialized_variables([w1, b1, w2])
updates = 2 * tf_utils.make_single_vector([w1, b1, w2]) + 1
updates = tf_utils.setup_parameter_updates([w1, b1, w2], updates)
sess = tf_utils.tensorflow_session()
for parameter, new_value in updates:
sess.run(parameter.assign(new_value))
np.testing.assert_array_almost_equal(
self.eval(w1),
3 * np.ones((4, 3)),
)
np.testing.assert_array_almost_equal(
self.eval(b1),
np.ones(3),
)
np.testing.assert_array_almost_equal(
self.eval(w2),
3 * np.ones((3, 2)),
)
def test_initialize_uninitialized_variables(self):
sess = tf_utils.tensorflow_session()
a = tf.Variable(np.ones((4, 3)), name='a')
b = tf.Variable(np.ones((4, 3)), name='b')
tf_utils.initialize_uninitialized_variables()
actual = sess.run(a + b)
np.testing.assert_array_almost_equal(actual, 2 * np.ones((4, 3)))
c = tf.Variable(np.ones((2, 3)), name='c')
d = tf.Variable(np.ones((2, 3)), name='dx')
tf_utils.initialize_uninitialized_variables([c])
with self.assertRaisesRegexp(FailedPreconditionError, "value dx"):
sess.run(c + d)
def load_layer_parameter(layer, layer_data):
"""
Set layer parameters to the values specified in the
stored data
"""
session = tf_utils.tensorflow_session()
for param_name, param_data in layer_data['parameters'].items():
parameter = getattr(layer, param_name)
if not isinstance(parameter, tf.Variable):
raise ParameterLoaderError(
"The `{}` parameter from the `{}` layer expected to be "
"instance of the tf.Variable, but current value equal to {}. "
"Layer: {}".format(param_name, layer.name, parameter, layer))
parameter.load(asfloat(param_data['value']), session)
def test_partially_defined_input_shape(self):
network = layers.join(
layers.Input((None, None, 3)),
layers.Convolution((3, 3, 5)),
layers.Reshape((-1, 5)),
)
self.assertShapesEqual(network.input_shape, (None, None, None, 3))
self.assertShapesEqual(network.output_shape, (None, None, 5))
x = network.inputs
y = network.outputs
session = tf_utils.tensorflow_session()
images = np.random.random((2, 10, 10, 3))
output = session.run(y, feed_dict={x: images})
self.assertEqual(output.shape, (2, 64, 5))
def predict(self, *inputs, **kwargs):
session = tf_utils.tensorflow_session()
batch_size = kwargs.pop('batch_size', None)
verbose = kwargs.pop('verbose', True)
# We require do to this check for python 2 compatibility
if kwargs:
raise TypeError("Unknown arguments: {}".format(kwargs))
def single_batch_predict(*inputs):
feed_dict = dict(zip(as_tuple(self.inputs), inputs))
return session.run(self.outputs, feed_dict=feed_dict)
outputs = iters.apply_batches(
function=single_batch_predict,
inputs=inputs,
batch_size=batch_size,
show_progressbar=verbose,
)
return np.concatenate(outputs, axis=0)
def save_dict(network):
"""
Save network into the dictionary.
Parameters
----------
network : network, list of layer or network
Returns
-------
dict
Saved parameters and information about network in dictionary
using specific format. Learn more about the NeuPy's storage
format in the official documentation.
Examples
--------
>>> from neupy import layers, storage
>>>
>>> network = layers.Input(10) >> layers.Softmax(3)
>>> layers_data = storage.save_dict(network)
>>>
>>> layers_data.keys()
['layers', 'graph', 'metadata']
"""
network = extract_network(network)
network.create_variables()
session = tf_utils.tensorflow_session()
tf_utils.initialize_uninitialized_variables()
data = {
'metadata': {
'language': 'python',
'library': 'neupy',
'version': neupy.__version__,
'created': strftime("%a, %d %b %Y %H:%M:%S %Z", gmtime()),
},
# Make it as a list in order to save the right order
# of paramters, otherwise it can be convert to the dictionary.
'graph': network.layer_names_only(),
'layers': [],
}
for layer in network:
parameters = {}
configs = {}
for attrname, parameter in layer.variables.items():
parameters[attrname] = {
'value': asfloat(session.run(parameter)),
'trainable': parameter.trainable,
}
for option_name in layer.options:
if option_name not in parameters:
configs[option_name] = getattr(layer, option_name)
data['layers'].append({
'class_name': layer.__class__.__name__,
'name': layer.name,
'parameters': parameters,
'configs': configs,
})
return data
