finish modularization

Author: leohsuofnthu

IMDB_Dataset.csv

@@ -24,7 +24,7 @@ def split_train_valid(path_data, path_train, path_valid, frac=0.7):
     rng = RandomState()
     tr = df.sample(frac=0.7, random_state=rng)
     tst = df.loc[~df.index.isin(tr.index)]
-    print("spliting original file to train/valid set...")
+    print("Spliting original file to train/valid set...")
     tr.to_csv(path_train, index=False)
     tst.to_csv(path_valid, index=False)
 
@@ -70,7 +70,7 @@ def tokenizer(text):
     #clean the text
     TEXT.preprocessing = torchtext.data.Pipeline(clean_str)
 
-    print('Creating tabular datasets...')
+    print('Creating tabular datasets...It might take a while to finish!')
     train_datafield = [('text', TEXT),  ('label', LABEL)]
     tabular_train = TabularDataset(path = path_train,  
                                  format= 'csv',
@@ -98,13 +98,13 @@ def create_data_iterator(tr_batch_size, val_batch_size,tabular_train,
     train_iter = Iterator(
             tabular_train, 
             batch_size=tr_batch_size,
-            device= d, 
+            device = d, 
             sort_within_batch=False,
             repeat=False)
 
     valid_iter = Iterator(
             tabular_valid, 
-            batch_size=val_batch_size, 
+            batch_size=val_batch_size,
             device=d,
             sort_within_batch=False, 
             repeat=False)

dataset.py

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+"""main.ipynb
+
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/17VqaftLE6Xo9iUJryPp7DbtrZNmNHU1J
+"""
+
+import argparse
+
+import torch
+import torch.optim as optim
+
+import dataset
+import model
+import training
+
+import matplotlib.pyplot as plt
+
+
+
+#%%
+
+def main():
+    
+    print("Pytorch Version:", torch.__version__)
+    parser = argparse.ArgumentParser(description='TextCNN')
+    #Training args
+    parser.add_argument('--data-csv', type=str, default='./IMDB_Dataset.csv', metavar='./IMDB_Dataset.csv',
+                        help='file path of training data in CSV forma (default: ./train.csv)')
+    
+    parser.add_argument('--spacy-lang', type=str, default='en', metavar='en',
+                        help='language choice for spacy to tokenize the text (ex: en or fr')
+                        
+    parser.add_argument('--pretrained', type=str, default='glove.6B.300d', metavar='glove.6B.300d',
+                    help='choice of pretrined word embedding from torchtext')              
+                        
+    parser.add_argument('--epochs', type=int, default=10, metavar='N',
+                        help='number of epochs to train (default: 10)')
+    
+    parser.add_argument('--lr', type=float, default=0.001, metavar='LR',
+                        help='learning rate (default: 0.01)')
+    
+    parser.add_argument('--momentum', type=float, default=0.9, metavar='M',
+                        help='SGD momentum (default: 0.9)')
+    
+    parser.add_argument('--batch-size', type=int, default=64, metavar='N',
+                    help='input batch size for training (default: 64)')
+    
+    parser.add_argument('--val-batch-size', type=int, default=64, metavar='N',
+                        help='input batch size for testing (default: 64)')
+    
+    parser.add_argument('--kernel-height', type=str, default='3,4,5', metavar='S',
+                    help='how many kernel width for convolution (default: 3, 4, 5)')
+    
+    parser.add_argument('--out-channel', type=int, default=100, metavar='N',
+                    help='output channel for convolutionaly layer (default: 100)')
+    
+    parser.add_argument('--dropout', type=int, default=0.5, metavar='N',
+                        help='dropout rate for linear layer (default: 0.5)')
+    
+    parser.add_argument('--num-class', type=int, default=2, metavar='N',
+                        help='number of category to classify (default: 2)')
+    
+    #if you are using jupyternotebook with argparser
+    args = parser.parse_known_args()[0]
+    #args = parser.parse_args()
+    
+    
+    #Use GPU if it is available
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    
+    
+    #%% Split whole dataset into train and valid set
+    dataset.split_train_valid(args.data_csv, './train.csv', './valid.csv', 0.7)
+    
+    trainset, validset, vocab = dataset.create_tabular_dataset('./train.csv',
+                                 './valid.csv',args.spacy_lang, args.pretrained)
+    
+    #%%Show some example to show the dataset
+    print("Show some examples from train/valid..")
+    print(trainset[0].text,  trainset[0].label)
+    print(validset[0].text,  validset[0].label)
+    
+    train_iter, valid_iter = dataset.create_data_iterator(args.batch_size, args.val_batch_size,
+                                                         trainset, validset,device)
+                
+    #%%Create
+    kernels = [int(x) for x in args.kernel_height.split(',')]
+    m = model.textCNN(vocab, args.out_channel, kernels , args.num_class).to(device)
+    # print the model summery
+    print(m)    
+        
+    train_loss = []
+    train_acc = []
+    test_loss = []
+    test_acc = []
+    best_test_acc = -1
+    
+    #optimizer
+    optimizer = optim.Adam(m.parameters(), lr=args.lr)
+    
+    for epoch in range(1, args.epochs+1):
+        #train loss
+        tr_loss, tr_acc = training.train(m, device, train_iter, optimizer, epoch, args.epochs)
+        print('Train Epoch: {} \t Loss: {} \t Accuracy: {}%'.format(epoch, tr_loss, tr_acc))
+        
+        ts_loss, ts_acc = training.valid(m, device, valid_iter)
+        print('Valid Epoch: {} \t Loss: {} \t Accuracy: {}%'.format(epoch, ts_loss, ts_acc))
+        
+        if ts_acc > best_test_acc:
+            best_test_acc = ts_acc
+            #save paras(snapshot)
+            print("model saves at {}% accuracy".format(best_test_acc))
+            torch.save(m.state_dict(), "best_validation")
+            
+        train_loss.append(tr_loss)
+        train_acc.append(tr_acc)
+        test_loss.append(ts_loss)
+        test_acc.append(ts_acc)
+    
+    #plot train/validation loss versus epoch
+    x = list(range(1, args.epochs+1))
+    plt.figure()
+    plt.title("train/validation loss versus epoch")
+    plt.xlabel("epoch")
+    plt.ylabel("total loss")
+    plt.plot(x, train_loss,label="train loss")
+    plt.plot(x, test_loss, color='red', label="test loss")
+    plt.legend(loc='upper right')
+    plt.grid(True)
+    plt.show()
+    
+    #plot train/validation accuracy versus epoch
+    x = list(range(1, args.epochs+1))
+    plt.figure()
+    plt.title("train/validation loss versus epoch")
+    plt.xlabel("epoch")
+    plt.ylabel("total loss")
+    plt.plot(x, train_acc,label="train accuracy")
+    plt.plot(x, test_acc, color='red', label="test accuracy")
+    plt.legend(loc='upper right')
+    plt.grid(True)
+    plt.show()
+
+if __name__ == '__main__':
+    main()
+

main.py

@@ -12,10 +12,10 @@
 #%% Text CNN model
 class textCNN(nn.Module):
 
-    def __init__(self, vocab_built, emb_dim, dim_channel, kernel_wins, num_class):
+    def __init__(self, vocab_built, dim_channel, kernel_wins, num_class):
         super(textCNN, self).__init__()
         #load pretrained embedding in embedding layer.
-        print(vocab_built)
+        emb_dim = vocab_built.vectors.size()[1]
         self.embed = nn.Embedding(len(vocab_built), emb_dim)
         self.embed.weight.data.copy_(vocab_built.vectors)