def make_graph(fc_weights):
graph = tf.Graph()
with graph.as_default():
outfeed_queue = ipu_outfeed_queue.IPUOutfeedQueue()
fc, weights["init_weights"] = create_sparse_layers(opts, fc_weights)
model_op = partial(model,
fc=fc,
opts=opts,
outfeed_queue=outfeed_queue,
dtype=dtype)
with tf.device("cpu"):
x_fc = tf.placeholder(dtype,
shape=[opts.batchsize, opts.input_size])
with ipu_scope('/device:IPU:0'):
test_op = ipu_compiler.compile(model_op, inputs=[x_fc])
with tf.device("cpu"):
fc.create_placeholders()
with ipu_scope('/device:IPU:0'):
upload_sparse = build_update_op(fc)
sparse_feed = {}
sparse_feed.update(fc.feed_dict())
dequeue = outfeed_queue.dequeue()
ipu.utils.move_variable_initialization_to_cpu()
return graph, outfeed_queue, fc, x_fc, test_op, upload_sparse, dequeue
def testSendScalar(self, dtype):
with self.session() as sess:
def device_fn(x):
return gen_sendrecv_ops.ipu_send_to_host(
x,
tensor_name="test_tensor",
send_device="/device:IPU:0",
send_device_incarnation=0,
recv_device="/device:CPU:0")
inputs = array_ops.placeholder(dtype=dtype, shape=())
with ipu_scope("/device:IPU:0"):
send_op = ipu_compiler.compile(device_fn, inputs=[inputs])
with ops.device("/device:CPU:0"):
recv_op = gen_sendrecv_ops.ipu_recv_at_host(
T=dtype,
tensor_name="test_tensor",
send_device="/device:IPU:0",
send_device_incarnation=0,
recv_device="/device:CPU:0")
opts = utils.create_ipu_config()
utils.configure_ipu_system(opts)
sent, received = sess.run([send_op, recv_op],
feed_dict={inputs: 1})
self.assertIsNone(sent) # Send op has no output
self.assertEqual(dtype, received.dtype)
self.assertEqual(0, len(received.shape))
self.assertEqual(1, received)
def training_graph(opts, training_data):
train_graph = tf.Graph()
with train_graph.as_default():
dataset, train_iterator, placeholders = training_data.get_dataset(
opts, is_training=True)
infeed = ipu_infeed_queue.IPUInfeedQueue(dataset)
with ipu_scope('/device:IPU:0'):
def comp_fn():
def body(total_loss_, sum_rmse_metric, *args, **kwargs):
data_tensors = args
observed_ratings = data_tensors[0]
loss, rmse_metric, apply_grads_ = graph_builder(opts,
observed_ratings=observed_ratings,
learning_rate=placeholders["learning_rate"],
type='TRAIN')
with tf.control_dependencies([apply_grads_]):
return total_loss_ + loss, sum_rmse_metric + rmse_metric
return loops.repeat(opts.batches_per_step,
body,
[tf.constant(0, tf.float32),
tf.constant(0, tf.float32)],
infeed)
total_loss, sum_rmse_metric = ipu_compiler.compile(comp_fn, [])
rmse = sum_rmse_metric / opts.batches_per_step
loss = total_loss / opts.batches_per_step
tf.summary.scalar("loss", loss)
tf.summary.scalar("learning_rate", placeholders["learning_rate"])
tf.summary.scalar("RMSE/train", rmse)
train_summary = tf.summary.merge_all()
train_saver = tf.train.Saver()
ipu_utils.move_variable_initialization_to_cpu()
train_init = tf.global_variables_initializer()
train_writer = tf.summary.FileWriter(
opts.logs_path + '/train',
graph=train_graph,
flush_secs=30)
ipu_options = util.get_config(opts)
ipu_options.configure_ipu_system()
train_sess = tf.Session(graph=train_graph)
return GraphOps(train_graph,
train_sess,
train_init,
[loss, train_summary, rmse],
placeholders,
infeed,
train_saver,
train_writer)
def body(img):
with scopes.ipu_scope('/device:IPU:0'):
if mode == 'sharded':
with autoshard.ipu_autoshard():
probs = tf.import_graph_def(
network.optimized_graph,
input_map={network.graph_input: img},
name="optimized",
return_elements=[network.graph_output])[0]
autoshard.automatic_sharding(num_shards=num_ipus,
input_ts=img,
loss_ts=probs,
frozen_inference=True)
outfeed_op = outfeed_queue.enqueue(probs)
outfeed_op._set_attr(
sharding._XLA_SHARDING,
attr_value_pb2.AttrValue(
s=probs.op.get_attr('_XlaSharding')))
else:
probs = tf.import_graph_def(
network.optimized_graph,
input_map={network.graph_input: img},
name="optimized",
return_elements=[network.graph_output])[0]
outfeed_op = outfeed_queue.enqueue(probs)
# Note that enqueue happens on the IPU.
return outfeed_op
def device_fn(x):
with ipu_scope("/device:IPU:0"):
x = x * x
with outside_compilation_scope():
y = constant_op.constant(2.0, dtype=dtypes.float32)
z = constant_op.constant(3.0, dtype=dtypes.float32)
return x + y + z
def validation_graph(model, opts):
valid_graph = tf.Graph()
with valid_graph.as_default():
# datasets must be defined outside the ipu device scope
valid_iterator = ipu_infeed_queue.IPUInfeedQueue(
dataset.data(opts, is_training=False),
feed_name='validation_feed',
replication_factor=opts['replicas'] * opts['shards'])
with ipu_scope('/device:IPU:0'):
def comp_fn():
def body(total_accuracy, image, label):
accuracy = validation_graph_builder(
model, image, label, opts)
return total_accuracy + (
tf.cast(accuracy, tf.float32) /
opts["validation_batches_per_step"])
accuracy = loops.repeat(
int(opts["validation_batches_per_step"]), body,
[tf.constant(0, tf.float32)], valid_iterator)
if opts['replicas'] > 1:
accuracy = cross_replica_ops.cross_replica_sum(
accuracy) / (opts['replicas'] * opts['shards'])
return accuracy
(accuracy, ) = xla.compile(comp_fn, [])
accuracy = 100 * accuracy
valid_saver = tf.train.Saver()
ipu.utils.move_variable_initialization_to_cpu()
valid_init = tf.global_variables_initializer()
globalAMP = None
if opts["available_memory_proportion"] and len(
opts["available_memory_proportion"]) == 1:
globalAMP = opts["available_memory_proportion"][0]
ipu_options = get_config(
ipu_id=opts["select_ipu"],
prng=not opts["no_stochastic_rounding"],
shards=1,
number_of_replicas=opts['replicas'] * opts['shards'],
max_cross_replica_buffer_size=opts["max_cross_replica_buffer_size"],
fp_exceptions=opts["fp_exceptions"],
xla_recompute=opts["xla_recompute"],
seed=opts["seed"],
profile=opts['profile'],
availableMemoryProportion=globalAMP,
stable_norm=opts["stable_norm"])
ipu.utils.configure_ipu_system(ipu_options)
valid_sess = tf.Session(graph=valid_graph, config=tf.ConfigProto())
return train.GraphOps(valid_graph, valid_sess, valid_init, [accuracy],
None, valid_iterator, None, valid_saver, None)
def device_fn(x):
with ipu_scope("/device:IPU:0"):
x = x * x
with outside_compilation_scope():
logging_ops.print_v2(x,
output_stream=sys.stdout,
end="")
return x
def device_fn(x):
with ipu_scope("/device:IPU:0"):
x *= x
with outside_compilation_scope():
a = x + 1.0
b = x + 1.0
x = a + b
x += 1.0
return x
def validation_graph(opts, valid_data):
# Do not apply dropout during validation
opts.apply_dropout = False
valid_graph = tf.Graph()
tf_device_ordinal = 0 if opts.multiprocessing else 1
with valid_graph.as_default():
dataset, _, _ = valid_data.get_dataset(opts, is_training=False)
infeed = ipu_infeed_queue.IPUInfeedQueue(
dataset, device_ordinal=tf_device_ordinal)
with ipu_scope('/device:IPU:{}'.format(tf_device_ordinal)):
def comp_fn():
def body(sum_rmse_metric, *args, **kwargs):
data_tensors = args
observed_ratings, ground_truth = tf.split(
data_tensors[0], num_or_size_splits=2, axis=1)
rmse_metric = graph_builder(opts,
observed_ratings=observed_ratings,
ground_truth=ground_truth,
type='VALID')
return sum_rmse_metric + rmse_metric
return loops.repeat(opts.validation_batches_per_step,
body,
[tf.constant(0, tf.float32)],
infeed)
(sum_rmse_metric,) = ipu_compiler.compile(comp_fn, [])
# Accuracy Ops
rmse = sum_rmse_metric / opts.validation_batches_per_step
valid_summary = tf.summary.scalar("RMSE/validation", rmse)
valid_saver = tf.train.Saver()
ipu_utils.move_variable_initialization_to_cpu()
valid_init = tf.global_variables_initializer()
valid_writer = tf.summary.FileWriter(
opts.logs_path + '/valid',
graph=valid_graph,
flush_secs=30)
ipu_options = util.get_config(opts)
if opts.multiprocessing:
ipu_options.configure_ipu_system()
valid_sess = tf.Session(graph=valid_graph)
return GraphOps(valid_graph,
valid_sess,
valid_init,
[rmse, valid_summary],
None,
infeed,
valid_saver,
valid_writer)
def device_fn(x):
with ipu_scope("/device:IPU:0"):
x = math_ops.cast(x * x, dtype=dtype)
with outside_compilation_scope():
# Use float64 which is not supported on IPU
x = math_ops.cast(x, dtype=dtypes.float64)
x *= constant_op.constant(2.0, dtype=dtypes.float64)
x = math_ops.cast(x, dtype=dtype)
x += constant_op.constant(2, dtype=dtype)
return x
def device_fn(x):
with ipu_scope("/device:IPU:0"):
x *= 2.0
with outside_compilation_scope():
x *= 2.0
x *= 2.0
with outside_compilation_scope():
x *= 2.0
x *= 2.0
return x
def device_fn(x1, x2):
with ipu_scope("/device:IPU:0"):
x1 *= x1
x2 *= x2
with outside_compilation_scope():
x1 += 1.0
x2 += 2.0
x1 *= 1.0
x2 *= 2.0
return x1, x2
def body(img):
with scopes.ipu_scope('/device:IPU:0'):
probs = tf.import_graph_def(
network.optimized_graph,
input_map={network.graph_input: img},
name="optimized",
return_elements=[network.graph_output])[0]
outfeed_op = outfeed_queue.enqueue(probs)
# Note that enqueue happens on the IPU.
return outfeed_op
def test_log_twice_not_supported(self):
hook = IPULoggingTensorHook(at_end=True)
with ipu_scope("/device:IPU:0"):
t = constant_op.constant(0.0)
hook.log(t)
with self.assertRaisesRegex(
RuntimeError,
"Cannot use this hook object's log function more than once"
):
return hook.log(t)
def without_outside_scope(x1, x2):
with ipu_scope("/device:IPU:0"):
x1 *= 1.0
x2 *= 2.0
y1 = constant_op.constant(1.0, dtype=dtypes.float32)
y1 += x1
y2 = constant_op.constant(2.0, dtype=dtypes.float32)
y2 += x2
x1 += y1
x2 += y2
return x1, x2
def testResetSeed(self):
# The dataset for feeding the graphs
ds = dataset_ops.Dataset.from_tensors(
array_ops.constant(1.0, shape=[SIZE]))
ds = ds.map(lambda x: [x, x])
ds = ds.repeat()
# The host side queues
infeed_queue = ipu_infeed_queue.IPUInfeedQueue(
ds, feed_name="infeed", replication_factor=REPLICAS)
outfeed_queue = ipu_outfeed_queue.IPUOutfeedQueue(
feed_name="outfeed", replication_factor=REPLICAS)
# The device side
def body(x1, x2):
d1 = rand_ops.dropout(x1)
d2 = rand_ops.dropout(x2)
outfeed = outfeed_queue.enqueue({'d1': d1, 'd2': d2})
return outfeed
def my_net():
r = loops.repeat(REPEATS, body, [], infeed_queue)
return r
with scopes.ipu_scope('/device:IPU:0'):
res = ipu_compiler.compile(my_net, inputs=[])
# The outfeed dequeue has to happen after the outfeed enqueue
dequeue_outfeed = outfeed_queue.dequeue()
# Configure the hardware
config = utils.create_ipu_config(profiling=True)
config = utils.auto_select_ipus(config, REPLICAS)
config = utils.set_floating_point_behaviour_options(config)
utils.configure_ipu_system(config)
with session.Session() as sess:
res_all = set()
total = 0
sess.run(infeed_queue.initializer)
for _ in range(EXECS):
sess.run(res)
outfed_result = sess.run(dequeue_outfeed)
for r in np.array(list(outfed_result.values())).reshape(
[-1, SIZE]):
total += 1
res_all.add(r.tostring())
# 2 dropouts per replica * REPLICAS * REPEATS * EXECS
expected = 2 * REPLICAS * REPEATS * EXECS
self.assertEqual(total, expected)
self.assertEqual(len(res_all), expected)
def generic_train_graph(opts, is_training):
data_type = 'float32'
train_graph = tf.Graph()
with train_graph.as_default():
placeholders = {}
placeholders["learning_rate"] = tf.compat.v1.placeholder(data_type, shape=[])
uid_embedding, mid_embedding, cat_embedding = id_embedding(opts, is_training, seed)
if opts['use_synthetic_data']:
dataset_train = get_synthetic_dataset(opts)
else:
dataset_train = get_dataset_embed(opts, is_training=True)
infeed_train = ipu_infeed_queue.IPUInfeedQueue(dataset_train, feed_name = 'DIN_dataset_infeed_train', replication_factor = (opts['replicas']))
with ipu_scope('/device:IPU:0'):
def comp_fn():
def body(total_loss, total_aux_loss, total_accuracy, uids, mids, cats, mid_his, cat_his, mid_mask, target, seqlen):
prob, loss, aux_loss, accuracy, grad_op = graph_builder(opts, uid_embedding, mid_embedding, cat_embedding, placeholders['learning_rate'], uids, mids, cats, mid_his, cat_his, mid_mask, target, seqlen, use_negsampling=False)
with tf.control_dependencies([grad_op]):
return total_loss + loss, total_aux_loss + aux_loss, total_accuracy + accuracy
return loops.repeat(opts['batches_per_step'], body, [tf.constant(0, getattr(np, 'float32'))] * 3, infeed_train)
outputs_train = ipu_compiler.compile(comp_fn, [])
avg_loss, avg_aux_loss, avg_accuracy = [x / opts['batches_per_step'] for x in outputs_train]
outfeed = None
saver = tf.compat.v1.train.Saver()
utils.move_variable_initialization_to_cpu()
init = tf.compat.v1.global_variables_initializer()
if opts['use_ipu_model']:
os.environ["TF_POPLAR_FLAGS"] = "--use_ipu_model"
ipu_options = utils.create_ipu_config()
ipu_options = utils.set_optimization_options(ipu_options,
combine_embedding_lookups=True)
ipu_options = utils.set_recomputation_options(ipu_options, allow_recompute=True)
ipu_options = utils.auto_select_ipus(ipu_options, [opts['replicas']])
utils.configure_ipu_system(ipu_options)
if seed is not None:
utils.reset_ipu_seed(seed)
ops_train = [avg_loss, avg_aux_loss, avg_accuracy]
sess = tf.compat.v1.Session(graph=train_graph)
return GraphOps(sess,
init,
ops_train,
placeholders,
infeed_train,
outfeed,
saver), uid_embedding, mid_embedding, cat_embedding
def training_graph(model, opts, iterations_per_step=1):
train_graph = tf.Graph()
with train_graph.as_default():
placeholders = dict()
datatype = tf.float16 if opts["precision"].split(
'.') == '16' else tf.float32
placeholders['learning_rate'] = tf.placeholder(datatype, shape=[])
learning_rate = placeholders['learning_rate']
# datasets must be defined outside the ipu device scope
train_iterator = ipu_infeed_queue.IPUInfeedQueue(
dataset.data(opts, is_training=True),
feed_name='training_feed',
replication_factor=opts['replicas'])
outfeed_queue = ipu_outfeed_queue.IPUOutfeedQueue(
feed_name="outfeed", replication_factor=opts['replicas'])
with ipu_scope('/device:IPU:0'):
train = training_step_with_infeeds_and_outfeeds(
train_iterator, outfeed_queue, model, opts, learning_rate,
iterations_per_step)
outfeed = outfeed_queue.dequeue()
logging.print_trainable_variables(opts)
train_saver = tf.train.Saver(max_to_keep=999999)
ipu.utils.move_variable_initialization_to_cpu()
train_init = tf.global_variables_initializer()
globalAMP = None
if opts["available_memory_proportion"] and len(
opts["available_memory_proportion"]) == 1:
globalAMP = opts["available_memory_proportion"][0]
ipu_options = get_config(
ipu_id=opts["select_ipu"],
prng=not opts["no_stochastic_rounding"],
shards=opts["shards"],
number_of_replicas=opts['replicas'],
max_cross_replica_buffer_size=opts["max_cross_replica_buffer_size"],
fp_exceptions=opts["fp_exceptions"],
xla_recompute=opts["xla_recompute"],
seed=opts["seed"],
availableMemoryProportion=globalAMP)
ipu.utils.configure_ipu_system(ipu_options)
train_sess = tf.Session(graph=train_graph, config=tf.ConfigProto())
return GraphOps(train_graph, train_sess, train_init, [train], placeholders,
train_iterator, outfeed, train_saver)
def device_fn(x):
with ipu_scope("/device:IPU:0"):
x *= x # 4
with outside_compilation_scope():
y = x + 1.0 # 5
# Use `x` after receiving `y` and make sure that we still have the correct
# value of `x` (i.e. it is not overwritten by the receive, in which case
# we would get 25).
z = x * y # 20
return z
def device_fn(x):
with ipu_scope("/device:IPU:0"):
x = x + x
with outside_compilation_scope():
# Use float64 which is not supported on IPU
x = math_ops.cast(x, dtype=dtypes.float64)
c = constant_op.constant(2.0,
dtype=dtypes.float64,
shape=(2, ))
x += c
x = math_ops.cast(x, dtype=dtypes.float32)
x = x + 2.0
return x
def testSendFromTwoEngines(self):
with self.session() as sess:
def make_device_fn(i):
def device_fn(x):
return gen_sendrecv_ops.ipu_send_to_host(
x,
tensor_name="tensor_{}".format(i),
send_device="/device:IPU:0",
send_device_incarnation=0,
recv_device="/device:CPU:0")
return device_fn
input_1 = array_ops.placeholder(dtype=dtypes.float32, shape=())
input_2 = array_ops.placeholder(dtype=dtypes.float32, shape=())
with ipu_scope("/device:IPU:0"):
send_1 = ipu_compiler.compile(make_device_fn(1),
inputs=[input_1])
send_2 = ipu_compiler.compile(make_device_fn(2),
inputs=[input_2])
with ops.device("/device:CPU:0"):
recv_1 = gen_sendrecv_ops.ipu_recv_at_host(
T=dtypes.float32,
tensor_name="tensor_1",
send_device="/device:IPU:0",
send_device_incarnation=0,
recv_device="/device:CPU:0")
recv_2 = gen_sendrecv_ops.ipu_recv_at_host(
T=dtypes.float32,
tensor_name="tensor_2",
send_device="/device:IPU:0",
send_device_incarnation=0,
recv_device="/device:CPU:0")
opts = utils.create_ipu_config()
utils.configure_ipu_system(opts)
# Test it a couple of times to verify the communication channel is reusable.
for i in range(2):
_, _, result_1, result_2 = sess.run(
[send_1, send_2, recv_1, recv_2],
feed_dict={
input_1: i,
input_2: i + 1
})
self.assertEqual(i, result_1)
self.assertEqual(i + 1, result_2)
def build_train_op(previous_loss, *infeed_data):
"""Construct loss and optimizer."""
with ipu_scope("/device:IPU:0"):
action_prob = create_policy(*infeed_data)
loss = tf.reduce_sum(action_prob * infeed_data[-2])
opt = tf.train.GradientDescentOptimizer(LEARNING_RATE)
if args.accumulate_grad:
opt = gradient_accumulation_optimizer.GradientAccumulationOptimizer(
opt, num_mini_batches=args.num_mini_batches)
opt = cross_replica_optimizer.CrossReplicaOptimizer(opt)
train_op = opt.minimize(loss)
with tf.control_dependencies([train_op]):
loss = tf.identity(loss)
return previous_loss + loss
def train():
graph = tf.Graph()
with graph.as_default():
dataset = tf.data.Dataset.from_tensors(tf.constant(1, shape=[]))
# dataset = tf.data.Dataset.from_tensors(np.array([1,2,3,4,5,6,7,8,9,0]))
dataset = dataset.map(lambda x: [x, x])
dataset = dataset.batch(BS, drop_remainder=True)
dataset = dataset.repeat()
infeed_queue = ipu_infeed_queue.IPUInfeedQueue(get_data_set(),
feed_name="infeed")
outfeed_queue = ipu_outfeed_queue.IPUOutfeedQueue(feed_name='outfeed')
time_steps_ph = tf.placeholder(tf.int32, shape=[])
with ipu_scope('/device:IPU:0'):
def compile_fn():
def body(x, y):
# z1, z2 = model1(x, y, time_steps_ph)
# outfeed = outfeed_queue.enqueue({'z1':z1, 'z2':z2})
z3 = model2(time_steps_ph)
outfeed = outfeed_queue.enqueue({'z3': z3})
return outfeed
return loops.repeat(1, body, [], infeed_queue)
utils.move_variable_initialization_to_cpu()
init = tf.global_variables_initializer()
outputs = ipu_compiler.compile(compile_fn, [])
dequeue_outfeed = outfeed_queue.dequeue()
ipu_options = utils.create_ipu_config(
profiling=False,
profile_execution=False,
max_cross_replica_sum_buffer_size=10000000,
max_inter_ipu_copies_buffer_size=10000000)
ipu_options = utils.auto_select_ipus(ipu_options, 1)
utils.configure_ipu_system(ipu_options)
utils.reset_ipu_seed(SEED)
sess = tf.Session(graph=graph)
sess.run(init)
sess.run(infeed_queue.initializer)
steps = 6
i = 0
while i < steps:
sess.run(outputs, feed_dict={time_steps_ph: 3})
result = sess.run(dequeue_outfeed)
print(result)
i = i + 1
break
def test_print_tensor(self):
hook = IPULoggingTensorHook(at_end=True)
def model():
t = constant_op.constant(42.0, name="foo")
return hook.log(t)
with ipu_scope("/device:IPU:0"):
compiled_model = ipu_compiler.compile(model)
with test.mock.patch.object(tf_logging, "info", self.mock_log):
with MonitoredTrainingSession(hooks=[hook]) as mon_sess:
mon_sess.run(compiled_model)
self.assertRegex(str(self.logged_message), "foo:0 = 42.0")
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--connection_type",
choices=['ALWAYS', 'ON_DEMAND', 'NEVER'],
help="Specify connection type")
parser.set_defaults(connection_type='ALWAYS')
opts = parser.parse_args()
with tf.device("cpu"):
pa = tf.compat.v1.placeholder(np.float32, [2], name="a")
pb = tf.compat.v1.placeholder(np.float32, [2], name="b")
pc = tf.compat.v1.placeholder(np.float32, [2], name="c")
# Create the IPU section of the graph.
with scopes.ipu_scope("/device:IPU:0"):
out = ipu_compiler.compile(my_graph, [pa, pb, pc])
# Define the feed_dict input data.
fd = {pa: [1., 1.], pb: [0., 1.], pc: [1., 5.]}
# Connection type from options.
connection_type = device_connection_type(opts.connection_type)
cfg = utils.create_ipu_config()
cfg = utils.auto_select_ipus(cfg, 1)
cfg = utils.set_ipu_connection_type(cfg,
connection_type,
1)
utils.configure_ipu_system(cfg)
# Run the session.
# If running with DeviceConnectionType.NEVER then anticipate the
# specific exception with message "configured for compilation only".
with tf.compat.v1.Session() as sess:
try:
result = sess.run(out, fd)
print(result)
except tf.errors.InvalidArgumentError as invalid_arg_exception:
if (connection_type == utils.DeviceConnectionType.NEVER) and \
("configured for compilation only" in invalid_arg_exception.message):
print("Compiled")
pass
else:
print("ERROR: {}".format(invalid_arg_exception.message))
except:
general_exception = sys.exc_info()[0]
print("ERROR: {}".format(general_exception))
def testSyntheticDataWithOutfeeds(self):
poplar_flags = os.environ.get("TF_POPLAR_FLAGS", "")
poplar_flags += " --use_ipu_model"
poplar_flags += " --use_synthetic_data"
poplar_flags += " --synthetic_data_initializer=random"
with test.mock.patch.dict("os.environ", {"TF_POPLAR_FLAGS": poplar_flags}):
# The device side main
def body(x1, x2):
d1 = x1 + x2
d2 = x1 - x2
outfeed = outfeed_queue.enqueue({'d1': d1, 'd2': d2})
return outfeed
def my_net():
r = loops.repeat(5, body, [], infeed_queue)
return r
with ops.device('cpu'):
# The dataset for feeding the graphs
ds = tf.data.Dataset.from_tensors(tf.constant(1.0, shape=[10]))
ds = ds.map(lambda x: [x, x])
ds = ds.repeat()
# The host side queues
infeed_queue = ipu_infeed_queue.IPUInfeedQueue(ds, feed_name="infeed2")
outfeed_queue = ipu_outfeed_queue.IPUOutfeedQueue(feed_name="outfeed2")
with scopes.ipu_scope('/device:IPU:0'):
run_loop = ipu_compiler.compile(my_net, inputs=[])
# The outfeed dequeue has to happen after the outfeed enqueue
dequeue_outfeed = outfeed_queue.dequeue()
# Configure the hardware
config = utils.create_ipu_config()
config = utils.auto_select_ipus(config, 1)
utils.configure_ipu_system(config)
with tf.Session() as sess:
sess.run(infeed_queue.initializer)
sess.run(run_loop)
result = sess.run(dequeue_outfeed)
self.assertAllEqual(len(result['d1']), 0)
def testInput():
config = utils.create_ipu_config()
config = utils.auto_select_ipus(config, 1)
config = utils.create_ipu_config(profiling=True,
use_poplar_text_report=True)
utils.configure_ipu_system(config)
# config = utils.set_convolution_options(config, {"partialsType": str('half')})
# config = utils.set_matmul_options(config, {"partialsType": str('half')})
gdv = tf.Graph()
with gdv.as_default():
g1 = tf.GraphDef()
# Load model with pywrap isntead? https://github.com/graphcore/examples/blob/master/applications/tensorflow/cnns/training/weight_avg.py#L33
with tf.gfile.GFile('model.pb', 'rb') as fid:
serialized_graph = fid.read()
g1.ParseFromString(serialized_graph)
tf.import_graph_def(g1, name='')
with tf.Session(graph=gdv) as sess:
inp_tensor = gdv.get_tensor_by_name('input:0')
out_tensor = gdv.get_tensor_by_name(
'InceptionV3/Predictions/Softmax:0')
image_np = getExamples()
#image_np = getSyntheticExamples()
np.set_printoptions(threshold=np.inf)
import time
tic = time.time()
# This is new and doesn't crash
# But doesn't seem to do anything either
with ipu_scope("/device:IPU:0"):
proba = sess.run(out_tensor, {inp_tensor: image_np})
print(proba)
toc = time.time()
duration = toc - tic
num_images = len(image_np)
print("Total time taken: {0} seconds".format(duration))
print("Number of examples: {0}".format(num_images))
print("Throughput: {0} im/s".format(num_images / duration))
def testSendMatrices(self, dtype):
with self.session() as sess:
L = 3
def device_fn(x):
for i in range(L):
x = math_ops.matmul(x, x)
if i < L - 1:
gen_sendrecv_ops.ipu_send_to_host(
x,
tensor_name="x_{}".format(i),
send_device="/device:IPU:0",
send_device_incarnation=0,
recv_device="/device:CPU:0")
return x
N = 2
inputs = array_ops.placeholder(dtype=dtype, shape=(N, N))
with ipu_scope("/device:IPU:0"):
[device_out] = ipu_compiler.compile(device_fn, inputs=[inputs])
received = []
with ops.device("/device:CPU:0"):
for i in range(L - 1):
received.append(
gen_sendrecv_ops.ipu_recv_at_host(
T=dtype,
tensor_name="x_{}".format(i),
send_device="/device:IPU:0",
send_device_incarnation=0,
recv_device="/device:CPU:0"))
opts = utils.create_ipu_config()
utils.configure_ipu_system(opts)
received_values, device_value = sess.run(
[received, device_out], feed_dict={inputs: np.ones((N, N))})
self.assertAllClose(2 * np.ones((N, N)), received_values[0])
self.assertAllClose(8 * np.ones((N, N)), received_values[1])
self.assertAllClose(128 * np.ones((N, N)), device_value)
def testReportInfoDirCreated0(self):
with self.session() as sess:
tmpdir = tempfile.mkdtemp()
cfg = ipu.utils.create_ipu_config(profiling=True,
use_poplar_text_report=True,
profile_execution=True,
report_directory=tmpdir)
cfg = ipu.utils.set_ipu_model_options(cfg, compile_ipu_code=False)
cfg = ipu.utils.auto_select_ipus(cfg, 1)
ipu.utils.configure_ipu_system(cfg)
with ops.device("cpu"):
pa = array_ops.placeholder(np.float32, [2], name="a")
pb = array_ops.placeholder(np.float32, [2], name="b")
pc = array_ops.placeholder(np.float32, [2], name="c")
def basic_graph(pa, pb, pc):
o1 = pa + pb
o2 = pa + pc
simple_graph_output = o1 + o2
return simple_graph_output
with ipu_scope("/device:IPU:0"):
result = basic_graph(pa, pb, pc)
result = sess.run(result,
feed_dict={
pa: [1., 1.],
pb: [0., 1.],
pc: [1., 5.]
})
tmpdir_files = os.listdir(tmpdir)
self.assertEqual(1, len(tmpdir_files))
tmpdir_sub = tmpdir + "/" + tmpdir_files[0]
tmpdir_sub_files = os.listdir(tmpdir_sub)
self.assertTrue("framework.json" in tmpdir_sub_files)
test_file = tmpdir_sub + "/framework.json"
with open(test_file) as f:
json_txt = json.load(f)
is_j, _ = is_json(json_txt)
self.assertTrue(is_j)
def run_without_ipu_functions(opts, input_values):
g = tf.Graph()
with g.as_default():
with tf.device("cpu"):
input_x = tf.placeholder(np.float32, input_values.shape, name="input_x")
with ipu_scope("/device:IPU:0"):
result = ipu.ipu_compiler.compile(partial(model, opts, False), [input_x])
with tf.device("cpu"):
variables = [var for var in tf.global_variables() if var.name.count("metainfo") == 1]
variables += tf.trainable_variables()
saver = tf.train.Saver(variables)
initializer = tf.global_variables_initializer()
g.finalize()
with tf.Session(graph=g) as sess:
sess.run(initializer)
saver.save(sess, opts.checkpoint_path) # save variables to use in second run
results = sess.run(result, feed_dict={input_x: input_values})
return results