def __init__(self, len_sequence, embedding_size, channels, device, readout_layers=2, layers=3, dropout=0., kernel_size=3, alphabet_size=4, non_linearity=True): super(CNNEncoder, self).__init__() self.embedding = nn.Embedding(alphabet_size + 1, 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 non_linearity: self.conv.add_module('relu_' + str(l + 1), nn.ReLU()) flat_size = channels * len_sequence self.readout = MLP(in_size=flat_size, hidden_size=embedding_size, out_size=embedding_size, layers=readout_layers, mid_activation='relu', dropout=dropout, device=device) self.to(device)
def __init__(self, len_sequence, embedding_size, layers, hidden_size, device, dropout=0., alphabet_size=4): super(MLPEncoder, self).__init__() self.device = device self.mlp = MLP(in_size=len_sequence * alphabet_size, hidden_size=hidden_size, out_size=embedding_size, layers=layers, mid_activation='relu', dropout=dropout, device=device) self.to(device)
def __init__(self, len_sequence, embedding_size, channels, device, readout_layers=2, layers=3, dropout=0., kernel_size=3, alphabet_size=4, pooling='avg', non_linearity=True, batch_norm=False, stride=1): super(CNN, self).__init__() assert pooling == 'none' or pooling == 'avg' or pooling == 'max', "Wrong pooling type" self.layers = layers self.kernel_size = kernel_size self.embedding = nn.Linear(alphabet_size, channels) # construct convolutional layers self.conv = torch.nn.Sequential() for l in range(self.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, stride=stride)) len_sequence = (len_sequence - 1) // stride + 1 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)) len_sequence //= 2 elif pooling == 'max': self.conv.add_module(pooling + 'pool_' + str(l + 1), nn.MaxPool1d(2)) len_sequence //= 2 # construct readout print(len_sequence) flat_size = channels * len_sequence self.readout = MLP(in_size=flat_size, hidden_size=embedding_size, out_size=embedding_size, layers=readout_layers, mid_activation='relu', dropout=dropout, device=device) self.to(device)
def __init__(self, len_sequence, embedding_size, hidden_size, recurrent_layers, device, readout_layers, alphabet_size=4, dropout=0.0): super(GRU, self).__init__() self.len_sequence = len_sequence self.sequence_encoder = nn.GRU(input_size=alphabet_size, hidden_size=hidden_size, num_layers=recurrent_layers, dropout=dropout) self.readout = MLP(in_size=hidden_size, hidden_size=hidden_size, out_size=embedding_size, layers=readout_layers, mid_activation='relu', dropout=dropout, device=device) self.to(device)
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, len_sequence, segment_size, embedding_size, hidden_size, trans_layers, readout_layers, device, alphabet_size=4, dropout=0.0, heads=1, layer_norm=False, mask='empty'): super(Transformer, self).__init__() self.segment_size = segment_size if mask == "empty": self.mask_sequence = generate_empty_mask(len_sequence // segment_size).to(device) elif mask == "no_prev": self.mask_sequence = generate_square_previous_mask( len_sequence // segment_size).to(device) elif mask[:5] == "local": self.mask_sequence = generate_local_mask( len_sequence // segment_size, k=int(mask[5:])).to(device) self.sequence_trans = TransformerEncoderModel( ntoken=alphabet_size * segment_size, nout=hidden_size, ninp=hidden_size, nhead=heads, nhid=hidden_size, nlayers=trans_layers, dropout=dropout, layer_norm=layer_norm, max_len=len_sequence // segment_size) self.readout = MLP(in_size=len_sequence // segment_size * hidden_size, hidden_size=embedding_size, out_size=embedding_size, layers=readout_layers, dropout=dropout, device=device) self.to(device)
def __init__(self, len_sequence, embedding_size, layers, hidden_size, device, batch_norm=True, dropout=0., alphabet_size=4): super(MLPEncoder, self).__init__() self.encoder = MLP(in_size=alphabet_size * len_sequence, hidden_size=hidden_size, out_size=embedding_size, layers=layers, mid_activation='relu', dropout=dropout, device=device, mid_b_norm=batch_norm)