Add application file

README.md

@@ -1,13 +1,67 @@
+# NLP based Chatbot in PyTorch
+<img src="https://miro.medium.com/max/1400/1*VqLvWcTKgVpv1idxII591A.jpeg" width="470" height="350">
+
+
+## Simple chatbot implementation with PyTorch.
+
+* The implementation should be easy to follow for beginners and provide a basic understanding of chatbots.
+
+* The implementation is straightforward with a Feed Forward Neural net with 2 hidden layers.
+
+* Customization for your own use case is super easy. Just modify intents.json with possible patterns and responses and re-run the training (see below for more info).
+
+In [this article](https://medium.com/@mlvictoriamaslova/nlp-based-chatbot-in-pytorch-bonus-flask-and-javascript-deployment-474c4e59ceff) on Medium I explain some NLP concepts that underlies building Chatbots.
+
 ---
-title: Clinical Segnemt
-emoji: 🌖
-colorFrom: purple
-colorTo: yellow
-sdk: streamlit
-sdk_version: 1.17.0
-app_file: app.py
-pinned: false
-license: cc-by-3.0
----
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+## Installation
+
+### Create an environment
+
+Whatever you prefer (e.g. conda or venv)
+
+```
+mkdir myproject
+$ cd myproject
+$ python3 -m venv venv
+```
+
+### Activate it
+
+Mac / Linux:
+```
+. venv/bin/activate
+```
+Windows:
+
+```
+venv\Scripts\activate
+```
+
+### Install PyTorch and dependencies
+
+For Installation of PyTorch see official website.
+
+You also need nltk:
+```
+pip install nltk
+```
+If you get an error during the first run, you also need to install nltk.tokenize.punkt: Run this once in your terminal:
+
+```
+$ python
+>>> import nltk
+>>> nltk.download('punkt')
+```
+
+### Usage
+
+Run
+```
+python train.py
+```
+This will dump data.pth file. And then run
+```
+python chat.py
+```

app.py

@@ -0,0 +1,19 @@
+from flask import Flask, render_template, request, jsonify
+
+from chat import get_response
+
+app = Flask(__name__)
+
+@app.get("/")
+def index_get():
+    return render_template("base.html")
+
+@app.post("/predict")
+def predict():
+    text = request.get_json().get("message")
+    response = get_response(text)
+    message = {"answer": response}
+    return jsonify(message)
+
+if __name__=="__main__":
+    app.run(debug=True)

chat.py

@@ -0,0 +1,66 @@
+import random
+import json
+
+import torch
+
+from nltk_utils import bag_of_words, tokenize
+from run_segbot import get_model 
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+with open('intents.json', 'r') as json_data:
+    intents = json.load(json_data)
+
+#FILE = "data.pth"
+#data = torch.load(FILE)
+
+#input_size = data["input_size"]
+#hidden_size = data["hidden_size"]
+#output_size = data["output_size"]
+#all_words = data['all_words']
+#tags = data['tags']
+#model_state = data["model_state"]
+
+#model = NeuralNet(input_size, hidden_size, output_size).to(device)
+#model.load_state_dict(model_state)
+#with open('model.pickle', 'rb') as f:
+#    model = pickle.load(f)
+
+model = get_model()
+
+model.eval()
+
+bot_name = "Sam"
+
+
+def get_response(msg):
+    sentence = tokenize(msg)
+    X = bag_of_words(sentence, all_words)
+    X = X.reshape(1, X.shape[0])
+    X = torch.from_numpy(X).to(device)
+
+    output = model(X)
+    _, predicted = torch.max(output, dim=1)
+
+    tag = tags[predicted.item()]
+
+    probs = torch.softmax(output, dim=1)
+    prob = probs[0][predicted.item()]
+    if prob.item() > 0.75:
+        for intent in intents['intents']:
+            if tag == intent["tag"]:
+                return random.choice(intent['responses'])
+
+    return "I do not understand..."
+
+
+if __name__ == "__main__":
+    print("Let's chat! (type 'quit' to exit)")
+    while True:
+        # sentence = "do you use credit cards?"
+        sentence = input("You: ")
+        if sentence == "quit":
+            break
+
+        resp = get_response(sentence)
+        print(resp)

data.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f20bb4bda5d1517c4bb6d201139d136b0840d48cda09237e92bbb5b0b1fd63f4
+size 5015

index2word.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75789974bed3cd0bc31ad888f26cf977a1c14fb35bc504849fa066cab1f845dd
+size 47914175

intents.json

@@ -0,0 +1,84 @@
+{
+  "intents": [
+    {
+      "tag": "greeting",
+      "patterns": [
+        "Hi",
+        "Hey",
+        "How are you",
+        "Is anyone there?",
+        "Hello",
+        "Good day"
+      ],
+      "responses": [
+        "Hey :-)",
+        "Hello, thanks for visiting",
+        "Hi there, what can I do for you?",
+        "Hi there, how can I help?"
+      ]
+    },
+    {
+      "tag": "goodbye",
+      "patterns": ["Bye", "See you later", "Goodbye"],
+      "responses": [
+        "See you later, thanks for visiting",
+        "Have a nice day",
+        "Bye! Come back again soon."
+      ]
+    },
+    {
+      "tag": "thanks",
+      "patterns": ["Thanks", "Thank you", "That's helpful", "Thank's a lot!"],
+      "responses": ["Happy to help!", "Any time!", "My pleasure"]
+    },
+    {
+      "tag": "items",
+      "patterns": [
+        "Which items do you have?",
+        "What kinds of items are there?",
+        "What do you sell?"
+      ],
+      "responses": [
+        "We sell coffee and tea",
+        "We have coffee and tea"
+      ]
+    },
+    {
+      "tag": "payments",
+      "patterns": [
+        "Do you take credit cards?",
+        "Do you accept Mastercard?",
+        "Can I pay with Paypal?",
+        "Are you cash only?"
+      ],
+      "responses": [
+        "We accept VISA, Mastercard and Paypal",
+        "We accept most major credit cards, and Paypal"
+      ]
+    },
+    {
+      "tag": "delivery",
+      "patterns": [
+        "How long does delivery take?",
+        "How long does shipping take?",
+        "When do I get my delivery?"
+      ],
+      "responses": [
+        "Delivery takes 2-4 days",
+        "Shipping takes 2-4 days"
+      ]
+    },
+    {
+      "tag": "funny",
+      "patterns": [
+        "Tell me a joke!",
+        "Tell me something funny!",
+        "Do you know a joke?"
+      ],
+      "responses": [
+        "Why did the hipster burn his mouth? He drank the coffee before it was cool.",
+        "What did the buffalo say when his son left for college? Bison."
+      ]
+    }
+  ]
+}

model.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc13a6fa988683240ebd80f50a53a864fc5c9b6ad90c0e3d72c624749b542a9d
+size 4948315605

nltk_utils.py

@@ -0,0 +1,27 @@
+import nltk
+import numpy as np
+#nltk.download('all')
+from nltk.stem.porter import PorterStemmer
+stemmer = PorterStemmer()
+def tokenize(sentence):
+    """
+        split sentence into array of words/tokens
+        a token can be a word or punctuation character, or number
+    """
+    return nltk.word_tokenize(sentence)
+
+def stem(word):
+    
+    return stemmer.stem(word.lower())
+
+def bag_of_words(tokenized_sentence, all_words):
+
+    tokenized_sentence = [stem(w) for w in tokenized_sentence]
+
+    bag = np.zeros(len(all_words), dtype=np.float32)
+    for idx, w in enumerate(all_words):
+        if w in tokenized_sentence:
+            bag[idx] = 1.0
+    return bag
+
+

run_segbot.py

@@ -0,0 +1,106 @@
+import re
+from nltk.tokenize import word_tokenize
+import pickle
+import numpy as np
+import random
+import torch
+from solver import TrainSolver
+
+from model import PointerNetworks
+import gensim
+from tqdm import tqdm
+
+class Lang:
+    def __init__(self, name):
+        self.name = name
+        self.word2index = {"RE_DIGITS":1,"UNKNOWN":0,"PADDING":2000001}
+        self.word2count = {"RE_DIGITS":1,"UNKNOWN":1,"PADDING":1}
+        self.index2word = {2000001: "PADDING", 1: "RE_DIGITS", 0: "UNKNOWN"}
+        self.n_words = 3  # Count SOS and EOS
+
+    def addSentence(self, sentence):
+        for word in sentence.strip('\n').strip('\r').split(' '):
+            self.addWord(word)
+
+    def addWord(self, word):
+        if word not in self.word2index:
+            self.word2index[word] = self.n_words
+            self.word2count[word] = 1
+            self.index2word[self.n_words] = word
+            self.n_words += 1
+        else:
+            self.word2count[word] += 1
+
+
+
+def mytokenizer(inS,all_dict):
+
+    #repDig = re.sub(r'\d+[\.,/]?\d+','RE_DIGITS',inS)
+    #repDig = re.sub(r'\d*[\d,]*\d+', 'RE_DIGITS', inS)
+    toked = inS
+    or_toked = inS
+    re_unk_list = []
+    ori_list = []
+
+    for (i,t) in enumerate(toked):
+        if t not in all_dict and t not in ['RE_DIGITS']:
+            re_unk_list.append('UNKNOWN')
+            ori_list.append(or_toked[i])
+        else:
+            re_unk_list.append(t)
+            ori_list.append(or_toked[i])
+
+    labey_edus = [0]*len(re_unk_list)
+    labey_edus[-1] = 1
+
+
+
+
+    return ori_list,re_unk_list,labey_edus
+
+
+
+def get_mapping(X,Y,D):
+
+    X_map = []
+    for w in X:
+        if w in D:
+            X_map.append(D[w])
+        else:
+            X_map.append(D['UNKNOWN'])
+
+    X_map = np.array([X_map])
+    Y_map = np.array([Y])
+
+
+
+    return X_map,Y_map
+
+
+
+
+
+def get_model():
+    with open('model.pickle', 'rb') as f:
+        mysolver = pickle.load(f)
+    return mysolver
+
+    #for i in tqdm(range(0,26431)):
+    test_batch_ave_loss, test_pre, test_rec, test_f1, visdata = mysolver.check_accuracy(X_tes, Y_tes,index2word, fukugen)
+    #test_batch_ave_loss, test_pre, test_rec, test_f1, visdata = mysolver.check_accuracy(X_tes, Y_tes,0)
+        #with open(str(i)+"seped","w")as f:
+        #    f.write(o)
+    #test_batch_ave_loss, test_pre, test_rec, test_f1, visdata = mysolver.check_accuracy(X_tes, Y_tes,0)
+    print(test_pre, test_rec, test_f1)
+    #start_b = visdata[3][0]
+    #end_b = visdata[2][0] + 1
+    #segments = []
+
+    #for i, END in enumerate(end_b):
+    #    START = start_b[i]
+    #    segments.append(' '.join(ori_X[START:END]))
+
+    return test_pre, test_rec, test_f1
+
+
+

solver.py

@@ -0,0 +1,445 @@
+import torch.optim as optim
+import numpy as np
+import torch
+from torch.autograd import Variable
+
+import random
+from torch.nn.utils import clip_grad_norm
+import copy
+from tqdm import tqdm
+
+import os
+import pickle
+
+
+
+def get_decoder_index_XY(batchY):
+    '''
+
+    :param batchY: like [0 0 1 0 0 0 0 1]
+    :return:
+    '''
+
+
+    returnX =[]
+    returnY =[]
+    for i in range(len(batchY)):
+
+        curY = batchY[i]
+        index_1 = np.where(curY==1)
+
+        decoderY = index_1[0]
+
+        if len(index_1[0]) ==1:
+            decoderX = np.array([0])
+        else:
+            decoderX = np.append([0],decoderY[0:-1]+1)
+        returnX.append(decoderX)
+        returnY.append(decoderY)
+
+    returnX = np.array(returnX)
+    returnY = np.array(returnY)
+
+    return returnX,returnY
+
+def align_variable_numpy(X,maxL,paddingNumber):
+
+    aligned = []
+    for cur in X:
+        ext_cur = []
+        ext_cur.extend(cur)
+        ext_cur.extend([paddingNumber] * (maxL - len(cur)))
+        aligned.append(ext_cur)
+    aligned = np.array(aligned)
+
+    return aligned
+
+
+def sample_a_sorted_batch_from_numpy(numpyX,numpyY,batch_size,use_cuda):
+
+
+    if batch_size != None:
+        select_index = random.sample(range(len(numpyY)), batch_size)
+    else:
+        select_index = np.array(range(len(numpyY)))
+    
+    select_index = np.array(range(len(numpyX)))
+
+    batch_x = [copy.deepcopy(numpyX[i]) for i in select_index]
+    batch_y = [copy.deepcopy(numpyY[i]) for i in select_index]
+
+    #print(batch_y)
+    index_decoder_X,index_decoder_Y = get_decoder_index_XY(batch_y)
+    #index_decoder = [get_decoder_index_XY(i) for i in batch_y]
+    #index_decoder_X = [i[0] for i in index_decoder]
+    #index_decoder_Y = [i[1] for i in index_decoder]
+    #print(index_decoder_Y)
+
+
+    #all_lens = []
+    all_lens = np.array([len(x) for x in batch_y])
+    #for x in batch_y:
+    #    print(x)
+    #    try:
+    #        all_lens.append(len(x))
+    #    except:
+    #        all_lens.append(1)
+    #all_lens = np.array(all_lens)
+    
+    maxL = np.max(all_lens)
+    
+    #idx = all_lens
+    #print(idx)
+    idx = np.argsort(all_lens)
+    idx = np.sort(idx)
+    #print(idx)
+    #idx = idx[::-1]  # decreasing
+    #print(idx)
+    batch_x = [batch_x[i] for i in idx]
+    batch_y = [batch_y[i] for i in idx]
+    all_lens = all_lens[idx]
+    
+    index_decoder_X = np.array([index_decoder_X[i] for i in idx])
+    index_decoder_Y = np.array([index_decoder_Y[i] for i in idx])
+    #print(index_decoder_Y)
+
+    numpy_batch_x = batch_x
+
+
+
+    batch_x = align_variable_numpy(batch_x,maxL,2000001)
+    batch_y = align_variable_numpy(batch_y,maxL,2)
+
+
+
+
+
+
+
+    print(len(batch_x))
+    #batch_x = Variable(torch.from_numpy(batch_x.astype(np.int64)))
+    batch_x = Variable(torch.from_numpy(np.array(batch_x, dtype="int64")))
+
+
+    if use_cuda:
+        batch_x = batch_x.cuda()
+
+
+
+    return  numpy_batch_x,batch_x,batch_y,index_decoder_X,index_decoder_Y,all_lens,maxL
+
+
+
+
+class TrainSolver(object):
+    def __init__(self, model,train_x,train_y,dev_x,dev_y,save_path,batch_size,eval_size,epoch, lr,lr_decay_epoch,weight_decay,use_cuda):
+
+        self.lr = lr
+        self.model = model
+        self.epoch = epoch
+        self.train_x = train_x
+        self.train_y = train_y
+        self.use_cuda = use_cuda
+        self.batch_size = batch_size
+        self.lr_decay_epoch = lr_decay_epoch
+        self.eval_size  = eval_size
+
+
+        self.dev_x, self.dev_y = dev_x, dev_y
+
+        self.model = model
+        self.save_path = save_path
+        self.weight_decay =weight_decay
+
+
+
+
+    def sample_dev(self):
+        test_tr_x = []
+        test_tr_y = []
+        select_index = random.sample(range(len(self.train_y)),self.eval_size)
+        test_tr_x = [self.train_x[n] for n in select_index]
+        test_tr_y = [self.train_y[n] for n in select_index]
+
+        return test_tr_x,test_tr_y
+
+
+
+
+
+
+
+    def get_batch_micro_metric(self,pre_b, ground_b, x,index2word, fukugen, nloop):
+
+        tokendic = {}
+        #with open('index2word.pickle', 'rb') as f:
+        #    index2word = pickle.load(f)
+        for n,i in enumerate(index2word):
+            tokendic[n] = i
+        All_C = []
+        All_R = []
+        All_G = []
+        """
+        for i,cur_seq_y in enumerate(zip(ground_b,fukugen[nloop])):
+            #print(fukugen[nloop])
+            fuku = cur_seq_y[1]
+            cur_seq_y = cur_seq_y[0]
+            index_of_1 = np.where(cur_seq_y==1)[0]
+            #print(index_of_1)
+            index_pre = pre_b[i]
+            inp = x[i]
+            #print(len(inp))
+        """
+        print(len(pre_b), len(ground_b), len(fukugen))
+        #global leng
+        #print(fukugen)
+        for i,cur_seq_y in enumerate(ground_b):
+            #print(fukugen[nloop])
+            fuku = fukugen[i]
+            #cur_seq_y = cur_seq_y[0]
+            index_of_1 = np.where(cur_seq_y==1)[0]
+            #print(index_of_1)
+            index_pre = pre_b[i]
+            inp = x[i]
+            #print(len(inp))
+
+            index_pre = np.array(index_pre)
+            END_B = index_of_1[-1]
+            index_pre = index_pre[index_pre != END_B]
+            index_of_1 = index_of_1[index_of_1 != END_B]
+
+            no_correct = len(np.intersect1d(list(index_of_1), list(index_pre)))
+            All_C.append(no_correct)
+            All_R.append(len(index_pre))
+            All_G.append(len(index_of_1))
+
+            index_of_1 = list(index_of_1)
+            index_pre = list(index_pre)
+
+            FN = []
+            FP = []
+            TP = []
+            sent = []
+            ex = ""
+            for j in inp:
+                sent.append(tokendic[int(j.to('cpu').detach().numpy().copy())])
+            for k in index_of_1:    
+                if k not in index_pre:
+                    FN.append(k)
+                if k in index_pre:
+                    TP.append(k)
+            for k in index_pre:
+                if k not in index_of_1:
+                    FP.append(k)
+            #if len(FN) == 0 and len(FP) == 0:
+            #    continue
+            #for n,i in enumerate(sent):
+            for n,k in enumerate(zip(sent, fuku)):
+                f = k[1]
+                i = k[0]
+                if k == "<pad>":
+                    continue
+                if n in FP:
+                    ex += f + "<FP>"
+                else:
+                    ex += f
+                """
+                if n in FN:
+                    #ex += i + "<FN>"
+                    ex += i
+                elif n in FP:
+                    ex += i + "<FP>"
+                elif n in TP:
+                    ex += i + "<TP>"
+                else:
+                    ex += i
+                """
+            #with open(str(nloop)+"_sep_nounk.txt", "a")as f:
+            #    f.write(ex+"\n")
+            #print(i)
+            #leng += 1
+
+        return All_C,All_R,All_G
+
+
+
+
+
+    def get_batch_metric(self,pre_b, ground_b):
+
+        b_pr =[]
+        b_re =[]
+        b_f1 =[]
+        for i,cur_seq_y in enumerate(ground_b):
+            index_of_1 = np.where(cur_seq_y==1)[0]
+            index_pre = pre_b[i]
+
+            no_correct = len(np.intersect1d(index_of_1,index_pre))
+
+            cur_pre = no_correct / len(index_pre)
+            cur_rec = no_correct / len(index_of_1)
+            cur_f1 = 2*cur_pre*cur_rec/ (cur_pre+cur_rec)
+
+            b_pr.append(cur_pre)
+            b_re.append(cur_rec)
+            b_f1.append(cur_f1)
+
+        return b_pr,b_re,b_f1
+
+
+
+    def check_accuracy(self,data2X,data2Y,index2word, fukugen2):
+        for nloop in tqdm(range(0,108)):
+            dataY = data2Y[nloop]
+            dataX = data2X[nloop]
+            fukugen = fukugen2[nloop]
+            #print(len(dataX), len(dataY), len(fukugen))
+            need_loop = int(np.ceil(len(dataY) / self.batch_size))
+            #need_loop = int(np.ceil(len(dataY) / 1))
+            all_ave_loss =[]
+            all_boundary =[]
+            all_boundary_start = []
+            all_align_matrix = []
+            all_index_decoder_y =[]
+            all_x_save = []
+    
+            all_C =[]
+            all_R =[]
+            all_G =[]
+            
+            for lp in range(need_loop):
+                startN = lp*self.batch_size
+                endN =  (lp+1)*self.batch_size
+                if endN > len(dataY):
+                    endN = len(dataY)
+                #print(fukugen)
+                fukuge = fukugen[startN:endN]
+                #print(startN, endN)
+                #print(len(fukugen))
+                #print(fukugen)
+                #for nloop in tqdm(range(0,26431)):
+                numpy_batch_x, batch_x, batch_y, index_decoder_X, index_decoder_Y, all_lens, maxL = sample_a_sorted_batch_from_numpy(
+                    dataX[startN:endN], dataY[startN:endN], None, self.use_cuda)
+                #numpy_batch_x, batch_x, batch_y, index_decoder_X, index_decoder_Y, all_lens, maxL = sample_a_sorted_batch_from_numpy(
+                #    dataX, dataY, None, self.use_cuda)
+
+                batch_ave_loss, batch_boundary, batch_boundary_start, batch_align_matrix = self.model.predict(batch_x,
+                                                                                                          index_decoder_Y,
+                                                                                                      all_lens)
+    
+                all_ave_loss.extend([batch_ave_loss.data.item()])  #[batch_ave_loss.data[0]]
+                all_boundary.extend(batch_boundary)
+                all_boundary_start.extend(batch_boundary_start)
+                all_align_matrix.extend(batch_align_matrix)
+                all_index_decoder_y.extend(index_decoder_Y)
+                all_x_save.extend(numpy_batch_x)
+    
+    
+    
+                #print(batch_y)
+                ba_C,ba_R,ba_G = self.get_batch_micro_metric(batch_boundary,batch_y,batch_x,index2word, fukuge, nloop)
+    
+                all_C.extend(ba_C)
+                all_R.extend(ba_R)
+                all_G.extend(ba_G)
+    
+    
+            ba_pre = np.sum(all_C)/ np.sum(all_R)
+            ba_rec = np.sum(all_C)/ np.sum(all_G)
+            ba_f1 = 2*ba_pre*ba_rec/ (ba_pre+ba_rec)
+
+
+        return np.mean(all_ave_loss),ba_pre,ba_rec,ba_f1, (all_x_save,all_index_decoder_y,all_boundary, all_boundary_start, all_align_matrix)
+
+
+
+
+
+
+
+    def adjust_learning_rate(self,optimizer,epoch,lr_decay=0.5, lr_decay_epoch=5):
+
+        if (epoch % lr_decay_epoch == 0) and (epoch != 0):
+            for param_group in optimizer.param_groups:
+                param_group['lr'] *= lr_decay
+
+
+
+    def train(self,n):
+
+        self.test_train_x, self.test_train_y = self.sample_dev()
+
+        optimizer = optim.Adam(filter(lambda p: p.requires_grad, self.model.parameters()), lr=self.lr, weight_decay=self.weight_decay)
+
+
+
+        num_each_batch = int(np.round(len(self.train_y) / self.batch_size))
+
+        #os.mkdir(self.save_path)
+
+        best_i =0
+        best_f1 =0
+
+        for epoch in range(self.epoch):
+            print(epoch)
+            self.adjust_learning_rate(optimizer, epoch, 0.8, self.lr_decay_epoch)
+
+            track_epoch_loss = []
+            for iter in tqdm(range(num_each_batch)):
+                #print("epoch:%d,iteration:%d" % (epoch, iter))
+
+                self.model.zero_grad()
+
+                numpy_batch_x,batch_x, batch_y, index_decoder_X, index_decoder_Y, all_lens, maxL = sample_a_sorted_batch_from_numpy(
+                    self.train_x, self.train_y, self.batch_size, self.use_cuda)
+
+                neg_loss = self.model.neg_log_likelihood(batch_x, index_decoder_X, index_decoder_Y,all_lens)
+
+
+
+                neg_loss_v = float(neg_loss.data.item())
+                #print(neg_loss_v)
+                track_epoch_loss.append(neg_loss_v)
+
+                neg_loss.backward()
+
+                clip_grad_norm(self.model.parameters(), 5)
+                optimizer.step()
+
+
+            #TODO: after each epoch,check accuracy
+
+
+            self.model.eval()
+
+            #tr_batch_ave_loss, tr_pre, tr_rec, tr_f1 ,visdata=    self.check_accuracy(self.test_train_x,self.test_train_y)
+            
+            dev_batch_ave_loss, dev_pre, dev_rec, dev_f1, visdata =self.check_accuracy(self.dev_x,self.dev_y,n)
+            print("f1="+str(dev_f1))
+            print("loss="+str(dev_batch_ave_loss))
+            """
+            if best_f1 < dev_f1:
+                best_f1 = dev_f1
+                best_rec = dev_rec
+                best_pre = dev_pre
+                best_i = epoch
+
+
+
+            save_data = [epoch,dev_batch_ave_loss,dev_pre,dev_rec,dev_f1]
+
+
+            save_file_name = 'bs_{}_es_{}_lr_{}_lrdc_{}_wd_{}_epoch_loss_acc_pk_wd.txt'.format(self.batch_size,self.eval_size,self.lr,self.lr_decay_epoch,self.weight_decay)
+            """
+            #with open(os.path.join(self.save_path,save_file_name), 'a') as f:
+            #    f.write(','.join(map(str,save_data))+'\n')
+
+
+            #if epoch % 1 ==0 and epoch !=0:
+            #    torch.save(self.model, os.path.join(self.save_path,r'model_epoch_%d.torchsave'%(epoch)))
+
+
+            self.model.train()
+
+        #return best_i,best_pre,best_rec,best_f1
+        return best_i,best_f1,n

static/app.js

@@ -0,0 +1,91 @@
+class Chatbox {
+    constructor() {
+        this.args = {
+            openButton: document.querySelector('.chatbox__button'),
+            chatBox: document.querySelector('.chatbox__support'),
+            sendButton: document.querySelector('.send__button')
+        }
+
+        this.state = false;
+        this.messages = [];
+    }
+
+    display() {
+        const {openButton, chatBox, sendButton} = this.args;
+
+        openButton.addEventListener('click', () => this.toggleState(chatBox))
+
+        sendButton.addEventListener('click', () => this.onSendButton(chatBox))
+
+        const node = chatBox.querySelector('input');
+        node.addEventListener("keyup", ({key}) => {
+            if (key === "Enter") {
+                this.onSendButton(chatBox)
+            }
+        })
+    }
+
+    toggleState(chatbox) {
+        this.state = !this.state;
+
+        // show or hides the box
+        if(this.state) {
+            chatbox.classList.add('chatbox--active')
+        } else {
+            chatbox.classList.remove('chatbox--active')
+        }
+    }
+
+    onSendButton(chatbox) {
+        var textField = chatbox.querySelector('input');
+        let text1 = textField.value
+        if (text1 === "") {
+            return;
+        }
+
+        let msg1 = { name: "User", message: text1 }
+        this.messages.push(msg1);
+
+        fetch('http://127.0.0.1:5000/predict', {
+            method: 'POST',
+            body: JSON.stringify({ message: text1 }),
+            mode: 'cors',
+            headers: {
+              'Content-Type': 'application/json'
+            },
+          })
+          .then(r => r.json())
+          .then(r => {
+            let msg2 = { name: "Sam", message: r.answer };
+            this.messages.push(msg2);
+            this.updateChatText(chatbox)
+            textField.value = ''
+
+        }).catch((error) => {
+            console.error('Error:', error);
+            this.updateChatText(chatbox)
+            textField.value = ''
+          });
+    }
+
+    updateChatText(chatbox) {
+        var html = '';
+        this.messages.slice().reverse().forEach(function(item, index) {
+            if (item.name === "Sam")
+            {
+                html += '<div class="messages__item messages__item--visitor">' + item.message + '</div>'
+            }
+            else
+            {
+                html += '<div class="messages__item messages__item--operator">' + item.message + '</div>'
+            }
+          });
+
+        const chatmessage = chatbox.querySelector('.chatbox__messages');
+        chatmessage.innerHTML = html;
+    }
+}
+
+
+const chatbox = new Chatbox();
+chatbox.display();

static/style.css

@@ -0,0 +1,200 @@
+* {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    font-family: 'Nunito', sans-serif;
+    font-weight: 400;
+    font-size: 100%;
+    background: #F1F1F1;
+}
+
+*, html {
+    --primaryGradient: linear-gradient(93.12deg, #581B98 0.52%, #9C1DE7 100%);
+    --secondaryGradient: linear-gradient(268.91deg, #581B98 -2.14%, #9C1DE7 99.69%);
+    --primaryBoxShadow: 0px 10px 15px rgba(0, 0, 0, 0.1);
+    --secondaryBoxShadow: 0px -10px 15px rgba(0, 0, 0, 0.1);
+    --primary: #581B98;
+}
+
+/* CHATBOX
+=============== */
+.chatbox {
+    position: absolute;
+    bottom: 30px;
+    right: 30px;
+}
+
+/* CONTENT IS CLOSE */
+.chatbox__support {
+    display: flex;
+    flex-direction: column;
+    background: #eee;
+    width: 300px;
+    height: 350px;
+    z-index: -123456;
+    opacity: 0;
+    transition: all .5s ease-in-out;
+}
+
+/* CONTENT ISOPEN */
+.chatbox--active {
+    transform: translateY(-40px);
+    z-index: 123456;
+    opacity: 1;
+
+}
+
+/* BUTTON */
+.chatbox__button {
+    text-align: right;
+}
+
+.send__button {
+    padding: 6px;
+    background: transparent;
+    border: none;
+    outline: none;
+    cursor: pointer;
+}
+
+
+/* HEADER */
+.chatbox__header {
+    position: sticky;
+    top: 0;
+    background: orange;
+}
+
+/* MESSAGES */
+.chatbox__messages {
+    margin-top: auto;
+    display: flex;
+    overflow-y: scroll;
+    flex-direction: column-reverse;
+}
+
+.messages__item {
+    background: orange;
+    max-width: 60.6%;
+    width: fit-content;
+}
+
+.messages__item--operator {
+    margin-left: auto;
+}
+
+.messages__item--visitor {
+    margin-right: auto;
+}
+
+/* FOOTER */
+.chatbox__footer {
+    position: sticky;
+    bottom: 0;
+}
+
+.chatbox__support {
+    background: #f9f9f9;
+    height: 450px;
+    width: 350px;
+    box-shadow: 0px 0px 15px rgba(0, 0, 0, 0.1);
+    border-top-left-radius: 20px;
+    border-top-right-radius: 20px;
+}
+
+/* HEADER */
+.chatbox__header {
+    background: var(--primaryGradient);
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    justify-content: center;
+    padding: 15px 20px;
+    border-top-left-radius: 20px;
+    border-top-right-radius: 20px;
+    box-shadow: var(--primaryBoxShadow);
+}
+
+.chatbox__image--header {
+    margin-right: 10px;
+}
+
+.chatbox__heading--header {
+    font-size: 1.2rem;
+    color: white;
+}
+
+.chatbox__description--header {
+    font-size: .9rem;
+    color: white;
+}
+
+/* Messages */
+.chatbox__messages {
+    padding: 0 20px;
+}
+
+.messages__item {
+    margin-top: 10px;
+    background: #E0E0E0;
+    padding: 8px 12px;
+    max-width: 70%;
+}
+
+.messages__item--visitor,
+.messages__item--typing {
+    border-top-left-radius: 20px;
+    border-top-right-radius: 20px;
+    border-bottom-right-radius: 20px;
+}
+
+.messages__item--operator {
+    border-top-left-radius: 20px;
+    border-top-right-radius: 20px;
+    border-bottom-left-radius: 20px;
+    background: var(--primary);
+    color: white;
+}
+
+/* FOOTER */
+.chatbox__footer {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    justify-content: space-between;
+    padding: 20px 20px;
+    background: var(--secondaryGradient);
+    box-shadow: var(--secondaryBoxShadow);
+    border-bottom-right-radius: 10px;
+    border-bottom-left-radius: 10px;
+    margin-top: 20px;
+}
+
+.chatbox__footer input {
+    width: 80%;
+    border: none;
+    padding: 10px 10px;
+    border-radius: 30px;
+    text-align: left;
+}
+
+.chatbox__send--footer {
+    color: white;
+}
+
+.chatbox__button button,
+.chatbox__button button:focus,
+.chatbox__button button:visited {
+    padding: 10px;
+    background: white;
+    border: none;
+    outline: none;
+    border-top-left-radius: 50px;
+    border-top-right-radius: 50px;
+    border-bottom-left-radius: 50px;
+    box-shadow: 0px 10px 15px rgba(0, 0, 0, 0.1);
+    cursor: pointer;
+}

templates/base.html

@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html lang="en">
+<link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+
+<head>
+    <meta charset="UTF-8">
+    <title>Chatbot</title>
+</head>
+<body>
+<div class="container">
+    <div class="chatbox">
+        <div class="chatbox__support">
+            <div class="chatbox__header">
+                <div class="chatbox__image--header">
+                    <img src="https://img.icons8.com/color/48/000000/circled-user-female-skin-type-5--v1.png" alt="image">
+                </div>
+                <div class="chatbox__content--header">
+                    <h4 class="chatbox__heading--header">Chat support</h4>
+                    <p class="chatbox__description--header">Hi. My name is Sam. How can I help you?</p>
+                </div>
+            </div>
+            <div class="chatbox__messages">
+                <div></div>
+            </div>
+            <div class="chatbox__footer">
+                <input type="text" placeholder="Write a message...">
+                <button class="chatbox__send--footer send__button">Send</button>
+            </div>
+        </div>
+        <div class="chatbox__button">
+            <button><img src="{{ url_for('static', filename='images/chatbox-icon.svg') }}" /></button>
+        </div>
+    </div>
+</div>
+
+    <script>
+        $SCRIPT_ROOT = {{ request.script_root|tojson }};
+    </script>
+    <script type="text/javascript" src="{{ url_for('static', filename='app.js') }}"></script>
+
+</body>
+</html>