def compute_moments(self, x): ''' compute moments of output Gaussian distribution INPUTS: x - input OUTPUTS: mu_y - mean of output Gaussian distribution log_sig_sq_y - log variance of output Gaussian distribution ''' hidden1_pre = tfm.add(tfl.matmul(x, self.weights['W_x_to_h1']), self.weights['b_x_to_h1']) hidden_post = self.nonlinearity(hidden1_pre) num_layers_middle = np.shape(self.N_h)[0] - 1 for i in range(num_layers_middle): ni = i + 2 hidden_pre = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_h{}'.format(ni - 1, ni)]), self.weights['b_h{}_to_h{}'.format(ni - 1, ni)]) hidden_post = self.nonlinearity(hidden_pre) mu_y = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_muy'.format(ni)]), self.weights['b_h{}_to_muy'.format(ni)]) mu_y = tf.nn.sigmoid(mu_y) log_sig_sq_y = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_sy'.format(ni)]), self.weights['b_h{}_to_sy'.format(ni)]) log_sig_sq_y = 100 * (tf.nn.sigmoid(log_sig_sq_y / 100) - 0.5) return mu_y, log_sig_sq_y
def compute_moments(self, x): ''' compute moments of latent Gaussian distribution INPUTS: x - conditional input OUTPUTS: mu_z - mean of latent Gaussian distribution log_sig_sq_z - log variance of latent Gaussian distribution ''' hidden1_pre = tfm.add(tfl.matmul(x, self.weights['W_x_to_h1']), self.weights['b_x_to_h1']) hidden_post = self.nonlinearity(hidden1_pre) num_layers_middle = np.shape(self.N_h)[0] - 1 for i in range(num_layers_middle): ni = i + 2 hidden_pre = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_h{}'.format(ni - 1, ni)]), self.weights['b_h{}_to_h{}'.format(ni - 1, ni)]) hidden_post = self.nonlinearity(hidden_pre) mu_z = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_muz'.format(ni)]), self.weights['b_h{}_to_muz'.format(ni)]) log_sig_sq_z = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_sz'.format(ni)]), self.weights['b_h{}_to_sz'.format(ni)]) log_sig_sq_z = self.sig_lim * ( tf.nn.sigmoid(log_sig_sq_z / self.sig_lim) - 0.5) return mu_z, log_sig_sq_z
def compute_py(self, x): ''' compute probability for each class INPUTS: x - input OUTPUTS: py - histogram of probabilities for each class ''' hidden1_pre = tfm.add(tfl.matmul(x, self.weights['W_x_to_h1']), self.weights['b_x_to_h1']) hidden_post = self.nonlinearity(hidden1_pre) num_layers_middle = np.shape(self.N_h)[0] - 1 for i in range(num_layers_middle): ni = i + 2 hidden_pre = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_h{}'.format(ni - 1, ni)]), self.weights['b_h{}_to_h{}'.format(ni - 1, ni)]) hidden_post = self.nonlinearity(hidden_pre) p_un = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_py'.format(ni)]), self.weights['b_h{}_to_py'.format(ni)]) p_un = tf.nn.sigmoid(p_un) + 1e-6 py = tfm.divide( p_un, tf.tile(tf.expand_dims(tfm.reduce_sum(p_un, axis=1), axis=1), [1, self.n_y])) return py
def compute_py(self, xl): ''' compute moments of output Gaussian distribution INPUTS: x - input OUTPUTS: mu_y - mean of output Gaussian distribution log_sig_sq_y - log variance of output Gaussian distribution ''' x, _ = NN_utils.reshape_and_extract(xl, self.sz_im) hidden_post = layers.tf_conv_layer(x, self.weights['W_x_to_h1'], self.weights['b_x_to_h1'], self.St[0], self.nonlinearity) # print(tf.shape(hidden_post).numpy()) num_layers_1 = np.shape(self.N_h1)[0] - 1 for i in range(num_layers_1): ni = i + 2 hidden_post = layers.tf_conv_layer( hidden_post, self.weights['W_h{}_to_h{}'.format(ni - 1, ni)], self.weights['b_h{}_to_h{}'.format(ni - 1, ni)], self.St[ni - 1], self.nonlinearity) # print(tf.shape(hidden_post).numpy()) hidden_post = NN_utils.flatten(hidden_post) # print(tf.shape(hidden_post).numpy()) num_layers_F = np.shape(self.NF_h)[0] for i in range(num_layers_F): ni = ni + 1 hidden_pre = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_h{}'.format(ni - 1, ni)]), self.weights['b_h{}_to_h{}'.format(ni - 1, ni)]) hidden_post = self.nonlinearity(hidden_pre) # print(tf.shape(hidden_post).numpy()) p_un = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_py'.format(ni)]), self.weights['b_h{}_to_py'.format(ni)]) p_un = tf.nn.sigmoid(p_un) + 1e-6 py = tfm.divide( p_un, tf.tile(tf.expand_dims(tfm.reduce_sum(p_un, axis=1), axis=1), [1, self.n_y])) return py
def call(self, x, beta): if self.res == 1: h_stack, v_stack = tf.unstack(x, axis=-1) else: h_stack = x v_stack = x #Vertical stack is acted by a vertical convolution #equivalent to a masked one v_stack = self.ver_cropping(v_stack) v_stack = self.ver_padding(v_stack) v_stack = self.ver_conv(v_stack) v_stack += self.ver_seq(beta) #Horizontal stack is acted by a horizontal convolution #equivalent to a masked one- h_stack2 is kept for later h_stack2 = h_stack h_stack = self.hor_cropping(h_stack) h_stack = self.hor_padding(h_stack) h_stack = self.hor_conv(h_stack) h_stack = tfm.add(h_stack, self.hor_seq(beta)) #Add v_stack to h_stack h_stack = tfm.add(h_stack, v_stack) #"Gating" performed on horizontal stack h_stack0, h_stack1 = tf.split(h_stack, 2, axis=-1) h_stack0 = tfk.activations.tanh(h_stack0) h_stack1 = tfk.activations.sigmoid(h_stack1) h_stack = tfm.multiply(h_stack0, h_stack1) #"Gating" and convolving vertical stack if not self.last_layer: v_stack0, v_stack1 = tf.split(v_stack, 2, axis=-1) v_stack0 = tfk.activations.tanh(v_stack0) v_stack1 = tfk.activations.sigmoid(v_stack1) v_stack = tfm.multiply(v_stack0, v_stack1) v_stack = self.ver_conv2(v_stack) #Convolve h_stack2, h_stack and connect them h_stack = self.hor_conv2(h_stack) if self.res: h_stack2 = self.res_conv(h_stack2) h_stack = tfm.add(h_stack, h_stack2) if self.last_layer: output = h_stack else: output = tf.stack([h_stack, v_stack], axis=-1) return output
def trainModel(self, infos): with self.graph.as_default(): states = tf.constant([i["state"].tolist() for i in infos], shape=[infos.size, 24]) rewards = tf.constant([i["reward"] for i in infos], dtype=tf.float32, shape=[infos.size, 1]) # next_states = tf.constant([i["next_state"].tolist() for i in infos], shape=[infos.size, 24]) actions = tf.constant([i["action"] for i in infos], dtype=tf.float32, shape=[infos.size, 12]) # Qtargets = tf.constant(self.model.predict(next_states, steps=1), shape=[infos.size, 12]) # Recupere l'etat actuel targets = tf.constant(self.model.predict(states, steps=1), shape=[infos.size, 12]) # Calcure le mask negatif mask = tf.ones([infos.size, 12], dtype=tf.float32) mask = tfm.subtract(mask, actions) # Applique le mask négatif targets = tfm.multiply(targets, mask) # Calcure le mask positif mask = tfm.multiply(rewards, actions) # Applique le mask positif targets = tfm.add(targets, mask) self.model.fit(states, targets, steps_per_epoch=200) # 1000
def time_step(self, x, y1, y2): """Take a step through time. Parameters ---------- x : Input value(s) at current time step, batched in first dimension y1 : Scalar wave field one time step ago (part of the hidden state) y2 : Scalar wave field two time steps ago (part of the hidden state) """ dt = self.dt c = self.c b = self.b term_a = 2 + dt**2*math.multiply(c.pow(2), self.compute_laplacian(y1)) term_two = math.multiply(-1 - dt * b, y2) denominator = dt ** (-2) + b * 0.5 * dt ** (-1) y = math.multiply(denominator.pow(-1), math.add(term_a, term_two)) # Insert the source y_out = y[:, self.src_x, self.src_y] y_out = y_out + tf.broadcast_to(x, tf.shape(y_out)) return y_out, y1
def call(self, x, beta): if self.res: l_stack, m_stack, r_stack = tf.unstack(x, axis=-1) m_stack2 = m_stack else: l_stack = x r_stack = x m_stack = tf.zeros_like(x) #Left stack is cropped, padded followed by convolution l_stack = self.l_cropping(l_stack) l_stack = self.l_padding(l_stack) l_stack = self.l_conv(l_stack) #Conditioning on beta l_stack += self.l_seq(beta) #Right stack is cropped, padded followed by convolution r_stack = self.r_cropping(r_stack) r_stack = self.r_padding(r_stack) r_stack = self.r_conv(r_stack) #Conditioning on beta r_stack += self.r_seq(beta) #Update/initialise m_stack m_stack = self.m_conv(m_stack) m_stack += tfm.add(l_stack, r_stack) #Gating operation on m_stack m_stack0, m_stack1 = tf.split(m_stack, 2, axis=-1) m_stack0 = tfk.activations.tanh(m_stack0) m_stack1 = tfk.activations.sigmoid(m_stack1) m_stack = tfm.multiply(m_stack0, m_stack1) if not self.last_layer: l_stack = self.l_conv2(l_stack) r_stack = self.r_conv2(r_stack) #Convolve m_stack2, m_stack and connect them m_stack = self.m_conv2(m_stack) if self.res: m_stack2 = self.m_res_conv(m_stack2) m_stack = tfm.add(m_stack, m_stack2) if self.last_layer: output = m_stack else: output = tf.stack([l_stack, m_stack, r_stack], axis=-1) return output
def call(self, x): for i in range(self.net_depth + 1): x = self.custom_layers[i](x) if self.z2 and x.shape[1] == self.L: x_hat = tfm.multiply(x, self.x_hat_mask) x_hat = tfm.add(x_hat, self.x_hat_bias) else: x_hat = x return x_hat
def call(self, x): if self.res: h_stack, v_stack = tf.unstack(x, axis=-1) else: h_stack = x v_stack = x #Vertical stack is acted by a vertical convolution #equivalent to a masked one v_stack = self.ver_cropping(v_stack) v_stack = self.ver_padding(v_stack) v_stack = self.ver_conv(v_stack) #Horizontal stack is acted by a horizontal convolution #equivalent to a masked one- h_stack2 is kept for later h_stack2 = h_stack h_stack = self.hor_cropping(h_stack) h_stack = self.hor_padding(h_stack) h_stack = self.hor_conv(h_stack) #Connect horizontal and vertical stacks h_stack = tfm.add(h_stack, v_stack) #Convolve and act translationally invariant version of Prelu using #tf.maximum and passing user-defined scalar variable for alpha h_stack = tfm.maximum(self.alpha_scalar * h_stack, h_stack) h_stack = self.sec_conv(h_stack) if not self.last_layer: v_stack = tfm.maximum(self.alpha_scalar2 * h_stack, h_stack) v_stack = self.sec_conv2(v_stack) #Make a residual connection between input state and output if self.res == 1: h_stack2 = self.res_conv(h_stack2) h_stack = tfm.add(h_stack, h_stack2) if self.last_layer: output = h_stack else: output = tf.stack([h_stack, v_stack], axis=-1) #Act with non-linear activation function return output
def compute_moments(self, z, constrain=True): ''' compute moments of input/output Gaussian distribution INPUTS: z - latent variable OPTIONAL INPUTS: constrain - whether to force the output mean to be between 0 and 1 OUTPUTS: mu_x - mean of output Gaussian distribution log_sig_sq_x - log variance of output Gaussian distribution ''' hidden1_pre = tfm.add(tfl.matmul(z, self.weights['W_z_to_h1']), self.weights['b_z_to_h1']) hidden_post = self.nonlinearity(hidden1_pre) num_layers_middle = np.shape(self.N_h)[0] - 1 for i in range(num_layers_middle): ni = i + 2 hidden_pre = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_h{}'.format(ni - 1, ni)]), self.weights['b_h{}_to_h{}'.format(ni - 1, ni)]) hidden_post = self.nonlinearity(hidden_pre) mu_x = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_mux'.format(ni)]), self.weights['b_h{}_to_mux'.format(ni)]) if constrain == True: mu_x = tf.nn.sigmoid(mu_x) log_sig_sq_x = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_sx'.format(ni)]), self.weights['b_h{}_to_sx'.format(ni)]) log_sig_sq_x = self.sig_lim * ( tf.nn.sigmoid(log_sig_sq_x / self.sig_lim) - 0.5) return mu_x, log_sig_sq_x
def call(self, x): X = [] for i in range(self.n_activations): self.i = i frame = x[:, :, i:i + 1] sigma1 = K.variable( np.zeros((self.batch, frame.shape[1], frame.shape[2]))) for j in range(self.v_order): j_fact = math.factorial(j) p = tfm.divide(K.pow(frame, j), j_fact) sigma1 = tfm.add(sigma1, tfm.multiply(self.v[i][j], p)) sigma2 = K.variable( np.zeros((self.batch, frame.shape[1], frame.shape[2]))) for j in range(1, self.w_order + 1): self.k = j sigma2 = tfm.add(sigma2, K.map_fn(self.basis2, frame)) X.append(tfm.add(sigma1, sigma2)) output = K.concatenate(X, axis=2) return output
def reparameterisation_trick(mu, log_sig_sq): ''' Sample from Gaussian such that it stays differentiable INPUTS: mu - mean of distribution log_sig_sq - log variance of diatribution OUTPUTS: samp - sample from distribution ''' eps = tf.random.normal([tf.shape(mu)[0], tf.shape(mu)[1]], 0, 1., dtype=tf.float32) samp = tfm.add(mu, tfm.multiply(tfm.sqrt(tfm.exp(log_sig_sq)), eps)) return samp
def call(self, x, beta): """Produces the network output for a sample Args: x (float32): A sample configuration of Ising model beta (float32): Inverse temperature Returns: float32: Probabilities of +1 value at every lattice site """ for i in range(self.net_depth): x = self.custom_layers[i](x, beta) x = self.custom_layers[self.net_depth](x) if self.z2 and x.shape[1] == self.L: x_hat = tfm.multiply(x, self.x_hat_mask) x_hat = tfm.add(x_hat, self.x_hat_bias) else: x_hat = x return x_hat
def compute_moments(self, z, x, x2, constrain=True): ''' compute moments of output Gaussian distribution INPUTS: x - conditional input x2 - conditional input z - latent variable OPTIONAL INPUTS: constrain - whether to force the output mean to be between 0 and 1 OUTPUTS: mu_y - mean of output Gaussian distribution log_sig_sq_y - log variance of output Gaussian distribution ''' # Channel for latent variable alone hidden_pre_z = tfm.add(tfl.matmul(z, self.weights['W_z_to_h1z']), self.weights['b_z_to_h1z']) hidden_post_z = self.nonlinearity(hidden_pre_z) num_layers_middle_z = np.shape(self.N_hz)[0] - 1 for i in range(num_layers_middle_z): ni = i + 2 hidden_pre_z = tfm.add( tfl.matmul(hidden_post_z, self.weights['W_h{}z_to_h{}z'.format(ni - 1, ni)]), self.weights['b_h{}z_to_h{}z'.format(ni - 1, ni)]) hidden_post_z = self.nonlinearity(hidden_pre_z) # Channel for first conditional input alone hidden_pre_x = tfm.add(tfl.matmul(x, self.weights['W_x_to_h1x']), self.weights['b_x_to_h1x']) hidden_post_x = self.nonlinearity(hidden_pre_x) num_layers_middle_x = np.shape(self.N_hx)[0] - 1 for i in range(num_layers_middle_x): ni = i + 2 hidden_pre_x = tfm.add( tfl.matmul(hidden_post_x, self.weights['W_h{}x_to_h{}x'.format(ni - 1, ni)]), self.weights['b_h{}x_to_h{}x'.format(ni - 1, ni)]) hidden_post_x = self.nonlinearity(hidden_pre_x) # Channel for second conditional input alone hidden_pre_x2 = tfm.add(tfl.matmul(x2, self.weights['W_x2_to_h1x2']), self.weights['b_x2_to_h1x2']) hidden_post_x2 = self.nonlinearity(hidden_pre_x2) num_layers_middle_x2 = np.shape(self.N_hx2)[0] - 1 for i in range(num_layers_middle_x2): ni = i + 2 hidden_pre_x2 = tfm.add( tfl.matmul(hidden_post_x2, self.weights['W_h{}x2_to_h{}x2'.format(ni - 1, ni)]), self.weights['b_h{}x2_to_h{}x2'.format(ni - 1, ni)]) hidden_post_x2 = self.nonlinearity(hidden_pre_x2) hidden_post = tf.concat([hidden_post_z, hidden_post_x, hidden_post_x2], 1) # Channel after combining the inputs hidden_pre = tfm.add( tfl.matmul(hidden_post, self.weights['W_h0_to_h1']), self.weights['b_h0_to_h1']) hidden_post = self.nonlinearity(hidden_pre) num_layers_middle = np.shape(self.N_h)[0] - 1 for i in range(num_layers_middle): ni = i + 2 hidden_pre = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_h{}'.format(ni - 1, ni)]), self.weights['b_h{}_to_h{}'.format(ni - 1, ni)]) hidden_post = self.nonlinearity(hidden_pre) mu_y = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_muy'.format(ni)]), self.weights['b_h{}_to_muy'.format(ni)]) if constrain == True: mu_y = tf.nn.sigmoid(mu_y) log_sig_sq_y = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_sy'.format(ni)]), self.weights['b_h{}_to_sy'.format(ni)]) log_sig_sq_y = self.sig_lim * ( tf.nn.sigmoid(log_sig_sq_y / self.sig_lim) - 0.5) return mu_y, log_sig_sq_y
def iou_metrics(Y_true, Y_pred, defaults): """ Input: - Y_true, Y_pred: tensors of shape (batch_size, n_defaults, 1 + numClasses + 4) Output: - iou_metric: The total overlapping area for positive coords_pred between Y_true and Y_pred """ # Create a mask for positive boxes pos_mask = tf.cast(tf.reduce_max(Y_true[:, :, 1:-4], axis=-1), 'float64') pos_mask = tf.expand_dims(pos_mask, axis=-1) Y_true = tf.cast(Y_true, 'float64') Y_pred = tf.cast(Y_pred, 'float64') defaults = tf.cast(tf.constant(defaults), 'float64') xy_pred = add(multiply(Y_pred[:, :, -4:-2], defaults[:, -2:]), defaults[:, :2]) wh_pred = multiply(exp(Y_pred[:, :, -2:]), defaults[:, -2:]) xy_true = add(multiply(Y_true[:, :, -4:-2], defaults[:, -2:]), defaults[:, :2]) wh_true = multiply(exp(Y_true[:, :, -2:]), defaults[:, -2:]) x1, y1 = tf.split(xy_pred, 2, axis=2) w1, h1 = tf.split(wh_pred, 2, axis=2) x2, y2 = tf.split(xy_true, 2, axis=2) w2, h2 = tf.split(wh_true, 2, axis=2) x12 = add(x1, w1) x22 = add(x2, w2) y12 = add(y1, h1) y22 = add(y2, h2) topleft_x = maximum(x1, x2) topleft_y = maximum(y1, y2) botright_x = minimum(x12, x22) botright_y = minimum(y12, y22) intersect = multiply( maximum(botright_x - topleft_x, tf.cast(0, 'float64')), maximum(botright_y - topleft_y, tf.cast(0, 'float64'))) # Calculate areas of every coords_true coords_pred and ground-truth coords_pred area_pred = multiply(w1, h1) area_truth = multiply(w2, h2) # Union of area union = add(add(area_pred, area_truth), multiply(tf.cast(-1, 'float64'), intersect)) # Avoid division by 0 union = maximum(union, 1e-8) iou_matrix = maximum(tf.math.divide(intersect, union), tf.cast(0, 'float64')) # Only keep the positive boxes iou_matrix = multiply(iou_matrix, pos_mask) num_pos = K.sum(pos_mask) def fn(): return tf.math.divide(K.sum(iou_matrix), tf.cast(num_pos, 'float64')) def fn0(): return tf.cast(0, 'float64') iou_total = tf.cond(tf.equal(num_pos, tf.cast(0, 'float64')), true_fn=lambda: fn0(), false_fn=lambda: fn()) return iou_total
def cart2pol(x, y): theta = tfm.atan2(y, x) rho = tfm.sqrt(tfm.add(tfm.square(x), tfm.square(y))) return (theta, rho)
def tf_ssim(x, y, is_normalized=False): """ k1 = 0.01 k2 = 0.03 L = 1.0 if is_normalized else 255.0 c1 = np.power(k1 * L, 2) c2 = np.power(k2 * L, 2) c3 = c2 / 2 """ k1 = 0.01 k2 = 0.03 L = 1.0 if is_normalized else 255.0 c1 = tf_pow(multiply(k1, L), 2.0) c2 = tf_pow(multiply(k2, L), 2.0) c3 = divide(c2, 2.0) # if type(x) is np.ndarray: # x = tf.convert_to_tensor(x, dtype=tf.float32) # if type(y) is np.ndarray: # y = tf.convert_to_tensor(y, dtype=tf.float32) """ ux = x.mean() uy = y.mean() """ ux = tf_mean(x) uy = tf_mean(y) """ std_x = x.std() std_y = y.std() """ std_x = tf_std(x) std_y = tf_std(y) """ xy = (x - ux) * (y - uy) std_xy = xy.mean() """ xy = multiply(subtract(x, ux), subtract(y, uy)) std_xy = tf_mean(xy) """ l_xy = (2 * ux * uy + c1) / (np.power(ux, 2) + np.power(uy, 2) + c1) """ l_son = add(multiOperation(multiply, 2.0, ux, uy), c1) l_mom = multiOperation(add, tf_pow(ux, 2.0), tf_pow(uy, 2.0), c1) l_xy = divide(l_son, l_mom) """ c_xy = (2 * std_x * std_y + c2) / (np.power(std_x, 2) + np.power(std_y, 2) + c2) """ c_son = add(multiOperation(multiply, 2.0, std_x, std_y), c2) c_mom = multiOperation(add, tf_pow(std_x, 2.0), tf_pow(std_y, 2.0), c2) c_xy = divide(c_son, c_mom) """ s_xy = (std_xy + c3) / (std_x * std_y + c3) """ s_son = add(std_xy, c3) s_mom = add(multiply(std_x, std_y), c3) s_xy = divide(s_son, s_mom) one = tf.constant(1.0) _ssim = multiOperation(multiply, l_xy, c_xy, s_xy) _result = tf.cond(greater(_ssim, one), lambda: one, lambda: _ssim) return _result
def f1(): return tfm.add( tfm.subtract(tfm.divide(tfm.multiply(x, x), 2), tfm.multiply(k_1, x)), tfm.divide(tfm.multiply(k_1, k_1), 2))
def f2(): val1 = tfm.divide( tfm.multiply(tfm.subtract(k, k_1), tfm.subtract(k, k_1)), 2) val2 = tfm.multiply(tfm.subtract(k, k_1), tfm.subtract(x, k)) val = tfm.add(val1, val2) return val
def compute_moments(self, y, x, x2): ''' compute moments of latent Gaussian distribution INPUTS: x - conditional input y - output to encode OUTPUTS: mu_z - mean of output Gaussian distribution log_sig_sq_z - log variance of output Gaussian distribution ''' # Channel for input/output alone hidden_pre_y = tfm.add(tfl.matmul(y, self.weights['W_y_to_h1y']), self.weights['b_y_to_h1y']) hidden_post_y = self.nonlinearity(hidden_pre_y) num_layers_middle_y = np.shape(self.N_hy)[0] - 1 for i in range(num_layers_middle_y): ni = i + 2 hidden_pre_y = tfm.add( tfl.matmul(hidden_post_y, self.weights['W_h{}y_to_h{}y'.format(ni - 1, ni)]), self.weights['b_h{}y_to_h{}y'.format(ni - 1, ni)]) hidden_post_y = self.nonlinearity(hidden_pre_y) # Channel for conditional input alone hidden_pre_x = tfm.add(tfl.matmul(x, self.weights['W_x_to_h1x']), self.weights['b_x_to_h1x']) hidden_post_x = self.nonlinearity(hidden_pre_x) num_layers_middle_x = np.shape(self.N_hx)[0] - 1 for i in range(num_layers_middle_x): ni = i + 2 hidden_pre_x = tfm.add( tfl.matmul(hidden_post_x, self.weights['W_h{}x_to_h{}x'.format(ni - 1, ni)]), self.weights['b_h{}x_to_h{}x'.format(ni - 1, ni)]) hidden_post_x = self.nonlinearity(hidden_pre_x) # Channel for second conditional input alone hidden_pre_x2 = tfm.add(tfl.matmul(x2, self.weights['W_x2_to_h1x2']), self.weights['b_x2_to_h1x2']) hidden_post_x2 = self.nonlinearity(hidden_pre_x2) num_layers_middle_x2 = np.shape(self.N_hx2)[0] - 1 for i in range(num_layers_middle_x2): ni = i + 2 hidden_pre_x2 = tfm.add( tfl.matmul(hidden_post_x2, self.weights['W_h{}x2_to_h{}x2'.format(ni - 1, ni)]), self.weights['b_h{}x2_to_h{}x2'.format(ni - 1, ni)]) hidden_post_x2 = self.nonlinearity(hidden_pre_x2) hidden_post = tf.concat([hidden_post_y, hidden_post_x, hidden_post_x2], 1) # Channel after combining the inputs hidden_pre = tfm.add( tfl.matmul(hidden_post, self.weights['W_h0_to_h1']), self.weights['b_h0_to_h1']) hidden_post = self.nonlinearity(hidden_pre) num_layers_middle = np.shape(self.N_h)[0] - 1 for i in range(num_layers_middle): ni = i + 2 hidden_pre = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_h{}'.format(ni - 1, ni)]), self.weights['b_h{}_to_h{}'.format(ni - 1, ni)]) hidden_post = self.nonlinearity(hidden_pre) mu_z = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_muz'.format(ni)]), self.weights['b_h{}_to_muz'.format(ni)]) log_sig_sq_z = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_sz'.format(ni)]), self.weights['b_h{}_to_sz'.format(ni)]) log_sig_sq_z = self.sig_lim * ( tf.nn.sigmoid(log_sig_sq_z / self.sig_lim) - 0.5) return mu_z, log_sig_sq_z
def call(self, x): x_hat = self.net(x) if self.z2: x_hat = tfm.multiply(x_hat, self.x_hat_mask) x_hat = tfm.add(x_hat, self.x_hat_bias) return x_hat
def compute_moments(self, xl): ''' compute moments of output Gaussian distribution INPUTS: x - input OUTPUTS: mu_y - mean of output Gaussian distribution log_sig_sq_y - log variance of output Gaussian distribution ''' x, l = NN_utils.reshape_and_extract(xl, self.sz_im) hidden_post = layers.tf_conv_layer(x, self.weights['W_x_to_h1'], self.weights['b_x_to_h1'], self.St[0], self.nonlinearity) # print(tf.shape(hidden_post).numpy()) num_layers_1 = np.shape(self.N_h1)[0] - 1 for i in range(num_layers_1): ni = i + 2 hidden_post = layers.tf_conv_layer( hidden_post, self.weights['W_h{}_to_h{}'.format(ni - 1, ni)], self.weights['b_h{}_to_h{}'.format(ni - 1, ni)], self.St[ni - 1], self.nonlinearity) # print(tf.shape(hidden_post).numpy()) hidden_post = NN_utils.flatten(hidden_post) hidden_post = tf.concat([hidden_post, l], axis=1) # print(tf.shape(hidden_post).numpy()) num_layers_F = np.shape(self.NF_h)[0] for i in range(num_layers_F): ni = ni + 1 hidden_pre = tfm.add( tfl.matmul(hidden_post, self.weights['W_h{}_to_h{}'.format(ni - 1, ni)]), self.weights['b_h{}_to_h{}'.format(ni - 1, ni)]) hidden_post = self.nonlinearity(hidden_pre) # print(tf.shape(hidden_post).numpy()) hidden_post = NN_utils.reshape_to_images(hidden_post, self.Sz2[0, :]) # print(tf.shape(hidden_post).numpy()) num_layers_2 = np.shape(self.N_h2)[0] for i in range(num_layers_2): ni = ni + 1 hidden_post = layers.tf_conv_layer( hidden_post, self.weights['W_h{}_to_h{}'.format(ni - 1, ni)], self.weights['b_h{}_to_h{}'.format(ni - 1, ni)], self.St[ni - 1], self.nonlinearity) # print(tf.shape(hidden_post).numpy()) mu_y = layers.tf_conv_layer(hidden_post, self.weights['W_h{}_to_muy'.format(ni)], self.weights['b_h{}_to_muy'.format(ni)], 1, self.nonlinearity) mu_y = tf.nn.sigmoid(mu_y) log_sig_sq_y = layers.tf_conv_layer( hidden_post, self.weights['W_h{}_to_sy'.format(ni)], self.weights['b_h{}_to_sy'.format(ni)], 1, self.nonlinearity) log_sig_sq_y = 100 * (tf.nn.sigmoid(log_sig_sq_y / 100) - 0.5) mu_y = NN_utils.flatten(mu_y) mu_y = tf.concat([mu_y, tf.zeros([tf.shape(mu_y)[0], 1])], axis=1) log_sig_sq_y = NN_utils.flatten(log_sig_sq_y) log_sig_sq_y = tf.concat( [log_sig_sq_y, tf.zeros([tf.shape(log_sig_sq_y)[0], 1])], axis=1) return mu_y, log_sig_sq_y