def __init__(self, num_conv1d_banks, num_highway_blocks, in_dims, out_dims,
activation):
super(CBHG, self).__init__()
self.num_highway_blocks = num_highway_blocks
self.conv1d_banks = Conv1dBanks(num_conv1d_banks, in_dims, out_dims,
activation)
# Since kernel_size = 2, padding + 1
self.max_pool1d = MaxPool1d(kernel_size=2, stride=1, padding=1)
self.projection1 = Conv1dNorm(in_dims=num_conv1d_banks * out_dims,
out_dims=out_dims,
kernel_size=3,
activation_fn=activation)
self.projection2 = Conv1dNorm(in_dims=out_dims,
out_dims=out_dims,
kernel_size=3,
activation_fn=None)
self.highway = HighwayNet(in_dims=out_dims)
self.gru = GRU(out_dims,
out_dims,
batch_first=True,
bidirectional=True)
def __init__(self,
idim: int,
hdim: int,
nlayers: int = 1,
enc_type: str = "blstm"):
"""
This represents the computation that happens for 1 RNN Layer
Uses packing,padding utils from Pytorch
:param int input_dim- The input size of the RNN
:param int hidden_dim- The hidden size of the RNN
:param int nlayers- Number of RNN Layers
:param str enc_type : Type of encoder- RNN/GRU/LSTM
"""
super(RNNLayer, self).__init__()
bidir = True if enc_type[0] == 'b' else False
enc_type = enc_type[1:] if enc_type[0] == 'b' else enc_type
if enc_type == "rnn":
self.elayer = RNN(idim,
hdim,
nlayers,
batch_first=True,
bidirectional=bidir)
elif enc_type == "lstm":
self.elayer = LSTM(idim,
hdim,
nlayers,
batch_first=True,
bidirectional=bidir)
else:
self.elayer = GRU(idim,
hdim,
nlayers,
batch_first=True,
bidirectional=bidir)
def __init__(self,
num_nodes,
num_rels,
hidden_channels,
seq_len,
num_layers=1,
dropout=0.,
bias=True):
super(RENet, self).__init__()
self.num_nodes = num_nodes
self.hidden_channels = hidden_channels
self.num_rels = num_rels
self.seq_len = seq_len
self.dropout = dropout
self.ent = Parameter(torch.Tensor(num_nodes, hidden_channels))
self.rel = Parameter(torch.Tensor(num_rels, hidden_channels))
self.sub_gru = GRU(3 * hidden_channels,
hidden_channels,
num_layers,
batch_first=True,
bias=bias)
self.obj_gru = GRU(3 * hidden_channels,
hidden_channels,
num_layers,
batch_first=True,
bias=bias)
self.sub_lin = Linear(3 * hidden_channels, num_nodes, bias=bias)
self.obj_lin = Linear(3 * hidden_channels, num_nodes, bias=bias)
self.reset_parameters()
def __init__(self,dim=64,edge_dim=12,node_in=8,edge_in=19,edge_in3=8,num_layers=1):
super(Net_int_2Edges_Set2Set3, self).__init__()
self.num_layers = num_layers
self.dim = dim
self.lin_node = torch.nn.Linear(node_in, dim)
self.lin_edge_attr = torch.nn.Linear(edge_in, edge_dim)
nn1 = Linear(edge_dim, dim * dim, bias=False)
nn2 = Linear(edge_in3, dim * dim * 2 * 2, bias=False)
self.conv1 = NNConv(dim, dim, nn1, aggr='mean', root_weight=False)
self.gru1 = GRU(dim, dim)
self.lin_covert = Sequential(BatchNorm1d(dim),Linear(dim, dim*2), \
RReLU(), Dropout(),Linear(dim*2, dim*2),RReLU())
self.conv2 = NNConv(dim*2, dim*2, nn2, aggr='mean', root_weight=False)
self.gru2 = GRU(dim*2, dim*2)
self.lin_weight = Linear(edge_in3, dim*2*2, bias=False)
self.lin_bias = Linear(edge_in3, 1, bias=False)
self.norm = BatchNorm1d(dim*2*2)
self.norm_x = BatchNorm1d(node_in)
self.head = Set2Set(dim*2,processing_steps=3,num_layers=num_layers)
self.pool = Set2Set(dim*2,processing_steps=3)
self.h_lin = Linear(edge_in3,num_layers*dim*2*2)
self.q_star_lin = Linear(dim*2*2,dim*2*2)
def __init__(self,
hidden_size=100,
num_layers=1,
num_roads=192,
prev_timesteps=6,
prediction_steps=6):
super().__init__(name="Sequence2Sequence")
self.prev_timesteps = prev_timesteps
self.num_roads = num_roads
self.prediction_steps = prediction_steps
self.num_layers = num_layers
self.hidden_size = hidden_size
self.encoder = GRU(num_roads,
hidden_size,
batch_first=True,
num_layers=num_layers)
self.decoder = GRU(num_roads,
hidden_size,
batch_first=True,
num_layers=num_layers)
#self.activation = Sig()
self.decoder_l1 = Linear(hidden_size, num_roads)
self.criterion = L1Loss()
class Encoder(nn.Module):
def __init__(self, input_dim, hidden_dim, bidirectional=False, embedding=None, cell='LSTM', num_layers=1):
super(Encoder, self).__init__()
if embedding =='mlp':
self.embedding = nn.Sequential(nn.Linear(input_dim, hidden_dim), nn.Tanh())
rnn_input = hidden_dim
else:
self.embedding = nn.Identity()
rnn_input = input_dim
if bidirectional:
hidden_dim = hidden_dim//2
if cell == 'LSTM':
self.rnn = LSTM(input_size=rnn_input, hidden_size=hidden_dim, num_layers=num_layers, bidirectional=bidirectional, batch_first=True)
elif cell == 'GRU':
self.rnn = GRU(input_size=rnn_input, hidden_size=hidden_dim, num_layers=num_layers, bidirectional=bidirectional, batch_first=True)
# self.rnn.flatten_parameters()
def forward(self, seq):
if len(seq.shape)>3:
seq = reshap_input_for_lstm(seq)
seq = seq.float()
# t, b, f = seq.shape
b, t, f = seq.shape
seq = self.embedding(seq.reshape([-1, f])).reshape([b, t, -1])
self.rnn.flatten_parameters()
seq, _ = self.rnn(seq)
return seq
def __init__(self,
embedding_size,
hidden_size,
output_size,
num_layers=1,
dropout=0.0,
length=20,
device=torch.device('cuda:1')):
super(Decoder, self).__init__()
self.embedding = Embedding(output_size, embedding_dim=embedding_size)
self.gru = GRU(input_size=embedding_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
bidirectional=False)
hidden_size_2 = 300
self.output = Linear(in_features=hidden_size_2,
out_features=output_size)
self.hidden2 = Linear(hidden_size, hidden_size_2)
self.length = length
self.output_size = output_size
self.device = device
# do orthogonal initialization
for name, param in self.gru.named_parameters():
if 'bias' in name:
nn.init.constant_(param, 0.0)
elif 'weight_ih' in name:
nn.init.kaiming_normal_(param)
elif 'weight_hh' in name:
nn.init.orthogonal_(param)
def __init__(self, n_steps_in, n_steps_out, n_features, n_cells):
super(Net, self).__init__()
self.n_steps_in = n_steps_in
self.n_steps_out = n_steps_out
self.n_features = n_features
self.n_cells = n_cells
self.gru0 = GRU(n_features,
self.n_cells,
4,
dropout=0.1,
bidirectional=True,
batch_first=True)
self.gru1 = GRU(self.n_cells * 2,
self.n_cells,
3,
dropout=0.1,
bidirectional=True,
batch_first=True)
self.gru2 = GRU(self.n_cells * 2,
self.n_cells,
3,
dropout=0.1,
bidirectional=True,
batch_first=True)
self.linear1 = Linear(2 * n_cells, 30)
self.linear2 = Linear(2 * n_cells, 30)
self.linear1_2 = Linear(30, 1)
self.linear2_2 = Linear(30, 1)
self.relu = ReLU()
class Decoder(nn.Module):
def __init__(self, input_dim, hidden_dim, output_dim, bidirectional=False, cell='LSTM', num_layers=1):
super(Decoder, self).__init__()
rnn_hidden_dim = hidden_dim//2 if bidirectional else hidden_dim
if cell == 'LSTM':
self.rnn = LSTM(input_size=input_dim, hidden_size=rnn_hidden_dim, num_layers=num_layers, bidirectional=bidirectional, batch_first=True)
elif cell == 'GRU':
self.rnn = GRU(input_size=input_dim, hidden_size=rnn_hidden_dim, num_layers=num_layers, bidirectional=bidirectional, batch_first=True)
rnn_hidden_output = rnn_hidden_dim * 2 if bidirectional else hidden_dim
self.output_lin = nn.Linear(rnn_hidden_output, output_dim)
# self.output_lin = nn.Sequential(nn.Linear(rnn_hidden_output, output_dim), nn.Tanh())
def forward(self, seq):
# seq = seq.permute(1, 0, 2).contiguous() # t,b,h
self.rnn.flatten_parameters()
seq, _ = self.rnn(seq)
# seq = seq.permute(1, 0, 2).contiguous() # b,t,h
# t, b, f = seq.shape
b, t, f = seq.shape
output = self.output_lin(seq.reshape([-1, f])).reshape([b, t, -1])
return output
def __init__(self, cfg, **kwargs):
super(Model, self).__init__()
self.enc_hidden_sz = cfg.MODEL.ENC_HIDDEN_SZ
self.ctx_hidden_sz = cfg.MODEL.CTX_HIDDEN_SZ
self.dec_hidden_sz = cfg.MODEL.DEC_HIDDEN_SZ
self.input_sz = cfg.MODEL.EMBED_SZ
self.ctx_in_sz = cfg.MODEL.CTX_IN_SZ
self.num_layers = cfg.MODEL.NUM_LAYERS
self.embed = torch.nn.Embedding(kwargs['vocab_size'], cfg.MODEL.EMBED_SZ)
self.enc = GRU(input_size=self.input_sz,
hidden_size=self.enc_hidden_sz,
num_layers=self.num_layers,
batch_first=True
)
self.enc_to_ctx = nn.Linear(self.enc_hidden_sz, self.ctx_in_sz)
self.ctx = GRU(input_size=self.ctx_in_sz,
hidden_size=self.ctx_hidden_sz,
num_layers=self.num_layers,
batch_first=True
)
self.ctx_to_dec = nn.Linear(self.ctx_hidden_sz, self.dec_hidden_sz)
self.dec = GRU(input_size=self.input_sz,
hidden_size=self.dec_hidden_sz,
num_layers=self.num_layers,
batch_first=True
)
def __init__(self, input_size, hidden_size, pad_idx,
vocab_size):
super().__init__()
self.embedding = Embedding(
num_embeddings=vocab_size,
embedding_dim=input_size,
padding_idx=pad_idx)
self.dropout = Dropout(p=0.1)
self.merge = Linear(
in_features=hidden_size * 2,
out_features=hidden_size,
bias=False)
# creating rnn layer as module list so locked
# dropout can be applied between each layer
# NOTE: currently not using weight drop, because
# it is incompatible with apex
self.rnn = ModuleList([
GRU(input_size=input_size,
hidden_size=hidden_size,
bidirectional=True,
batch_first=True)] + [
GRU(input_size=hidden_size,
hidden_size=hidden_size,
batch_first=True)
for _ in range(2)
])
def __init__(self,
sample_size,
conv_bank_max_filter_size=16,
conv_projections_channel_size=(128, 128),
num_highways=4):
super(CBHG, self).__init__()
self.sample_size = sample_size
self.relu = ReLU()
# conv_bank_max_filter_size sets of 1-D convolutional filters
self.conv1d_banks = []
for k in range(1, conv_bank_max_filter_size + 1):
self.conv1d_banks.append(
BatchNormConv1d(in_channels=sample_size,
out_channels=sample_size,
kernel_size=k,
stride=1,
padding=k // 2,
activation=self.relu))
self.conv1d_banks = ModuleList(modules=self.conv1d_banks)
# max pooling of conv bank (to increase local invariances)
self.max_pool1d = MaxPool1d(kernel_size=2, stride=1, padding=1)
out_features = [conv_bank_max_filter_size * sample_size
] + conv_projections_channel_size[:-1]
activations = [self.relu
] * (len(conv_projections_channel_size) - 1) + [None]
# conv1d projection layers
self.conv1d_projections = []
for (in_size, out_size, ac) in zip(out_features,
conv_projections_channel_size,
activations):
self.conv1d_projections.append(
BatchNormConv1d(in_channels=in_size,
out_channels=out_size,
kernel_size=3,
stride=1,
padding=1,
activation=ac))
self.conv1d_projections = ModuleList(modules=self.conv1d_projections)
# Highway layers
self.pre_highway = Linear(
in_features=conv_projections_channel_size[-1],
out_features=sample_size,
bias=False)
self.highways = ModuleList(modules=[
Highway(in_size=sample_size, out_size=sample_size)
for _ in range(num_highways)
])
# bi-directional GPU layer
self.gru = GRU(input_size=sample_size,
hidden_size=sample_size,
num_layers=1,
batch_first=True,
bidirectional=True)
def gru_test(nsteps):
gru_net = GRU(input_size=4, hidden_size=20, num_layers=3, batch_first=False, dropout=0.0, bidirectional=True)
gru_net.cuda(device=0)
with Profile("gru"):
for i in range(nsteps):
gru_func(max_length=450, seq_length=350, gru_net=gru_net)
print(Profile.to_string())
def __init__(
self,
weight_file: str,
uid_column: CategoricalColumnWithIdentity,
iid_column: CategoricalColumnWithIdentity,
pos_state_len_column: CategoricalColumnWithIdentity,
pos_state_column: CategoricalColumnWithIdentity,
pos_next_state_len_column: CategoricalColumnWithIdentity,
pos_next_state_column: CategoricalColumnWithIdentity,
neg_state_len_column: CategoricalColumnWithIdentity,
neg_state_column: CategoricalColumnWithIdentity,
neg_next_state_len_column: CategoricalColumnWithIdentity,
neg_next_state_column: CategoricalColumnWithIdentity,
rl_sample_column: CategoricalColumnWithIdentity,
emb_size: int,
hidden_size: int,
):
super().__init__()
self.emb_size = emb_size
self.hidden_size = hidden_size
self.uid_column = uid_column
self.iid_column = iid_column
self.pos_state_len_column = pos_state_len_column
self.pos_state_column = pos_state_column
self.pos_next_state_len_column = pos_next_state_len_column
self.pos_next_state_column = pos_next_state_column
self.neg_state_len_column = neg_state_len_column
self.neg_state_column = neg_state_column
self.neg_next_state_len_column = neg_next_state_len_column
self.neg_next_state_column = neg_next_state_column
self.rl_sample_column = rl_sample_column
self.weight_file = weight_file
self.i_embeddings = Embedding(self.iid_column.category_num,
self.emb_size)
self.pos_rnn = GRU(input_size=self.emb_size,
hidden_size=self.hidden_size,
batch_first=True)
self.pos_mlp = MLP(self.hidden_size + self.emb_size,
[self.emb_size] * 3,
activation="relu",
dropout=0.2)
self.neg_rnn = GRU(input_size=self.emb_size,
hidden_size=self.hidden_size,
batch_first=True)
self.neg_mlp = MLP(self.hidden_size + self.emb_size,
[self.emb_size] * 3,
activation="relu",
dropout=0.2)
self.mlp = Dense(self.emb_size * 2,
self.emb_size,
activation="relu",
dropout=0.2)
self.prediction = Linear(self.emb_size, 1, bias=False)
class Net(nn.Module):
def __init__(self, large=True, lstm=True):
super(Net, self).__init__()
self.large = large
self.lstm = lstm
self.relu = nn.ReLU()
if lstm:
self.hidden = self.init_hidden()
self.rnn = LSTM(input_size=FEATURES,
hidden_size=FRAMES,
num_layers=1,
batch_first=True)
else:
self.rnn = GRU(input_size=FEATURES,
hidden_size=FRAMES,
num_layers=1,
batch_first=True)
if large:
self.lin1 = nn.Linear(FRAMES**2, 26)
self.lin2 = nn.Linear(26, 2)
else:
self.lin = nn.Linear(FRAMES**2, 2)
self.softmax = nn.Softmax(dim=1)
def init_hidden(self):
h = Variable(torch.zeros(1, BATCH_SIZE, FRAMES))
c = Variable(torch.zeros(1, BATCH_SIZE, FRAMES))
if OBJ_CUDA:
h = h.cuda()
c = c.cuda()
return h, c
def forward(self, x):
if OBJ_CUDA:
self.rnn.flatten_parameters()
# (batch, frames, features)
if hasattr(self, 'lstm') and self.lstm:
x, _ = self.rnn(x, self.hidden)
else:
x, _ = self.rnn(x).cuda()
x = x.contiguous().view(-1, FRAMES**2)
# (batch, units)
if self.large:
x = self.relu(self.lin1(x))
x = self.lin2(x)
else:
x = self.lin(x)
return self.softmax(x)
class RNNLayer(torch.nn.Module):
def __init__(self,
idim: int,
hdim: int,
nlayers: int = 1,
enc_type: str = "blstm"):
"""
This represents the computation that happens for 1 RNN Layer
Uses packing,padding utils from Pytorch
:param int input_dim- The input size of the RNN
:param int hidden_dim- The hidden size of the RNN
:param int nlayers- Number of RNN Layers
:param str enc_type : Type of encoder- RNN/GRU/LSTM
"""
super(RNNLayer, self).__init__()
bidir = True if enc_type[0] == 'b' else False
enc_type = enc_type[1:] if enc_type[0] == 'b' else enc_type
if enc_type == "rnn":
self.elayer = RNN(idim,
hdim,
nlayers,
batch_first=True,
bidirectional=bidir)
elif enc_type == "lstm":
self.elayer = LSTM(idim,
hdim,
nlayers,
batch_first=True,
bidirectional=bidir)
else:
self.elayer = GRU(idim,
hdim,
nlayers,
batch_first=True,
bidirectional=bidir)
def forward(self, x: torch.Tensor, inp_lens: torch.LongTensor):
"""
Foward propogation for the RNNLayer
:params torch.Tensor x - Input Features
:params torch.LongTensor inp_lens - Input lengths without padding
:returns torch.Tensor Encoded output
:returns list Encoded output lengths
:returns Encoder hidden state
"""
total_length = x.size(1)
packed_x = pack_padded_sequence(x, inp_lens, batch_first=True)
self.elayer.flatten_parameters()
output, (hidden, _) = self.elayer(packed_x)
unpacked_out, inp_lens = pad_packed_sequence(output,
batch_first=True,
total_length=total_length)
return unpacked_out, inp_lens, hidden
def __init__(self, input_dim, hidden_dim, output_dim, bidirectional=False, cell='LSTM', num_layers=1):
super(Decoder, self).__init__()
rnn_hidden_dim = hidden_dim//2 if bidirectional else hidden_dim
if cell == 'LSTM':
self.rnn = LSTM(input_size=input_dim, hidden_size=rnn_hidden_dim, num_layers=num_layers, bidirectional=bidirectional, batch_first=True)
elif cell == 'GRU':
self.rnn = GRU(input_size=input_dim, hidden_size=rnn_hidden_dim, num_layers=num_layers, bidirectional=bidirectional, batch_first=True)
rnn_hidden_output = rnn_hidden_dim * 2 if bidirectional else hidden_dim
self.output_lin = nn.Linear(rnn_hidden_output, output_dim)
def __init__(self,
input_dim: int,
hidden_dim: int,
output_dim: int,
dropout_p: float) \
-> None:
"""Encoder module.
:param input_dim: Input dimensionality.
:type input_dim: int
:param hidden_dim: Hidden dimensionality.
:type hidden_dim: int
:param output_dim: Output dimensionality.
:type output_dim: int
:param dropout_p: Dropout.
:type dropout_p: float
"""
super(Encoder, self).__init__()
self.input_dim = input_dim
self.hidden_dim = hidden_dim
self.output_dim = output_dim
self.dropout: Module = Dropout(p=dropout_p)
self.gru_1: GRU = GRU(input_size=self.input_dim,
hidden_size=self.hidden_dim,
num_layers=1,
bias=True,
batch_first=True,
bidirectional=True)
self.gru_2: GRU = GRU(input_size=self.hidden_dim * 2,
hidden_size=self.hidden_dim,
num_layers=1,
bias=True,
batch_first=True,
bidirectional=True)
self.gru_3: GRU = GRU(input_size=self.hidden_dim * 2,
hidden_size=self.output_dim,
num_layers=1,
bias=True,
batch_first=True,
bidirectional=True)
self.gru_1.flatten_parameters()
self.gru_2.flatten_parameters()
self.gru_3.flatten_parameters()
def _create_layers(self):
self.recurrent_layer = GRU(input_size=self.in_channels,
hidden_size=self.in_channels,
num_layers=1)
for param in self.recurrent_layer.parameters():
param.requires_grad = True
param.retain_grad()
self.conv_layer = GCNConv_Fixed_W(in_channels=self.in_channels,
out_channels=self.in_channels,
improved=self.improved,
cached=self.cached,
normalize=self.normalize,
add_self_loops=self.add_self_loops)
def __init__(self, dim, edge_dim, heads=4, time_step=3):
super(Block, self).__init__()
self.time_step = time_step
self.conv = MultiHeadTripletAttention(
dim, edge_dim) # GraphMultiHeadAttention
self.gru = GRU(dim, dim)
self.ln = NodeLevelLayerNorm(dim)
def __init__(self, args, device):
super(Net, self).__init__()
self.args = args
self.device = device
node_dim = self.args.node_dim
edge_dim = self.args.edge_dim
hidden_dim = self.args.hidden_dim
processing_steps = self.args.processing_steps
self.depth = self.args.depth
self.lin0 = torch.nn.Linear(node_dim, hidden_dim)
nn = Sequential(Linear(edge_dim, hidden_dim * 2), ReLU(),
Linear(hidden_dim * 2, hidden_dim * hidden_dim))
self.conv = NNConv(hidden_dim, hidden_dim, nn, aggr='mean')
self.gru = GRU(hidden_dim, hidden_dim)
self.set2set = Set2Set(hidden_dim, processing_steps=processing_steps)
self.lin1 = torch.nn.Linear(2 * hidden_dim, hidden_dim)
self.lin2 = torch.nn.Linear(hidden_dim, 1)
self.lin3 = torch.nn.Linear(hidden_dim, 36)
self.lin4 = torch.nn.Linear(36, 2)
self.lin5 = torch.nn.Linear(hidden_dim, 36)
self.lin6 = torch.nn.Linear(36, 2)
self.apply(init_weights)
def __init__(self, is_gru, input_size, hidden_size, bidirectional,
stacked_layers):
"""
:param is_gru: GRU cell type if true, otherwise LSTM
:param input_size: the size of the tensors that will be used as input (embeddings or projected embeddings)
:param hidden_size: the size of the cell
:param bidirectional: boolean
:param stacked_layers: the number of stacked layers
"""
super(CellLayer, self).__init__()
if is_gru:
self.cell = GRU(input_size=input_size,
hidden_size=hidden_size,
batch_first=True,
bidirectional=bidirectional,
num_layers=stacked_layers)
else:
self.cell = LSTM(input_size=input_size,
hidden_size=hidden_size,
batch_first=True,
bidirectional=bidirectional,
num_layers=stacked_layers)
self._output_size = hidden_size * 2 if bidirectional else hidden_size
self._input_size = input_size
def build_encoder(args, vocab):
"""Builds the encoder to params."""
input_size = len(vocab.source)
rnn_layer = None
bidirectional = False if args.encoder_mode != 'bigru' else True
dropout = args.rnn_dropout if args.encoder_layers != 1 else 0
if args.encoder_mode == 'rnn':
rnn_layer = RNN(args.hidden_size,
args.hidden_size,
num_layers=args.encoder_layers,
dropout=dropout,
batch_first=True)
elif args.encoder_mode == 'gru' or args.encoder_mode == 'bigru':
rnn_layer = GRU(args.hidden_size,
args.hidden_size,
num_layers=args.encoder_layers,
dropout=dropout,
bidirectional=bidirectional,
batch_first=True)
else:
raise ValueError('Invalid encoder mode: %s' % (args.encoder_mode))
return Encoder(input_size,
args.hidden_size,
rnn_layer,
bidirectional=bidirectional)
def __init__(
self,
in_dim=15,
out_dim=64,
edge_in_dim=7,
):
super(ResidualMessagePassingBlock, self).__init__()
edge_nn = Sequential(Linear(edge_in_dim, 64), ReLU(),
Linear(64, in_dim * in_dim))
self.mp = NNConv(in_dim,
in_dim,
edge_nn,
aggr='mean',
root_weight=True)
edge_nn2 = Sequential(Linear(edge_in_dim, 64), ReLU(),
Linear(64, in_dim * in_dim))
self.dmp = DirectedMessagePassing(in_dim,
in_dim,
edge_nn2,
aggr='mean',
root_weight=True)
self.fu = GRU(in_dim, in_dim)
self.lin = torch.nn.Linear(in_dim, out_dim)
self.bn = NodeLevelBatchNorm(num_features=out_dim)
self.relu = torch.nn.ReLU()
self.short_cut = Sequential(nn.Linear(in_dim, out_dim))
def __init__(self,
input_dim=129,
filter_dim=20,
n_channels=1,
hidden_layers=64,
bidir=True,
dropout=0.25,
dropout2d=0.):
"""
input_dim (int): size of the original filter bank
filter_dim (int): size of the fitted filter bank
n_channels (int): number of distinct signals (i.e. number of channels in the time-frequency representation)
context_size (int): context size of the attention module
hidden_layers (int): Hidden layers in the GRU module
bidir (bool): Use bidirectionnal gru ?
"""
super().__init__()
self.dropout = nn.Dropout(dropout)
self.dropout2D = nn.Dropout2d(dropout2d)
self.hidden_size = hidden_layers
self.num_layers = 1
self.filter_bank = FilterBankLayer(input_dim, filter_dim, n_channels)
self.gru = GRU(bidirectional=bidir,
input_size=filter_dim * n_channels,
num_layers=self.num_layers,
batch_first=True,
hidden_size=self.hidden_size)
def __init__(self,dim=64,edge_dim=12,node_in=8,edge_in=19,edge_in3=8):
super(Net_int_2Edges_attention, self).__init__()
self.lin_node = torch.nn.Linear(node_in, dim)
self.conv1 = GATConv(dim, dim, negative_slope=0.2, dropout=0.1, bias=True)
self.gru1 = GRU(dim, dim)
self.lin_covert = Sequential(BatchNorm1d(dim),Linear(dim, dim*2), \
RReLU(), Dropout(),Linear(dim*2, dim*2),RReLU())
self.conv2 = GATConv(dim*2, dim*2, negative_slope=0.2, dropout=0.1, bias=True)
self.gru2 = GRU(dim*2, dim*2)
self.lin_weight = Linear(8, dim*3*2, bias=False)
self.lin_bias = Linear(8, 1, bias=False)
self.norm = BatchNorm1d(dim*3*2)
self.norm_x = BatchNorm1d(node_in)
def __init__(
self,
weight_file: str,
iid_column: CategoricalColumnWithIdentity,
state_len_column: CategoricalColumnWithIdentity,
state_column: CategoricalColumnWithIdentity,
next_state_len_column: CategoricalColumnWithIdentity,
next_state_column: CategoricalColumnWithIdentity,
rl_sample_column: CategoricalColumnWithIdentity,
emb_size: int,
hidden_size: int,
):
super().__init__()
self.emb_size = emb_size
self.hidden_size = hidden_size
self.iid_column = iid_column
self.state_len_column = state_len_column
self.state_column = state_column
self.next_state_len_column = next_state_len_column
self.next_state_column = next_state_column
self.rl_sample_column = rl_sample_column
self.weight_file = weight_file
self.i_embedding = Embedding(self.iid_column.category_num,
self.emb_size)
self.rnn = GRU(input_size=self.emb_size,
hidden_size=self.hidden_size,
batch_first=True)
self.out = Linear(self.hidden_size, self.emb_size)
def __init__(self, vocabulary_size, sos_token, eos_token, pad_token, attention_size=default_attention['size'],
embedding_size=default_embedding['size'], hidden_size=default_gru['hidden_size'],
num_layers=default_gru['num_layers'], dropout=default_gru['dropout'], shift_focus=True):
super().__init__()
self.attention_size = attention_size
self.vocabulary_size = vocabulary_size
self.embedding = Embedding(vocabulary_size, embedding_size, padding_idx=0)
self.gru1 = GRU(2 * hidden_size + embedding_size, hidden_size, num_layers=num_layers, batch_first=True,
dropout=dropout, bidirectional=True)
self.gru2 = GRU(2 * hidden_size + embedding_size, hidden_size, num_layers=num_layers, batch_first=True,
dropout=dropout, bidirectional=True)
self.decoder = EmptyDecoderAndPointer(vocabulary_size, embedding_size, hidden_size, attention_size, pad_token,
shift_focus=shift_focus)
self.sos_token = sos_token
self.eos_token = eos_token
def __init__(self,
vocab_size,
emb_dim,
hidden_size,
weight,
kqv_dim,
rnn_type='gru',
bidirectional=False,
batch_first=False,
padding_idx=None):
super(ZXOTextEncoder, self).__init__()
self.embed = nn.Embedding(vocab_size,
embedding_dim=emb_dim,
_weight=weight)
if rnn_type == 'rnn':
self.rnn = RNN(emb_dim,
hidden_size,
bidirectional=bidirectional,
num_layers=6,
batch_first=batch_first)
elif rnn_type == 'gru':
self.rnn = GRU(emb_dim,
hidden_size,
bidirectional=bidirectional,
num_layers=6,
batch_first=batch_first)
elif rnn_type == 'lstm':
self.rnn = LSTM(emb_dim,
hidden_size,
bidirectional=bidirectional,
num_layers=6,
batch_first=batch_first)
self.attn = Attn(emb_dim, kqv_dim)
self.linear = nn.Linear(emb_dim, 2)
def __init__(self):
super(Net, self).__init__()
self.lin0 = torch.nn.Linear(dataset.num_features, dim)
nn0 = Sequential(Linear(2, 64), ReLU(), Linear(64, 2*dim*dim))
nn = Sequential(Linear(2, 64), ReLU(), Linear(64, dim * dim))
#nn = Sequential(Linear(5, dim * dim))
self.conv0 = NNConv(dim, 2*dim, nn0, aggr='mean')
self.gru0 = GRU(2*dim, dim)
self.conv = NNConv(dim, dim, nn, aggr='mean')
self.gru = GRU(dim, dim)
self.set2set = Set2Set(dim, processing_steps=1)
self.lin1 = torch.nn.Linear(2 * dim, dim)
self.lin2 = torch.nn.Linear(dim, 1)