def __init__(self, input_h, input_w, batch_size, output_size, out_h, out_w, init_weights, config): self.gpu_policy = _utils.TensorFlowGPUPolicy() self.gpu_policy.start() # Converting incoming weights from shared_float_array to numpy for key in init_weights.keys(): init_weights[key] = _utils.convert_shared_float_array_to_numpy(init_weights[key]) self.od_graph = _tf.Graph() self.config = config self.batch_size = batch_size self.grid_shape = [out_h, out_w] self.num_classes = int(_utils.convert_shared_float_array_to_numpy(config['num_classes'])) self.anchors = [ (1.0, 2.0), (1.0, 1.0), (2.0, 1.0), (2.0, 4.0), (2.0, 2.0), (4.0, 2.0), (4.0, 8.0), (4.0, 4.0), (8.0, 4.0), (8.0, 16.0), (8.0, 8.0), (16.0, 8.0), (16.0, 32.0), (16.0, 16.0), (32.0, 16.0), ] self.num_anchors = len(self.anchors) self.output_size = output_size self.sess = _tf.Session(graph=self.od_graph) with self.od_graph.as_default(): self.init_object_detector_graph(input_h, input_w, init_weights)
def __init__(self, config, net_params): self.gpu_policy = _utils.TensorFlowGPUPolicy() self.gpu_policy.start() _tf.reset_default_graph() for key in net_params.keys(): net_params[key] = _utils.convert_shared_float_array_to_numpy(net_params[key]) for key in config.keys(): config[key] = _utils.convert_shared_float_array_to_numpy(config[key]) self._batch_size = 1 self._finetune_all_params = True self._define_training_graph = bool(config['st_training']) self._tf_variables = define_tensorflow_variables(net_params) # TODO: take care of batch size self.tf_input = _tf.placeholder(dtype = _tf.float32, shape = [None, 256, 256, 3]) self.tf_style = _tf.placeholder(dtype = _tf.float32, shape = [None, 256, 256, 3]) self.tf_index = _tf.placeholder(dtype = _tf.int64, shape = [self.batch_size]) self.__define_graph(); self.sess = _tf.Session() init = _tf.global_variables_initializer() self.sess.run(init)
def __init__( self, net_params, batch_size, num_features, num_classes, prediction_window, seq_len, seed, ): _utils.suppress_tensorflow_warnings() self.gpu_policy = _utils.TensorFlowGPUPolicy() self.gpu_policy.start() for key in net_params.keys(): net_params[key] = _utils.convert_shared_float_array_to_numpy( net_params[key] ) self.ac_graph = _tf.Graph() self.num_classes = num_classes self.batch_size = batch_size self.seq_len = seq_len self.sess = _tf.Session(graph=self.ac_graph) with self.ac_graph.as_default(): self.init_activity_classifier_graph( net_params, num_features, prediction_window, seed )
def __init__(self, num_inputs, num_classes, custom_layer_sizes): """ Defines the TensorFlow model, loss, optimisation and accuracy. """ self.gpu_policy = _utils.TensorFlowGPUPolicy() self.gpu_policy.start() self.sc_graph = _tf.Graph() self.num_classes = num_classes self.sess = _tf.Session(graph=self.sc_graph) with self.sc_graph.as_default(): self.init_sound_classifier_graph(num_inputs, custom_layer_sizes)
def __init__(self, num_inputs, num_classes, custom_layer_sizes): """ Defines the TensorFlow model, loss, optimisation and accuracy. """ self.num_inputs = num_inputs self.num_classes = num_classes self.custom_layer_sizes = custom_layer_sizes self.gpu_policy = _utils.TensorFlowGPUPolicy() self.gpu_policy.start() self.sc_graph = _tf.Graph() self.sess = _tf.Session(graph=self.sc_graph) self.is_initialized = False
def __init__(self): vggish_model_file = VGGish() if _mac_ver() < (10, 14): # Use TensorFlow/Keras import turicreate.toolkits._tf_utils as _utils self.gpu_policy = _utils.TensorFlowGPUPolicy() self.gpu_policy.start() model_path = vggish_model_file.get_model_path(format='tensorflow') self.vggish_model = _keras.models.load_model(model_path) else: # Use Core ML model_path = vggish_model_file.get_model_path(format='coreml') self.vggish_model = MLModel(model_path)
def __init__(self, net_params, batch_size, num_classes): """ Defines the TensorFlow model, loss, optimisation and accuracy. Then loads the weights into the model. """ self.gpu_policy = _utils.TensorFlowGPUPolicy() self.gpu_policy.start() for key in net_params.keys(): net_params[key] = _utils.convert_shared_float_array_to_numpy( net_params[key]) self.dc_graph = _tf.Graph() self.num_classes = num_classes self.batch_size = batch_size self.sess = _tf.Session(graph=self.dc_graph) with self.dc_graph.as_default(): self.init_drawing_classifier_graph(net_params)
def __init__(self): vggish_model_file = VGGish() self.mac_ver = _mac_ver() if self.mac_ver < (10, 14): # Use TensorFlow/Keras import turicreate.toolkits._tf_utils as _utils self.gpu_policy = _utils.TensorFlowGPUPolicy() self.gpu_policy.start() model_path = vggish_model_file.get_model_path(format="tensorflow") _tf = _minimal_package_import_check("tensorflow") self.vggish_model = _tf.keras.models.load_model(model_path) else: # Use Core ML model_path = vggish_model_file.get_model_path(format="coreml") coremltools = _minimal_package_import_check("coremltools") self.vggish_model = coremltools.models.MLModel(model_path)
def __init__(self, config, net_params): self.gpu_policy = _utils.TensorFlowGPUPolicy() self.gpu_policy.start() for key in net_params.keys(): net_params[key] = _utils.convert_shared_float_array_to_numpy( net_params[key]) for key in config.keys(): config[key] = _utils.convert_shared_float_array_to_numpy( config[key]) self.st_graph = _tf.Graph() self._batch_size = 1 self._finetune_all_params = True self._define_training_graph = bool(config['st_training']) self.sess = _tf.Session(graph=self.st_graph) with self.st_graph.as_default(): self.init_style_transfer_graph(net_params)
def __init__(self, ptModel): """ Parameters ---------- ptModel: ImageClassifierPreTrainedModel An instance of a pre-trained model. """ # Suppresses verbosity to only errors _utils.suppress_tensorflow_warnings() from tensorflow import keras self.gpu_policy = _utils.TensorFlowGPUPolicy() self.gpu_policy.start() self.ptModel = ptModel self.input_shape = ptModel.input_image_shape self.coreml_data_layer = ptModel.coreml_data_layer self.coreml_feature_layer = ptModel.coreml_feature_layer model_path = ptModel.get_model_path("tensorflow") self.model = keras.models.load_model(model_path)
def __init__(self, net_params, batch_size, num_classes): """ Defines the TensorFlow model, loss, optimisation and accuracy. Then loads the MXNET weights into the model. """ self.gpu_policy = _utils.TensorFlowGPUPolicy() self.gpu_policy.start() for key in net_params.keys(): net_params[key] = _utils.convert_shared_float_array_to_numpy( net_params[key]) _tf.reset_default_graph() self.num_classes = num_classes self.batch_size = batch_size self.input = _tf.placeholder(_tf.float32, [None, 28, 28, 1]) self.one_hot_labels = _tf.placeholder(_tf.int32, [None, self.num_classes]) # Weights weights = { 'drawing_conv0_weight': _tf.Variable(_tf.zeros([3, 3, 1, 16]), name='drawing_conv0_weight'), 'drawing_conv1_weight': _tf.Variable(_tf.zeros([3, 3, 16, 32]), name='drawing_conv1_weight'), 'drawing_conv2_weight': _tf.Variable(_tf.zeros([3, 3, 32, 64]), name='drawing_conv2_weight'), 'drawing_dense0_weight': _tf.Variable(_tf.zeros([576, 128]), name='drawing_dense0_weight'), 'drawing_dense1_weight': _tf.Variable(_tf.zeros([128, self.num_classes]), name='drawing_dense1_weight') } # Biases biases = { 'drawing_conv0_bias': _tf.Variable(_tf.zeros([16]), name='drawing_conv0_bias'), 'drawing_conv1_bias': _tf.Variable(_tf.zeros([32]), name='drawing_conv1_bias'), 'drawing_conv2_bias': _tf.Variable(_tf.zeros([64]), name='drawing_conv2_bias'), 'drawing_dense0_bias': _tf.Variable(_tf.zeros([128]), name='drawing_dense0_bias'), 'drawing_dense1_bias': _tf.Variable(_tf.zeros([self.num_classes]), name='drawing_dense1_bias') } conv_1 = _tf.nn.conv2d(self.input, weights["drawing_conv0_weight"], strides=1, padding='SAME') conv_1 = _tf.nn.bias_add(conv_1, biases["drawing_conv0_bias"]) relu_1 = _tf.nn.relu(conv_1) pool_1 = _tf.nn.max_pool2d(relu_1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID') conv_2 = _tf.nn.conv2d(pool_1, weights["drawing_conv1_weight"], strides=1, padding='SAME') conv_2 = _tf.nn.bias_add(conv_2, biases["drawing_conv1_bias"]) relu_2 = _tf.nn.relu(conv_2) pool_2 = _tf.nn.max_pool2d(relu_2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID') conv_3 = _tf.nn.conv2d(pool_2, weights["drawing_conv2_weight"], strides=1, padding='SAME') conv_3 = _tf.nn.bias_add(conv_3, biases["drawing_conv2_bias"]) relu_3 = _tf.nn.relu(conv_3) pool_3 = _tf.nn.max_pool2d(relu_3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID') # Flatten the data to a 1-D vector for the fully connected layer fc1 = _tf.reshape(pool_3, (-1, 576)) fc1 = _tf.nn.xw_plus_b(fc1, weights=weights["drawing_dense0_weight"], biases=biases["drawing_dense0_bias"]) fc1 = _tf.nn.relu(fc1) out = _tf.nn.xw_plus_b(fc1, weights=weights["drawing_dense1_weight"], biases=biases["drawing_dense1_bias"]) softmax_out = _tf.nn.softmax(out) self.predictions = softmax_out # Loss self.cost = _tf.losses.softmax_cross_entropy( logits=out, onehot_labels=self.one_hot_labels, reduction=_tf.losses.Reduction.NONE) # Optimizer self.optimizer = _tf.train.AdamOptimizer(learning_rate=0.001).minimize( self.cost) # Predictions correct_prediction = _tf.equal(_tf.argmax(self.predictions, 1), _tf.argmax(self.one_hot_labels, 1)) self.sess = _tf.Session() self.sess.run(_tf.global_variables_initializer()) # Assign the initialised weights from C++ to tensorflow layers = [ 'drawing_conv0_weight', 'drawing_conv0_bias', 'drawing_conv1_weight', 'drawing_conv1_bias', 'drawing_conv2_weight', 'drawing_conv2_bias', 'drawing_dense0_weight', 'drawing_dense0_bias', 'drawing_dense1_weight', 'drawing_dense1_bias' ] for key in layers: if 'bias' in key: self.sess.run( _tf.assign( _tf.get_default_graph().get_tensor_by_name(key + ":0"), net_params[key])) else: if 'drawing_dense0_weight' in key: ''' To make output of CoreML pool3 (NCHW) compatible with TF (NHWC). Decompose FC weights to NCHW. Transpose to NHWC. Reshape back to FC. ''' coreml_128_576 = net_params[key] coreml_128_576 = _np.reshape(coreml_128_576, (128, 64, 3, 3)) coreml_128_576 = _np.transpose(coreml_128_576, (0, 2, 3, 1)) coreml_128_576 = _np.reshape(coreml_128_576, (128, 576)) self.sess.run( _tf.assign( _tf.get_default_graph().get_tensor_by_name(key + ":0"), _np.transpose(coreml_128_576, (1, 0)))) elif 'dense' in key: dense_weights = _utils.convert_dense_coreml_to_tf( net_params[key]) self.sess.run( _tf.assign( _tf.get_default_graph().get_tensor_by_name(key + ":0"), dense_weights)) else: # TODO: Call _utils.convert_conv2d_coreml_to_tf when #2513 is merged self.sess.run( _tf.assign( _tf.get_default_graph().get_tensor_by_name(key + ":0"), _np.transpose(net_params[key], (2, 3, 1, 0))))
def __init__(self, net_params, batch_size, num_features, num_classes, prediction_window, seq_len): self.gpu_policy = _utils.TensorFlowGPUPolicy() self.gpu_policy.start() for key in net_params.keys(): net_params[key] = _utils.convert_shared_float_array_to_numpy( net_params[key]) _tf.reset_default_graph() self.num_classes = num_classes self.batch_size = batch_size self.seq_len = seq_len # Vars self.data = _tf.placeholder( _tf.float32, [None, prediction_window * seq_len, num_features]) self.weight = _tf.placeholder(_tf.float32, [None, seq_len, 1]) self.target = _tf.placeholder(_tf.int32, [None, seq_len, 1]) self.is_training = _tf.placeholder(_tf.bool) # Reshaping weights reshaped_weight = _tf.reshape(self.weight, [self.batch_size, seq_len]) # One hot encoding target reshaped_target = _tf.reshape(self.target, [self.batch_size, seq_len]) one_hot_target = _tf.one_hot(reshaped_target, depth=self.num_classes, axis=-1) # Weights self.weights = { 'conv_weight': _tf.Variable(_tf.zeros([prediction_window, num_features, CONV_H]), name='conv_weight'), 'dense0_weight': _tf.Variable(_tf.zeros([LSTM_H, DENSE_H]), name='dense0_weight'), 'dense1_weight': _tf.Variable(_tf.zeros([DENSE_H, self.num_classes]), name='dense1_weight') } # Biases self.biases = { 'conv_bias': _tf.Variable(_tf.zeros([CONV_H]), name='conv_bias'), 'dense0_bias': _tf.Variable(_tf.zeros([DENSE_H]), name='dense0_bias'), 'dense1_bias': _tf.Variable(_tf.zeros([num_classes]), name='dense1_bias') } # Convolution conv = _tf.nn.conv1d(self.data, self.weights['conv_weight'], stride=prediction_window, padding='SAME') conv = _tf.nn.bias_add(conv, self.biases['conv_bias']) conv = _tf.nn.relu(conv) dropout = _tf.layers.dropout(conv, rate=0.2, training=self.is_training) # Long Stem Term Memory lstm = self.load_lstm_weights_params(net_params) cells = _tf.nn.rnn_cell.LSTMCell(num_units=LSTM_H, reuse=_tf.AUTO_REUSE, forget_bias=0.0, initializer=_tf.initializers.constant( lstm, verify_shape=True)) init_state = cells.zero_state(batch_size, _tf.float32) rnn_outputs, final_state = _tf.nn.dynamic_rnn(cells, dropout, initial_state=init_state) # Dense dense = _tf.reshape(rnn_outputs, (-1, LSTM_H)) dense = _tf.add(_tf.matmul(dense, self.weights['dense0_weight']), self.biases['dense0_bias']) dense = _tf.layers.batch_normalization( inputs=dense, beta_initializer=_tf.initializers.constant(net_params['bn_beta'], verify_shape=True), gamma_initializer=_tf.initializers.constant(net_params['bn_gamma'], verify_shape=True), moving_mean_initializer=_tf.initializers.constant( net_params['bn_running_mean'], verify_shape=True), moving_variance_initializer=_tf.initializers.constant( net_params['bn_running_var'], verify_shape=True), training=self.is_training) dense = _tf.nn.relu(dense) dense = _tf.layers.dropout(dense, rate=0.5, training=self.is_training) # Output out = _tf.add(_tf.matmul(dense, self.weights['dense1_weight']), self.biases['dense1_bias']) out = _tf.reshape(out, (-1, self.seq_len, self.num_classes)) self.probs = _tf.nn.softmax(out) # Weights seq_sum_weights = _tf.reduce_sum(reshaped_weight, axis=1) binary_seq_sum_weights = _tf.reduce_sum( _tf.cast(seq_sum_weights > 0, dtype=_tf.float32)) # Loss loss = _tf.losses.softmax_cross_entropy( logits=out, onehot_labels=one_hot_target, weights=reshaped_weight, reduction=_tf.losses.Reduction.NONE) self.loss_per_seq = _tf.reduce_sum(loss, axis=1) / (seq_sum_weights + 1e-5) self.loss_op = _tf.reduce_sum( self.loss_per_seq) / (binary_seq_sum_weights + 1e-5) # Optimizer update_ops = _tf.get_collection(_tf.GraphKeys.UPDATE_OPS) self.set_learning_rate(1e-3) train_op = self.optimizer.minimize(self.loss_op) self.train_op = _tf.group([train_op, update_ops]) # Session self.sess = _tf.Session() # Initialize all variables self.sess.run(_tf.global_variables_initializer()) self.sess.run(_tf.local_variables_initializer()) self.load_weights(net_params)
def __init__(self, input_h, input_w, batch_size, output_size, out_h, out_w, init_weights, config): self.gpu_policy = _utils.TensorFlowGPUPolicy() self.gpu_policy.start() #reset tensorflow graph when a new model is created _tf.reset_default_graph() # Converting incoming weights from shared_float_array to numpy for key in init_weights.keys(): init_weights[key] = _utils.convert_shared_float_array_to_numpy( init_weights[key]) self.config = config self.batch_size = batch_size self.grid_shape = [out_h, out_w] self.num_classes = int( _utils.convert_shared_float_array_to_numpy(config['num_classes'])) self.anchors = [ (1.0, 2.0), (1.0, 1.0), (2.0, 1.0), (2.0, 4.0), (2.0, 2.0), (4.0, 2.0), (4.0, 8.0), (4.0, 4.0), (8.0, 4.0), (8.0, 16.0), (8.0, 8.0), (16.0, 8.0), (16.0, 32.0), (16.0, 16.0), (32.0, 16.0), ] self.num_anchors = len(self.anchors) self.output_size = output_size self.is_train = _tf.placeholder( _tf.bool) # Set flag for training or val # Create placeholders for image and labels self.images = _tf.placeholder(_tf.float32, [self.batch_size, input_h, input_w, 3], name='images') self.labels = _tf.placeholder(_tf.float32, [ self.batch_size, self.grid_shape[0], self.grid_shape[1], self.num_anchors, self.num_classes + 5 ], name='labels') self.init_weights = init_weights self.tf_model = self.tiny_yolo(inputs=self.images, output_size=self.output_size) self.global_step = _tf.Variable(0, trainable=False, name="global_step") self.loss = self.loss_layer(self.tf_model, self.labels) self.base_lr = _utils.convert_shared_float_array_to_numpy( config['learning_rate']) self.num_iterations = int( _utils.convert_shared_float_array_to_numpy( config['num_iterations'])) self.init_steps = [ self.num_iterations // 2, 3 * self.num_iterations // 4, self.num_iterations ] self.lrs = [ _np.float32(self.base_lr * 10**(-i)) for i, step in enumerate(self.init_steps) ] self.steps_tf = self.init_steps[:-1] self.lr = _tf.train.piecewise_constant(self.global_step, self.steps_tf, self.lrs) # TODO: Evaluate method to update lr in set_learning_rate() self.opt = _tf.train.MomentumOptimizer(self.lr, momentum=0.9) self.clip_value = _utils.convert_shared_float_array_to_numpy( self.config.get('gradient_clipping')) grads_and_vars = self.opt.compute_gradients(self.loss) clipped_gradients = [(self.ClipIfNotNone(g, self.clip_value), v) for g, v in grads_and_vars] self.train_op = self.opt.apply_gradients(clipped_gradients, global_step=self.global_step) self.sess = _tf.Session() self.sess.run(_tf.global_variables_initializer()) self.sess.run(_tf.local_variables_initializer()) self.load_weights(self.init_weights)