def __init__(self, backbone: nn.Module, num_modes: int,
n_hidden_layers: List[int] = None,
input_shape: Tuple[int, int, int] = (3, 500, 500)):
"""
Inits Covernet.
:param backbone: Backbone model. Typically ResNetBackBone or MobileNetBackbone
:param num_modes: Number of modes in the lattice
:param n_hidden_layers: List of dimensions in the fully connected layers after the backbones.
If None, set to [4096]
:param input_shape: Shape of image input. Used to determine the dimensionality of the feature
vector after the CNN backbone.
"""
if n_hidden_layers and not isinstance(n_hidden_layers, list):
raise ValueError(f"Param n_hidden_layers must be a list. Received {type(n_hidden_layers)}")
super().__init__()
if not n_hidden_layers:
n_hidden_layers = [4096]
self.backbone = backbone
backbone_feature_dim = calculate_backbone_feature_dim(backbone, input_shape)
n_hidden_layers = [backbone_feature_dim + ASV_DIM] + n_hidden_layers + [num_modes]
linear_layers = [nn.Linear(in_dim, out_dim)
for in_dim, out_dim in zip(n_hidden_layers[:-1], n_hidden_layers[1:])]
self.head = nn.ModuleList(linear_layers)
def __init__(self, backbone: nn.Module, num_modes: int,
seconds: float = 6, frequency_in_hz: float = 2,
n_hidden_layers: int = 4096, input_shape: Tuple[int, int, int] = (3, 500, 500)):
"""
Inits the MTP network.
:param backbone: CNN Backbone to use.
:param num_modes: Number of predicted paths to estimate for each agent.
:param seconds: Number of seconds into the future to predict.
Default for the challenge is 6.
:param frequency_in_hz: Frequency between timesteps in the prediction (in Hz).
Highest frequency is nuScenes is 2 Hz.
:param n_hidden_layers: Size of fully connected layer after the CNN
backbone processes the image.
:param input_shape: Shape of the input expected by the network.
This is needed because the size of the fully connected layer after
the backbone depends on the backbone and its version.
Note:
Although seconds and frequency_in_hz are typed as floats, their
product should be an int.
"""
super().__init__()
self.backbone = backbone
self.num_modes = num_modes
backbone_feature_dim = calculate_backbone_feature_dim(backbone, input_shape)
self.fc1 = nn.Linear(backbone_feature_dim + ASV_DIM, n_hidden_layers)
# self.fc1 = nn.Linear(backbone_feature_dim, n_hidden_layers)
predictions_per_mode = int(seconds * frequency_in_hz) * 2
self.fc2 = nn.Linear(n_hidden_layers, int(num_modes * predictions_per_mode + num_modes))