def test_control_flow(self): @tf.function(input_signature=[tf.TensorSpec([], tf.float32)]) def control_flow(x): if x <= 0: return 0. else: return x * 3. to_save = tf.Module() to_save.control_flow = control_flow saved_model_dir = tempfile.mkdtemp() tf.saved_model.save(to_save, saved_model_dir) tf_model = tf.saved_model.load(saved_model_dir) concrete_func = tf_model.signatures[ tf.saved_model.DEFAULT_SERVING_SIGNATURE_DEF_KEY] model = coremltools.converters.tensorflow.convert([concrete_func], inputs={'x': (1, )}, outputs=['Identity']) self.assertTrue(isinstance(model, coremltools.models.MLModel)) input_data = generate_data(shape=[20]) for data in input_data: tf_prediction = to_save.control_flow(data).numpy().flatten() cm_prediction = model.predict({'x': np.array([data]) })['Identity'].flatten() np.testing.assert_array_almost_equal(tf_prediction, cm_prediction, decimal=2)
def run_single_case(args): """ Run a single CTC loss test case """ np.random.seed(42) (inputs, target, input_length_data, target_length_data) = test_utils.generate_data(args) (result, log_probs, gradients, nll) = build_and_run_popart_graph( inputs, target, input_length_data, target_length_data, args ) ipu_grad = result[gradients] ipu_loss = result[nll] print(ipu_grad) pytorch_loss, pytorch_res = torch_ctc_loss( result[log_probs], target, input_length_data, target_length_data, args ) ipu_grad = np.transpose(ipu_grad, (1, 0, 2)).reshape(pytorch_res.shape) grad_err = test_utils.getTensorError(ipu_grad, pytorch_res) loss_err = test_utils.getTensorError(ipu_loss, pytorch_loss) print("Gradient Error", grad_err) print("Loss Error", loss_err) print(f"IPU Loss: {ipu_loss}") print("Grad result: " + ("Pass" if grad_err < 1e-4 else "FAIL")) print("Loss result: " + ("Pass" if loss_err < 1e-5 else "FAIL")) return grad_err, loss_err
def test_subclassed_keras_model(self): class MyModel(tf.keras.Model): def __init__(self): super(MyModel, self).__init__() self.dense1 = tf.keras.layers.Dense(4) self.dense2 = tf.keras.layers.Dense(5) @tf.function def call(self, input_data): return self.dense2(self.dense1(input_data)) keras_model = MyModel() inputs = generate_data(shape=(4, 4)) # subclassed model can only be saved as SavedModel format keras_model._set_inputs(inputs) keras_model.save(self.saved_model_dir, save_format='tf') input_name = keras_model.inputs[0].name.split(':')[0] output_name = keras_model.outputs[0].name.split(':')[0].split('/')[-1] # convert and validate model = coremltools.converters.tensorflow.convert( self.saved_model_dir, inputs={input_name: (4, 4)}, outputs=[output_name]) self.assertTrue(isinstance(model, coremltools.models.MLModel)) self._test_prediction(keras_model=keras_model, core_ml_model=model, inputs=inputs)
def run_single_case(args, splits=[]): """ Run a single RNN-T loss test case """ np.random.seed(42) (inputs, target, input_length_data, target_length_data) = test_utils.generate_data(args) ( result, compacted_probs, gradients, compacted_gradients, nll, ) = build_and_run_graph(inputs, target, input_length_data, target_length_data, args, splits=splits) ipu_grad = result[gradients] # ipu_compacted_grad = result[compacted_gradients] ipu_loss = result[nll] pytorch_loss, pytorch_grads_wlogits, pytorch_grads_wlogprobs = reference_rnnt_loss( inputs, target, input_length_data, target_length_data) grad_err = test_utils.getTensorError(ipu_grad, pytorch_grads_wlogits) loss_err = test_utils.getTensorError(ipu_loss, pytorch_loss) print("Gradient Error", grad_err) print("Loss Error", loss_err) print(f"IPU Loss: {ipu_loss}") print("Grad result: " + ("Pass" if grad_err < 1e-5 else "FAIL")) print("Loss result: " + ("Pass" if loss_err < 1e-5 else "FAIL")) return grad_err, loss_err
def test_rnn_no_memory_pass(): T.manual_seed(1111) input_size = 100 hidden_size = 100 rnn_type = 'gru' num_layers = 3 num_hidden_layers = 5 dropout = 0.2 nr_cells = 5000 cell_size = 17 sparse_reads = 3 gpu_id = -1 debug = True lr = 0.001 sequence_max_length = 10 batch_size = 10 cuda = gpu_id clip = 20 length = 13 rnn = SAM(input_size=input_size, hidden_size=hidden_size, rnn_type=rnn_type, num_layers=num_layers, num_hidden_layers=num_hidden_layers, dropout=dropout, nr_cells=nr_cells, cell_size=cell_size, sparse_reads=sparse_reads, gpu_id=gpu_id, debug=debug) optimizer = optim.Adam(rnn.parameters(), lr=lr) optimizer.zero_grad() input_data, target_output = generate_data(batch_size, length, input_size, cuda) target_output = target_output.transpose(0, 1).contiguous() (chx, mhx, rv) = (None, None, None) outputs = [] for x in range(6): output, (chx, mhx, rv), v = rnn(input_data, (chx, mhx, rv), pass_through_memory=False) output = output.transpose(0, 1) outputs.append(output) output = functools.reduce(lambda x, y: x + y, outputs) loss = criterion((output), target_output) loss.backward() T.nn.utils.clip_grad_norm(rnn.parameters(), clip) optimizer.step() assert target_output.size() == T.Size([27, 10, 100]) assert chx[0].size() == T.Size([num_hidden_layers, 10, 100]) # assert mhx['memory'].size() == T.Size([10,12,17]) assert rv == None
def test_rnn_n(): T.manual_seed(1111) input_size = 100 hidden_size = 100 rnn_type = 'gru' num_layers = 3 num_hidden_layers = 5 dropout = 0.2 nr_cells = 200 cell_size = 17 read_heads = 2 sparse_reads = 4 temporal_reads = 3 gpu_id = -1 debug = True lr = 0.001 sequence_max_length = 10 batch_size = 10 cuda = gpu_id clip = 20 length = 13 rnn = SDNC(input_size=input_size, hidden_size=hidden_size, rnn_type=rnn_type, num_layers=num_layers, num_hidden_layers=num_hidden_layers, dropout=dropout, nr_cells=nr_cells, cell_size=cell_size, read_heads=read_heads, sparse_reads=sparse_reads, temporal_reads=temporal_reads, gpu_id=gpu_id, debug=debug) optimizer = optim.Adam(rnn.parameters(), lr=lr) optimizer.zero_grad() input_data, target_output = generate_data(batch_size, length, input_size, cuda) target_output = target_output.transpose(0, 1).contiguous() output, (chx, mhx, rv), v = rnn(input_data, None) output = output.transpose(0, 1) loss = criterion((output), target_output) loss.backward() T.nn.utils.clip_grad_norm_(rnn.parameters(), clip) optimizer.step() assert target_output.size() == T.Size([27, 10, 100]) assert chx[0].size() == T.Size([num_hidden_layers, 10, 100]) # assert mhx['memory'].size() == T.Size([10,12,17]) assert rv.size() == T.Size([10, 34])
def test_rnn_1(): T.manual_seed(1111) input_size = 100 hidden_size = 100 rnn_type = 'lstm' num_layers = 1 num_hidden_layers = 1 dropout = 0 nr_cells = 100 cell_size = 10 read_heads = 1 sparse_reads = 2 gpu_id = -1 debug = True lr = 0.001 sequence_max_length = 10 batch_size = 10 cuda = gpu_id clip = 10 length = 10 rnn = SAM(input_size=input_size, hidden_size=hidden_size, rnn_type=rnn_type, num_layers=num_layers, num_hidden_layers=num_hidden_layers, dropout=dropout, nr_cells=nr_cells, cell_size=cell_size, read_heads=read_heads, sparse_reads=sparse_reads, gpu_id=gpu_id, debug=debug) optimizer = optim.Adam(rnn.parameters(), lr=lr) rnn = DNI(rnn, optim=optimizer) optimizer.zero_grad() input_data, target_output = generate_data(batch_size, length, input_size, cuda) target_output = target_output.transpose(0, 1).contiguous() output, (chx, mhx, rv), v = rnn(input_data, None) output = output.transpose(0, 1) loss = criterion((output), target_output) loss.backward() T.nn.utils.clip_grad_norm(rnn.parameters(), clip) assert target_output.size() == T.Size([21, 10, 100]) assert chx[0][0][0].size() == T.Size([10, 100]) # assert mhx['memory'].size() == T.Size([10,1,1]) assert rv.size() == T.Size([10, 10])
def test_basic1(): D = 2 N = 100 pi = np.array([0.99, 0.01]) A = np.array([[0.90, 0.10], [0.10, 0.90]]) mus = np.array([[0., 0.], [20., 20.]]) sigmas = np.array([np.eye(2), 5. * np.eye(2)]) kappa = 0.5 nu = 5 params = [[mus[0], sigmas[0]], [mus[1], sigmas[1]]] print 'label 1 true' print mus[0] print sample_invwishart(sigmas[0], nu) print kappa print nu print 'label 2 true' print mus[1] print sample_invwishart(sigmas[1], nu) print kappa print nu obs, sts = generate_data(D, N, pi, A, params) A_0 = 2 * np.ones((2, 2)) emits = [ NIW(np.ones(2), np.eye(2), kappa, nu), NIW(20 * np.ones(2), 5. * np.eye(2), kappa, nu) ] hmm = HMMSVI(obs, A_0, emits, 1., 0.7) hmm.infer(10, 10, HMMSVI.metaobs_unif, 20) var_x = hmm.full_local_update() sts_pred = np.argmax(var_x, axis=1) print 'hamming distance = ', np.min([ hamming(np.array([0, 1])[sts_pred], sts), hamming(np.array([1, 0])[sts_pred], sts) ]) print 'label 1 learned' print hmm.emits[0].mu_N print sample_invwishart(hmm.emits[0].sigma_N, hmm.emits[0].nu_N) print hmm.emits[0].kappa_N print hmm.emits[0].nu_N print 'label 2 learned' print hmm.emits[1].mu_N print sample_invwishart(hmm.emits[1].sigma_N, hmm.emits[1].nu_N) print hmm.emits[1].kappa_N print hmm.emits[1].nu_N
def _test_model(self, keras_model, model_path, inputs, outputs=None, decimal=4, use_cpu_only=False, verbose=False): keras_model.save(model_path) # convert and validate model = coremltools.converters.tensorflow.convert(model_path, inputs=inputs, outputs=outputs) self.assertTrue(isinstance(model, coremltools.models.MLModel)) if verbose: print('TensorFlow Keras model saved at {}'.format(model_path)) tmp_model_path = self.model_path.rsplit('.')[0] + '.mlmodel' model.save(tmp_model_path) print('Core ML model saved at {}'.format(tmp_model_path)) # verify numeric correctness of predictions # assume one input one output for now name, shape = list(inputs.items())[0] data = generate_data(shape=shape) keras_prediction = keras_model.predict(data) # If outputs are not supplied, get the output name # from the keras model. if not outputs: output_name = keras_model.outputs[0].name outputs = [output_name.split('/')[1].split(':')[0]] prediction = model.predict({name: data}, use_cpu_only=use_cpu_only)[outputs[0]] if verbose: print('Shape Keras:', keras_prediction.shape, ' vs. Core ML:', prediction.shape) print('Input :', data.flatten()[:16]) print('Keras :', keras_prediction.flatten()[:16]) print('Core ML:', prediction.flatten()[:16]) np.testing.assert_array_equal(keras_prediction.shape, prediction.shape) np.testing.assert_almost_equal(keras_prediction.flatten(), prediction.flatten(), decimal=decimal) return model
def _test_conversion_prediction(self, keras_model, model_path, inputs, outputs): # convert and validate model = coremltools.converters.tensorflow.convert(model_path, inputs=inputs, outputs=outputs) self.assertTrue(isinstance(model, coremltools.models.MLModel)) # verify numeric correctness of predictions inputs = generate_data(shape=self.input_shape) keras_prediction = keras_model.predict(inputs) output_name = keras_model.outputs[0].name.split(':')[0].split('/')[-1] prediction = model.predict( {keras_model.inputs[0].name.split(':')[0]: inputs})[output_name] np.testing.assert_array_equal(keras_prediction.shape, prediction.shape) np.testing.assert_almost_equal(keras_prediction.flatten(), prediction.flatten(), decimal=4)
def _test_keras_model_tf2(self, model, data_mode, decimal, use_cpu_only, has_variables, verbose): core_ml_model_file = self.model_file.rsplit('.')[0] + '.mlmodel' input_dict = {inp.op.name: inp.shape.as_list() for inp in model.inputs} for name, shape in input_dict.items(): input_dict[name] = [dim if dim is not None else 1 for dim in shape] output_list = ['Identity'] model.save(self.model_file) # convert Keras model into Core ML model format core_ml_model = coremltools.converters.tensorflow.convert( filename=self.model_file, inputs=input_dict, outputs=output_list, use_cpu_only=use_cpu_only) if verbose: print('\nKeras model saved at {}'.format(self.model_file)) print('\nCore ML model description:') from coremltools.models.neural_network.printer import print_network_spec print_network_spec(core_ml_model.get_spec(), style='coding') core_ml_model.save(core_ml_model_file) print('\nCore ML model saved at {}'.format(core_ml_model_file)) core_ml_inputs = { name: generate_data(shape, data_mode) for name, shape in input_dict.items() } # run prediction and compare results keras_output = model.predict(list(core_ml_inputs.values())[0]) core_ml_output = core_ml_model.predict( core_ml_inputs, useCPUOnly=use_cpu_only)[output_list[0]] if verbose: print('\nPredictions', keras_output.shape, ' vs.', core_ml_output.shape) print(keras_output.flatten()[:6]) print(core_ml_output.flatten()[:6]) np.testing.assert_array_equal( keras_output.shape, core_ml_output.shape) np.testing.assert_almost_equal( keras_output.flatten(), core_ml_output.flatten(), decimal=decimal)
def _test_model(self, keras_model, model_path, inputs, outputs, decimal=4, verbose=False): keras_model.save(model_path) # convert and validate model = coremltools.converters.tensorflow.convert(model_path, inputs=inputs, outputs=outputs, target_ios='13') assert isinstance(model, coremltools.models.MLModel) if verbose: print('TensorFlow Keras model saved at {}'.format(model_path)) tmp_model_path = self.model_path.rsplit('.')[0] + '.mlmodel' model.save(tmp_model_path) print('Core ML model saved at {}'.format(tmp_model_path)) # verify numeric correctness of predictions # assume one input one output for now name, shape = list(inputs.items())[0] data = generate_data(shape=shape) # self._predict_keras_intermediate_layer(data, 'conv1') keras_prediction = keras_model.predict(data) prediction = model.predict({name: data})[outputs[0]] if verbose: print('Shape Keras:', keras_prediction.shape, ' vs. Core ML:', prediction.shape) print('Input :', data.flatten()[:16]) print('Keras :', keras_prediction.flatten()[:16]) print('Core ML:', prediction.flatten()[:16]) np.testing.assert_array_equal(keras_prediction.shape, prediction.shape) np.testing.assert_almost_equal(keras_prediction.flatten(), prediction.flatten(), decimal=decimal)
def test_basic3(): N = 100 D = 2 pi = np.array([0.999, 0.001]) A = np.array([[0.9, 0.1], [0.1, 0.9]]) mus_0 = np.array([[0., 0.], [20., 20.]]) sigmas_0 = np.array([np.eye(2), 5 * np.eye(2)]) kappa_0 = 0.5 nu_0 = 5 mu_1, sigma_1 = sample_niw(mus_0[0], sigmas_0[0], kappa_0, nu_0) mu_2, sigma_2 = sample_niw(mus_0[1], sigmas_0[1], kappa_0, nu_0) params = [[mu_1, sigma_1], [mu_2, sigma_2]] obs, _ = generate_data(D, N, pi, A, params) #plt.scatter(obs[:,0], obs[:,1]) #plt.show() A_0 = 2 * np.ones((A.shape[0], A.shape[0])) mus_N = np.array([np.mean(obs, axis=0), np.mean(obs, axis=0)]) sigmas_N = 0.75 * np.array([np.cov(obs.T), np.cov(obs.T)]) A_nat_0 = A_0 - 1 n1s_0 = [ kappa_0 * mus_N[0], kappa_0, sigmas_N[0] + kappa_0 * np.outer(mus_N[0], mus_N[0]), nu_0 + D + 2 ] n2s_0 = [ kappa_0 * mus_N[1], kappa_0, sigmas_N[1] + kappa_0 * np.outer(mus_N[1], mus_N[1]), nu_0 + D + 2 ] A_nat_N = A_nat_0[:] n1s_N = n1s_0[:] n2s_N = n2s_0[:] iters = 20 print 'A true' print A print 'label 1 true' #print mus_0[0] #print sigmas_0[0] print mu_1 print sigma_1 print 'label 2 true' #print mus_0[1] #print sigmas_0[1] print mu_2 print sigma_2 print 'A_nat_0' print A_nat_0 for _ in xrange(iters): mu_1N, sigma_1N, kappa_1N, nu_1N = natural_to_standard( n1s_N[0], n1s_N[1], n1s_N[2], n1s_N[3]) mu_2N, sigma_2N, kappa_2N, nu_2N = natural_to_standard( n2s_N[0], n2s_N[1], n2s_N[2], n2s_N[3]) lliks1 = niw.expected_log_likelihood(obs, mu_1N, sigma_1N, kappa_1N, nu_1N) lliks2 = niw.expected_log_likelihood(obs, mu_2N, sigma_2N, kappa_2N, nu_2N) lliks = np.vstack((lliks1, lliks2)).T.copy(order='C') lA_mod = dir.expected_sufficient_statistics(A_nat_N + 1) A_mod = np.exp(lA_mod) lalpha = fb.forward_msgs(pi, A_mod, lliks) lbeta = fb.backward_msgs(A_mod, lliks) lexpected_states, expected_transcounts = fb.expected_statistics( pi, A_mod, lliks, lalpha, lbeta) #lexpected_states = lalpha + lbeta #lexpected_states -= np.max(lexpected_states, axis=1)[:,np.newaxis] expected_states = np.exp(lexpected_states) expected_states /= np.sum(expected_states, axis=1)[:, np.newaxis] #A_ss = np.zeros_like(A_nat_0) #for i in xrange(1,expected_states.shape[0]): # A_ss += np.outer(expected_states[i-1], expected_states[i]) A_ss = dir.sufficient_statistics(expected_states) # convert to natural parameter? A_ss -= 1 A_nat_N = dir.meanfield_update(A_nat_0, A_ss) s11, s12, s13 = niw.expected_sufficient_statistics( obs, expected_states[:, 0].copy(order='C')) s21, s22, s23 = niw.expected_sufficient_statistics( obs, expected_states[:, 1].copy(order='C')) s1s = np.array([s11, s21]) s2s = np.array([s12, s22]) s3s = np.array([s13, s23]) n11, n12, n13, n14 = niw.meanfield_update(n1s_0[0], n1s_0[1], n1s_0[2], n1s_0[3], s1s[0], s2s[0], s3s[0]) n21, n22, n23, n24 = niw.meanfield_update(n2s_0[0], n2s_0[1], n2s_0[2], n2s_0[3], s1s[1], s2s[1], s3s[1]) n1s_N = [n11, n12, n13, n14] n2s_N = [n21, n22, n23, n24] print 'A learned' A_sample = np.array([ stats.dirichlet.rvs(A_nat_N[i, :] + 1, size=1)[0] for i in xrange(A.shape[0]) ]) print A_sample mu_0, sigma_0, kappa_0, nu_0 = natural_to_standard(n11, n12, n13, n14) mu_1, sigma_1 = sample_niw(mu_0, sigma_0, kappa_0, nu_0) print 'label 1 learned' print mu_1 print sigma_1 mu_0, sigma_0, kappa_0, nu_0 = natural_to_standard(n21, n22, n23, n24) mu_2, sigma_2 = sample_niw(mu_0, sigma_0, kappa_0, nu_0) print 'label 2 learned' print mu_2 print sigma_2
def _test_tf_model( self, graph, input_shapes, output_node_names, data_mode='random', input_refs=None, delta=1e-2, use_cpu_only=False, graph_optimizations="freeze", # one of ["freeze", "convert_variables_to_constants", None] quantize_tf_model=False): """ Common entry to testing routine. graph - defined TensorFlow graph. input_shapes - dict str:shape for each input op (placeholder) output_node_names - output_node_names, a list of strings data_mode - auto-generated input vectors, can be 'random', 'zeros', 'ones', 'linear', etc. input_refs - a dictionary of reference input in tensorFlow axis order, each entry is str:shape. When using auto-generated input vectors, set input_refs to None. delta - maximum difference of normalized TensorFlow and CoreML outputs use_cpu_only - If True, instantiate and run CoreML model with CPU only graph_optimizations == "freeze" - Force TensorFlow graph to be frozen before converting. quantize_tf_model - If True, try to quantize TensorFlow model before converting """ # Some file processing model_dir = tempfile.mkdtemp() graph_def_file = os.path.join(model_dir, 'tf_graph.pb') checkpoint_file = os.path.join(model_dir, 'tf_model.ckpt') static_model_file = os.path.join(model_dir, 'tf_static.pb') coreml_model_file = os.path.join(model_dir, 'coreml_model.mlmodel') # add a saver tf.reset_default_graph() if graph_optimizations == "freeze": with graph.as_default() as g: saver = tf.train.Saver() if input_refs is None: feed_dict = { self._get_tf_tensor_name(graph, name): generate_data(input_shapes[name], data_mode) for name in input_shapes } else: feed_dict = { self._get_tf_tensor_name(graph, name): input_refs[name] for name in list(input_refs.keys()) } with tf.Session(graph=graph) as sess: # initialize initializer_op = tf.global_variables_initializer() sess.run(initializer_op) # run the result fetches = [ graph.get_operation_by_name(name).outputs[0] for name in output_node_names ] result = sess.run(fetches, feed_dict=feed_dict) # save graph definition somewhere tf.train.write_graph(sess.graph, model_dir, graph_def_file, as_text=False) # save the weights if freezing is needed if not graph_optimizations: static_model_file = graph_def_file elif graph_optimizations == "freeze": saver.save(sess, checkpoint_file) self._simple_freeze( input_graph=graph_def_file, input_checkpoint=checkpoint_file, output_graph=static_model_file, output_node_names=",".join(output_node_names)) else: output_graph_def = tf.graph_util.convert_variables_to_constants( sess, graph.as_graph_def(), output_node_names) with tf.gfile.GFile(static_model_file, "wb") as f: f.write(output_graph_def.SerializeToString()) # if TF needs to be quantized, quantize the graph if quantize_tf_model: static_model_file = self._quantize_static_tf_model( model_dir, static_model_file, output_node_names) # convert to CoreML mlmodel = coremltools.converters.tensorflow.convert( static_model_file, inputs=input_shapes, outputs=output_node_names, use_cpu_only=use_cpu_only) if DEBUG: print('\n mlmodel description: \n') from coremltools.models.neural_network.printer import print_network_spec print_network_spec(mlmodel.get_spec(), style='coding') mlmodel.save(coreml_model_file) print('\n mlmodel saved at %s' % coreml_model_file) # Transpose input data as CoreML requires coreml_inputs = { name: tf_transpose(feed_dict[self._get_tf_tensor_name(graph, name)]) for name in input_shapes } # Run predict in CoreML coreml_output = mlmodel.predict(coreml_inputs, useCPUOnly=use_cpu_only) for idx, out_name in enumerate(output_node_names): tf_out = result[idx] if len(tf_out.shape) == 0: tf_out = np.array([tf_out]) tp = tf_out.flatten() coreml_out = coreml_output[out_name] cp = coreml_out.flatten() self.assertTrue(tf_out.shape == coreml_out.shape) for i in range(len(tp)): max_den = max(1.0, tp[i], cp[i]) self.assertAlmostEqual(tp[i] / max_den, cp[i] / max_den, delta=delta) # Cleanup files - models on disk no longer useful if os.path.exists(model_dir): shutil.rmtree(model_dir)
def _test_tf_model_constant(self, graph, input_shapes, output_node_names, data_mode='random_zero_mean', delta=1e-2, use_cpu_only=False, validate_bool_only=False): """ Common entry to testing routine for graphs that have no variables. Parameters ---------- graph: tf.Graph() TensorFlow graph. input_shapes: dict [str : shape] Shapes for each input (placeholder). output_node_names: list of str Output tensor names. data_mode: str Data mode for the placeholder data generation. input_refs: a dictionary of reference input in tensorFlow axis order. Each entry is str:shape. When using auto-generated input vectors, set input_refs to None. delta: float Delta for error checking, default 1e-2. use_cpu_only: bool If true, force use CPU only, default False. validate_bool_only: bool If true, only validate it's zero or non-zero, otherwise, validate float values, default False. """ model_dir = tempfile.mkdtemp() frozen_model_file = os.path.join(model_dir, 'tf_frozen.pb') coreml_model_file = os.path.join(model_dir, 'coreml_model.mlmodel') feed_dict = { self._get_tf_tensor_name(graph, name): generate_data(input_shapes[name], data_mode) for name in input_shapes } with tf.Session(graph=graph) as sess: # initialize sess.run(tf.global_variables_initializer()) # run the result fetches = [ graph.get_operation_by_name(name).outputs[0] for name in output_node_names ] result = sess.run(fetches, feed_dict=feed_dict) output_graph_def = tf.graph_util.convert_variables_to_constants( sess, # The session is used to retrieve the weights tf.get_default_graph().as_graph_def( ), # The graph_def is used to retrieve the nodes output_node_names # The output node names are used to select the useful nodes ) with tf.gfile.GFile(frozen_model_file, 'wb') as f: f.write(output_graph_def.SerializeToString()) # convert to CoreML mlmodel = coremltools.converters.tensorflow.convert( frozen_model_file, inputs=input_shapes, outputs=output_node_names, use_cpu_only=use_cpu_only) if DEBUG: print('\n mlmodel description: \n') from coremltools.models.neural_network.printer import print_network_spec print_network_spec(mlmodel.get_spec(), style='coding') mlmodel.save(coreml_model_file) print('\n mlmodel saved at %s' % coreml_model_file) # Transpose input data as CoreML requires coreml_inputs = { name: tf_transpose(feed_dict[self._get_tf_tensor_name(graph, name)]) for name in input_shapes } # Run predict in CoreML coreml_output = mlmodel.predict(coreml_inputs, useCPUOnly=use_cpu_only) for idx, out_name in enumerate(output_node_names): tf_out = result[idx] if len(tf_out.shape) == 0: tf_out = np.array([tf_out]) tp = tf_out.flatten() coreml_out = coreml_output[out_name] cp = coreml_out.flatten() self.assertTrue(tf_out.shape == coreml_out.shape, msg=(tf_out.shape, 'vs.', coreml_out.shape)) if validate_bool_only: cp = np.logical_and(cp, cp) for i in range(len(tp)): max_den = max(1.0, tp[i], cp[i]) self.assertAlmostEqual(tp[i] / max_den, cp[i] / max_den, delta=delta) # Cleanup files - models on disk no longer useful if os.path.exists(model_dir): shutil.rmtree(model_dir)
def test_basic1(): N = 100 D = 2 pi = np.array([0.999, 0.001]) A = np.array([[0.9, 0.1], [0.1, 0.9]]) mus_0 = np.array([[0., 0.], [20., 20.]]) sigmas_0 = np.array([np.eye(2), 2 * np.eye(2)]) kappa_0 = 0.5 nu_0 = 5 mu_1, sigma_1 = sample_niw(mus_0[0], sigmas_0[0], kappa_0, nu_0) mu_2, sigma_2 = sample_niw(mus_0[1], sigmas_0[1], kappa_0, nu_0) print 'label 1 before' print mu_1 print sigma_1 print 'label 2 before' print mu_2 print sigma_2 params = [[mu_1, sigma_1], [mu_2, sigma_2]] obs, _ = generate_data(D, N, pi, A, params) n1s = [ kappa_0 * mus_0[0], kappa_0, sigmas_0[0] + kappa_0 * np.outer(mus_0[0], mus_0[0]), nu_0 + D + 2 ] n2s = [ kappa_0 * mus_0[1], kappa_0, sigmas_0[1] + kappa_0 * np.outer(mus_0[1], mus_0[1]), nu_0 + D + 2 ] lliks1 = niw.expected_log_likelihood(obs, mus_0[0], sigmas_0[0], kappa_0, nu_0) lliks2 = niw.expected_log_likelihood(obs, mus_0[1], sigmas_0[1], kappa_0, nu_0) lliks = np.vstack((lliks1, lliks2)).T.copy(order='C') lalpha = fb.forward_msgs(pi, A, lliks) lbeta = fb.backward_msgs(A, lliks) lexpected_states = lalpha + lbeta lexpected_states -= np.max(lexpected_states, axis=1)[:, np.newaxis] expected_states = np.exp(lexpected_states) expected_states /= np.sum(expected_states, axis=1)[:, np.newaxis] s1s = np.sum(expected_states, axis=0) s2s = np.array([ np.sum(obs * expected_states[:, i, np.newaxis], axis=0) for i in xrange(2) ]) s3s = np.array([ np.sum([ np.outer(obs[i], obs[i]) * expected_states[i, 0] for i in xrange(obs.shape[0]) ], axis=0), np.sum([ np.outer(obs[i], obs[i]) * expected_states[i, 1] for i in xrange(obs.shape[0]) ], axis=0) ]) n11, n12, n13, n14 = niw.meanfield_update(n1s[0], n1s[1], n1s[2], n1s[3], s1s[0], s2s[0], s3s[0]) n21, n22, n23, n24 = niw.meanfield_update(n2s[0], n2s[1], n2s[2], n2s[3], s1s[1], s2s[1], s3s[1]) # Note might need to add small positive to diagonal mu_0, sigma_0, kappa_0, nu_0 = natural_to_standard(n11, n12, n13, n14) mu_1, sigma_1 = sample_niw(mu_0, sigma_0, kappa_0, nu_0) print 'label 1 after' print mu_1 print sigma_1 mu_0, sigma_0, kappa_0, nu_0 = natural_to_standard(n21, n22, n23, n24) mu_2, sigma_2 = sample_niw(mu_0, sigma_0, kappa_0, nu_0) print 'label 2 after' print mu_2 print sigma_2
def _test_keras_model_tf1(self, model, data_mode, decimal, use_cpu_only, has_variables, verbose): graph_def_file = os.path.join(self.saved_model_dir, 'graph.pb') frozen_model_file = os.path.join(self.saved_model_dir, 'frozen.pb') core_ml_model_file = os.path.join(self.saved_model_dir, 'model.mlmodel') input_shapes = {inp.op.name: inp.shape.as_list() for inp in model.inputs} for name, shape in input_shapes.items(): input_shapes[name] = [dim if dim is not None else 1 for dim in shape] output_node_names = [output.op.name for output in model.outputs] tf_graph = _keras.get_session().graph tf.reset_default_graph() if has_variables: with tf_graph.as_default(): saver = tf.train.Saver() # note: if Keras backend has_variable is False, we're not making variables constant with tf.Session(graph=tf_graph) as sess: sess.run(tf.global_variables_initializer()) feed_dict = {} for name, shape in input_shapes.items(): tensor_name = tf_graph.get_operation_by_name(name).outputs[0].name feed_dict[tensor_name] = generate_data(shape, data_mode) # run the result fetches = [ tf_graph.get_operation_by_name(name).outputs[0] for name in output_node_names ] result = sess.run(fetches, feed_dict=feed_dict) # save graph definition somewhere tf.train.write_graph(sess.graph, self.saved_model_dir, graph_def_file, as_text=False) # freeze_graph() has been raising error with tf.keras models since no # later than TensorFlow 1.6, so we're not using freeze_graph() here. # See: https://github.com/tensorflow/models/issues/5387 output_graph_def = tf.graph_util.convert_variables_to_constants( sess, # The session is used to retrieve the weights tf_graph.as_graph_def(), # The graph_def is used to retrieve the nodes output_node_names # The output node names are used to select the useful nodes ) with tf.gfile.GFile(frozen_model_file, 'wb') as f: f.write(output_graph_def.SerializeToString()) _keras.clear_session() # convert to Core ML model format core_ml_model = coremltools.converters.tensorflow.convert( frozen_model_file, inputs=input_shapes, outputs=output_node_names, use_cpu_only=use_cpu_only) if verbose: print('\nFrozen model saved at {}'.format(frozen_model_file)) print('\nCore ML model description:') from coremltools.models.neural_network.printer import print_network_spec print_network_spec(core_ml_model.get_spec(), style='coding') core_ml_model.save(core_ml_model_file) print('\nCore ML model saved at {}'.format(core_ml_model_file)) # transpose input data as Core ML requires core_ml_inputs = { name: tf_transpose(feed_dict[self._get_tf_tensor_name(tf_graph, name)]) for name in input_shapes } # run prediction in Core ML core_ml_output = core_ml_model.predict(core_ml_inputs, useCPUOnly=use_cpu_only) for idx, out_name in enumerate(output_node_names): tf_out = result[idx] if len(tf_out.shape) == 0: tf_out = np.array([tf_out]) tp = tf_out.flatten() coreml_out = core_ml_output[out_name] cp = coreml_out.flatten() self.assertTrue(tf_out.shape == coreml_out.shape) for i in range(len(tp)): max_den = max(1.0, tp[i], cp[i]) self.assertAlmostEqual(tp[i] / max_den, cp[i] / max_den, delta=10 ** -decimal)
def _test_keras_model(self, model, data_mode='random', delta=1e-2, use_cpu_only=True, has_variables=True): """Saves out the backend TF graph from the Keras model and tests it """ model_dir = tempfile.mkdtemp() graph_def_file = os.path.join(model_dir, 'tf_graph.pb') checkpoint_file = os.path.join(model_dir, 'tf_model.ckpt') frozen_model_file = os.path.join(model_dir, 'tf_frozen.pb') coreml_model_file = os.path.join(model_dir, 'coreml_model.mlmodel') input_shapes = { inp.op.name: inp.shape.as_list() for inp in model.inputs } for name, shape in input_shapes.items(): input_shapes[name] = [ dim if dim is not None else 1 for dim in shape ] output_node_names = [output.op.name for output in model.outputs] tf_graph = K.get_session().graph tf.reset_default_graph() if has_variables: with tf_graph.as_default() as g: saver = tf.train.Saver() # TODO - if Keras backend has_variable is False, we're not making variables constant with tf.Session(graph=tf_graph) as sess: sess.run(tf.global_variables_initializer()) feed_dict = {} for name, shape in input_shapes.items(): tensor_name = tf_graph.get_operation_by_name( name).outputs[0].name feed_dict[tensor_name] = generate_data(shape, data_mode) # run the result fetches = [ tf_graph.get_operation_by_name(name).outputs[0] for name in output_node_names ] result = sess.run(fetches, feed_dict=feed_dict) # save graph definition somewhere tf.train.write_graph(sess.graph, model_dir, graph_def_file, as_text=False) # freeze_graph() has been raising error with tf.keras models since no # later than TensorFlow 1.6, so we're not using freeze_graph() here. # See: https://github.com/tensorflow/models/issues/5387 output_graph_def = tf.graph_util.convert_variables_to_constants( sess, # The session is used to retrieve the weights tf_graph.as_graph_def( ), # The graph_def is used to retrieve the nodes output_node_names # The output node names are used to select the useful nodes ) with tf.gfile.GFile(frozen_model_file, "wb") as f: f.write(output_graph_def.SerializeToString()) K.clear_session() # convert to CoreML mlmodel = coremltools.converters.tensorflow.convert( frozen_model_file, inputs=input_shapes, outputs=output_node_names, use_cpu_only=use_cpu_only) if DEBUG: print('\n mlmodel description: \n') from coremltools.models.neural_network.printer import print_network_spec print_network_spec(mlmodel.get_spec(), style='coding') mlmodel.save(coreml_model_file) print('\n mlmodel saved at %s' % (coreml_model_file)) # Transpose input data as CoreML requires coreml_inputs = { name: tf_transpose(feed_dict[self._get_tf_tensor_name(tf_graph, name)]) for name in input_shapes } # Run predict in CoreML coreml_output = mlmodel.predict(coreml_inputs, useCPUOnly=use_cpu_only) for idx, out_name in enumerate(output_node_names): tf_out = result[idx] if len(tf_out.shape) == 0: tf_out = np.array([tf_out]) tp = tf_out.flatten() coreml_out = coreml_output[out_name] cp = coreml_out.flatten() self.assertTrue(tf_out.shape == coreml_out.shape) for i in range(len(tp)): max_den = max(1.0, tp[i], cp[i]) self.assertAlmostEqual(tp[i] / max_den, cp[i] / max_den, delta=delta) # Cleanup files - models on disk no longer useful if os.path.exists(model_dir): shutil.rmtree(model_dir)
def test_basic2(): N = 100 D = 2 pi = np.array([0.999, 0.001]) A = np.array([[0.9, 0.1], [0.1, 0.9]]) mus_0 = np.array([[0., 0.], [20., 20.]]) sigmas_0 = np.array([np.eye(2), 5 * np.eye(2)]) kappa_0 = 0.5 nu_0 = 5 mu_1, sigma_1 = sample_niw(mus_0[0], sigmas_0[0], kappa_0, nu_0) mu_2, sigma_2 = sample_niw(mus_0[1], sigmas_0[1], kappa_0, nu_0) params = [[mu_1, sigma_1], [mu_2, sigma_2]] obs, _ = generate_data(D, N, pi, A, params) plt.scatter(obs[:, 0], obs[:, 1]) plt.show() mus_N = np.array([np.mean(obs, axis=0), np.mean(obs, axis=0)]) sigmas_N = 0.75 * np.array([np.cov(obs.T), np.cov(obs.T)]) n1s_0 = [ kappa_0 * mus_N[0], kappa_0, sigmas_N[0] + kappa_0 * np.outer(mus_N[0], mus_N[0]), nu_0 + D + 2 ] n2s_0 = [ kappa_0 * mus_N[1], kappa_0, sigmas_N[1] + kappa_0 * np.outer(mus_N[1], mus_N[1]), nu_0 + D + 2 ] n1s_N = n1s_0[:] n2s_N = n2s_0[:] iters = 20 print 'label 1 true' print mus_0[0] print sigmas_0[0] print 'label 2 true' print mus_0[1] print sigmas_0[1] for _ in xrange(iters): mu_1N, sigma_1N, kappa_1N, nu_1N = natural_to_standard( n1s_N[0], n1s_N[1], n1s_N[2], n1s_N[3]) mu_2N, sigma_2N, kappa_2N, nu_2N = natural_to_standard( n2s_N[0], n2s_N[1], n2s_N[2], n2s_N[3]) lliks1 = niw.expected_log_likelihood(obs, mu_1N, sigma_1N, kappa_1N, nu_1N) lliks2 = niw.expected_log_likelihood(obs, mu_2N, sigma_2N, kappa_2N, nu_2N) lliks = np.vstack((lliks1, lliks2)).T.copy(order='C') lalpha = fb.forward_msgs(pi, A, lliks) lbeta = fb.backward_msgs(A, lliks) lexpected_states = lalpha + lbeta lexpected_states -= np.max(lexpected_states, axis=1)[:, np.newaxis] expected_states = np.exp(lexpected_states) expected_states /= np.sum(expected_states, axis=1)[:, np.newaxis] s11, s12, s13 = niw.expected_sufficient_statistics( obs, expected_states[:, 0].copy(order='C')) s21, s22, s23 = niw.expected_sufficient_statistics( obs, expected_states[:, 1].copy(order='C')) s1s = np.array([s11, s21]) s2s = np.array([s12, s22]) s3s = np.array([s13, s23]) n11, n12, n13, n14 = niw.meanfield_update(n1s_0[0], n1s_0[1], n1s_0[2], n1s_0[3], s1s[0], s2s[0], s3s[0]) n21, n22, n23, n24 = niw.meanfield_update(n2s_0[0], n2s_0[1], n2s_0[2], n2s_0[3], s1s[1], s2s[1], s3s[1]) n1s_N = [n11, n12, n13, n14] n2s_N = [n21, n22, n23, n24] mu_0, sigma_0, kappa_0, nu_0 = natural_to_standard(n11, n12, n13, n14) mu_1, sigma_1 = sample_niw(mu_0, sigma_0, kappa_0, nu_0) print 'label 1 learned' print mu_1 print sigma_1 mu_0, sigma_0, kappa_0, nu_0 = natural_to_standard(n21, n22, n23, n24) mu_2, sigma_2 = sample_niw(mu_0, sigma_0, kappa_0, nu_0) print 'label 2 learned' print mu_2 print sigma_2