def __init__(self,
input_dim=(3, 32, 32),
num_filters=32,
kernel_size=7,
stride_conv=1,
weight_scale=0.001,
pool=2,
stride_pool=2,
hidden_dim=100,
num_classes=10,
dropout=0.0):
"""
Initialize a new network.
Inputs:
- input_dim: Tuple (C, H, W) giving size of input data.
- num_filters: Number of filters to use in the convolutional layer.
- kernel_size: Size of filters to use in the convolutional layer.
- hidden_dim: Number of units to use in the fully-connected hidden layer-
- num_classes: Number of scores to produce from the final affine layer.
- stride_conv: Stride for the convolution layer.
- stride_pool: Stride for the max pooling layer.
- weight_scale: Scale for the convolution weights initialization
- pool: The size of the max pooling window.
- dropout: Probability of an element to be zeroed.
"""
super(ClassificationCNN, self).__init__()
channels, height, width = input_dim
########################################################################
# TODO: Initialize the necessary trainable layers to resemble the #
# ClassificationCNN architecture from the class docstring. #
# #
# In- and output features should not be hard coded which demands some #
# calculations especially for the input of the first fully #
# convolutional layer. #
# #
# The convolution should use "same" padding which can be derived from #
# the kernel size and its weights should be scaled. Layers should have #
# a bias if possible. #
# #
# Note: Avoid using any of PyTorch's random functions or your output #
# will not coincide with the Jupyter notebook cell. #
########################################################################
#conv - relu - 2x2 max pool - fc - dropout - relu - fc
padding = int((kernel_size - 1) / 2)
self.conv1 = Conv2D(channels,
num_filters,
kernel_size,
stride=stride_conv,
padding=padding)
self.conv1.weight.data.mul_(weight_scale)
self.pool = (pool, stride_pool)
new_height = int((height - kernel_size + 1 + padding * 2) / pool)
new_width = int((width - kernel_size + 1 + padding * 2) / pool)
self.fc1 = nn.Linear(new_height * new_width * num_filters,
hidden_dim,
bias=True)
self.dropout = dropout
self.fc2 = nn.Linear(hidden_dim, num_classes)
def __init__(self, channel_in, classes):
super(UNet, self).__init__()
self.input_conv = self.conv = nn.Sequential(
Conv2D(channel_in, 8, kernel_size=3, padding=1), nn.BatchNorm2d(8),
nn.ReLU(inplace=True))
self.down1 = Down(8, 16)
self.down2 = Down(16, 32)
self.down3 = Down(32, 32)
self.up1 = Up(64, 16)
self.up2 = Up(32, 8)
self.up3 = Up(16, 4)
self.output_conv = nn.Conv2d(4, classes, kernel_size=1)
def __init__(self, channel_in, channel_out):
super(Down, self).__init__()
self.conv = nn.Sequential(
Conv2D(channel_in, channel_out, kernel_size=3, padding=1),
nn.BatchNorm2d(channel_out), nn.ReLU(inplace=True))
def __init__(self, channel_in, channel_out):
super(Up, self).__init__()
self.upsample = nn.Upsample(scale_factor=2, mode='bilinear')
self.conv = nn.Sequential(
Conv2D(channel_in, channel_out, kernel_size=3, padding=1),
nn.BatchNorm2d(channel_out), nn.ReLU(inplace=True))