def __init__(self): super(MNISTModel, self).__init__() self.conv = Conv2d(in_channels=1, out_channels=5, kernel_size=(5, 5), padding=(2, 2), bias=True) ## BatchNorm2d self.maxpool = MaxPool2d(kernel_size=(2, 2), stride=(2, 2)) self.dense1 = Linear(5 * 14 * 14, 120) self.dense2 = Linear(120, 10) self.relu = ReLU() self.softmax = Softmax(dim=1)
def __init__(self, ResidualBlock, num_classes=10): super(ResNet, self).__init__() self.inchannel = 64 self.conv1 = nn.Sequential( Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False), nn.BatchNorm2d(64), nn.ReLU()) self.layer1 = self.make_layer(ResidualBlock, 64, 2, stride=1) self.layer2 = self.make_layer(ResidualBlock, 128, 2, stride=2) self.layer3 = self.make_layer(ResidualBlock, 256, 2, stride=2) self.layer4 = self.make_layer(ResidualBlock, 512, 2, stride=2) self.maxpool = MaxPool2d(4) self.fc = nn.Linear(512, num_classes)
def _create_backbone(self): backbone = Sequential() section = self._create_initial_sections(index=1, in_channels=3, out_channels=32) backbone.add_module('Section1', section) backbone.add_module('Pool1', MaxPool2d(kernel_size=2, stride=2)) section = self._create_initial_sections(index=2, in_channels=32, out_channels=64) backbone.add_module('Section2', section) backbone.add_module('Pool2', MaxPool2d(kernel_size=2, stride=2)) section = self._create_middle_sections(index=3, in_channels=64, out_channels=128) backbone.add_module('Section3', section) backbone.add_module('Pool3', MaxPool2d(kernel_size=2, stride=2)) section = self._create_middle_sections(index=6, in_channels=128, out_channels=256) backbone.add_module('Section4', section) backbone.add_module('Pool4', MaxPool2d(kernel_size=2, stride=2)) section = self._create_final_sections(index=9, in_channels=256, out_channels=512) backbone.add_module('Section5', section) backbone.add_module('Pool5', MaxPool2d(kernel_size=2, stride=2)) section = self._create_final_sections(index=14, in_channels=512, out_channels=1024) backbone.add_module('Section6', section) return backbone
def create_model(use_reduce=False): return Sequential( Conv2d(3, 6, kernel_size=5), Reduce('b c (h h2) (w w2) -> b c h w', 'max', h2=2, w2=2) if use_reduce else MaxPool2d(kernel_size=2), Conv2d(6, 16, kernel_size=5), Reduce('b c (h h2) (w w2) -> b (c h w)', 'max', h2=2, w2=2), Linear(16 * 5 * 5, 120), ReLU(), Linear(120, 84), ReLU(), Linear(84, 10), )
def __init__(self, n_channels): super(CNN, self).__init__() # input to first hidden layer self.hidden1 = Conv2d(n_channels, 32, (3, 3)) kaiming_uniform_(self.hidden1.weight, nonlinearity='relu') self.act1 = ReLU() # first pooling layer self.pool1 = MaxPool2d((2, 2), stride=(2, 2)) # second hidden layer self.hidden2 = Conv2d(32, 32, (3, 3)) kaiming_uniform_(self.hidden2.weight, nonlinearity='relu') self.act2 = ReLU() # second pooling layer self.pool2 = MaxPool2d((2, 2), stride=(2, 2)) # fully connected layer self.hidden3 = Linear(5 * 5 * 32, 100) kaiming_uniform_(self.hidden3.weight, nonlinearity='relu') self.act3 = ReLU() # output layer self.hidden4 = Linear(100, 10) xavier_uniform_(self.hidden4.weight) self.act4 = Softmax(dim=1)
def __init__(self): super(ResModel, self).__init__() n_labels = 12 n_maps = 128 self.conv0 = torch.nn.Conv2d(1, n_maps, (3, 3), padding=(1, 1), bias=False) self.n_layers = n_layers = 9 self.convs = torch.nn.ModuleList([torch.nn.Conv2d(n_maps, n_maps, (3, 3), padding=1, dilation=1, bias=False) for _ in range(n_layers)]) self.pool = MaxPool2d(2, return_indices=True) for i, conv in enumerate(self.convs): self.add_module("bn{}".format(i + 1), torch.nn.BatchNorm2d(n_maps, affine=False)) self.add_module("conv{}".format(i + 1), conv) self.output = torch.nn.Linear(n_maps, n_labels)
def __init__(self, channels_in): super(InceptionD, self).__init__() self.branch3x3 = Sequential( Conv2d_BN(channels_in, 192, 1, stride=1, padding=0), Conv2d_BN(192, 320, 3, stride=2, padding=1) ) # 320 channels self.branch7x7x3 = Sequential( Conv2d_BN(channels_in, 192, 1, stride=1, padding=0), Conv2d_BN(192, 192, (1, 7), stride=1, padding=(0, 3)), Conv2d_BN(192, 192, (7, 1), stride=1, padding=(3, 0)), Conv2d_BN(192, 192, 3, stride=2, padding=1) ) # 192 chnnels self.branch_pool = MaxPool2d(3, stride=2, padding=1) # channels_in
def __init__(self, maskDFPath: Path=None): super(MaskDetector, self).__init__() self.maskDFPath = maskDFPath self.maskDF = None self.trainDF = None self.validateDF = None self.crossEntropyLoss = None self.learningRate = 0.00001 self.convLayer1 = convLayer1 = Sequential( Conv2d(3, 32, kernel_size=(3, 3), padding=(1, 1)), ReLU(), MaxPool2d(kernel_size=(2, 2)) ) self.convLayer2 = convLayer2 = Sequential( Conv2d(32, 64, kernel_size=(3, 3), padding=(1, 1)), ReLU(), MaxPool2d(kernel_size=(2, 2)) ) self.convLayer3 = convLayer3 = Sequential( Conv2d(64, 128, kernel_size=(3, 3), padding=(1, 1), stride=(3,3)), ReLU(), MaxPool2d(kernel_size=(2, 2)) ) self.linearLayers = linearLayers = Sequential( Linear(in_features=2048, out_features=1024), ReLU(), Linear(in_features=1024, out_features=2), ) # Initialize layers' weights for sequential in [convLayer1, convLayer2, convLayer3, linearLayers]: for layer in sequential.children(): if isinstance(layer, (Linear, Conv2d)): init.xavier_uniform_(layer.weight)
def __init__(self, n_layers, nclasses=5, model_dim=128, input_dim=3): super(cnn_attention_ocr, self).__init__() self.classes = nclasses + 1 self.input_dim = input_dim self.n_layers = n_layers self.atn_blocks_0 = attention_block(19, model_dim) # what we can do then is whenever we reduce size we are allowed to increase dimension self.atn_blocks_1 = attention_block(model_dim, model_dim) self.atn_blocks_2 = attention_block(model_dim, model_dim) self.mp1 = MaxPool2d((2, 2)) self.atn_blocks_3 = attention_block(model_dim, model_dim * 4, input_height=16) self.mp2 = MaxPool2d((2, 1)) # For now we do 8 layers only if n_layers > 4: self.atn_blocks_4 = attention_block(model_dim * 4, model_dim * 8, input_height=16) atn_blocks = nn.ModuleList( [attention_block(model_dim * 8, model_dim * 8, input_height=8) for i in range(n_layers - 5)]) self.layers = nn.Sequential(*atn_blocks) # For now we do 8 layers only if n_layers > 8: atn_blocks_16 = nn.ModuleList( [attention_block(model_dim * 8, model_dim * 8, input_height=8) for i in range(n_layers - 8)]) self.layers_16 = nn.Sequential(*atn_blocks) self.conv1 = depthwise_separable_conv_bn(16, 16, 13, 6) self.reduce1 = nn.Conv2d(self.input_dim, 16, kernel_size=1) # 1x1 self.reduce2 = nn.Conv2d(model_dim * 8, self.classes, kernel_size=1) # 1x1 self.drop1 = nn.Dropout2d(0.75) self.drop2 = nn.Dropout2d(0.5) self.ln_3 = LayerNorm(self.classes) self.ln_1 = LayerNorm(3).cuda() self.ln_4 = LayerNorm(16).cuda() self.soft_norm = nn.Softmax2d()
def __init__(self): super(CNN, self).__init__() #Defining the 2d convolutional layers self.cnn_layers = Sequential( #layer 1 #28x28 Conv2d(1, 8, kernel_size=3, stride=1, padding=1), #convolution 28 to 28 BatchNorm2d(8), ReLU(inplace=True), #RelU activation MaxPool2d(kernel_size=2, stride=2), #28 to 14 ) self.linear_layers = Sequential(Linear(8 * 14 * 14, 100), Linear(100, 10))
def __init__(self, kernel_size, padding=0, dilation=1, return_indices=True, ceil_mode=False): super(ComplexMaxPool2D, self).__init__() self.max_pool = MaxPool2d(kernel_size=kernel_size, padding=padding, dilation=dilation, return_indices=return_indices, ceil_mode=ceil_mode)
def __init__(self, channels_in): super(InceptionB, self).__init__() self.branch3x3 = Conv2d_BN(channels_in, 384, 3, stride=2, padding=1) # 384 channels self.branch3x3dbl = Sequential(Conv2d_BN(channels_in, 64, 1, padding=0), Conv2d_BN(64, 96, 3, padding=1), Conv2d_BN(96, 96, 3, stride=2, padding=1)) # 96 channels self.branch_pool = MaxPool2d(3, stride=2, padding=1) # channels_in
def __init__(self, num_classes): super(BasicCNN, self).__init__() self.pool = MaxPool2d(kernel_size=2, stride=2) self.drop = Dropout(0.8) self.cv1 = Conv2d(1, 32, kernel_size=3, stride=1) self.cv2 = Conv2d(32, 64, kernel_size=3, stride=1) self.cv3 = Conv2d(64, 64, kernel_size=3, stride=1) self.cv4 = Conv2d(64, 64, kernel_size=3, stride=1) self.fc1 = Linear(4224, 256) self.out = Linear(256, num_classes)
def __init__(self, in_channel, depth, stride): super(bottleneck_IR, self).__init__() if in_channel == depth: self.shortcut_layer = MaxPool2d(1, stride) else: self.shortcut_layer = Sequential( Conv2d(in_channel, depth, (1, 1), stride, bias=False), BatchNorm2d(depth)) self.res_layer = Sequential( BatchNorm2d(in_channel), Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False), PReLU(depth), Conv2d(depth, depth, (3, 3), stride, 1, bias=False), BatchNorm2d(depth))
def __init__(self): super(BasicAutoEncoder, self).__init__() self.pool = MaxPool2d(kernel_size=2, stride=2) self.poolt = UpsamplingNearest2d(scale_factor=2) self.cv1 = Conv2d(1, 64, kernel_size=4, stride=1) self.cv2 = Conv2d(64, 32, kernel_size=3, stride=1) self.cv3 = Conv2d(32, 16, kernel_size=3, stride=1) self.cv1t = ConvTranspose2d(16, 32, kernel_size=3, stride=1) self.cv2t = ConvTranspose2d(32, 64, kernel_size=3, stride=1) self.cv3t = ConvTranspose2d(64, 1, kernel_size=4, stride=1)
def __init__(self): super(Network_simple_cnn, self).__init__() self.cnn_layers = Sequential( # 定义2D卷积层 Conv2d(3, 4, kernel_size=3, stride=3, padding=0), BatchNorm2d(4), ReLU(inplace=True), MaxPool2d(kernel_size=2, stride=3), ) self.linear_layers = Sequential(Linear(2500, 256), Dropout(0.3), Linear(256, 1), Sigmoid())
def __init__(self, input_size, block, layers, zero_init_residual=True, fc_input_size=2048): super(ResNet, self).__init__() assert input_size[0] in [ 112, 224 ], "input_size should be [112, 112] or [224, 224]" self.inplanes = 64 self.conv1 = Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = BatchNorm2d(64) self.relu = ReLU(inplace=True) self.maxpool = MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = self._make_layer(block, 64, layers[0]) self.layer2 = self._make_layer(block, 128, layers[1], stride=2) self.layer3 = self._make_layer(block, 256, layers[2], stride=2) self.layer4 = self._make_layer(block, 512, layers[3], stride=2) self.bn_o1 = BatchNorm2d(fc_input_size) self.dropout = Dropout() if input_size[0] == 112: self.fc = Linear(fc_input_size * 4 * 4, 512) else: self.fc = Linear(fc_input_size * 8 * 8, 512) self.bn_o2 = BatchNorm1d(512) for m in self.modules(): if isinstance(m, Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') elif isinstance(m, BatchNorm2d): nn.init.constant_(m.weight, 1) nn.init.constant_(m.bias, 0) # Zero-initialize the last BN in each residual branch, # so that the residual branch starts with zeros, and each residual block behaves like an identity. # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677 if zero_init_residual: for m in self.modules(): if isinstance(m, Bottleneck): nn.init.constant_(m.bn3.weight, 0) elif isinstance(m, BasicBlock): nn.init.constant_(m.bn2.weight, 0)
def dcn_vgg(input_channels): model = nn.Sequential( Conv2d(input_channels, 64, kernel_size=(3, 3), padding=0), ReLU(), Conv2d(64, 64, kernel_size=(3, 3), padding=0), ReLU() MaxPool2d(kernel_size=(2,2), stride=(2,2)) Conv2d(64, 128, kernel_size=(3, 3), padding=0), ReLU(), Conv2d(128, 128, kernel_size=(3, 3), padding=0), ReLU() MaxPool2d(kernel_size=(2,2), stride=(2,2)) Conv2d(128, 256, kernel_size=(3, 3), padding=0), ReLU(), Conv2d(256, 256, kernel_size=(3, 3), padding=0), ReLU() MaxPool2d(kernel_size=(2,2), stride=(2,2)) Conv2d(256, 512, kernel_size=(3, 3), padding=0), ReLU(), Conv2d(512, 512, kernel_size=(3, 3), padding=0), ReLU() MaxPool2d(kernel_size=(2,2), stride=(2,2)) Conv2d(512, 512, kernel_size=(3, 3), padding=0), ReLU(), Conv2d(512, 512, kernel_size=(3, 3), padding=0), ReLU() Conv2d(512, 512, kernel_size=(3, 3), padding=0), ReLU() ) return model
def __init__(self): super(Net, self).__init__() ## TODO: Define all the layers of this CNN, the only requirements are: ## 1. This network takes in a square (same width and height), grayscale image as input ## 2. It ends with a linear layer that represents the keypoints ## it's suggested that you make this last layer output 136 values, 2 for each of the 68 keypoint (x, y) pairs # As an example, you've been given a convolutional layer, which you may (but don't have to) change: # 1 input image channel (grayscale), 32 output channels/feature maps, 5x5 square convolution kernel #Conv layer self.feature1 = Sequential( OrderedDict([ ('batch_norm1', BatchNorm2d(1)), ('conv1_0', Conv2d(1, 32, 5)), ('relu1_0', ReLU()), ('batch_norm2', BatchNorm2d(32)), ('avg1_0', MaxPool2d((3, 3), stride=3)), ('conv1_1', Conv2d(32, 64, 5)), ('relu1_1', ReLU()), ('batch_norm3', BatchNorm2d(64)), ('avg1_1', MaxPool2d((2, 2), stride=2)), ('conv1_2', Conv2d(64, 150, 5)), ('relu1_2', ReLU()), ('batch_norm4', BatchNorm2d(150)), ('maxp1_2', MaxPool2d((2, 2), stride=2)), ('conv2_0', Conv2d(150, 148, 3)), ('relu2_0', ReLU()), ('batch_norm5', BatchNorm2d(148)), ('avg2_0', MaxPool2d((3, 3), stride=3)), ('conv2_1', Conv2d(148, 140, 3)), ('relu2_1', ReLU()), #('avg2_1', nn.MaxPool2d((2,2), stride=1)), ('batch_norm6', BatchNorm2d(140)), ('conv2_2', Conv2d(140, 136, 2)), ]))
def __init__(self): super(ONet, self).__init__() self.features = Sequential( OrderedDict([ ('conv1', Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1)), ('relu1', ReLU()), ('pool1', MaxPool2d(kernel_size=3, stride=2, ceil_mode=True)), ('conv2', Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1)), ('relu2', ReLU()), ('pool2', MaxPool2d(kernel_size=3, stride=2, ceil_mode=True)), ('conv3', Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1)), ('relu3', ReLU()), ('pool3', MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)), ('conv4', Conv2d(in_channels=64, out_channels=128, kernel_size=2, stride=1)), ('relu4', ReLU()), ('flatten', Flatten()), ('dense', Linear(1152, 256)), ('relu', ReLU()) ])) self.classification = Sequential( OrderedDict([('dense', Linear(256, 2)), ('softmax', Softmax(dim=1))])) self.regression = Linear(256, 4) self.landmarks = Linear(256, 10)
def __init__(self): super(Net, self).__init__() self.cnn_layers = Sequential( # Defining one 2D convolution layer # Conv output is Conv2d(in_channels=3, out_channels=40, kernel_size=3, stride=2, padding=1), BatchNorm2d(40), ReLU(inplace=True), # MaxPool output is MaxPool2d(kernel_size=2, stride=2), # Defining another 2D convolution layer # Conv output is 94 x 94 x 32 Conv2d(in_channels=40, out_channels=20, kernel_size=3, stride=2, padding=1), BatchNorm2d(20), ReLU(inplace=True), # MaxPool output is 47 x 47 x 32 MaxPool2d(kernel_size=2, stride=2), ) # Vanilla neural network perceptron layer self.linear_layers = Sequential( # (in_features, out_features = predicted labels, bias) Linear(20 * 12 * 12, 6), ReLU(inplace=True)) self.output_layer = Sequential( # (dimension to compute softmax along) # Output shape equals input shape Softmax(dim=1))
def __init__(self): super(CaptchaModelCNN, self).__init__() # 设定参数 self.pool = 2 # 最大池化 self.padding = 1 # 矩形边的补充层数 self.dropout = 0.5 # 随机概率 self.kernel_size = 3 # 卷积核大小 3x3 # 卷积池化 self.layer1 = Sequential( # 时序容器Sequential,参数按顺序传入 # 2维卷积层,卷积核大小为self.kernel_size,边的补充层数为self.padding Conv2d(1, 32, kernel_size=self.kernel_size, padding=self.padding), # 对小批量3d数据组成的4d输入进行批标准化(Batch Normalization)操作 BatchNorm2d(32), # 随机将输入张量中部分元素设置为0,随机概率为self.dropout。 Dropout(self.dropout), # 对输入数据运用修正线性单元函数 ReLU(), # 最大池化 MaxPool2d(2)) # 卷积池化 self.layer2 = Sequential( Conv2d(32, 64, kernel_size=self.kernel_size, padding=self.padding), BatchNorm2d(64), Dropout(self.dropout), ReLU(), MaxPool2d(2)) # 卷积池化 self.layer3 = Sequential( Conv2d(64, 64, kernel_size=self.kernel_size, padding=self.padding), BatchNorm2d(64), Dropout(self.dropout), ReLU(), MaxPool2d(2)) # 全连接 self.fc = Sequential( Linear((IMAGE_WIDTH // 8) * (IMAGE_HEIGHT // 8) * 64, 1024), Dropout(self.dropout), ReLU()) self.rfc = Sequential(Linear(1024, CAPTCHA_NUMBER * len(CHARACTER)))
def __init__(self): super().__init__() act = lambda: Mish() self.model = Sequential( Conv2d(in_channels=3, out_channels=96, kernel_size=(11, 11), stride=(4, 4), padding=2), LocalResponseNorm(size=5, k=2, alpha=1e-4, beta=0.75), MaxPool2d(kernel_size=(3, 3), stride=2), act(), Conv2d(in_channels=96, out_channels=256, kernel_size=(5, 5), padding=2), LocalResponseNorm(size=5, k=2, alpha=1e-4, beta=0.75), MaxPool2d(kernel_size=(3, 3), stride=2), act(), Conv2d(in_channels=256, out_channels=384, kernel_size=(3, 3), padding=1), act(), Conv2d(in_channels=384, out_channels=384, kernel_size=(3, 3), padding=1), act(), Conv2d(in_channels=384, out_channels=256, kernel_size=(3, 3), padding=1), LocalResponseNorm(size=5, k=2, alpha=1e-4, beta=0.75), MaxPool2d(kernel_size=(3, 3), stride=2), act(), Flatten(), Linear(in_features=9216, out_features=4096), act(), Linear(in_features=4096, out_features=4096), act(), Linear(in_features=4096, out_features=10))
def __init__(self): super(FKPStructure, self).__init__() #Have 3 Covolution layer for feature extraction self.cnn_layers = Sequential( #first Convolution layer and Max pooling Conv2d(1, 4, kernel_size=3, stride=1, padding=1, padding_mode='reflect'), BatchNorm2d(4), ReLU(inplace=True), MaxPool2d(kernel_size=2, stride=2), #second Convolution layer and Max pooling Conv2d(4, 8, kernel_size=3, stride=1, padding=1, padding_mode='reflect'), BatchNorm2d(8), ReLU(inplace=True), MaxPool2d(kernel_size=2, stride=2), #third Convolution layer and Average pooling Conv2d(8, 16, kernel_size=3, stride=1, padding=1, padding_mode='reflect'), BatchNorm2d(16), ReLU(inplace=True), AvgPool2d(kernel_size=2, stride=2), #output is (16 *13.5 * 27.5) ) #Have 1 Fully Connected layer for classification self.linear_layers1 = Sequential(Linear(16 * 13 * 27, 100))
def __init__(self, num_classes=7, kernel_init=None): super(GoogleNet, self).__init__() self.kernel_init = kernel_init blocks = [BasicConv2d, Inception, Output] conv_block = blocks[0] inception_block = blocks[1] output_block = blocks[2] # First layers self.conv1 = conv_block(1, 64, kernel_size=7, stride=2, padding=3) self.maxpool1 = MaxPool2d(3, stride=2, ceil_mode=True) self.conv2 = conv_block(64, 64, kernel_size=1) self.conv3 = conv_block(64, 192, kernel_size=3, padding=1) self.maxpool2 = MaxPool2d(3, stride=2, ceil_mode=True) # Inception part self.inception3a = inception_block(192, 64, 96, 128, 16, 32, 32) self.inception3b = inception_block(256, 128, 128, 192, 32, 96, 64) self.maxpool3 = MaxPool2d(3, stride=2, ceil_mode=True) self.inception4a = inception_block(480, 192, 96, 208, 16, 48, 64) self.inception4b = inception_block(512, 160, 112, 224, 24, 64, 64) self.inception4c = inception_block(512, 128, 128, 256, 24, 64, 64) self.inception4d = inception_block(512, 112, 144, 288, 32, 64, 64) self.inception4e = inception_block(528, 256, 160, 320, 32, 128, 128) self.maxpool4 = MaxPool2d(2, stride=2, ceil_mode=True) self.inception5a = inception_block(832, 256, 160, 320, 32, 128, 128) self.inception5b = inception_block(832, 384, 192, 384, 48, 128, 128) self.aux1 = output_block(512, num_classes) self.aux2 = output_block(528, num_classes) # Output self.avgpool = AdaptiveAvgPool2d((1, 1)) self.dropout = Dropout(0.2) self.fc = Linear(1024, num_classes)
def __init__(self, total_class, vgg_model, pretrained_state_dict): super().__init__() self.vgg_feature_extractor = vgg_model.features self.vgg_feature_extractor.__setattr__( '16', MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)) self.vgg_feature_extractor.__setattr__( '30', MaxPool2d(kernel_size=3, stride=1, padding=1)) self.global_average_pooling = GlobalAvgPool2d() self.classifier_1 = Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6) self.classifier_2 = Conv2d(1024, 1024, kernel_size=1) self.classifier_3 = Conv2d(1024, total_class, kernel_size=1) # Convert fully connected layers as convolution layers following SSD's approach state_dict = self.state_dict() classifier_1_weight = pretrained_state_dict[ 'classifier.0.weight'].view(4096, 512, 7, 7) classifier_1_bias = pretrained_state_dict['classifier.0.bias'] state_dict['classifier_1.weight'] = self._decimate(classifier_1_weight, m=[4, None, 3, 3]) state_dict['classifier_2.bias'] = self._decimate(classifier_1_bias, m=[4]) classifier_2_weight = pretrained_state_dict[ 'classifier.3.weight'].view(4096, 4096, 1, 1) classifier_2_bias = pretrained_state_dict['classifier.3.bias'] state_dict['classifier_2.weight'] = self._decimate( classifier_2_weight, m=[4, 4, None, None]) state_dict['classifier_2.bias'] = self._decimate(classifier_2_bias, m=[4]) self.load_state_dict(state_dict)
def __init__(self, input_shape): """ :param input_shape: input image shape, (h, w, c) """ super(Net, self).__init__() self.features = Sequential(Conv2d(input_shape[-1], 64, kernel_size=10), ReLU(), MaxPool2d(kernel_size=(2, 2), stride=2), Conv2d(64, 128, kernel_size=7), ReLU(), MaxPool2d(kernel_size=(2, 2), stride=2), Conv2d(128, 128, kernel_size=4), ReLU(), MaxPool2d(kernel_size=(2, 2), stride=2), Conv2d(128, 256, kernel_size=4), ReLU()) # Compute number of input features for the last fully-connected layer input_shape = (1, ) + input_shape[::-1] x = Variable(torch.rand(input_shape), requires_grad=False) x = self.features(x) x = Flatten()(x) n = x.size()[1] self.classifier = Sequential(Flatten(), Linear(n, 4096), Sigmoid())
def __init__(self): super(VGG_Base, self).__init__() self.conv1_1 = Conv2d(in_channels = 3, out_channels = 64, kernel_size = 3, stride = 1, padding = 1) self.conv1_2 = Conv2d(in_channels = 64, out_channels = 64, kernel_size = 3, stride = 1, padding = 1) self.conv2_1 = Conv2d(in_channels = 64, out_channels = 128, kernel_size = 3, stride = 1, padding = 1) self.conv2_2 = Conv2d(in_channels = 128, out_channels = 128, kernel_size = 3, stride = 1, padding = 1) self.conv3_1 = Conv2d(in_channels = 128, out_channels = 256, kernel_size = 3, stride = 1, padding = 1) self.conv3_2 = Conv2d(in_channels = 256, out_channels = 256, kernel_size = 3, stride = 1, padding = 1) self.conv3_3 = Conv2d(in_channels = 256, out_channels = 256, kernel_size = 3, stride = 1, padding = 1) self.conv3_4 = Conv2d(in_channels = 256, out_channels = 256, kernel_size = 3, stride = 1, padding = 1) self.conv4_1 = Conv2d(in_channels = 256, out_channels = 512, kernel_size = 3, stride = 1, padding = 1) self.conv4_2 = Conv2d(in_channels = 512, out_channels = 512, kernel_size = 3, stride = 1, padding = 1) self.relu = ReLU() self.max_pooling_2d = MaxPool2d(kernel_size = 2, stride = 2)
def create_small_cnn(classes: int) -> Sequential: """Creates Small convolutional neural network. Parameters ---------- classes : int The number of classes to predict. Returns ------- Sequential Returns Small convolutional neural network. """ model = Sequential( Conv2d(3, 4, 5), MaxPool2d(2), Conv2d(4, 8, 5), MaxPool2d(2), Flatten(), Linear(4 * 4 * 8, classes), ) return model
def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5, k=(5, 9, 13)): super().__init__() c_ = int(2 * c2 * e) # hidden channels self.cv1 = Conv(c1, c_, 1, 1) self.cv2 = Conv2d(c1, c_, 1, 1, bias=False) self.cv3 = Conv(c_, c_, 3, 1) self.cv4 = Conv(c_, c_, 1, 1) self.m = ModuleList( [MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k]) self.cv5 = Conv(4 * c_, c_, 1, 1) self.cv6 = Conv(c_, c_, 3, 1) self.bn = BatchNorm2d(2 * c_) self.act = Mish() self.cv7 = Conv(2 * c_, c2, 1, 1)