def _train(self):
tf.disable_eager_execution()
ps_tasks = 0
worker_replicas = 1
worker_job_name = 'lonely_worker'
task = 0
is_chief = True
master = ''
graph_rewriter_fn = None
# loading and reading the config file
configs = create_configs_from_pipeline_proto(self.pipeline)
model_config = configs['model']
train_config = configs['train_config']
input_config = configs['train_input_config']
# creating the tf object detection api model (from the config parameters)
model_fn = functools.partial(model_builder.build, model_config=model_config, is_training=True)
def get_next(config):
return dataset_builder.make_initializable_iterator(dataset_builder.build(config)).get_next()
create_input_dict_fn = functools.partial(get_next, input_config)
if 'graph_rewriter_config' in configs:
graph_rewriter_fn = graph_rewriter_builder.build(configs['graph_rewriter_config'], is_training=True)
# training the model with the new parameters
trainer.train(create_input_dict_fn, model_fn, train_config, master, task, 1, worker_replicas, False, ps_tasks,
worker_job_name, is_chief, str(self._out_folder), graph_hook_fn=graph_rewriter_fn)
def setUp(self) -> None:
import tensorflow as tf
tf.reset_default_graph()
if "_eager" in self._testMethodName:
tf.enable_eager_execution()
else:
tf.disable_eager_execution()
def _setup_tfgraph(*args):
import tensorflow as tf
tf.disable_eager_execution()
tf.reset_default_graph()
from delira.models import AbstractTfGraphNetwork
from delira.training.backends.tf_graph.utils import \
initialize_uninitialized
class Model(AbstractTfGraphNetwork):
def __init__(self):
super().__init__()
self.dense = tf.keras.layers.Dense(1, activation="relu")
data = tf.placeholder(shape=[None, 1], dtype=tf.float32)
labels = tf.placeholder_with_default(tf.zeros(
[tf.shape(data)[0], 1]),
shape=[None, 1])
preds_train = self.dense(data)
preds_eval = self.dense(data)
self.inputs["data"] = data
self.inputs["labels"] = labels
self.outputs_train["pred"] = preds_train
self.outputs_eval["pred"] = preds_eval
model = Model()
initialize_uninitialized(model._sess)
return model
def main(unused_args):
# Eager execution is enabled by default in TF 2.0, but generated example
# tests are still using non-eager features (e.g. `tf.placeholder`).
tf.disable_eager_execution()
options = generate_examples_lib.Options()
options.output_path = FLAGS.output_path
options.zip_to_output = FLAGS.zip_to_output
options.toco = FLAGS.toco
options.known_bugs_are_errors = FLAGS.known_bugs_are_errors
options.ignore_converter_errors = FLAGS.ignore_converter_errors
options.save_graphdefs = FLAGS.save_graphdefs
options.run_with_flex = FLAGS.run_with_flex
options.make_edgetpu_tests = FLAGS.make_edgetpu_tests
options.make_forward_compat_test = FLAGS.make_forward_compat_test
options.tflite_convert_function = toco_convert.toco_convert
options.no_tests_limit = FLAGS.no_tests_limit
options.no_conversion_report = FLAGS.no_conversion_report
if FLAGS.test_sets:
test_sets = FLAGS.test_sets.split(",")
generate_examples_lib.generate_multi_set_examples(options, test_sets)
else:
generate_examples_lib.generate_examples(options)
def _init_class_grads(self, label=None):
# pylint: disable=E0401
import tensorflow as tf
if tf.__version__[0] == '2':
import tensorflow.compat.v1 as tf
tf.disable_eager_execution()
if not hasattr(self, '_class_grads'):
self._class_grads = [None for _ in range(self.nb_classes())]
# Construct the class gradients graph
if label is None:
if None in self._class_grads:
self._class_grads = [
tf.gradients(self._output[:, i], self._input_ph)[0]
for i in range(self.nb_classes())
]
elif isinstance(label, int):
if self._class_grads[label] is None:
self._class_grads[label] = tf.gradients(
self._output[:, label], self._input_ph)[0]
else:
for unique_label in np.unique(label):
if self._class_grads[unique_label] is None:
self._class_grads[unique_label] = tf.gradients(
self._output[:, unique_label], self._input_ph)[0]
def __init__(self, model, config):
import tensorflow.compat.v1 as tf
tf.disable_eager_execution()
self.config = config
self.model = model
self.net_input_dim = config['net_input_dim']
self.att_input_dim = config['att_input_dim']
self.net_shape = config['net_shape']
self.att_shape = config['att_shape']
self.drop_prob = config['drop_prob']
self.beta = config['beta']
self.gamma = config['gamma']
self.alpha = config['alpha']
self.learning_rate = config['learning_rate']
self.batch_size = config['batch_size']
self.num_epochs = config['num_epochs']
self.model_path = config['model_path']
self.x = tf.placeholder(tf.float32, [None, self.net_input_dim])
self.z = tf.placeholder(tf.float32, [None, self.att_input_dim])
self.w = tf.placeholder(tf.float32, [None, None])
self.neg_x = tf.placeholder(tf.float32, [None, self.net_input_dim])
self.neg_z = tf.placeholder(tf.float32, [None, self.att_input_dim])
self.neg_w = tf.placeholder(tf.float32, [None, None])
self.optimizer, self.loss = self._build_training_graph()
self.net_H, self.att_H, self.H = self._build_eval_graph()
gpu_config = tf.ConfigProto()
gpu_config.gpu_options.allow_growth = True
self.sess = tf.Session(config=gpu_config)
self.sess.run(tf.global_variables_initializer())
self.saver = tf.train.Saver()
def initialize_variables(self):
import tensorflow as tf
if tf.__version__[0] == '2':
print('Adjusting for tensorflow 2.0')
tf = tf.compat.v1
tf.disable_eager_execution()
self._session.run(tf.global_variables_initializer())
self.saver = tf.train.Saver(max_to_keep=100, allow_empty=True)
def run(self):
src_path = os.path.abspath('./phi/tf/cuda/src')
build_path = os.path.abspath('./phi/tf/cuda/build')
print('Source Path:\t' + src_path)
print('Build Path:\t' + build_path)
# Get TF Compile/Link Flags and write to env
import tensorflow as tf
if tf.__version__[0] == '2':
print('Adjusting for tensorflow 2.0')
tf = tf.compat.v1
tf.disable_eager_execution()
tf_cflags = tf.sysconfig.get_compile_flags()
tf_lflags = tf.sysconfig.get_link_flags()
# Remove old build files
if os.path.isdir(build_path):
print('Removing old build files from %s' % build_path)
for file in os.listdir(build_path):
os.remove(os.path.join(build_path, file))
else:
print('Creating build directory at %s' % build_path)
os.mkdir(build_path)
print('Compiling CUDA code...')
# Build the Laplace Matrix Generation CUDA Kernels
subprocess.check_call([
self.nvcc, '-std=c++11', '-c', '-o',
os.path.join(build_path, 'laplace_op.cu.o'),
os.path.join(src_path, 'laplace_op.cu.cc'), '-x', 'cu',
'-Xcompiler', '-fPIC'
] + tf_cflags)
# Build the Laplace Matrix Generation Custom Op
# This is only needed for the Laplace Matrix Generation Benchmark
subprocess.check_call([
self.gcc, '-std=c++11', '-shared', '-o',
os.path.join(build_path, 'laplace_op.so'),
os.path.join(src_path, 'laplace_op.cc'),
os.path.join(build_path, 'laplace_op.cu.o'), '-fPIC'
] + tf_cflags + tf_lflags)
# Build the Pressure Solver CUDA Kernels
subprocess.check_call([
self.nvcc, '-std=c++11', '-c', '-lcublas', '-o',
os.path.join(build_path, 'pressure_solve_op.cu.o'),
os.path.join(src_path, 'pressure_solve_op.cu.cc'), '-x', 'cu',
'-Xcompiler', '-fPIC'
] + tf_cflags)
# Build the Pressure Solver Custom Op
subprocess.check_call([
self.gcc, '-std=c++11', '-shared', '-o',
os.path.join(build_path, 'pressure_solve_op.so'),
os.path.join(src_path, 'pressure_solve_op.cc'),
os.path.join(build_path, 'pressure_solve_op.cu.o'),
os.path.join(build_path, 'laplace_op.cu.o'), '-fPIC'
] + tf_cflags + tf_lflags)
def get_activations(self, x, layer, batch_size=128):
"""
Return the output of the specified layer for input `x`. `layer` is specified by layer index (between 0 and
`nb_layers - 1`) or by name. The number of layers can be determined by counting the results returned by
calling `layer_names`.
:param x: Input for computing the activations.
:type x: `np.ndarray`
:param layer: Layer for computing the activations
:type layer: `int` or `str`
:param batch_size: Size of batches.
:type batch_size: `int`
:return: The output of `layer`, where the first dimension is the batch size corresponding to `x`.
:rtype: `np.ndarray`
"""
# pylint: disable=E0401
import tensorflow as tf
if tf.__version__[0] == '2':
import tensorflow.compat.v1 as tf
tf.disable_eager_execution()
# Get the computational graph
with self._sess.graph.as_default():
graph = tf.get_default_graph()
if isinstance(layer, six.string_types): # basestring for Python 2 (str, unicode) support
if layer not in self._layer_names:
raise ValueError("Layer name %s is not part of the graph." % layer)
layer_tensor = graph.get_tensor_by_name(layer)
elif isinstance(layer, (int, np.integer)):
layer_tensor = graph.get_tensor_by_name(self._layer_names[layer])
else:
raise TypeError("Layer must be of type `str` or `int`. Received %s" % layer)
# Apply preprocessing
x_preprocessed, _ = self._apply_preprocessing(x, y=None, fit=False)
# Run prediction with batch processing
results = []
num_batch = int(np.ceil(len(x_preprocessed) / float(batch_size)))
for m in range(num_batch):
# Batch indexes
begin, end = m * batch_size, min((m + 1) * batch_size, x_preprocessed.shape[0])
# Create feed_dict
feed_dict = {self._input_ph: x_preprocessed[begin:end]}
feed_dict.update(self._feed_dict)
# Run prediction for the current batch
layer_output = self._sess.run(layer_tensor, feed_dict=feed_dict)
results.append(layer_output)
results = np.concatenate(results)
return results
def __init__(self, sess, iterator, iterator_type, iterator_arg, size,
batch_size):
"""
Create a data generator wrapper for TensorFlow. Supported iterators: initializable, reinitializable, feedable.
:param sess: TensorFlow session.
:type sess: `tf.Session`
:param iterator: Data iterator from TensorFlow.
:type iterator: `tensorflow.python.data.ops.iterator_ops.Iterator`
:param iterator_type: Type of the iterator. Supported types: `initializable`, `reinitializable`, `feedable`.
:type iterator_type: `string`
:param iterator_arg: Argument to initialize the iterator. It is either a feed_dict used for the initializable
and feedable mode, or an init_op used for the reinitializable mode.
:type iterator_arg: `dict`, `tuple` or `tensorflow.python.framework.ops.Operation`
:param size: Total size of the dataset.
:type size: `int`
:param batch_size: Size of the minibatches.
:type batch_size: `int`
:raises: `TypeError`, `ValueError`
"""
# pylint: disable=E0401
import tensorflow as tf
if tf.__version__[0] == '2':
import tensorflow.compat.v1 as tf
tf.disable_eager_execution()
super(TFDataGenerator, self).__init__(size=size, batch_size=batch_size)
self.sess = sess
self.iterator = iterator
self.iterator_type = iterator_type
self.iterator_arg = iterator_arg
if not isinstance(iterator, tf.data.Iterator):
raise TypeError("Only support object tf.data.Iterator")
if iterator_type == 'initializable':
if not isinstance(iterator_arg, dict):
raise TypeError(
"Need to pass a dictionary for iterator type %s" %
iterator_type)
elif iterator_type == 'reinitializable':
if not isinstance(iterator_arg, tf.Operation):
raise TypeError(
"Need to pass a tensorflow operation for iterator type %s"
% iterator_type)
elif iterator_type == 'feedable':
if not isinstance(iterator_arg, tuple):
raise TypeError("Need to pass a tuple for iterator type %s" %
iterator_type)
else:
raise TypeError("Iterator type %s not supported" % iterator_type)
def __init__(self, shape, para, data, layer_idx, activation_fun1,
activation_fun2):
import tensorflow.compat.v1 as tf
tf.disable_eager_execution()
self.para = para
self.data = data
self.layer_idx = layer_idx
self.x = tf.placeholder(tf.float32, [None, shape[0]])
self.dropout = tf.placeholder(tf.float32)
self.lr = tf.placeholder(tf.float32)
self.var_list = []
# 设定变量作用域SAE
with tf.variable_scope('SAE') as scope:
stddev = 1.0 / np.sqrt(shape[0])
# self.x_c = gaussian_noise_layer(self.x, 0.001)
# Dropout就是在不同的训练过程中随机扔掉一部分神经元。
# 也就是让某个神经元的激活值以一定的概率p，让其停止工作，这次训练过程中不更新权值，也不参加神经网络的计算。
# 但是它的权重得保留下来（只是暂时不更新而已），因为下次样本输入时它可能又得工作了
self.x_c = tf.nn.dropout(self.x, self.dropout)
self.W1 = tf.Variable(tf.random_normal([shape[0], shape[1]],
stddev=stddev),
name="W1")
self.b1 = tf.Variable(tf.zeros([shape[1]], name='b1'))
self.h = tf.add(tf.matmul(self.x_c, self.W1), self.b1)
if activation_fun1 != None:
self.h = activation_fun1(self.h)
self.h = tf.nn.dropout(self.h, self.dropout)
stddev = 1.0 / np.sqrt(shape[1])
self.W2 = tf.Variable(tf.random_normal([shape[1], shape[0]],
stddev=stddev),
name='W2')
self.b2 = tf.Variable(tf.zeros([shape[0]], name='b2'))
self.x_hat = tf.add(tf.matmul(self.h, self.W2), self.b2)
if activation_fun2 != None:
self.x_hat = activation_fun2(self.x_hat)
self.var_list.extend([self.W1, self.b1, self.W2, self.b2])
self.loss = tf.reduce_mean(tf.square(self.x - self.x_hat))
# self.loss = -tf.reduce_mean(self.x * tf.log(self.x_hat)+(1-self.x)*tf.log(1-self.x_hat))
self.opt = tf.train.AdamOptimizer(learning_rate=self.lr).minimize(
loss=self.loss, var_list=self.var_list)
gpu_config = tf.ConfigProto()
gpu_config.gpu_options.allow_growth = True
self.sess = tf.Session(config=gpu_config)
self.sess.run(tf.global_variables_initializer())
def _get_layers(self):
"""
Return the hidden layers in the model, if applicable.
:return: The hidden layers in the model, input and output layers excluded.
:rtype: `list`
"""
# pylint: disable=E0401
import tensorflow as tf
if tf.__version__[0] == '2':
import tensorflow.compat.v1 as tf
tf.disable_eager_execution()
# Get the computational graph
with self._sess.graph.as_default():
graph = tf.get_default_graph()
# Get the list of operators and heuristically filter them
tmp_list = []
ops = graph.get_operations()
# pylint: disable=R1702
for op in ops:
if op.values():
if op.values()[0].get_shape() is not None:
if op.values()[0].get_shape().ndims is not None:
if len(op.values()[0].get_shape().as_list()) > 1:
if op.values()[0].get_shape().as_list()[0] is None:
if op.values()[0].get_shape().as_list(
)[1] is not None:
if not op.values()[0].name.startswith(
"gradients"):
if not op.values()[0].name.startswith(
"softmax_cross_entropy_loss"):
if not op.type == "Placeholder":
tmp_list.append(
op.values()[0].name)
# Shorten the list
if not tmp_list:
return tmp_list
result = [tmp_list[-1]]
for name in reversed(tmp_list[:-1]):
if result[0].split("/")[0] != name.split("/")[0]:
result = [name] + result
logger.info('Inferred %i hidden layers on TensorFlow classifier.',
len(result))
return result
def test_load_save(self):
import tensorflow as tf
tf.disable_eager_execution()
from delira.io.tf import load_checkpoint, save_checkpoint
from delira.models import AbstractTfGraphNetwork
from delira.training.backends import initialize_uninitialized
import numpy as np
class DummyNetwork(AbstractTfGraphNetwork):
def __init__(self, in_channels, n_outputs):
super().__init__(in_channels=in_channels, n_outputs=n_outputs)
self.net = self._build_model(in_channels, n_outputs)
@staticmethod
def _build_model(in_channels, n_outputs):
return tf.keras.models.Sequential(
layers=[
tf.keras.layers.Dense(
64,
input_shape=in_channels,
bias_initializer='glorot_uniform'),
tf.keras.layers.ReLU(),
tf.keras.layers.Dense(
n_outputs,
bias_initializer='glorot_uniform')])
net = DummyNetwork((32,), 1)
initialize_uninitialized(net._sess)
vars_1 = net._sess.run(tf.global_variables())
save_checkpoint("./model", model=net)
net._sess.run(tf.initializers.global_variables())
vars_2 = net._sess.run(tf.global_variables())
load_checkpoint("./model", model=net)
vars_3 = net._sess.run(tf.global_variables())
for var_1, var_2 in zip(vars_1, vars_2):
with self.subTest(var_1=var_1, var2=var_2):
self.assertTrue(np.all(var_1 != var_2))
for var_1, var_3 in zip(vars_1, vars_3):
with self.subTest(var_1=var_1, var_3=var_3):
self.assertTrue(np.all(var_1 == var_3))
def main(argv):
del argv # Unused.
tf.disable_eager_execution()
weight = np.load(FLAGS.chainer_model_path)
if FLAGS.keras_model_path == "":
FLAGS.keras_model_path = FLAGS.chainer_model_path.replace(
".npz", "_Keras.h5")
if FLAGS.tfjs_model_path == "":
FLAGS.tfjs_model_path = FLAGS.chainer_model_path.replace(
".npz", "_tfjs")
print('Tensorflow.js model path: ', FLAGS.tfjs_model_path)
if FLAGS.arch == 'resnet128':
get_generator = partial(get_resnet128_keras_generator,
input_dim=128,
ch=1024)
elif FLAGS.arch == 'resnet256':
get_generator = partial(get_resnet256_keras_generator,
input_dim=128,
ch=1024)
elif FLAGS.arch == 'dcgan64':
get_generator = partial(get_dcgan64_keras_generator,
input_dim=128,
ch=512)
else:
raise ValueError('Unknow --arch %s' % FLAGS.arch)
generator = get_generator(weight=weight)
print('Keras summary')
generator.summary()
logging.info('Saving keras model (weights) to %s', FLAGS.keras_model_path)
generator.save_weights(FLAGS.keras_model_path)
del generator
# this avoids lambda initilizers in generator, which whould cause error in tfjs.
generator = get_generator()
generator.load_weights(FLAGS.keras_model_path)
generator.save_weights(FLAGS.keras_model_path)
logging.info('Saving tensorflow.js model to %s', FLAGS.tfjs_model_path)
os.system('mkdir -p "%s"' % FLAGS.tfjs_model_path)
tfjs.converters.save_keras_model(generator, FLAGS.tfjs_model_path)
sample_output_dir = FLAGS.keras_model_path + '.sample'
logging.info('Sampling images, saving to %s', sample_output_dir)
os.system('mkdir -p "%s"' % sample_output_dir)
for index in range(10):
generate_images(generator, sample_output_dir, index)
def show_tf_graph():
tf.disable_eager_execution() # TODO: This is TF v1 only
d = ds_tf.frame_sequence_dataset('data')
d_merged = ds_tf.frame_sequence_dataset('data', merge_channels=True)
it = d.make_one_shot_iterator()
ne = it.get_next()
it = d_merged.make_one_shot_iterator()
ne_merged = it.get_next()
with tf.Session() as sess:
for _ in range(3):
image_pair, image_pair_444 = sess.run([ne, ne_merged])
visualize(image_pair, image_pair_444)
def show_tf_graph():
tf.disable_eager_execution()
d = ds_tf.frame_pairs_dataset('data')
d_rgb = ds_tf.frame_pairs_dataset('data', merge_channels=True)
it = d.make_one_shot_iterator()
ne = it.get_next()
it = d_rgb.make_one_shot_iterator()
ne_rgb = it.get_next()
with tf.Session() as sess:
for _ in range(3):
image_pair, image_pair_444 = sess.run([ne, ne_rgb])
visualize(image_pair, image_pair_444)
def build_style_map_model(self, layers=[1, 4, 7], smooth=1, mean=1):
import tensorflow as tf
from netty import module_style as ms
from netty import model_variational as mv
from tensorflow.keras.layers import Input, Lambda
from tensorflow.keras.models import Model
tf.disable_eager_execution()
tf.keras.backend.clear_session()
vgg = ms.model_vgg.build({})
vgg = ms.extract_layers(vgg, layers)
mask_input = Input((None, None), name="MINPUT")
style_input = Input((None, None, 3), name="SINPUT")
render_input = Input((None, None, 3), name="RINPUT")
def resize_fn(args):
x = args[0]
y = args[1]
return tf.compat.v2.image.resize(tf.expand_dims(x, -1),
tf.shape(y[0])[:2],
antialias=True)[..., 0]
resize = Lambda(resize_fn)
apmask = ms.apply_mask()
loss_layer = ms.loss_l(1 / len(vgg.outputs))
gram_layer = ms.gram_l(0)
mask_gram_layer = ms.mask_gram_l()
vgg_a = vgg(style_input)
vgg_b = vgg(render_input)
losses = []
for a, b in zip(vgg_a, vgg_b):
mask = resize([mask_input, a])
a = apmask([a, mask])
loss = loss_layer([gram_layer(a), gram_layer(b)])
losses.append(loss)
loss = Lambda(lambda x: tf.expand_dims(tf.reduce_sum(x), 0))(losses)
var = mv.build({"weight": smooth, "power": 1.25})
var_loss = var(Lambda(lambda x: tf.expand_dims(x, -1))(mask_input))
loss = Lambda(lambda x: x[0] + x[1])([loss, var_loss])
mean_loss = Lambda(lambda x: tf.square(tf.reduce_mean(x) - 1) * mean)(
mask_input)
loss = Lambda(lambda x: x[0] + x[1])([loss, mean_loss])
self.style_map_model = Model([mask_input, style_input, render_input],
[loss])
def _create_tfclassifier():
"""
To create a simple TensorFlowClassifier for testing.
:return:
"""
import tensorflow as tf
if tf.__version__[0] == "2":
import tensorflow.compat.v1 as tf
tf.disable_eager_execution()
# Define input and output placeholders
input_ph = tf.placeholder(tf.float32, shape=[None, 28, 28, 1])
labels_ph = tf.placeholder(tf.int32, shape=[None, 10])
# Define the TensorFlow graph
conv = tf.layers.conv2d(input_ph, 4, 5, activation=tf.nn.relu)
conv = tf.layers.max_pooling2d(conv, 2, 2)
fc = tf.layers.flatten(conv)
# Logits layer
logits = tf.layers.dense(fc, 10)
# Train operator
loss = tf.reduce_mean(
tf.losses.softmax_cross_entropy(logits=logits,
onehot_labels=labels_ph))
optimizer = tf.train.AdamOptimizer(learning_rate=0.01)
train = optimizer.minimize(loss)
# TensorFlow session and initialization
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# Create the classifier
tfc = TensorFlowClassifier(
input_ph=input_ph,
output=logits,
labels_ph=labels_ph,
train=train,
loss=loss,
learning=None,
sess=sess,
clip_values=(0, 1),
)
return tfc
def solve(self, divergence, domain, pressure_guess):
assert isinstance(domain, FluidDomain)
active_mask = domain.active_tensor(extend=1)
fluid_mask = domain.accessible_tensor(extend=1)
dimensions = list(divergence.shape[1:-1])
N = int(np.prod(dimensions))
if math.choose_backend(divergence).matches_name('TensorFlow'):
import tensorflow as tf
if tf.__version__[0] == '2':
print('Adjusting for tensorflow 2.0')
tf = tf.compat.v1
tf.disable_eager_execution()
sidx, sorting = sparse_indices(dimensions)
sval_data = sparse_values(dimensions, active_mask, fluid_mask,
sorting)
A = tf.SparseTensor(indices=sidx,
values=sval_data,
dense_shape=[N, N])
else:
A = sparse_pressure_matrix(dimensions, active_mask, fluid_mask)
if self.autodiff:
return sparse_cg(divergence,
A,
self.max_iterations,
pressure_guess,
self.accuracy,
back_prop=True)
else:
def pressure_gradient(op, grad):
return sparse_cg(grad, A, max_gradient_iterations, None,
self.gradient_accuracy)[0]
pressure, iteration = math.with_custom_gradient(
sparse_cg, [
divergence, A, self.max_iterations, pressure_guess,
self.accuracy
],
pressure_gradient,
input_index=0,
output_index=0,
name_base='scg_pressure_solve')
max_gradient_iterations = iteration if self.max_gradient_iterations == 'mirror' else self.max_gradient_iterations
return pressure, iteration
def run_eager_execution():
tf.enable_eager_execution()
tensor = tf.range(10)
tf.print("tensors:", tensor, output_stream=sys.stdout)
# tensors: [0 1 2 ... 7 8 9]
print(np.square(tensor))
# [ 0 1 4 9 16 25 36 49 64 81]
tensor = tf.square(tensor)
tf.print("tensors:", tensor, output_stream=sys.stdout)
# tensors: [0 1 4 ... 49 64 81]
tf.disable_eager_execution()
return
def test_pytorch_in_tensorflow_eager_mode():
tf.enable_eager_execution()
tfe = tf.contrib.eager
def pytorch_expr(a, b):
return 3 * a + 4 * b * b
x = tfpyth.eager_tensorflow_from_torch(pytorch_expr)
assert tf.math.equal(
x(tf.convert_to_tensor(1.0), tf.convert_to_tensor(3.0)), 39.0)
dx = tfe.gradients_function(x)
assert all(
tf.math.equal(dx(tf.convert_to_tensor(1.0), tf.convert_to_tensor(3.0)),
[3.0, 24.0]))
tf.disable_eager_execution()
def normalise_imgs_in_dir(dir_name: str, target_max_length: int = 512) -> None:
'''
:param dir_name: dir name of images to be normalised
:param target_max_length: images will be resize to target_max_length*target_max_length
:return: None
'''
tf.enable_eager_execution()
imgs = os.listdir(os.path.join(path_base, dir_name))
for i in imgs:
img = cv2.imread(os.path.join(path_base, dir_name,
i)).astype(np.float32)
result_img = tf.image.resize_image_with_pad(img, target_max_length,
target_max_length)
result_img = np.array(result_img, dtype=np.uint8)
cv2.imwrite(os.path.join(path_base, dir_name, i), result_img)
print(i)
tf.disable_eager_execution()
def setUp(self) -> None:
if check_for_tf_graph_backend():
import tensorflow as tf
tf.disable_eager_execution()
from delira.training import TfGraphExperiment
config = DeliraConfig()
config.fixed_params = {
"model": {},
"training": {
"losses": {
"CE":
tf.losses.softmax_cross_entropy},
"optimizer_cls": tf.train.AdamOptimizer,
"optimizer_params": {"learning_rate": 1e-3},
"num_epochs": 2,
"metrics": {"mae": mean_absolute_error},
"lr_sched_cls": None,
"lr_sched_params": {}}
}
model_cls = DummyNetworkTfGraph
experiment_cls = TfGraphExperiment
else:
config = None
model_cls = None
experiment_cls = None
len_train = 100
len_test = 50
self._test_cases = [
{
"config": config,
"network_cls": model_cls,
"len_train": len_train,
"len_test": len_test,
"key_mapping": {"data": "data"},
}
]
self._experiment_cls = experiment_cls
super().setUp()
def get_num_samples(record_dir):
"""
get tfrecord numbers
:param record_file:
:return:
"""
# check record file format
# record_list = glob.glob(os.path.join(self.record_dir, '*.record'))
file_pattern = os.path.join(record_dir, '*.record')
input_files = tf.io.gfile.glob(file_pattern)
num_samples = 0
print("counting number of sample, please waiting...")
# convert to dynamic mode
tf.enable_eager_execution()
for _ in tf.data.TFRecordDataset(input_files):
num_samples += 1
# recover to static mode
tf.disable_eager_execution()
return num_samples
def load_graph(model_path):
# check tf version to be compatible with TF 2.x
global tf
if tf.__version__.startswith('2'):
import tensorflow.compat.v1 as tf
tf.disable_eager_execution()
# We parse the graph_def file
with tf.gfile.GFile(model_path, "rb") as f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(f.read())
# We load the graph_def in the default graph
with tf.Graph().as_default() as graph:
tf.import_graph_def(graph_def,
input_map=None,
return_elements=None,
name="graph",
op_dict=None,
producer_op_list=None)
return graph
def test_increase_frequency(self, name, flatten):
tf.disable_eager_execution()
x = np.array([1.0, 0.1123, 0.7463], dtype=np.float32)
dim = 3
# pylint:disable=bad-whitespace
expected = [
[0, -1, 0, 1, 0, 1 ],
[0.345528, 0.938409, 0.648492, 0.761221, 0.987292, 0.158916],
[0.715278, -0.69884, -0.99973, -0.0232457, 0.0464788, -0.998919]
]
# pylint:enable=bad-whitespace
expected = np.array(expected, dtype=np.float32)
if flatten:
expected = np.reshape(expected, [-1])
y = math_util.increase_frequency(
tf.constant(x, dtype=tf.float32), dim, flatten=flatten, interleave=True)
with self.session() as sess:
out = sess.run(y)
distance = float(np.sum(np.abs(expected - out)))
self.assertLess(distance, FLOAT_DISTANCE_EPS,
f'Expected {expected} but got {out}')
import contextlib
import logging
import os
import threading
import numpy as np
import tensorflow as tf
if tf.__version__[0] == '2':
logging.info('Adjusting for tensorflow 2.0')
tf = tf.compat.v1
tf.disable_eager_execution()
from phi import struct
from .profiling import Timeliner
from .util import isplaceholder, istensor
class Session(object):
def __init__(self, scene, session=None):
self._scene = scene
self._session = session if session is not None else tf.Session()
assert self._session.graph == tf.get_default_graph(
), 'Session %s does not reference the current TensorFlow graph.'
self.graph = tf.get_default_graph()
self.summary_writers = {}
self.summary_directory = os.path.abspath(
scene.subpath('summary')) if scene is not None else None
self.profiling_directory = scene.subpath(
"profile") if scene is not None else None
self.trace_count = 0
self.saver = None
def __setstate__(self, state):
"""
Use to ensure `TensorFlowClassifier` can be unpickled.
:param state: State dictionary with instance parameters to restore.
:type state: `dict`
"""
self.__dict__.update(state)
# Load and update all functionality related to TensorFlow
# pylint: disable=E0611, E0401
import os
import tensorflow as tf
if tf.__version__[0] == '2':
import tensorflow.compat.v1 as tf
tf.disable_eager_execution()
from tensorflow.python.saved_model import tag_constants
from art import DATA_PATH
full_path = os.path.join(DATA_PATH, state['model_name'])
graph = tf.Graph()
sess = tf.Session(graph=graph)
loaded = tf.saved_model.loader.load(sess, [tag_constants.SERVING],
full_path)
# Recover session
self._sess = sess
# Recover input_ph
input_tensor_name = loaded.signature_def['predict'].inputs[
'SavedInputPhD'].name
self._input_ph = graph.get_tensor_by_name(input_tensor_name)
# Recover output layer
self._output = graph.get_tensor_by_name(state['_output'])
# Recover labels' placeholder if any
if state['_labels_ph'] is not None:
self._labels_ph = graph.get_tensor_by_name(state['_labels_ph'])
# Recover loss if any
if state['_loss'] is not None:
self._loss = graph.get_tensor_by_name(state['_loss'])
# Recover loss_grads if any
if state['_loss_grads']:
self._loss_grads = graph.get_tensor_by_name(state['_loss_grads'])
else:
self.__dict__.pop('_loss_grads', None)
# Recover learning if any
if state['_learning'] is not None:
self._learning = graph.get_tensor_by_name(state['_learning'])
# Recover train if any
if state['_train'] is not None:
self._train = graph.get_operation_by_name(state['_train'])
# Recover class_grads if any
if state['_class_grads']:
self._class_grads = [
ts if ts is None else graph.get_tensor_by_name(ts)
for ts in state['_class_grads']
]
else:
self.__dict__.pop('_class_grads', None)
self.__dict__.pop('model_name', None)
def __init__(self,
input_ph,
output,
labels_ph=None,
train=None,
loss=None,
learning=None,
sess=None,
channel_index=3,
clip_values=None,
defences=None,
preprocessing=(0, 1)):
"""
Initialization specific to TensorFlow models implementation.
:param input_ph: The input placeholder.
:type input_ph: `tf.Placeholder`
:param output: The output layer of the model. This can be logits, probabilities or anything else. Logits
output should be preferred where possible to ensure attack efficiency.
:type output: `tf.Tensor`
:param labels_ph: The labels placeholder of the model. This parameter is necessary when training the model and
when computing gradients w.r.t. the loss function.
:type labels_ph: `tf.Tensor`
:param train: The train tensor for fitting, including an optimizer. Use this parameter only when training the
model.
:type train: `tf.Tensor`
:param loss: The loss function for which to compute gradients. This parameter is necessary when training the
model and when computing gradients w.r.t. the loss function.
:type loss: `tf.Tensor`
:param learning: The placeholder to indicate if the model is training.
:type learning: `tf.Placeholder` of type bool.
:param sess: Computation session.
:type sess: `tf.Session`
:param channel_index: Index of the axis in data containing the color channels or features.
:type channel_index: `int`
:param clip_values: Tuple of the form `(min, max)` of floats or `np.ndarray` representing the minimum and
maximum values allowed for features. If floats are provided, these will be used as the range of all
features. If arrays are provided, each value will be considered the bound for a feature, thus
the shape of clip values needs to match the total number of features.
:type clip_values: `tuple`
:param defences: Defences to be activated with the classifier.
:type defences: `str` or `list(str)`
:param preprocessing: Tuple of the form `(subtractor, divider)` of floats or `np.ndarray` of values to be
used for data preprocessing. The first value will be subtracted from the input. The input will then
be divided by the second one.
:type preprocessing: `tuple`
"""
# pylint: disable=E0401
import tensorflow as tf
if tf.__version__[0] == '2':
import tensorflow.compat.v1 as tf
tf.disable_eager_execution()
super(TensorFlowClassifier, self).__init__(clip_values=clip_values,
channel_index=channel_index,
defences=defences,
preprocessing=preprocessing)
self._nb_classes = int(output.get_shape()[-1])
self._input_shape = tuple(input_ph.get_shape().as_list()[1:])
self._input_ph = input_ph
self._output = output
self._labels_ph = labels_ph
self._train = train
self._loss = loss
self._learning = learning
self._feed_dict = {}
# Assign session
if sess is None:
raise ValueError("A session cannot be None.")
self._sess = sess
# Get the internal layers
self._layer_names = self._get_layers()
# Get the loss gradients graph
if self._loss is not None:
self._loss_grads = tf.gradients(self._loss, self._input_ph)[0]
def test_tf_keras_eager_env(out_dir):
tf.enable_eager_execution()
train_model(out_dir, eager=False, steps=["train"])
tf.disable_eager_execution()
