restructure module: 4 classes; add modules; move prototype and rename

fastNLP/models/sequence_modeling.py

@@ -3,7 +3,7 @@ import torch.nn as nn
 from torch.nn import functional as F
 
 from fastNLP.models.base_model import BaseModel
-from fastNLP.modules.CRF import ContionalRandomField
+from fastNLP.modules.decoder.CRF import ContionalRandomField
 
 
 class SeqLabeling(BaseModel):

fastNLP/modules/attention/linear_attention.py → fastNLP/modules/aggregation/linear_attention.py

@@ -1,4 +1,4 @@
-from fastNLP.modules.attention.attention import Attention
+from fastNLP.modules.aggregation.attention import Attention
 
 
 class LinearAttention(Attention):

fastNLP/modules/prototype/aggregation.py → fastNLP/modules/aggregation/self_attention.py

@@ -2,7 +2,8 @@ import torch
 import torch.nn as nn
 from torch.autograd import Variable
 
-class Selfattention(nn.Module):
+
+class SelfAttention(nn.Module):
     """
     Self Attention Module.
 
@@ -12,7 +13,7 @@ class Selfattention(nn.Module):
     r : the number of encoded vectors
     """
     def __init__(self, input_size, d_a, r):
-        super(Selfattention, self).__init__()
+        super(SelfAttention, self).__init__()
         self.W_s1 = nn.Parameter(torch.randn(d_a, input_size), requires_grad=True)
         self.W_s2 = nn.Parameter(torch.randn(r, d_a), requires_grad=True)
         self.softmax = nn.Softmax(dim=2)

fastNLP/modules/prototype/embedding.py → fastNLP/modules/encoder/embedding.py

@@ -1,6 +1,6 @@
-import torch
 import torch.nn as nn
 
+
 class Lookuptable(nn.Module):
     """
     A simple lookup table
@@ -19,5 +19,6 @@ class Lookuptable(nn.Module):
     def forward(self, x):
         return self.embed(x)
 
+
 if __name__ == "__main__":
     model = Lookuptable(10, 20)

fastNLP/modules/prototype/encoder.py → fastNLP/modules/encoder/lstm.py

@@ -1,6 +1,6 @@
-import torch
 import torch.nn as nn
 
+
 class Lstm(nn.Module):
     """
     LSTM module
@@ -14,8 +14,8 @@ class Lstm(nn.Module):
     """
     def __init__(self, input_size, hidden_size, num_layers, dropout, bidirectional):
         super(Lstm, self).__init__()
-        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, bias=True, batch_first=True,\
-         dropout=dropout, bidirectional=bidirectional)
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, bias=True, batch_first=True,
+                            dropout=dropout, bidirectional=bidirectional)
         
     def forward(self, x):
         x, _ = self.lstm(x)

fastNLP/modules/prototype/dataloader.py → reproduction/LSTM+self_attention_sentiment_analysis/dataloader.py

@@ -1,9 +1,10 @@
-import random
 import pickle
+import random
+
 import torch
-import numpy as np
 from torch.autograd import Variable
 
+
 def float_wrapper(x, requires_grad=True, using_cuda=True):
     """
     transform float type list to pytorch variable

fastNLP/modules/prototype/predict.py → reproduction/LSTM+self_attention_sentiment_analysis/predict.py

@@ -1,4 +1,3 @@
-import torch
 import torch.nn as nn
 import torch.nn.functional as F
 

fastNLP/modules/prototype/prepare.py → reproduction/LSTM+self_attention_sentiment_analysis/prepare.py

@@ -1,6 +1,8 @@
 import pickle
+
 import Word2Idx
 
+
 def get_sets(m, n):
     """
     get a train set containing m samples and a test set containing n samples