def generate(self, xs): zs = self.make_noise(len(xs)) hs_0 = F.leaky_relu(self.l0_dense(xs), slope=0.2) hs_0 = F.concat([hs_0, zs], axis=1) hs_0 = self.l1_bn(self.l1_dense(hs_0)).reshape( (len(xs), -1, self.s16, self.s16)) hs_1 = F.relu(self.l2_bn(self.l2_conv(hs_0))) hs_1 = F.relu(self.l3_bn(self.l3_conv(hs_1))) hs_1 = self.l4_bn(self.l4_conv(hs_1)) hs_2 = F.relu(F.add(hs_0, hs_1)) hs_2 = self.l5_deconv(hs_2) hs_2 = self.l5_bn(self.l5_conv(hs_2)) hs_3 = F.relu(self.l6_bn(self.l6_conv(hs_2))) hs_3 = F.relu(self.l7_bn(self.l7_conv(hs_3))) hs_3 = self.l8_bn(self.l8_conv(hs_3)) hs_4 = F.relu(F.add(hs_2, hs_3)) hs_4 = self.l9_deconv(hs_4) hs_4 = F.relu(self.l9_bn(self.l9_conv(hs_4))) hs_5 = self.l10_deconv(hs_4) hs_5 = F.relu(self.l10_bn(self.l10_conv(hs_5))) hs_6 = self.l11_deconv(hs_5) hs_6 = F.tanh(self.l11_conv(hs_6)) return cuda.to_cpu(hs_6.data)
def forward(self, xs): zs = self.make_noise() hs_0 = F.leaky_relu(self.l0_dense(xs), slope=0.2) hs_0 = F.concat([hs_0, zs], axis=1) hs_0 = self.l1_bn(self.l1_dense(hs_0)).reshape( (self.batch_size, -1, self.s16, self.s16)) hs_1 = F.relu(self.l2_bn(self.l2_conv(hs_0))) hs_1 = F.relu(self.l3_bn(self.l3_conv(hs_1))) hs_1 = self.l4_bn(self.l4_conv(hs_1)) hs_2 = F.relu(F.add(hs_0, hs_1)) hs_2 = self.l5_deconv(hs_2) hs_2 = self.l5_bn(self.l5_conv(hs_2)) hs_3 = F.relu(self.l6_bn(self.l6_conv(hs_2))) hs_3 = F.relu(self.l7_bn(self.l7_conv(hs_3))) hs_3 = self.l8_bn(self.l8_conv(hs_3)) hs_4 = F.relu(F.add(hs_2, hs_3)) hs_4 = self.l9_deconv(hs_4) hs_4 = F.relu(self.l9_bn(self.l9_conv(hs_4))) hs_5 = self.l10_deconv(hs_4) hs_5 = F.relu(self.l10_bn(self.l10_conv(hs_5))) hs_6 = self.l11_deconv(hs_5) hs_6 = F.tanh(self.l11_conv(hs_6)) return hs_6
def __call__(self, atoms_feat, pair_feat, global_feat, atom_idx, pair_idx, start_idx, end_idx): # 1) Pass the Dense layer a_f_d = self.dense_for_atom(atoms_feat) p_f_d = self.dense_for_pair(pair_feat) g_f_d = self.dense_for_global(global_feat) # 2) Update the edge vector start_node = a_f_d[start_idx] end_node = a_f_d[end_idx] g_f_extend_with_pair_idx = g_f_d[pair_idx] concat_p_v = functions.concat( (p_f_d, start_node, end_node, g_f_extend_with_pair_idx)) update_p = self.update_for_atom(concat_p_v) # 3) Update the node vector # 1. get sum edge feature of all nodes using scatter_add method zero = self.xp.zeros(a_f_d.shape, dtype=self.xp.float32) sum_edeg_vec = functions.scatter_add(zero, start_idx, update_p) + \ functions.scatter_add(zero, end_idx, update_p) # 2. get degree of all nodes using scatter_add method one = self.xp.ones(p_f_d.shape, dtype=self.xp.float32) degree = functions.scatter_add(zero, start_idx, one) + \ functions.scatter_add(zero, end_idx, one) # 3. get mean edge feature of all nodes mean_edge_vec = sum_edeg_vec / degree # 4. concating g_f_extend_with_atom_idx = g_f_d[atom_idx] concat_a_v = functions.concat( (a_f_d, mean_edge_vec, g_f_extend_with_atom_idx)) update_a = self.update_for_pair(concat_a_v) # 4) Update the global vector out_shape = g_f_d.shape ave_p = get_mean_feat(update_p, pair_idx, out_shape, self.xp) ave_a = get_mean_feat(update_a, atom_idx, out_shape, self.xp) concat_g_v = functions.concat((ave_a, ave_p, g_f_d), axis=1) update_g = self.update_for_global(concat_g_v) # 5) Skip connection new_a_f = functions.add(a_f_d, update_a) new_p_f = functions.add(p_f_d, update_p) new_g_f = functions.add(g_f_d, update_g) # 6) dropout if self.dropout_ratio > 0.0: new_a_f = functions.dropout(new_a_f, ratio=self.dropout_ratio) new_p_f = functions.dropout(new_p_f, ratio=self.dropout_ratio) new_g_f = functions.dropout(new_g_f, ratio=self.dropout_ratio) return new_a_f, new_p_f, new_g_f
def __call__(self, atoms_1, g_1, atoms_2, g_2): """ :param atoms_1: atomic representation of molecule 1, with shape of (mb, N_1, hidden_dim) :param g_1: molecular representation of molecule 1, with shape of (mb, out_dim) :param atoms_2: atomic representation of molecule 2, with shape of (mb, N_2, hidden_dim) :param g_2: molecular representation of molecule 2, with shape of (mb, out_dim) :return: """ # C: (mb, N_2, N_1) C = self.compute_attention(query=atoms_2, key=atoms_1) # L_2: (mb, N_2, N_1) L_2 = functions.softmax(C, axis=1) # L_1: (mb, N_1, N_2) L_1 = functions.softmax(functions.transpose(C, (0, 2, 1)), axis=1) # lt_atoms_1: (mb, N_1, hidden_dim) -> (mb, N_1, head) for layer in self.prev_lt_layers_1: atoms_1 = layer(atoms_1) # atoms_1 = self.prev_lt_layer_1(atoms_1) lt_atoms_1 = self.lt_layer_1(atoms_1) # lt_atoms_2: (mb, N_2, hidden_dim) -> (mb, N_2, head) for layer in self.prev_lt_layers_2: atoms_2 = layer(atoms_2) # atoms_2 = self.prev_lt_layer_2(atoms_2) lt_atoms_2 = self.lt_layer_2(atoms_2) # L_1: (mb, N_1, N_2), lt_atoms_2: (mb, N_2, head) -> (mb, N_1, head) lt_atoms_2_C = functions.matmul(L_1, lt_atoms_2) # H_1: (mb, N_1, head) H_1 = functions.tanh(functions.add(lt_atoms_1, lt_atoms_2_C)) # L_2: (mb, N_2, N_1), lt_atoms_1: (mb, N_1, head) # lt_atoms_1_C: (mb, N_2, head) lt_atoms_1_C = functions.matmul(L_2, lt_atoms_1) H_2 = functions.tanh(functions.add(lt_atoms_2, lt_atoms_1_C)) # attn_1: (mb, N_1, 1) attn_1 = functions.softmax(self.attention_layer_1(H_1)) # attn_2: (mb, N_2, 1) attn_2 = functions.softmax(self.attention_layer_2(H_2)) compact_1 = functions.sum( functions.tile(attn_1, reps=(1, 1, self.out_dim)) * self.j_layer(atoms_1), axis=1) compact_2 = functions.sum( functions.tile(attn_2, reps=(1, 1, self.out_dim)) * self.j_layer(atoms_2), axis=1) return compact_1, compact_2
def __call__(self, x): h = self.conv0(x) h = self.bn0(h) h = F.relu(h) h = self.conv1(h) h = self.bn1(h) h = F.relu(h) h = self.conv2(h) h = self.bn2(h) h = F.add(h, x) h = F.relu(h) return h
def set2vec(self, input_set, num_timesteps, mprev=None, cprev=None, inner_prod='default', name='lstm'): batch_size = input_set.shape[0] node_dim = input_set.shape[3] assert self.node_dim == node_dim if mprev is None: mprev = chainer.Variable(self.xp.zeros(shape=(batch_size, node_dim), dtype=self.xp.float32)) # (batch_size, node_dim * 2) mprev = functions.concat( [mprev, chainer.Variable(self.xp.zeros(shape=(batch_size, node_dim), dtype=self.xp.float32))], axis=1) if cprev is None: cprev = chainer.Variable(self.xp.zeros(shape=(batch_size, node_dim), dtype=self.xp.float32)) logit_att = [] attention_w2_data = self.xp.zeros(shape=(node_dim, node_dim), dtype=self.xp.float32) init = chainer.initializers.GlorotUniform(dtype=self.xp.float32) init(attention_w2_data) attention_w2 = chainer.Variable(data=attention_w2_data, name=name + "att_W_2") attention_v_data = self.xp.zeros(shape=(node_dim, 1), dtype=self.xp.float32) attention_v = chainer.Variable(data=attention_v_data, name=name + "att_V") for i in range(num_timesteps): m, c = self.lstm_block(mprev, cprev) query = functions.matmul(m, attention_w2) query = functions.reshape(query, shape=(-1, 1, 1, node_dim)) if inner_prod == 'default': energies = functions.reshape( functions.matmul( functions.reshape(functions.tanh( functions.add(functions.broadcast_to(query, shape=input_set.shape), input_set)), shape=(-1, node_dim)), attention_v ), shape=(batch_size, -1) ) elif inner_prod == 'dot': att_mem_reshape = functions.reshape(input_set, shape=(batch_size, -1, node_dim)) query = functions.reshape(query, shape=(-1, node_dim, 1)) energies = functions.reshape(functions.matmul(att_mem_reshape, query), shape=(batch_size, -1)) else: raise ValueError("Invalid inner_prod type: {}".format(inner_prod)) att = functions.softmax(energies) att = functions.reshape(att, shape=(batch_size, -1, 1, 1)) read = functions.sum(functions.broadcast_to(att, shape=input_set.shape) * input_set, axis=(1, 2)) m = functions.concat([m, read], axis=1) logit_att.append(m) mprev = m cprev = c return logit_att, c, m
def __call__(self, x): # x:input h = self.conv0(x) # Convolution layer h = self.bn0(h) # BatchNormalization layer h = F.relu(h) # ReLU layer h0 = self.conv1(h) # Convolution_2 layer h0 = self.bn1(h0) # BatchNormalization_2 layer h0 = F.relu(h0) # ReLU_2 layer h0 = self.conv2(h0) # Convolution_3 layer h0 = self.bn2(h0) # BatchNormalization_3 layer h0 = F.relu(h0) # ReLU_3 layer h0 = self.conv3(h0) # Convolution_4 layer h0 = self.bn3(h0) # BatchNormalization_4 layer h = F.add(h, h0) # Add2 layer h = F.relu(h) # ReLU_4 layer h = F.max_pooling_2d(h, ksize=2, stride=2, pad=0) # MaxPooling layer # 1st repeat for _, f in self.res1: h = f(h) h = F.max_pooling_2d(h, ksize=2, stride=2, pad=0) # MaxPooling_2 layer # 2nd repeat for _, f in self.res2: h = f(h) h = F.max_pooling_2d(h, ksize=2, stride=2, pad=0) # MaxPooling_3 layer h1 = self.conv4(h) # Convolution_11 layer h1 = self.bn4(h1) # BatchNormalization_11 layer h1 = F.relu(h1) # ReLU_11 layer h1 = self.conv5(h1) # Convolution_12 layer h1 = self.bn5(h1) # BatchNormalization_12 layer h1 = F.relu(h1) # ReLU_12 layer h1 = self.conv6(h1) # Convolution_13 layer h1 = self.bn6(h1) # BatchNormalization_13 layer h = F.add(h, h1) # Add2_4 layer h = F.relu(h) # ReLU_13 layer h = F.average_pooling_2d(h, ksize=4, stride=4, pad=0) # AveragePooling layer h = self.fc0(h) # Affine layer return h
def forward(self, x): # negative samples h = np.random.randint(0, self.mes.nodeCnt, (x.shape[0], 1)) t = np.random.randint(0, self.mes.nodeCnt, (x.shape[0], 1)) r = x[:, 1].reshape(-1, 1) x_negative = np.concatenate((h, r, t), axis=1) # loss loss_x = self.transloss(x) loss_ne = self.transloss(x_negative) loss = F.add(loss_x, F.relu(loss_ne - self.Tau)) self.loss = F.sum(loss, axis=0).reshape(1) # loss的值必须是一个variable的列表 reporter.report({'loss': self.loss[0]}, self) accuracy = self.accuracy_func(x, self.settings['hit']) reporter.report({'accuracy': accuracy[0]}, self) return self.loss
def __call__(self, x): res_x = self.block(x) if self.fit_dim: x = self.fit_conv(x) x = self.fit_bn(x) x = F.relu(x) if self.stride == 2: x = F.max_pooling_2d(x, ksize=2, pad=0, stride=self.stride) x = F.add(res_x, x) x = F.relu(x) return x
def __call__(self, x, a, mode, is_nasp_upd_w=False): node = [x] edges = self.children() pos = 0 for i in range(1,4): node.append(None) for j in range(0,i): edge = edges.__next__() res = edge(x=node[j], a=a[pos], mode=mode, is_nasp_upd_w=is_nasp_upd_w) pos += 1 if node[i] is None: node[i] = res else: node[i] = F.add(node[i],res) return node[3]
def forward(self, st, act, r, st_dash, ep_end, ISWeights): s = Variable(st) s_dash = Variable(st_dash) Q = self.model.Q_func(s) Q_dash = self.model.Q_func(s_dash) Q_dash_target = self.target_model.Q_func(s_dash).data Q_dash_idmax = np.asanyarray(list(map(np.argmax, Q_dash.data))) max_Q_dash = np.asanyarray([ Q_dash_target[i][Q_dash_idmax[i]] for i in range(len(Q_dash_idmax)) ]) target = np.asanyarray(copy.deepcopy(Q.data), dtype=np.float32) for i in range(self.batch_size): target[ i, act[i]] = r[i] + (self.gamma * max_Q_dash[i]) * (not ep_end[i]) squared_error = F.squared_error(Q, Variable(target)) loss = F.mean(squared_error * ISWeights) td_error = F.add(Q, Variable(-1 * target)) self.loss = loss.data return loss, td_error
def forward(self, xs, sent_vec): hs_0 = F.leaky_relu(self.l0_conv(xs), slope=0.2) hs_1 = F.leaky_relu(self.l1_bn(self.l1_conv(hs_0)), slope=0.2) hs_1 = F.leaky_relu(self.l2_bn(self.l2_conv(hs_1)), slope=0.2) hs_1 = self.l3_bn(self.l3_conv(hs_1)) hs_2 = F.leaky_relu(self.l4_bn(self.l4_conv(hs_1)), slope=0.2) hs_2 = F.leaky_relu(self.l5_bn(self.l5_conv(hs_2)), slope=0.2) hs_2 = self.l6_bn(self.l6_conv(hs_2)) hs_3 = F.leaky_relu(F.add(hs_1, hs_2), slope=0.2) sent_vec = F.leaky_relu(self.l7_dense(sent_vec), slope=0.2) sent_vec = F.expand_dims(F.expand_dims(sent_vec, axis=2), axis=3) sent_vec = F.tile(sent_vec, (1,1,4,4)) hs_4 = F.concat([hs_3, sent_vec], axis=1) hs_4 = F.leaky_relu(self.l8_bn(self.l8_conv(hs_4)), slope=0.2) hs_4 = self.l9_conv(hs_4) return hs_4.reshape((-1))
def forward(self, x): b_ = cf.tanh(self.b) # Not sure if implementation is wrong m_ = cf.softplus(self.m) # m = cf.repeat(m, 8, axis=2) # m = cf.repeat(m, 8, axis=1) m_ = cf.repeat(m_, 16, axis=2) m_ = cf.repeat(m_, 16, axis=1) b_ = b_ * m_ x_ = cf.add(x, b_) x_ = cf.clip(x_, -0.5, 0.5) z = [] zs, logdet = self.encoder.forward_step(x_) for (zi, mean, ln_var) in zs: z.append(zi) z = merge_factorized_z(z) return z, zs, logdet, xp.sum(xp.abs(b_.data)), xp.tanh( self.b.data * 1), m_, x_
def forward(self, x): # b_ = cf.tanh(self.b) b_ = self.b # Not sure if implementation is wrong self.modify_mask() # m = cf.repeat(m, 8, axis=2) # m = cf.repeat(m, 8, axis=1) # m = cf.repeat(m, 16, axis=2) # m = cf.repeat(m, 16, axis=1) # b = b * m x_ = cf.add(x, b_) x_ = cf.clip(x_, -0.5, 0.5) z = [] zs, logdet = self.encoder.forward_step(x_) for (zi, mean, ln_var) in zs: z.append(zi) z = merge_factorized_z(z) # return z, zs, logdet, cf.batch_l2_norm_squared(b), xp.tanh(self.b.data*1), cur_x, m return z, zs, logdet, xp.sum(xp.abs(b_.data)), xp.tanh( self.b.data * 1), self.m, x_
def __call__(self, *xs): return F.add(*xs)