def _compile_model(self, data): """ Compiles the model in TensorFlow """ data = tf.placeholder(tf.float32, [None, 4, self.seq_length, 1]) conv_layer1 = _get_conv_layer(data, 'first_conv', nb_rows=4, nb_cols=self.conv_width[0], nb_filters=self.num_filters[0], keep_prob=keep_prob) conv_layer2 = _get_conv_layer(conv_layer1, 'second_conv', nb_rows=1, nb_cols=self.conv_width[1], nb_filters=self.num_filters[1], keep_prob=keep_prob) conv_layer3 = _get_conv_layer(conv_layer2, 'third_conv', nb_rows=1, nb_cols=self.conv_width[2], nb_filters=self.num_filters[2], keep_prob=keep_prob) max_pool = _get_max_pool_layer(max_pool, 'max_pool', nb_rows=1, nb_cols=25, strides=[1,2,2,1]) with tf.variable_scope('fc_layer') as scope: flattened = tf.flatten(max_pool, [-1]) print('FC LAYER SHAPE', flattened.get_shape()[0].value) dim = flattened.get_shape()[0].value weights = _variable_with_weight_decay('weights', shape=[dim, NUM_CLASSES], stddev=0.04, wd=0.004) biases = _variable_on_gpu('biases', [NUM_CLASSES], tf.constant_initializer(0.0)) self.compiled_model = tf.nn.sigmoid(tf.matmul(flattened, weights) + biases, name=scope.name)
def build_model(data): """ Build a CNN using TF """ keep_prob = tf.placeholder(tf.float32) num_filters_1 = 45 num_filters_2 = 50 num_filters_3 = 50 with tf.variable_scope('first_conv') as scope: kernel = _variable_with_weight_decay('weights', shape=[4, 8, 1, num_filters_1], stddev=5e-2, wd=0.0) conv = tf.nn.conv2d(data, kernel, [1, 1, 1, 1], padding='SAME') biases = _variable_on_gpu('biases', [num_filters_1], tf.constant_initializer(0.0)) bias = tf.nn.bias_add(conv, biases) conv1 = tf.nn.relu(bias) conv1_drop = tf.nn.dropout(conv1, keep_prob, name=scope.name) with tf.variable_scope('second_conv') as scope: kernel = _variable_with_weight_decay('weights', shape=[1, 8, 1, num_filters_2], stddev=5e-2, wd=0.0) conv = tf.nn.conv2d(data, kernel, [1, 1, 1, 1], padding='SAME') biases = _variable_on_gpu('biases', [num_filters_2], tf.constant_initializer(0.0)) bias = tf.nn.bias_add(conv, biases) conv2 = tf.nn.relu(bias) conv2_drop = tf.nn.dropout(conv2, keep_prob, name=scope.name) with tf.variable_scope('third_conv') as scope: kernel = _variable_with_weight_decay('weights', shape=[1, 8, 1, num_filters_3], stddev=5e-2, wd=0.0) conv = tf.nn.confv2d(data, kernel, [1,1,1,1], padding='SAME') biases = _variable_on_gpu('biases', [num_filters_3], tf.constant_initializer(0.0)) bias = tf.nn.bias_add(conv, biases) conv3 = tf.nn.relu(bias) conv3_drop = tf.nn.dropout(conv3, keep_prob, name=scope.name) with tf.variable_scope('max_pool') as scope: maxpool = tf.nn.max_pool(conv3_drop, ksize=[1, 25, 1, 1], strides=[1, 2, 2, 1], padding='SAME', name=scope.name) with tf.variable_scope('fc_layer') as scope: flattened = tf.flatten(maxplool, [-1]) print('FC LAYER SHAPE', flattened.get_shape().value) dim = flattened.get_shape()[0].value weights = _variable_with_weight_decay('weights', shape=[dim, NUM_CLASSES], stddev=0.04, wd=0.004) biases = _variable_on_gpu('biases', [NUM_CLASSES], tf.constant_initializer(0.0)) sigmoid_result = tf.nn.sigmoid(tf.matmul(maxpool, weights) + biases, name=scope.name) return sigmoid_result
def __call__(self, x, reuse=True): with tf.variable_scope(self.name) as vs: if reuse: vs.reuse_variables() d = tcl.fully_connected(tf.flatten(x), 64, activation_fn=tf.nn.relu,normalizer_fn=tcl.batch_norm) d = tcl.fully_connected(d, 64,activation_fn=tf.nn.relu, normalizer_fn=tcl.batch_norm) d = tcl.fully_connected(d, 64,activation_fn=tf.nn.relu, normalizer_fn=tcl.batch_norm) logit = tcl.fully_connected(d, 1, activation_fn=None) return logit
def __call__(self, x, reuse=True): with tf.variable_scope(self.name) as vs: if reuse: vs.reuse_variables() d = tcl.fully_connected(tf.flatten(x), 64, activation_fn=tf.nn.relu,normalizer_fn=tcl.batch_norm) d = tcl.fully_connected(d, 64,activation_fn=tf.nn.relu, normalizer_fn=tcl.batch_norm) d = tcl.fully_connected(d, 64,activation_fn=tf.nn.relu, normalizer_fn=tcl.batch_norm) logit = tcl.fully_connected(d, 1, activation_fn=None) return logit
def __call__(self, x, reuse=True): with tf.variable_scope(self.name) as vs: if reuse: vs.reuse_variables() size = 64 x = tcl.fully_connected(tf.flatten(x), 64, activation_fn=tf.nn.relu) x = tcl.fully_connected(x, 64, activation_fn=tf.nn.relu) x = tcl.fully_connected(x, 64, activation_fn=tf.nn.relu) logit = tcl.fully_connected(x, 1, activation_fn=None) return logit
def __call__(self, x, reuse=True): with tf.variable_scope(self.name) as vs: if reuse: vs.reuse_variables() size = 64 x = tcl.fully_connected(tf.flatten(x), 64, activation_fn=tf.nn.relu) x = tcl.fully_connected(x, 64, activation_fn=tf.nn.relu) x = tcl.fully_connected(x, 64, activation_fn=tf.nn.relu) logit = tcl.fully_connected(x, 1, activation_fn=None) return logit
def intrinsic(self, x, mass_1, weight_1, ind_1, mv_1, ds_1, l_1, mass_2, weight_2, ind_2, mv_2, ds_2, l_2, mass_3, weight_3, ind_3, mv_3, ds_3, l_3): f1 = self.surface_conv(x, mass_1, weight_1, ind_1, mv_1, ds_1, l_1, self.ker1, self.bias1, self.n_channel, self.n_ker[0]) f2 = self.surface_conv(f1, mass_2, weight_2, ind_2, mv_2, ds_2, l_2, self.ker2, self.bias2, self.n_channel, self.n_ker[1]) f3 = self.surface_conv(f2, mass_3, weight_3, ind_3, mv_3, ds_3, l_3, self.ker3, self.bias3, self.n_channel, self.n_ker[2]) f4 = self.surface_conv(f3, mass_3, weight_3, ind_3, mv_3, ds_3, l_3, self.ker4, self.bias4, self.n_channel, self.n_ker[4]) print(f4) f5 = tf.flatten(f4) print(f5) return f4
def run_cnn(): mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) learning_rate = 0.0001 epochs = 10 batch_size = 50 x = tf.placeholder(tf.float32, [None, 784]) x_shaped = tf.reshape(x, [-1, 28, 28, 1]) y = tf.placeholder(tf.float32, [None, 10]) layer1 = create_conv_layer(x_shaped, 1, 32, [5, 5], [2, 2], "layer1") layer2 = create_conv_layer(layer1, 32, 64, [5, 5], [2, 2], "layer2") flattened = tf.flatten(layer2, [-1, 3136]) wd1 = tf.Variable(tf.truncated_normal([3136, 1000], stddev=0.03), name="wd1") bd1 = tf.Variable(tf.truncated_normal([1000], stddev=0.03), name="bd1") out_layer1 = tf.matmul(flattened, wd1) + bd1 out_layer1 = tf.nn.relu(out_layer1) wd2 = tf.Variable(tf.truncated_normal([1000, 10], stddev=0.03), name="wd2") bd2 = tf.Variable(tf.truncated_normal([10], stddev=0.03), name="bd2") out_layer2 = tf.matmul(out_layer1, wd2) + bd2 y_ = tf.nn.softmax(out_layer2) cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=out_layer2, labels=y)) optimiser = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(cross_entropy) correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) init_op = tf.global_variables_initializer()
def dice_coef(y_true, y_pred): smooth = 1. y_true_f = tf.flatten(y_true) y_pred_f = tf.flatten(y_pred) intersection = tf.sum(y_true_f * y_pred_f) return (2. * intersection + smooth) / (tf.sum(y_true_f) + tf.sum(y_pred_f) + smooth)
def __init__(self, policy, ob_space, ac_space, max_grad, encoef=0.01, vcoef=0.5, klcoef=0.1, aggregator='concat', traj_len=8, nh=64): ob_shape = ob_space.shape nfeat = np.prod(ob_shape) nactions = ac_space.n self.OBS = tf.placeholder(dtype=tf.float32, shape=(None, ) + ob_shape) self.NEXT_OBS = tf.placeholder(dtype=tf.float32, shape=(None, ) + ob_shape) self.R = tf.placeholder(dtype=tf.float32, shape=(None, )) self.ADV = tf.placeholder(dtype=tf.float32, shape=(None, )) self.OLDACTIONS = tf.placeholder(dtype=tf.int32, shape=(None, )) self.OLDVALUES = tf.placeholder(dtype=tf.float32, shape=(None, )) self.OLDNLPS = tf.placeholder(dtype=tf.float32, shape=(None, )) self.CLIPRANGE = tf.placeholder(dtype=tf.float32) self.LR = tf.placeholder(dtype=tf.float32) #placeholder flat_obs = tf.flatten(self.OBS) flat_next = tf.flatten(self.NEXT_OBS) pdtype = make_pdtype(ac_space) Aggregator = {'concat': tf.layers.flatten}[aggregator] self.sess = tf.get_default_session() encoder_params = [nh, tf.contrib.rnn.BasicLSTMCell, None, 'Encoder'] model_params = [ traj_len, 'Env_Model', self.LR, nh, nfeat, vcoef, tf.nn.tanh, max_grad ] mb_policy_params = ['Model_Based', nh, tf.nn.tanh] mf_policy_params = ['Model_Free', nh, tf.nn.tanh] trajectories = [] # Imagination Core # trajectory encoder self.model_free_policy = MFPolicy(flat_obs, pdtype, *mf_policy_params) model_free_pd = self.model_free_policy.pd(flat_obs)[0] model_free_output = model_free_pd.logits # model free policy for imagined rollouts self.environment_model = EnvironmentModel(flat_obs, nactions, self.OLDACTIONS, flat_next, self.R, self.model_free_policy, *model_params) # trajectory rollout model trajectories = tf.reshape( tf.stack(self.environment_model.trajectories), [1, 0, 2, 3]) self.encoder = Encoder(trajectories, *encoder_params) encoded_traj = self.encoder.encoded_traj plan = Aggregator(encoded_traj) # encoding self.model_based_policy = MBPolicy(flat_obs, model_free_output, plan, pdtype, *mb_policy_params) # model based policy self.act = self.model_based_policy.act nlp = self.model_based_policy.pd.neglogp(self.OLDACTIONS) val = self.model_based_policy.vf # training terms adv = self.ADV ratio = tf.exp(self.OLDNLPS - nlp) pl1 = -adv * ratio pl2 = -adv * tf.clip_by_value(ratio, 1.0 - self.CLIPRANGE, 1.0 + self.CLIPRANGE) ploss = tf.reduce_mean(tf.maximum(pl1, pl2)) vclip = self.OLDVALUES + tf.clip_by_value( val - self.OLDVALUES, -self.CLIPRANGE, self.CLIPRANGE) vf_losses1 = tf.square(val - self.R) vf_losses2 = tf.square(vclip - self.R) vloss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2)) self.approxkl = .5 * tf.reduce_mean(tf.square(nlp - self.OLDNLPS)) self.clipfrac = tf.reduce_mean( tf.to_float(tf.greater(tf.abs(ratio - 1.0), self.CLIPRANGE))) cross_entropy = model_free_pd.kl(self.model_based_policy.pd) label_entropy = self.model_based_policy.pd.entropy() logit_entropy = model_free_pd.entropy() entropy = klcoef * cross_entropy - encoef * (label_entropy + logit_entropy) self.rl_loss = ploss + vloss + entropy optimizer = tf.train.AdamOptimizer(self.LR) params = tf.trainable_variables() grads = tf.gradients(self.rl_loss, params) if max_grad is not None: grads, _grad_norm = tf.clip_by_global_norm(grads, max_grad) grads = list(zip(grads, params)) #self.rl_trainer = optimizer.apply_gradients(grads) self.rl_trainer = tf.no_op() self.environment_trainer = self.environment_model.trainer self.curiosity = self.environment_model.curiosity self.ploss = ploss self.vloss = vloss self.entropy = entropy self.nlp = nlp self.values = val self.loss_names = ['approxkl', 'clipfrac', 'ploss', 'vloss', 'entropy'] tf.global_variables_initializer().run(session=self.sess)
def dice_coefficient(y1, y2): y1 = tf.flatten(y1) y2 = tf.flatten(y2) return (2. * tf.sum(y1 * y2) + smoothness) / (tf.sum(y1) + tf.sum(y2) + smoothness)
predictions = model.predict(x[:20]) print("predictions:", predictions) print("results:", y[:20]) test_stream = read_g729_norm('dtmf_2021_H_02_H_18.vol1.0.18') i = 0 while i < len(test_stream): tf = test_stream[i:i + 10] if len(tf) < 10: break #res = [] #for row in np.transpose(tf): # res.append(scipy.fft.dct(row)) #tf = np.array(res).flatten() tf = tf.flatten() predictions = model.predict(np.array([ tf, ])) didx = np.argmax(predictions) dtmf = g729_model_ovec[didx] if dtmf != None: print(i, dtmf, predictions[0][didx]) i += 10 else: i += 1 if i % 10 == 0: print('_')
def dice_coefficient(y1, y2): y1 = tf.flatten(y1) y2 = tf.flatten(y2) return (2. * tf.sum(y1 * y2) + smoothness) / (tf.sum(y1) + tf.sum(y2) + smoothness)