def predictor(self, E, S): temp = torch.cat([E, S], 1) temp = self.pred_f1(temp) temp = F.relu(temp) out = self.pred_f2(temp) out = F.relu(out) return (out)
def forward(self, state, en1, en2): """ Input: state -> tensor[B, 128, H, W] en1 -> tensor[B, 64, H * 2, W * 2] en2 -> tensor[B, 32, H * 4, W * 4] Output: observation -> tensor[B, C, H * 8, W * 8] en1 -> tensor[B, 64, H * 2, W * 2] en2 -> tensor[B, 32, H * 4, W * 4] """ upsample1 = F.relu(self.deconv1(state)) cat1 = torch.cat([upsample1, en2], 1) en2 = self.conv1_skip_norm(F.relu(self.conv1_skip(cat1))) upsample1 = (self.conv1_norm(F.relu(self.conv1_1(upsample1))) + en2) / 2.0 upsample1 = F.relu(self.conv1_2(upsample1)) # upsample1 = F.relu(self.conv1(upsample1)) + en2 upsample2 = F.relu(self.deconv2(upsample1)) cat2 = torch.cat([upsample2, en1], 1) en1 = self.conv2_skip_norm(F.relu(self.conv2_skip(cat2))) upsample2 = (self.conv2_norm(F.relu(self.conv2_1(upsample2))) + en1) / 2.0 upsample2 = F.relu(self.conv2_2(upsample2)) # upsample2 = F.relu(self.conv2(upsample2)) + en1 upsample3 = F.relu(self.deconv3(upsample2)) upsample3 = F.relu(self.conv3(upsample3)) observation = self.conv_top(upsample3) return observation, en1, en2
def forward(self, x): x = F.relu(self._fc1(x)) x = F.relu(self._fc2(x)) x = F.relu(self._fc3(x)) x = self._fc4(x) return x
def forward(self, X): X = F.relu(self.conv1(X)) X = F.relu(self.conv2(X)) X = F.relu(self.conv3(X)) X = F.relu(self.conv4(X)) X = X.view(-1, 213 * 213 * 20) return F.softmax(self.fc1(X))
def forward(self, x, proposals): x = self.pooler(x, proposals) x = x.view(x.size(0), -1) x = F.relu(self.fc6(x)) x = F.relu(self.fc7(x)) return x
def forward(self, x): w1 = self.weather_encoder(x[:, 2:-7], encode=True) w2 = self.pollution_encoder(x[:, -7:], encode=True) feature = torch.cat([w1, w2, x[:, 0:2]], dim=1) h1 = F.relu(self.layer1(feature)) h2 = F.relu(self.layer2(h1)) return self.layer3(h2)
def forward(self, x): x = F.relu(F.max_pool2d(self.conv1(x), 2)) x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2)) x = x.view(-1, 320) x = F.relu(self.fc1(x)) x = F.dropout(x, training=self.training) x = self.fc2(x) return F.log_softmax(x)
def forward_features(self, x): x = self.pool1(F.relu(self.conv1_bn(self.conv1(x)))) x = self.pool2(F.relu(self.conv2_bn(self.conv2(x)))) x = x.view(-1, 16 * window_size * window_size) x = F.relu(self.fc1(x)) return x
def encoder(self, x): h = self.encoder_l(x) h = self.d_f1(h) h = F.relu(h) E = self.d_fE(h) E = F.relu(E) S = self.d_fS(h) S = F.relu(S) return E, S
def forward(self, x): out = F.relu(self.down_sample(x)) out1 = F.relu(self.spatial(out)) out2 = F.relu(self.temporal(out1)) out3 = self.up_sample(out2) out3 = self.temp_up_sample(out3) out4 = self.batch_norm(out3) return out4
def forward(self, x): x = F.relu(self.conv1(x)) x = self.pool(x) x = F.relu(self.conv2(x)) x = self.pool(x) x = F.relu(self.conv3(x)) x = x.view(-1, 1*1*120) x = F.relu(self.fc1(x)) return self.fc2(x)
def forward(self, x): x = F.relu(self.conv1(x)) x = F.max_pool2d(x, 2, 2) x = F.relu(self.conv2(x)) x = F.max_pool2d(x, 2, 2) x = x.view(-1, 4 * 4 * 50) x = F.relu(self.fc1(x)) x = self.fc2(x) return F.log_softmax(x, dim=1)
def forward(self, x): x = self.pool(F.relu(self.conv1(x))) x = self.pool(F.relu(self.conv2(x))) x = x.view(-1, 16 * 4 * 4) x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x
def forward(self, x): h1 = self.conv1(x) h2 = F.relu(h1) h3 = self.max_pool(h2) h4 = self.conv2(h3) h5 = F.relu(h4) return self.full(h5)
def forward(self, input): if flags.grayscale_model: out = input.view(input.shape[0], 2, 14 * 14).sum(dim=1) else: out = input.view(input.shape[0], 2 * 14 * 14) out1 = F.relu(self.lin1(out)) out2 = F.relu(self.lin2(out1)) out3 = self.lin3(out2) return out1, out2, out3
def _discriminative_loss(self, embedding, seg_gt): batch_size = embedding.shape[0] embed_dim = embedding.shape[1] var_loss = torch.tensor(0, dtype=embedding.dtype, device=embedding.device) dist_loss = torch.tensor(0, dtype=embedding.dtype, device=embedding.device) reg_loss = torch.tensor(0, dtype=embedding.dtype, device=embedding.device) for b in range(batch_size): embedding_b = embedding[b] # (embed_dim, H, W) seg_gt_b = seg_gt[b] labels = torch.unique(seg_gt_b) labels = labels[labels != 0] num_lanes = len(labels) if num_lanes == 0: # please refer to issue here: https://github.com/harryhan618/LaneNet/issues/12 _nonsense = embedding.sum() _zero = torch.zeros_like(_nonsense) var_loss = var_loss + _nonsense * _zero dist_loss = dist_loss + _nonsense * _zero reg_loss = reg_loss + _nonsense * _zero continue centroid_mean = [] for lane_idx in labels: seg_mask_i = (seg_gt_b == lane_idx) if not seg_mask_i.any(): continue embedding_i = embedding_b[seg_mask_i] mean_i = torch.mean(embedding_i, dim=0) centroid_mean.append(mean_i) # ---------- var_loss ------------- var_loss = var_loss + torch.mean(F.relu( torch.norm(embedding_i - mean_i, dim=1) - self.delta_var) ** 2) / num_lanes centroid_mean = torch.stack(centroid_mean) # (n_lane, embed_dim) if num_lanes > 1: centroid_mean1 = centroid_mean.reshape(-1, 1, embed_dim) centroid_mean2 = centroid_mean.reshape(1, -1, embed_dim) dist = torch.norm(centroid_mean1 - centroid_mean2, dim=2) # shape (num_lanes, num_lanes) dist = dist + torch.eye(num_lanes, dtype=dist.dtype, device=dist.device) * self.delta_dist # diagonal elements are 0, now mask above delta_d # divided by two for double calculated loss above, for implementation convenience dist_loss = dist_loss + torch.sum(F.relu(-dist + self.delta_dist) ** 2) / ( num_lanes * (num_lanes - 1)) / 2 # reg_loss is not used in original paper # reg_loss = reg_loss + torch.mean(torch.norm(centroid_mean, dim=1)) var_loss = var_loss / batch_size dist_loss = dist_loss / batch_size reg_loss = reg_loss / batch_size return var_loss, dist_loss, reg_loss
def forward(self, x): out = F.relu(self.down_sample(x)) out1 = self.temporal(out) out2 = self.temp_up_sample(out1) out3 = F.relu(self.spatial(out)) out4 = F.relu(out3 + out2) out5 = self.up_sample(out4) out6 = self.batch_norm(out5) return out6
def forward(self, x): x = x.view(x.size(0), self._in_shape[0], self._in_shape[1], self._in_shape[2]) x = F.relu(self.conv1(x)) x = F.relu(self.conv2(x)) x = F.relu(self.conv3(x)) x = F.relu(self.fc4(x.view(x.size(0), -1))) x = self.fc5(x.view(x.size(0), -1)) return x
def funnel_output(self, H): x = self.bn_out(H) x = (F.relu(self.lin1(x))) x = self.dropout(x) x = (F.relu(self.lin2(x))) x = self.dropout(x) x = self.out_fun(self.lin3(x)) return x
def forward(self, x): x = F.relu(self.conv1(x)) x = F.relu(self.conv2(x)) x = self.pool(x) x = F.relu(self.conv3(x)) #x = F.relu(self.conv4(x)) x = self.pool(x) x = x.view(-1, 6 * 6 * 128) x = F.relu(self.fc1(x)) return self.fc2(x)
def forward(self, x): x = self.h1(x) x = F.relu(x) x = self.h2(x) x = F.relu(x) x = self.out(x) x = torch.sigmoid(x) return x
def forward(self, param): # Flattened the input to make sure it fits the layer input # param = param.view(param.shape[0],-1) # Pass in the input to the layer and do forward propagation param = F.relu(self.layer_input(param)) # print("1") # param = self.layer_embedding(param) param = self.layer_dropout(param) param = F.relu(self.layer_hidden_one(param)) param = F.relu(self.layer_hidden_two(param)) param = F.relu(self.layer_hidden_two(param)) param = F.relu(self.layer_hidden_two(param)) param = F.relu(self.layer_hidden_two(param)) param = F.relu(self.layer_hidden_two(param)) # param = F.relu(self.layer_hidden_two(param)) # param = F.relu(self.layer_hidden_three(param)) # print("2") param = F.relu(self.layer_dropout(param)) # print("3") # print("4") # Dimension = 1, to get the sum of the output across the output row matrix param = F.relu(self.layer_output(param)) return param
def forward(self, x): # Dropout on image input x = self.img_dp(x) # Relu after batch_norm x = F.relu(self.conv1_bn(self.conv1(x))) x = F.relu(self.conv2_bn(self.conv2(x))) x = F.relu(self.conv3_bn(self.conv3(x))) # Dropout on max pool layer x = self.mp1_dp(x) # Relu after batch_norm x = F.relu(self.conv4_bn(self.conv4(x))) x = F.relu(self.conv5_bn(self.conv5(x))) x = F.relu(self.conv6_bn(self.conv6(x))) # Dropout on max pool layer x = self.mp2_dp(x) # Relu after batch_norm x = F.relu(self.conv7_bn(self.conv7(x))) x = F.relu(self.conv8_bn(self.conv8(x))) x = F.relu(self.conv9_bn(self.conv9(x))) # X here has shape (batch_size, num_features, w, h) which is (64, 100, 1, 1) # Global average pooling for each feature map (mean over the flattened feature map dimension) x = torch.mean(x.view(x.size(0), x.size(1), -1), dim=2) x = self.out(x) return x
def forward(self, x): x = F.relu(self.conv1(x)) x = F.max_pool2d(x, 2, 2) x = F.relu(self.conv2(x)) x = F.relu(self.conv3(x)) x = F.max_pool2d(x, 2, 2) x = x.view(-1, 7 * 7 * 70) x = F.relu(self.fc1(x)) x = self.fc2(x) return x
def forward(self, x): """Forward feature map of a single scale level.""" rpn_out = self.rpn_conv_dw(x) rpn_out = F.relu(rpn_out, inplace=True) rpn_out = self.rpn_conv_linear(rpn_out) rpn_out = F.relu(rpn_out, inplace=True) sam = F.sigmoid(self.bn(self.sam(rpn_out))) x = x * sam rpn_cls_score = self.rpn_cls(rpn_out) rpn_bbox_pred = self.rpn_reg(rpn_out) return rpn_cls_score, rpn_bbox_pred, x
def forward(self, x): x = self.pool1(F.relu(self.conv1_bn(self.conv1(x)))) x = self.pool2(F.relu(self.conv2_bn(self.conv2(x)))) x = x.view(-1, self.num_conv // 2 * window_size * window_size) x = F.relu(self.fc1(x)) x = self.fc1_dp(x) x = self.fc2(x) x = self.out(x) return x
def forward( self, state ) : r"""Forward pass for this deterministic policy, used for the max Q evaluation Args: state (torch.tensor): state used to decide the action """ x = F.relu( self.fc1( state ) ) x = F.relu( self.fc2( x ) ) x = F.tanh( self.fc3( x ) ) return x
def forward( self, observation ) : r"""Forward pass for this deterministic policy, used for the max Q evaluation Args: observation (torch.tensor): observation used to decide the action """ x = self.bn0( observation ) x = F.relu( self.bn1( self.fc1( x ) ) ) x = F.relu( self.bn2( self.fc2( x ) ) ) x = F.tanh( self.fc3( x ) ) return x
def forward( self, state, action ) : r"""Forward pass for this critic at a given (s,a) pair Args: state (torch.tensor): state of the pair to be evaluated action (torch.tensor): action of the pair to be evaluated """ x = F.relu( self.fc1( state ) ) x = F.relu( self.fc2( torch.cat( [x, action], dim = 1 ) ) ) x = self.fc3( x ) return x
def forward(self, x: Tensor) -> Tensor: x = self.conv1(x) x = F.relu(x) x = self.conv2(x) x = F.relu(x) x = F.max_pool2d(x, 2) x = self.dropout1(x) x = torch.flatten(x, 1) x = self.fc1(x) x = F.relu(x) x = self.dropout2(x) x = self.fc2(x) output = F.log_softmax(x, dim=1) return x