def test_set_backend_invalid(self): try: ngraph_bridge.set_backend('POTATO') error_thrown = False except: error_thrown = True assert error_thrown
def test_set_backend(self): # store env variables # when testing on backends like GPU the tests are run with NGRPAH_TF_BACKEND # by storing and restoring the env_variables we run the tests independent of the backend set # currently we store and restore only the NGRPAH_TF_BACKEND env_var_map = self.store_env_variables() # test ngraph_bridge.enable() backend_cpu = 'CPU' backend_interpreter = 'INTERPRETER' found_cpu = False found_interpreter = False # These will only print when running pytest with flag "-s" print("Number of supported backends ", ngraph_bridge.backends_len()) supported_backends = ngraph_bridge.list_backends() print(" ****** Supported Backends ****** ") for backend_name in supported_backends: print(backend_name) if backend_name == backend_cpu: found_cpu = True if backend_name == backend_interpreter: found_interpreter = True print(" ******************************** ") assert (found_cpu and found_interpreter) == True # Create Graph val = tf.placeholder(tf.float32) out1 = tf.abs(val) out2 = tf.abs(out1) # set INTERPRETER backend assert ngraph_bridge.is_supported_backend(backend_interpreter) == True ngraph_bridge.set_backend(backend_interpreter) currently_set_backend = ngraph_bridge.get_currently_set_backend_name() assert currently_set_backend == backend_interpreter # create new session to execute graph # If you want to re-confirm which backend the graph was executed # currently the only way is to enable NGRAPH_TF_VLOG_LEVEL=5 with tf.Session() as sess: sess.run((out2, ), feed_dict={val: ((1.4, -0.5, -1))}) currently_set_backend = ngraph_bridge.get_currently_set_backend_name() assert currently_set_backend == backend_interpreter # set CPU backend assert ngraph_bridge.is_supported_backend(backend_cpu) == True ngraph_bridge.set_backend(backend_cpu) currently_set_backend = ngraph_bridge.get_currently_set_backend_name() assert currently_set_backend == backend_cpu # create new session to execute graph with tf.Session() as sess: sess.run((out2, ), feed_dict={val: ((1.4, -0.5, -1))}) currently_set_backend = ngraph_bridge.get_currently_set_backend_name() assert currently_set_backend == backend_cpu # restore env_variables self.restore_env_variables(env_var_map)
def test_disable_3(self): old_backend = ngraph_bridge.get_backend() ngraph_bridge.set_backend('CPU') N = 1 C = 4 H = 10 W = 10 FW = 3 FH = 3 O = 6 inp = tf.compat.v1.placeholder(tf.float32, shape=(N, C, H, W)) filt = tf.constant(np.ones((FH, FW, C, O)), dtype=tf.float32) conv = nn_ops.conv2d(inp, filt, strides=[1, 1, 1, 2], padding="SAME", data_format='NCHW') def run_test(sess): return sess.run(conv, feed_dict={inp: np.ones((N, C, H, W))}) # Ensure that NCHW does not run on TF CPU backend natively test_passed = True try: self.without_ngraph(run_test) except: test_passed = False if (test_passed): ngraph_bridge.set_backend(old_backend) assert False, 'Had expected test to raise error, since NCHW in conv2d is not supported' # We have asserted the above network would not run on TF natively. # Now ensure it runs with ngraph test_passed = True try: self.with_ngraph(run_test) except: test_passed = False if (not test_passed): ngraph_bridge.set_backend(old_backend) assert False, 'Had expected test to pass, since NCHW in conv2d is supported through ngraph' # Now disabling Conv2D. Expecting the test to fail, even when run through ngraph ngraph_bridge.set_disabled_ops('Conv2D') test_passed = True try: self.with_ngraph(run_test) except: test_passed = False if (test_passed): ngraph_bridge.set_backend(old_backend) assert False, 'Had expected test to raise error, since conv2D is disabled in ngraph' # Clean up ngraph_bridge.set_backend(old_backend) ngraph_bridge.set_disabled_ops('')
def on_ngraph_change(self, change): if change['type'] == 'change' and change['name'] == 'value': i = self.ngraph_backends.index(change['new']) if self.ngraph_backends[i] == 'DISABLED': self.use_ngraph = False ngraph_bridge.disable() else: self.use_ngraph = True ngraph_bridge.enable() ngraph_bridge.set_backend(self.ngraph_backends[i])
def test_set_backend_invalid(self): env_var_map = self.store_env_variables(["NGRAPH_TF_BACKEND"]) self.unset_env_variable("NGRAPH_TF_BACKEND") current_backend = ngraph_bridge.get_backend() error_thrown = False try: ngraph_bridge.set_backend('POTATO') except: error_thrown = True ngraph_bridge.set_backend(current_backend) self.restore_env_variables(env_var_map) assert error_thrown
def test_set_backend(): ngraph_bridge.enable() backend_cpu = 'CPU' backend_interpreter = 'INTERPRETER' found_cpu = False found_interpreter = False # These will only print when running pytest with flag "-s" print("Number of supported backends ", ngraph_bridge.backends_len()) supported_backends = ngraph_bridge.list_backends() print(" ****** Supported Backends ****** ") for backend_name in supported_backends: print(backend_name) if backend_name == backend_cpu: found_cpu = True if backend_name == backend_interpreter: found_interpreter = True print(" ******************************** ") assert (found_cpu and found_interpreter) == True # Create Graph val = tf.placeholder(tf.float32) out1 = tf.abs(val) out2 = tf.abs(out1) # set INTERPRETER backend assert ngraph_bridge.is_supported_backend(backend_interpreter) == True ngraph_bridge.set_backend(backend_interpreter) currently_set_backend = ngraph_bridge.get_currently_set_backend_name() assert currently_set_backend == backend_interpreter # create new session to execute graph # If you want to re-confirm which backend the graph was executed # currently the only way is to enable NGRAPH_TF_VLOG_LEVEL=5 with tf.Session() as sess: sess.run((out2, ), feed_dict={val: ((1.4, -0.5, -1))}) currently_set_backend = ngraph_bridge.get_currently_set_backend_name() assert currently_set_backend == backend_interpreter # set CPU backend assert ngraph_bridge.is_supported_backend(backend_cpu) == True ngraph_bridge.set_backend(backend_cpu) currently_set_backend = ngraph_bridge.get_currently_set_backend_name() assert currently_set_backend == backend_cpu # create new session to execute graph with tf.Session() as sess: sess.run((out2, ), feed_dict={val: ((1.4, -0.5, -1))}) currently_set_backend = ngraph_bridge.get_currently_set_backend_name() assert currently_set_backend == backend_cpu
def setup_ngraph_bridge(self, backend): # Enviornment variables os.environ['PLAIDML_USE_STRIPE'] = '1' if self.workers < 1: os.environ['OMP_NUM_THREADS'] = 1 else: # Use default if os.getenv('OMP_NUM_THREADS') is not None: del os.environ['OMP_NUM_THREADS'] import ngraph_bridge if backend == 'DISABLED' or backend == 'TF': ngraph_bridge.disable() elif backend == 'CPU': ngraph_bridge.set_backend('CPU') ngraph_bridge.enable() elif backend == 'PLAIDML': ngraph_bridge.set_backend('PLAIDML') ngraph_bridge.enable() else: print("ERROR: Unsupported backend " + backend + " selected.")
def __init__(self, gui=1, training=0, model='ResNet50', backend='INTERPRETER', verbose=1): self.gui = gui self.verbose = verbose self.backend = backend ngraph_bridge.set_backend(self.backend) if gui: self.gui = widgets.VBox(children=[ self.tab, self.progress_box, self.out_initial, self.out, self.out_stats ]) display(self.init_gui()) # Images self.test_class_indices = [] self.test_dir = None self.init_images() self.sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) self.predicted_class_indices_init = [] self.wrong_guesses = [] self.train_button.disabled = False self.fine_tune_button.disabled = False self.init_model() if training: self.train_model(self.train_button, model=model)
def test_command_line_api(self, inp_format, inp_loc, out_node_name, save_ng_clusters, out_format, commandline, ng_device, shape_hints, precompile): # Only run this test when grappler is enabled if not ngraph_bridge.is_grappler_enabled(): return # Store and unset env variable NGRAPH_TF_BACKEND because the test # implicitly tests with different options env_var_map = self.store_env_variables(["NGRAPH_TF_BACKEND"]) self.set_env_variable("NGRAPH_TF_BACKEND", ng_device) ngraph_bridge.set_backend("INTERPRETER") assert Testtf2ngraph.format_and_loc_match(inp_format, inp_loc) out_loc = inp_loc.split('.')[0] + '_modified' + ('' if out_format == 'savedmodel' else ('.' + out_format)) try: (shutil.rmtree, os.remove)[os.path.isfile(out_loc)](out_loc) except: pass conversion_successful = False try: optional_backend_params = { 'CPU': { 'device_config': '0' }, 'INTERPRETER': { 'test_echo': '1' } }[ng_device] config_file_name = 'temp_config_file.json' Tf2ngraphJson.dump_json(config_file_name, optional_backend_params, shape_hints) if commandline: # In CI this test is expected to be run out of artifacts/test/python # out_node_str is empty if out_node_name is None. # Automatic output node inference display diagnostic logs # But the tf2ngraph call will still fail command = [ 'python', '../../tools/tf2ngraph.py', '--input_' + inp_format, inp_loc, '--output_' + out_format, out_loc, '--ng_backend', ng_device, '--config_file', config_file_name ] if out_node_name is not None: command.extend(['--output_nodes', out_node_name]) if precompile: command.append('--precompile') if save_ng_clusters: command.append('--save_ng_clusters') p = Popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE) output, err = p.communicate() rc = p.returncode if out_node_name is None: assert rc != 0, "Call to tf2ngraph should fail when no output name is provided" return else: convert(inp_format, inp_loc, out_format, out_loc, ['out_node'], ng_device, "", optional_backend_params, shape_hints, precompile, save_ng_clusters) file_present = 'ngraph_cluster_0.pbtxt' in os.listdir() assert save_ng_clusters == file_present conversion_successful = True finally: if not conversion_successful: try: (shutil.rmtree, os.remove)[os.path.isfile(out_loc)](out_loc) os.remove(config_file_name) except: pass if save_ng_clusters and 'ngraph_cluster_0.pbtxt' in os.listdir(): os.remove('ngraph_cluster_0.pbtxt') assert conversion_successful gdef = get_gdef(out_format, out_loc) (shutil.rmtree, os.remove)[os.path.isfile(out_loc)](out_loc) os.remove(config_file_name) with tf.Graph().as_default() as g: tf.import_graph_def(gdef, name='') # The graph should have exactly one encapsulate assert len([ 0 for i in g.get_operations() if i.type == 'NGraphEncapsulate' ]) == 1 # TODO: check that the encapsulate op has correct backend and extra params attached to it x = self.get_tensor(g, "x:0", False) y = self.get_tensor(g, "y:0", False) out = self.get_tensor(g, "out_node:0", False) sess_fn = lambda sess: sess.run( [out], feed_dict={i: np.zeros((10, )) for i in [x, y]}) res1 = self.with_ngraph(sess_fn) res2 = self.without_ngraph(sess_fn) exp = [0.5 * np.ones((10, ))] # Note both run on Host (because NgraphEncapsulate can only run on host) assert np.isclose(res1, res2).all() # Comparing with expected value assert np.isclose(res1, exp).all() # Restore env variable NGRAPH_TF_BACKEND that was stored self.restore_env_variables(env_var_map)
class Demo: # Cats & Dogs classes NUM_CLASSES = 2 # RGB CHANNELS = 3 RESNET50_POOLING_AVERAGE = 'avg' DENSE_LAYER_ACTIVATION = 'softmax' OBJECTIVE_FUNCTION = 'categorical_crossentropy' # Common accuracy metric for all outputs, but can use different metrics for different output LOSS_METRICS = ['accuracy'] IMAGE_SIZE = 160 # All images will be resized to 160x160 IMAGE_SHAPE = (IMAGE_SIZE, IMAGE_SIZE, 3) batch_size = 32 epochs = 2 fine_tune_at = 100 ngraph_backends = ngraph_bridge.list_backends() ngraph_backends.append('DISABLED') ngraph_bridge.set_backend(ngraph_backends[0]) base_model = None model = None # GUI Elements out = widgets.Output(layout={'border': '1px solid black'}) out_initial = widgets.Output(layout={'border': '1px solid black'}) out_stats = widgets.Output(layout={'border': '1px solid black'}) model_dropdown = widgets.Dropdown(options=['ResNet50', 'MobileNet v2'], value='ResNet50', description='Model:') ngraph_dropdown = widgets.Dropdown(options=ngraph_backends, value=ngraph_backends[0], description='nGraph:') progress_bar = widgets.IntProgress() progress_text = widgets.Label() epoch_text = widgets.Label() progress_box = widgets.HBox([progress_bar, progress_text, epoch_text]) batch_slider = widgets.IntSlider(min=1, max=100, value=batch_size, description='Batch Size:') epoch_slider = widgets.IntSlider(min=1, max=16, value=epochs, description='Epochs:') fine_tune_slider = widgets.IntSlider(min=1, max=500, value=fine_tune_at, description='Fine Tune at Layer:') train_button = widgets.Button(description='Train', disabled=True) classify_button = widgets.Button(description='Classify', disabled=True) fine_tune_button = widgets.Button(description='Fine Tune', disable=True) shuffle_button = widgets.Button(description='Shuffle') training_tab = widgets.VBox(children=[ model_dropdown, ngraph_dropdown, batch_slider, epoch_slider, train_button, classify_button, shuffle_button ]) fine_tuning_tab = widgets.VBox(children=[ batch_slider, epoch_slider, fine_tune_slider, fine_tune_button, classify_button, shuffle_button ]) tab = widgets.Tab(children=[training_tab, fine_tuning_tab]) tab.set_title(0, 'Training') tab.set_title(1, 'Fine Tuning') gui = widgets.VBox(children=[tab, progress_box, out_initial, out]) def __init__(self, verbose=0, test=0): self.verbose = verbose self.test = test if verbose: self.gui = widgets.VBox(children=[ self.tab, self.progress_box, self.out_initial, self.out, self.out_stats ]) # Images self.test_class_indices = [] self.test_dir = None self.init_images() self.sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) self.predicted_class_indices_init = [] self.wrong_guesses = [] if not test: display(self.init_gui()) self.train_button.disabled = False self.fine_tune_button.disabled = False self.init_model() def init_images(self): zip_file = tf.keras.utils.get_file( origin= "https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip", fname="cats_and_dogs_filtered.zip", extract=True) base_dir, _ = os.path.splitext(zip_file) train_dir = os.path.join(base_dir, 'train') validation_dir = os.path.join(base_dir, 'validation') self.test_dir = os.path.join(base_dir, 'test') if not os.path.exists(self.test_dir): os.makedirs(self.test_dir) # Directory with our training cat pictures train_cats_dir = os.path.join(train_dir, 'cats') # Directory with our training dog pictures train_dogs_dir = os.path.join(train_dir, 'dogs') # Directory with our validation cat pictures validation_cats_dir = os.path.join(validation_dir, 'cats') # Directory with our validation dog pictures validation_dogs_dir = os.path.join(validation_dir, 'dogs') # Directory with our test cat pictures test_cats_dir = os.path.join(self.test_dir, 'cats') if not os.path.exists(test_cats_dir): os.makedirs(test_cats_dir) for i in range(900, 1000): os.rename(train_cats_dir + '/cat.' + str(i) + '.jpg', test_cats_dir + '/cat.' + str(i) + '.jpg') # Directory with our test dog pictures test_dogs_dir = os.path.join(self.test_dir, 'dogs') if not os.path.exists(test_dogs_dir): os.makedirs(test_dogs_dir) for i in range(900, 1000): os.rename(train_dogs_dir + '/dog.' + str(i) + '.jpg', test_dogs_dir + '/dog.' + str(i) + '.jpg') # Preprocess images train_datagen = ImageDataGenerator( preprocessing_function=preprocess_input) validation_datagen = ImageDataGenerator( preprocessing_function=preprocess_input) with self.out_stats: # Flow training images in batches of 20 using train_datagen generator self.train_generator = train_datagen.flow_from_directory( train_dir, # Source directory for the training images target_size=(self.IMAGE_SIZE, self.IMAGE_SIZE), batch_size=self.batch_size, class_mode='categorical') # Flow validation images in batches of 20 using test_datagen generator self.validation_generator = validation_datagen.flow_from_directory( validation_dir, # Source directory for the validation images target_size=(self.IMAGE_SIZE, self.IMAGE_SIZE), batch_size=self.batch_size, class_mode='categorical') # Flow validation images in batches of 20 using test_datagen generator self.test_generator = validation_datagen.flow_from_directory( self.test_dir, # Source directory for the test images target_size=(self.IMAGE_SIZE, self.IMAGE_SIZE), batch_size=self.batch_size, class_mode=None, shuffle=False, seed=42) # Test Correct Values (0 Cat, 1 Dog) for file in self.test_generator.filenames: if "cat" in file: self.test_class_indices.append(0) elif "dog" in file: self.test_class_indices.append(1) else: print("Error, unclassifiable image " + file) def init_model(self, b=None): self.out_initial.clear_output() self.out.clear_output() self.out_stats.clear_output() # Initial prediction self.progress_bar.max = 13 self.progress_text.value = "Calculating Initital Predictions" with self.out: self.compile_model(self.model_dropdown.value) predictions_initial = self.model.predict_generator( self.test_generator, verbose=0, callbacks=[ProgressBar(self)]) self.predicted_class_indices_init = np.argmax(predictions_initial, axis=1) # ~ operator is equivalent to -x-1; so 0 becomes -1, 1 becomes -2; add 2 to implement xnor guesses = ~(self.predicted_class_indices_init ^ self.test_class_indices) + 2 # Randomly select 9 images that guessed incorrectly self.wrong_guesses = [] while len(self.wrong_guesses) < 9: randomIndex = random.randint( 0, len(self.predicted_class_indices_init) - 1) if not guesses[randomIndex]: self.wrong_guesses.append(randomIndex) with self.out_initial: f, ax = plt.subplots(3, 3, figsize=(15, 15)) for i in range(0, 9): test_image = os.path.join( self.test_dir, self.test_generator.filenames[self.wrong_guesses[i]]) imgRGB = mpimg.imread(test_image) predicted_class = "Dog" if self.predicted_class_indices_init[ self.wrong_guesses[i]] else "Cat" ax[i // 3, i % 3].imshow(imgRGB) ax[i // 3, i % 3].axis('off') ax[i // 3, i % 3].set_title("Predicted:{}".format(predicted_class), color='r') if predicted_class.lower() in self.test_generator.filenames[ self.wrong_guesses[i]]: ax[i // 3, i % 3].set_title("Predicted:{}".format(predicted_class), color='g') plt.show() def on_model_change(self, change): if change['type'] == 'change' and change['name'] == 'value': self.classify_button.disabled = True if change['new'] == 'ResNet50': self.epoch_slider.min = 1 self.epoch_slider.max = 16 self.epoch_slider.value = 2 if change['new'] == 'MobileNet v2': self.epoch_slider.min = 2 self.epoch_slider.max = 50 self.epoch_slider.value = 10 def on_ngraph_change(self, change): if change['type'] == 'change' and change['name'] == 'value': i = self.ngraph_backends.index(change['new']) if self.ngraph_backends[i] == 'DISABLED': self.use_ngraph = False ngraph_bridge.disable() else: self.use_ngraph = True ngraph_bridge.enable() ngraph_bridge.set_backend(self.ngraph_backends[i]) def init_gui(self): self.model_dropdown.observe(self.on_model_change) self.ngraph_dropdown.observe(self.on_ngraph_change) self.train_button.on_click(self.train_model) self.shuffle_button.on_click(self.init_model) self.classify_button.on_click(self.classify) self.fine_tune_button.on_click(self.train_model) return self.gui def train_model(self, b=None, epochs=1, batch_size=32, model='ResNet50', fine_tune_at=0): if not self.test: self.train_button.disabled = True self.epochs = self.epoch_slider.value self.batch_size = self.batch_slider.value model = self.model_dropdown.value self.progress_text.value = '' else: self.epochs = epochs self.batch_size = batch_size self.out.clear_output() if b == self.fine_tune_button: fine_tune_at = self.fine_tune_slider.value else: fine_tune_at = 0 self.compile_model(model, fine=fine_tune_at) steps_per_epoch = self.train_generator.n // self.batch_size validation_steps = self.validation_generator.n // self.batch_size with self.out_stats: history = self.model.fit_generator( self.train_generator, steps_per_epoch=steps_per_epoch, epochs=self.epochs, workers=8, validation_data=self.validation_generator, validation_steps=validation_steps, verbose=self.verbose, callbacks=[ProgressBar(self)]) self.classify_button.disabled = False # Test model immediately after training self.classify(b) self.train_button.disabled = False return history def compile_model(self, modelName, fine=0): if modelName == 'ResNet50': self.base_model = ResNet50(input_shape=self.IMAGE_SHAPE, include_top=False, weights='imagenet') elif modelName == 'MobileNet v2': self.base_model = MobileNetV2(input_shape=self.IMAGE_SHAPE, include_top=False, weights='imagenet') # GUI element update self.fine_tune_slider.max = len(self.base_model.layers) with self.out_stats: print('Setting base model to ' + modelName) # Fine Tuning if fine: self.base_model.trainable = True # Fine tune from this layer onwards self.fine_tune_at = fine # Freeze all the layers before the `fine_tune_at` layer for layer in self.base_model.layers[:self.fine_tune_at]: layer.trainable = False with self.out_stats: print('Fine tuning at layer ' + str(fine)) # Training else: self.base_model.trainable = False # Add layers self.model = tf.keras.Sequential([ self.base_model, keras.layers.GlobalAveragePooling2D(), keras.layers.Dense(self.NUM_CLASSES, activation=self.DENSE_LAYER_ACTIVATION) ]) self.model.compile(optimizer=self.sgd, loss=self.OBJECTIVE_FUNCTION, metrics=self.LOSS_METRICS) def classify(self, b): if b and b.description == 'Classify': out.clear_output() with self.out_stats: probabilities = self.model.predict_generator( self.test_generator, verbose=self.verbose, callbacks=[ProgressBar(self)]) predicted_class_indices = np.argmax(probabilities, axis=1) with self.out: f, ax = plt.subplots(3, 3, figsize=(15, 15)) for i in range(0, 9): test_image = os.path.join( self.test_dir, self.test_generator.filenames[self.wrong_guesses[i]]) imgRGB = mpimg.imread(test_image) predicted_class = "Dog" if predicted_class_indices[ self.wrong_guesses[i]] else "Cat" ax[i // 3, i % 3].imshow(imgRGB) ax[i // 3, i % 3].axis('off') ax[i // 3, i % 3].set_title("Predicted:{}".format(predicted_class), color='r') if predicted_class.lower() in self.test_generator.filenames[ self.wrong_guesses[i]]: ax[i // 3, i % 3].set_title("Predicted:{}".format(predicted_class), color='g') plt.show() with self.out_stats: wrong = ~(predicted_class_indices ^ self.test_class_indices) + 2 print("Correct Matrix") print(wrong)
from rl.callbacks import FileLogger, ModelIntervalCheckpoint INPUT_SHAPE = (84, 84) WINDOW_LENGTH = 4 try: import ngraph_bridge import tensorflow as tf config = tf.compat.v1.ConfigProto() config_ngraph_enabled = ngraph_bridge.update_config(config) sess = tf.compat.v1.Session(config=config_ngraph_enabled) print(ngraph_bridge.list_backends()) ngraph_bridge.set_backend('INTELGPU') except Exception as ex: print(ex) import tensorflow as tf config = tf.compat.v1.ConfigProto() config.gpu_options.allow_growth = True config.gpu_options.per_process_gpu_memory_fraction = 2 sess = tf.compat.v1.Session(config=config) class AtariProcessor(Processor): def __init__(self, show=False, output_dir=None): self.show = show
def attach_device_and_ng_backend(gdef, ng_backend): ngraph_bridge.set_backend(ng_backend) # Assumes that the whole graph runs on a single ng_backend for n in gdef.node: n.device = "/device:CPU:0"
def test_set_backend(self): ngraph_bridge.set_backend('CPU') assert ngraph_bridge.get_currently_set_backend_name() == "CPU"