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