def __init__(self, max_vocab=5000, seq_len=60): super(MIMOModel, self).__init__() self.embedding = nn.Embedding(max_vocab, 128) self.conv_sequence = nn.Conv1d(128, 128, 3, padding=1) self.pool_sequence = nn.AvgPool1d(seq_len) self.image_forward = resnet18(pretrained=False, num_classes=128) self.features = nn.Sequential(nn.Linear(256, 128), nn.ReLU()) self.output_layer = nn.Sequential(nn.Linear(128, 1000), nn.Softmax(dim=1))
def __init__(self, input_channels=6, seq_len=125, output_size=2, kernel_sizes=[5, 5], strides=[1, 1], conv_paddings=[0, 0], physNodes=0): super(DiscriminatorConv, self).__init__() # For other models, do not do any pooling # Adapt for the given stride value. cOut = 256 poolKernel = 2 cpad = conv_paddings[0] kernel_sizes = kernel_sizes strides = [1, 1] kernel_sizes[0] = self.get_kernel_size(kernel_sizes[0], seq_len) lout, cpad = self.conv_len_out(seq_len, cpad, kernel_sizes[0], strides[0]) lout2 = int((lout // 2) + (lout % 2)) # Fix output len and get the necessary padding pool_pad, lout = self.pool_from_len_out_to_pad(lout, lout2, poolKernel, poolKernel) self.first = nn.Sequential( nn.Conv1d(input_channels, 64, kernel_sizes[0], stride=strides[0], padding=cpad), nn.ReLU(), nn.AvgPool1d(poolKernel, stride=None, padding=pool_pad)) self.conv2_bn1 = nn.BatchNorm1d(64) cpad = conv_paddings[1] kernel_sizes[1] = self.get_kernel_size(kernel_sizes[1], lout) lout2, cpad = self.conv_len_out(lout, cpad, kernel_sizes[1], strides[1]) pool_pad2, lout2 = self.pool_from_len_out_to_pad( lout2, int((lout2 // 2) + (lout2 % 2)), poolKernel, poolKernel) self.dropout = nn.Dropout(0.5) self.set_same_scale = nn.Tanh() # self.set_same_scale = lambda x: x self.linears1 = nn.Sequential(nn.Linear(60, 64), nn.Softmax(dim=1)) self.linears2 = nn.Sequential( nn.Linear(int(64 * 1 * 64) + physNodes, output_size), nn.Softmax(dim=1)) self.cat = lambda x, y: x if physNodes > 0: self.cat = lambda x, y: torch.cat((x, y), 1)
def __init__(self): super().__init__() self.conv1 = nn.Conv1d(1, 200, 10, 4) self.bn1 = nn.BatchNorm1d(200) self.pool1 = nn.MaxPool1d(4) self.conv2 = nn.Conv1d(200, 400, 3) self.bn2 = nn.BatchNorm1d(400) self.pool2 = nn.MaxPool1d(4) self.avg_pool = nn.AvgPool1d(77) self.fc1 = nn.Linear(400, 400)
def __init__(self, num_classes): super(Net, self).__init__() # M11 network from https://arxiv.org/pdf/1610.00087.pdf self.layers = nn.ModuleList([ ManyConvMaxPool(1, 4, 1, 64, 80, stride=4), ManyConvMaxPool(2, 4, 64, 64, 3), ManyConvMaxPool(2, 4, 64, 128, 3), ManyConvMaxPool(3, 4, 128, 256, 3), ManyConvMaxPool(2, 4, 256, 512, 3) ]) self.avgPool = nn.AvgPool1d(6) self.fc1 = nn.Linear(512, num_classes)
def __init__(self, in_channels, out_channels1, out_channels2reduce, out_channels2, out_channels3reduce, out_channels3, out_channels4reduce, out_channels4, out_channels5): super(InceptionV2ModuleA, self).__init__() self.branch1 = ConvBN(in_channels=in_channels, out_channels=out_channels1, kernel_size=1) self.branch2 = nn.Sequential( ConvBNReLU(in_channels=in_channels, out_channels=out_channels2reduce, kernel_size=1), ConvBN(in_channels=out_channels2reduce, out_channels=out_channels2, kernel_size=3, padding=1), ) self.branch3 = nn.Sequential( ConvBNReLU(in_channels=in_channels, out_channels=out_channels3reduce, kernel_size=1), ConvBNReLU(in_channels=out_channels3reduce, out_channels=out_channels3, kernel_size=5, padding=2), ConvBN(in_channels=out_channels3, out_channels=out_channels3, kernel_size=5, padding=2), ) self.branch4 = nn.Sequential( ConvBNReLU(in_channels=in_channels, out_channels=out_channels4reduce, kernel_size=1), ConvBNReLU(in_channels=out_channels4reduce, out_channels=out_channels4, kernel_size=7, padding=3), ConvBN(in_channels=out_channels4, out_channels=out_channels4, kernel_size=7, padding=3), ) self.branch5 = nn.Sequential( nn.AvgPool1d(kernel_size=3, stride=1, padding=1), ConvBN(in_channels=in_channels, out_channels=out_channels5, kernel_size=1), )
def __init__(self): super(ReductionCPlus, self).__init__() # * Def Reduction 0 self.red0_branch0 = nn.Sequential(nn.MaxPool1d(3, stride=2), BasicConv1d(2080, 520, 1)) self.red0_branch1 = nn.Sequential(BasicConv1d(2080, 520, 1), BasicConv1d(520, 390, 3, padding=1), BasicConv1d(390, 260, 3, stride=2)) self.red0_branch2 = nn.Sequential(BasicConv1d(2080, 520, 1), BasicConv1d(520, 260, 3, stride=2)) # * Def Reduction 1 self.red1_pad = nn.ConstantPad1d((0, 1), 0) self.red1_branch0 = nn.Sequential( BasicConv1d(1040, 270, 1), nn.AvgPool1d(2, padding=1, count_include_pad=False)) self.red1_branch1 = nn.Sequential( BasicConv1d(1040, 270, 1), nn.ConstantPad1d((0, 1), 0), BasicConv1d(270, 270, 3, stride=2, padding=1)) # * Def Reduction 2 self.red2_avg_pool8 = nn.AvgPool1d(8, count_include_pad=False) self.red2_bconv = BasicConv1d(540, 250, 1)
def __init__(self): super(ConvSimple, self).__init__() self.n_classes = 5 self.conv1 = nn.Conv1d(1, 32, kernel_size=10, padding=1, stride=3) self.conv2 = nn.Conv1d(32, 32, kernel_size=10, padding=1, stride=3) self.pool1 = nn.AvgPool1d(2, stride=6) self.conv3 = nn.Conv1d(32, 64, kernel_size=3, padding=1) self.conv4 = nn.Conv1d(64, 64, kernel_size=3, padding=1) self.pool2 = nn.AvgPool1d(2, stride=2) self.conv5 = nn.Conv1d(64, 256, kernel_size=3, padding=1) self.conv6 = nn.Conv1d(256, 256, kernel_size=3, padding=1) self.pool_avg = nn.AvgPool1d(2) self.linear1 = nn.Linear(3328, 128) self.dropout1 = nn.Dropout(0.2) # LL2: 128 --> classes self.linear2 = nn.Linear(128, self.n_classes)
def __init__(self): super(model_1DCNN_2_dx, self).__init__() self.conv0 = nn.Sequential( nn.Conv1d(128, 32, kernel_size=8, stride=1, padding=0), nn.BatchNorm1d(32), nn.ReLU(), nn.MaxPool1d(8, stride=8)) self.conv1 = nn.Sequential( nn.Conv1d(32, 64, kernel_size=8, stride=1, padding=0), nn.BatchNorm1d(64), nn.ReLU(), nn.AvgPool1d(8, stride=2)) self.fc0 = nn.Linear(128, 10)
def forward(self, x): r""" :param torch.Tensor x: [N, C, L] 初始tensor :return: torch.Tensor x: [N, C] avg pool后的结果 """ # [N,C,L] -> [N,C] kernel_size = x.size(2) pooling = nn.AvgPool1d(kernel_size=kernel_size, stride=self.stride, padding=self.padding) x = pooling(x) return x.squeeze(dim=-1)
def __init__(self, args, **kwargs): super(AveragePool, self).__init__() # self.input_size = args.lookup_input_size # self.hidden_size = args.lookup_hidden_size # self.output_size = args.lookup_output_size self.kernel_size = args.lookup_kernel_size self.stride = args.lookup_stride ## output = [(input + 2*padding - kernel_size)/stride + 1] self.average_pooling = nn.AvgPool1d(kernel_size=self.kernel_size, stride=self.stride, padding=1)
def __init__(self, config): super().__init__() self.config = config self.pos_conv_embed = SEWPositionalConvEmbedding(config) self.pool = nn.AvgPool1d(config.squeeze_factor, config.squeeze_factor) self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) self.dropout = nn.Dropout(config.hidden_dropout) self.layers = nn.ModuleList( [SEWEncoderLayer(config) for _ in range(config.num_hidden_layers)]) self.upsample = SEWUpsampling(config) self.gradient_checkpointing = False
def forward(self, input_ids, token_type_ids, attention_mask): last_hidden_state = self.bert( input_ids=input_ids, token_type_ids=token_type_ids, attention_mask=attention_mask)['last_hidden_state'] last_hidden_state = last_hidden_state.permute(0, 2, 1).contiguous() h0, last_hidden_state = last_hidden_state[:, :, 0], last_hidden_state[:, :, 1:] h1 = nn.MaxPool1d(last_hidden_state.shape[-1])(last_hidden_state).squeeze(-1) h2 = nn.AvgPool1d(last_hidden_state.shape[-1])(last_hidden_state).squeeze(-1) h = torch.cat([h0, h1, h2], dim=1) logits = self.fc(h) return logits
def __init__(self): super(Model, self).__init__() self.pool_0 = nn.AvgPool1d(kernel_size=3) self.pool_1 = nn.AvgPool1d(kernel_size=4, stride=2, padding=2) self.pool_2 = nn.AvgPool1d(kernel_size=3, stride=1, padding=(0), ceil_mode=False, count_include_pad=True) self.pool_3 = nn.AvgPool1d(kernel_size=5, stride=2, padding=(2), ceil_mode=True, count_include_pad=False) self.pool_4 = nn.AvgPool1d(kernel_size=3, stride=2, padding=1, ceil_mode=False, count_include_pad=True) self.pool_5 = nn.AvgPool1d(kernel_size=2, stride=1, padding=0, ceil_mode=True, count_include_pad=True) self.pool_6 = nn.AvgPool1d(kernel_size=4, stride=1, padding=2, ceil_mode=False, count_include_pad=False)
def __init__(self, num_input_chars, hidden_size, output_classes): super(CharCNN, self).__init__() self.input_size = num_input_chars self.hidden_size = hidden_size self.output_size = output_classes self.lookup = nn.Embedding(num_input_chars, hidden_size) self.conv1d = nn.Conv1d(hidden_size, hidden_size, 2) #inChannel, outChannel, kH, kWid self.pool1d = nn.AvgPool1d(2) # kernel width over which to pool self.decoder = nn.Linear(hidden_size, output_classes)
def __init__(self, layers, channels, kernel_size, readout_layers=2, non_linearity=True, pooling='avg', dropout=0.0, batch_norm=False, rank=2, temperature=0.05, init_size=1e-3, max_scale=1. - 1e-3, alphabet_size=4, sequence_length=128, device='cpu'): super(HypHCCNN, self).__init__(temperature=temperature, init_size=init_size, max_scale=max_scale) self.alphabet_size = alphabet_size self.device = device self.embedding = nn.Linear(alphabet_size, channels) self.conv = torch.nn.Sequential() for l in range(layers): self.conv.add_module( 'conv_' + str(l + 1), nn.Conv1d(in_channels=channels, out_channels=channels, kernel_size=kernel_size, padding=kernel_size // 2)) if batch_norm: self.conv.add_module('batchnorm_' + str(l + 1), nn.BatchNorm1d(num_features=channels)) if non_linearity: self.conv.add_module('relu_' + str(l + 1), nn.ReLU()) if pooling == 'avg': self.conv.add_module(pooling + '_pool_' + str(l + 1), nn.AvgPool1d(2)) elif pooling == 'max': self.conv.add_module(pooling + 'pool_' + str(l + 1), nn.MaxPool1d(2)) flat_size = channels * sequence_length if pooling == 'none' else channels * ( sequence_length // 2**layers) self.readout = MLP(in_size=flat_size, hidden_size=rank, out_size=rank, layers=readout_layers, mid_activation='relu', dropout=dropout, device=device)
def __init__(self, channels, kernel_size, padding, pool=False, double_channels=False): super(ResBlock, self).__init__() self.pool = pool self.double_channels = double_channels self.channels = channels self.conv0 = nn.Conv1d(channels, channels, kernel_size, padding=padding) self.conv1 = nn.Conv1d(channels, channels, kernel_size, padding=padding) self.leakyrelu = nn.LeakyReLU(inplace=True) self.pooling_layer = nn.AvgPool1d(2) self.layer_norm0 = None self.layer_norm1 = None
def __init__(self, alphabet_size, embedding_dim=100, hidden_dim=50, dropout=0.5, gpu=True): super(CharCNN, self).__init__() self.gpu = gpu self.hidden_dim = hidden_dim self.char_drop = nn.Dropout(dropout) self.char_embeddings = nn.Embedding(alphabet_size, embedding_dim) self.char_cnn1 = nn.Conv1d(embedding_dim, self.hidden_dim, kernel_size=3, padding=1) self.pool1 = nn.AvgPool1d(4) self.char_cnn2 = nn.Conv1d(self.hidden_dim, self.hidden_dim, kernel_size=3, padding=1) self.pool2 = nn.AvgPool1d(4) self.char_cnn3 = nn.Conv1d(self.hidden_dim, self.hidden_dim, kernel_size=3, padding=1) self.pool3 = nn.AvgPool1d(2) if self.gpu: self.char_drop = self.char_drop.cuda() self.char_embeddings = self.char_embeddings.cuda() self.char_cnn1 = self.char_cnn1.cuda() self.pool1 = self.pool1.cuda() self.char_cnn2 = self.char_cnn2.cuda() self.pool2 = self.pool2.cuda() self.char_cnn3 = self.char_cnn3.cuda() self.pool3 = self.pool3.cuda()
def __init__(self, num_input_features, num_output_features): super().__init__() self.add_module('norm', nn.BatchNorm1d(num_input_features)) self.add_module('relu', nn.ReLU(inplace=True)) self.add_module( 'conv', nn.Conv1d(num_input_features, num_output_features, kernel_size=1, stride=1, bias=False)) self.add_module('pool', nn.AvgPool1d(kernel_size=2, stride=2))
def __init__(self, num_D, ndf, n_layers, downsampling_factor): super().__init__() self.model = nn.ModuleDict() for i in range(num_D): self.model[f"disc_{i}"] = NLayerDiscriminator( ndf, n_layers, downsampling_factor) self.downsample = nn.AvgPool1d(4, stride=2, padding=1, count_include_pad=False) self.apply(weights_init)
def __init__(self, in_planes, out_planes): super(_Transition, self).__init__() self.add_module('norm', nn.BatchNorm1d(in_planes)) self.add_module('relu', nn.ReLU(inplace=True)) self.add_module( 'conv', nn.Conv1d(in_planes, out_planes, kernel_size=1, stride=1, bias=False)) self.add_module('pool', nn.AvgPool1d(kernel_size=2, stride=2))
def __init__(self, input_channel, layers=[1, 1, 1, 1], num_classes=10): self.inplanes5_1 = 64 self.inplanes5_2 = 64 self.inplanes5_3 = 64 super(MSResNet, self).__init__() self.conv1 = nn.Conv1d(input_channel, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm1d(64) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool1d(kernel_size=3, stride=2, padding=1) self.layer5x5_11 = self._make_layer5_1(BasicBlock5x5_1, 64, layers[0], stride=2) self.layer5x5_12 = self._make_layer5_1(BasicBlock5x5_1, 128, layers[1], stride=2) self.layer5x5_13 = self._make_layer5_1(BasicBlock5x5_1, 256, layers[2], stride=2) # self.layer3x3_4 = self._make_layer3(BasicBlock3x3, 512, layers[3], stride=2) # maxplooing kernel size: 16, 11, 6 self.maxpool5_1 = nn.AvgPool1d(kernel_size=11, stride=1, padding=0) self.layer5x5_21 = self._make_layer5_2(BasicBlock5x5_2, 64, layers[0], stride=2) self.layer5x5_22 = self._make_layer5_2(BasicBlock5x5_2, 128, layers[1], stride=2) self.layer5x5_23 = self._make_layer5_2(BasicBlock5x5_2, 256, layers[2], stride=2) # self.layer3x3_4 = self._make_layer3(BasicBlock3x3, 512, layers[3], stride=2) # maxplooing kernel size: 16, 11, 6 self.maxpool5_2 = nn.AvgPool1d(kernel_size=11, stride=1, padding=0) self.layer5x5_31 = self._make_layer5_3(BasicBlock5x5_3, 64, layers[0], stride=2) self.layer5x5_32 = self._make_layer5_3(BasicBlock5x5_3, 128, layers[1], stride=2) self.layer5x5_33 = self._make_layer5_3(BasicBlock5x5_3, 256, layers[2], stride=2) # self.layer3x3_4 = self._make_layer3(BasicBlock3x3, 512, layers[3], stride=2) # maxplooing kernel size: 16, 11, 6 self.maxpool5_3 = nn.AvgPool1d(kernel_size=11, stride=1, padding=0) # self.drop = nn.Dropout(p=0.2) self.fc = nn.Linear(256*3, num_classes)
def __init__(self, length=256): super().__init__() self.starter = nn.Sequential(Block(2, 16), Block(16, 20), nn.AvgPool1d(kernel_size=2), Block(20, 24), nn.AvgPool1d(kernel_size=2), Block(24, 28), nn.AvgPool1d(kernel_size=2), Block(28, 32)) self.pass_down1 = nn.Sequential(nn.AvgPool1d(kernel_size=2), Block(32, 48)) self.pass_down2 = nn.Sequential(nn.AvgPool1d(kernel_size=2), Block(48, 64)) self.code = nn.Sequential(nn.AvgPool1d(kernel_size=2), Block(64, 96), nn.Upsample(scale_factor=2), Block(96, 64)) self.pass_up2 = nn.Sequential(nn.Upsample(scale_factor=2), Block(128, 64)) self.pass_up1 = nn.Sequential(nn.Upsample(scale_factor=2), Block(112, 48)) self.finisher = nn.Sequential(nn.Upsample(scale_factor=2), Block(80, 64), nn.Upsample(scale_factor=2), Block(64, 32), nn.Upsample(scale_factor=2), Block(32, 16), nn.Conv1d(16, 2, 1, padding=0))
def __init__(self, inplanes, planes, stride=1, downsample=None): super(Bottleneck, self).__init__() self.conv1 = nn.Conv1d(inplanes, planes, kernel_size=7, bias=False, padding=3) self.bn1 = nn.BatchNorm1d(planes) self.conv2 = nn.Conv1d(planes, planes, kernel_size=11, stride=stride, padding=5, bias=False) self.bn2 = nn.BatchNorm1d(planes) self.conv3 = nn.Conv1d(planes, planes * 4, kernel_size=7, bias=False, padding=3) self.bn3 = nn.BatchNorm1d(planes * 4) self.relu = nn.ReLU(inplace=True) if planes == 64: self.globalAvgPool = nn.AvgPool1d(313, stride=1) elif planes == 128: self.globalAvgPool = nn.AvgPool1d(157, stride=1) elif planes == 256: self.globalAvgPool = nn.AvgPool1d(79, stride=1) elif planes == 512: self.globalAvgPool = nn.AvgPool1d(40, stride=1) self.fc1 = nn.Linear(in_features=planes * 4, out_features=round(planes / 4)) self.fc2 = nn.Linear(in_features=round(planes / 4), out_features=planes * 4) self.downsample = downsample self.stride = stride self.dropout = nn.Dropout(.2)
def __init__(self, num_classes=12): super().__init__() self.in_channels = 12 self.pool0 = nn.AvgPool1d(kernel_size=2) self.pool1 = nn.AvgPool1d(kernel_size=3) self.conv0 = nn.Conv1d(in_channels=self.in_channels, out_channels=2*self.in_channels, kernel_size=51, groups=self.in_channels) self.bn0 = nn.BatchNorm1d(num_features=2*self.in_channels) self.conv1 = nn.Conv1d(in_channels=2*self.in_channels, out_channels=4*self.in_channels, kernel_size=26, groups=self.in_channels) self.bn1 = nn.BatchNorm1d(num_features=4*self.in_channels) self.conv2 = nn.Conv1d(in_channels=4*self.in_channels, out_channels=4*self.in_channels, kernel_size=10, groups=self.in_channels) self.bn2 = nn.BatchNorm1d(num_features=4*self.in_channels) self.conv3 = nn.Conv1d(in_channels=4*self.in_channels, out_channels=5*self.in_channels, kernel_size=8) self.bn3 = nn.BatchNorm1d(num_features=5*self.in_channels) self.conv4 = nn.Conv1d(in_channels=5*self.in_channels, out_channels=5*self.in_channels, kernel_size=4) self.bn4 = nn.BatchNorm1d(num_features=5*self.in_channels) self.conv5 = nn.Conv1d(in_channels=self.in_channels, out_channels=self.in_channels // 2, kernel_size=11) self.bn5 = nn.BatchNorm1d(num_features=self.in_channels // 2) self.pred = nn.Linear(in_features=6 * 730, out_features=num_classes) encoder_layer = nn.TransformerEncoderLayer(d_model=740, nhead=5, dim_feedforward=740*2) self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=6)
def __init__(self, in_size, out_size, input_channels = 1, convolutions = [16,16], kernel_size = [7,7], hiddenlayer=[512,256], maxpool = 4, dropout = 0.1): super(ResidualNetworkD1, self).__init__() convLayers = [] ## Convolutional layers for i, convolution in enumerate(convolutions): if (i==0): convLayers.append(nn.Conv1d(in_channels = input_channels, out_channels = convolutions[0], padding = kernel_size[0]//2, kernel_size = kernel_size[0])) convLayers.append(nn.BatchNorm1d(convolutions[0])) #layers.append(nn.MaxPool1d(maxpool)) convLayers.append(nn.ReLU()) #convLayers.append(nn.Dropout(p=dropout)) else: convLayers.append(ResnetBlock1d(in_num_filter = convolutions[i-1], out_num_filters = convolutions[i], padding_size = kernel_size[i]//2, kernel_sizes = kernel_size[i])) #convLayers.append(nn.BatchNorm1d(convolutions[i])) convLayers.append(nn.AvgPool1d(maxpool)) convLayers.append(nn.ReLU()) convLayers.append(nn.Dropout(p=dropout)) # Flatten before fully connected #layers.append(nn.MaxPool1d(maxpool)) flatten_layers = [] flatten_layers.append(Flatten()) ## Fully Connected layers for i, layer in enumerate(hiddenlayer): if i == 0: flatten_layers.append(nn.Linear(in_size//(maxpool**(len(convolutions)-1))*convolutions[-1],hiddenlayer[i])) flatten_layers.append(nn.ReLU()) flatten_layers.append(nn.Dropout(p=dropout)) else: flatten_layers.append(nn.Linear(hiddenlayer[i-1], hiddenlayer[i])) flatten_layers.append(nn.ReLU()) flatten_layers.append(nn.Dropout(p=dropout)) flatten_layers.append(nn.Linear(hiddenlayer[-1], out_size)) self.convnet = nn.Sequential(*convLayers) self.flatnet = nn.Sequential(*flatten_layers)
def __init__( self, vocab_size, embedding_dim, len_sentence, channel_size=4, x2_size=1, # additional data - cap ratio fc_dim=128, padding_idx=1, dropout=0.3, num_labels=7, batch_size=32, is_cuda=False, n_gram=5, additional_kernel_size=1, ): super(Net, self).__init__() self.embedding = nn.Embedding(vocab_size + 2, embedding_dim=embedding_dim, padding_idx=padding_idx) self.embedding_dim = embedding_dim self.vocab_size = vocab_size self.channel_size = channel_size self.len_sentence = len_sentence self.batch_size = batch_size self.x2_size = x2_size self.kernel_size = (n_gram, embedding_dim + additional_kernel_size) self.n_gram = n_gram self.additional_kernel_size = additional_kernel_size self.conv2d = nn.Conv2d(1, out_channels=channel_size, kernel_size=self.kernel_size, stride=1) # output : batch x channel x (len_sentence - 2) x 1 # -> squeeze : batch x channel x (len_sentence - 2) self.relu = nn.ReLU(inplace=True) self.dropout1d = nn.Dropout(p=dropout) self.pool1d = nn.AvgPool1d(kernel_size=2) # output : batch x channel x (len_sentence - 2) / 2 self.bottleneck_size = channel_size * (len_sentence - (self.n_gram - 1)) / 2 assert self.bottleneck_size.is_integer() self.bottleneck_size = int(self.bottleneck_size) + self.x2_size self.fcn1 = nn.Linear(self.bottleneck_size, fc_dim) self.relu1 = nn.ReLU(inplace=True) self.fcn2 = nn.Linear(fc_dim, num_labels) self.sigmoid = nn.Sigmoid() self.fc_dim = fc_dim self.num_labels = num_labels
def __init__(self, num_tokens, word_emb_size, hidden_size, device=torch.device("cuda" if torch.cuda.is_available() else "cpu"), num_layers=1, num_filters=3, kernel_size=1, stride=5, fusion="cat", env=None, condition_answer="none", attention_dim=512): super(PolicyLSTMBatch, self).__init__() self.device = device self.condition_answer = condition_answer self.num_tokens = num_tokens self.hidden_size = hidden_size self.num_layers = num_layers self.word_embedding = nn.Embedding(num_tokens, word_emb_size, padding_idx=0) self.lstm = nn.LSTM(word_emb_size, self.hidden_size, batch_first=True) truncature = {"masked": mask_truncature, "masked_inf": mask_inf_truncature} self.truncate = truncature["masked_inf"] self.answer_embedding = nn.Embedding(env.dataset.len_vocab_answer, word_emb_size) self.fusion = fusion self.num_filters = word_emb_size if num_filters is None else num_filters self.stride = stride self.kernel_size = kernel_size self.word_emb_size = word_emb_size self.attention_dim = attention_dim h_out = int((14 + 2 * 0 - 1 * (self.kernel_size - 1) - 1) / self.stride + 1) self.conv = nn.Conv2d(in_channels=1024, out_channels=self.num_filters, kernel_size=self.kernel_size, stride=self.stride) if self.fusion == "none": self.fusion_dim = self.hidden_size elif self.fusion == "film": self.gammabeta = nn.Linear(self.hidden_size, 2 * self.num_filters) self.film = contrib_nn.FiLM() self.fusion_dim = self.num_filters * h_out ** 2 elif self.fusion == "sat": self.attention = Attention(101, self.hidden_size, attention_dim, word_emb_size) self.init_h = nn.Linear(101, hidden_size) # linear layer to find initial hidden state of LSTMCell self.init_c = nn.Linear(101, hidden_size) # linear layer to find initial cell state of LSTMCell self.last_states = None self.f_beta = nn.Linear(hidden_size, 101) # linear layer to create a sigmoid-activated gate self.sigmoid = nn.Sigmoid() self.fc = nn.Linear(hidden_size, self.num_tokens) self.decode_step = nn.LSTMCell(word_emb_size + 101, hidden_size, bias=True) self.fusion_dim = hidden_size elif self.fusion == "average": self.projection = nn.Linear(2048, hidden_size) self.avg_pooling = nn.AvgPool1d(kernel_size=101) self.fusion_dim = 2 * hidden_size else: self.fusion_dim = self.num_filters * h_out ** 2 + self.hidden_size if self.condition_answer in ["after_fusion", "attention"]: self.fusion_dim += word_emb_size self.action_head = nn.Linear(self.fusion_dim, num_tokens) self.value_head = nn.Linear(self.fusion_dim, 1)
def __init__(self, embedding_size: int, embedding_dim: int, num_classes: int = 1, hidden_lstm_size: int = 64, hidden_gru_size: int = 64, dropout_rate: float = 0.5): super(LSTM_GRU, self).__init__() self.embedding = nn.Embedding(embedding_size, embedding_dim) self.embedding_dropout = EmbeddingDropout(dropout_rate) self.lstm = nn.LSTM( input_size=embedding_dim, hidden_size=hidden_lstm_size, bias=True, batch_first=True, bidirectional=True, ) self.gru = nn.GRU( input_size=hidden_lstm_size * 2, hidden_size=hidden_gru_size, bias=True, batch_first=True, bidirectional=True, ) self.max_pool = nn.MaxPool1d(2) self.avg_pool = nn.AvgPool1d(2) input_size = 2 * hidden_gru_size # 2 pooling layers self.head = nn.Sequential( OrderedDict([ ( "block1", nn.Sequential( nn.Linear(input_size, num_classes * 2), nn.ReLU(True), nn.BatchNorm1d(num_classes * 2), nn.Dropout(dropout_rate), ), ), ( "block2", nn.Sequential( nn.Linear(num_classes * 2, int(num_classes * 1.5)), nn.ReLU(True), nn.BatchNorm1d(int(num_classes * 1.5)), nn.Dropout(dropout_rate), ), ), ("head", nn.Linear(int(num_classes * 1.5), num_classes)), ]))
def __init__(self): super(Steganalysis, self).__init__() K = np.array([[-1, 2, -1]], dtype=float) K = K.reshape(1, 1, 3).astype(np.float32) K = torch.from_numpy(K) self.K = nn.Parameter(data=K, requires_grad=False) self.conv2 = nn.Conv1d(in_channels=1, out_channels=1, kernel_size=5, stride=1, padding=2) self.conv3 = nn.Conv1d(1, 8, 1, 1, 0) self.conv4 = nn.Conv1d(8, 8, 3, 2, 2) self.conv5 = nn.Conv1d(8, 8, 5, 1, 2) self.conv6 = nn.Conv1d(8, 16, 1, 1, 0) self.conv7 = nn.Conv1d(16, 16, 3, 2, 2) self.conv8 = nn.Conv1d(16, 16, 5, 1, 2) self.T1 = nn.ReLU() self.conv9 = nn.Conv1d(16, 32, 1, 1, 0) self.T2 = nn.ReLU() self.Max1 = nn.MaxPool1d(kernel_size=3, stride=2, padding=1) self.conv10 = nn.Conv1d(32, 32, 5, 1, 2) self.T3 = nn.ReLU() self.conv11 = nn.Conv1d(32, 64, 1, 1, 0) self.T4 = nn.ReLU() self.Max2 = nn.MaxPool1d(kernel_size=3, stride=2, padding=1) self.conv12 = nn.Conv1d(64, 64, 5, 1, 2) self.T5 = nn.ReLU() self.conv13 = nn.Conv1d(64, 128, 1, 1, 0) self.T6 = nn.ReLU() self.Max3 = nn.MaxPool1d(kernel_size=3, stride=2, padding=1) self.conv14 = nn.Conv1d(128, 128, 5, 1, 2) self.T7 = nn.ReLU() self.conv15 = nn.Conv1d(128, 256, 1, 1, 0) self.T8 = nn.ReLU() self.Max4 = nn.MaxPool1d(kernel_size=3, stride=2, padding=1) self.conv16 = nn.Conv1d(256, 256, 5, 1, 2) self.T9 = nn.ReLU() self.conv17 = nn.Conv1d(256, 512, 1, 1, 0) self.T10 = nn.ReLU() self.avg = nn.AvgPool1d(kernel_size=256, stride=256) self.fully_connected = nn.Linear(in_features=512, out_features=1) self.finall = nn.Sigmoid() self.init_weights()
def __init__(self, fixed_len=128, p=0.0): super(Encoder, self).__init__() self.fixed_len = fixed_len self.conv_layer1 = conv_layer(1, 64) self.stem = conv_stem(64, p=p) self.pool1 = nn.AvgPool1d(kernel_size=2) self.bottle_neck1 = conv_layer(64, 128, ksize=1) self.residual_block_1 = residual_block(128, 128, p=p) self.pool2 = nn.AvgPool1d(kernel_size=2) self.bottle_neck2 = conv_layer(128, 256, ksize=1) self.residual_block_2 = residual_block(256, 256, p=p) self.pool3 = nn.AvgPool1d(kernel_size=2) self.bottle_neck3 = conv_layer(256, 512, ksize=1) self.residual_block_3 = residual_block(512, 512, p=p) self.gap = nn.AdaptiveAvgPool1d(1)