add app.py file

app.py

@@ -0,0 +1,1374 @@
+
+from datetime import datetime
+from urllib.parse import ParseResultBytes
+from file_setting import leaf_idf_dict, leaf_IDF_dict, leafConv_dict
+from PIL import Image
+from segmentation import segmentation
+from seg_file import userdict
+from tqdm import tqdm
+
+import copy
+import faiss
+import json
+import math
+import numpy as np
+import os
+import pandas as pd
+import re
+from sentence_transformers import SentenceTransformer, util
+import streamlit as st
+from streamlit_option_menu import option_menu
+from streamlit_chat import message
+import sys
+import time
+import unicodedata as uni
+
+module_dir = os.path.dirname(__file__)
+data_dir = os.path.join(module_dir, "data")
+
+
+im = Image.open(os.path.join(data_dir, "MetaEdge.png"))
+st.set_page_config(
+    page_title="ChatBot Prototype testing",
+    page_icon=im,
+    layout="wide",
+)
+
+@st.experimental_singleton
+@st.cache
+def prepare_model1():   
+    return SentenceTransformer("paraphrase-multilingual-mpnet-base-v2")
+# model = SentenceTransformer("sentence-transformers/all-mpnet-base-v2")
+@st.experimental_singleton
+@st.cache(suppress_st_warning = True, allow_output_mutation=True)
+def prepare_model2():   
+    return SentenceTransformer("sentence-transformers/all-mpnet-base-v2")
+global model1
+global model2
+model1 = prepare_model1()
+model2 = prepare_model2()
+# model2 = model1
+
+seg = segmentation()
+noidf = []
+no_userdict = []
+class PreProcess():
+    """
+    去除括號、斷詞、leaf_conversion、leaf轉換、計算句向量
+
+    測試的時候的確彙整個excel資料夾丟進來匹配
+    但中心概念是API打過來一個外規，找到跟我們的目標內規最有關連的內規
+    """
+    def __init__(self):
+       pass
+    
+    def remove_parenthesis(self, text):
+
+        texts = uni.normalize('NFKC', str(text))
+        texts = re.split('[─│ ][(){}\[\]]', texts)
+        texts = ''.join(texts)
+
+        return texts
+
+    def word_to_leaf(self, text):
+
+        text_lst = text.split(" ")
+
+        leaf_result = []
+        for word in text_lst:
+            try:
+                tmpLeaf = userdict[word]
+                if tmpLeaf in leaf_idf_dict:
+                    leaf_result.append(tmpLeaf)
+                else:
+                    noidf.append(tmpLeaf)
+            except:
+                # 這裡要記錄有哪些不在userdict裡的word
+                no_userdict.append(word)
+                
+
+        return leaf_result
+
+    def leaf_conversion(self, segLeaves_lst):
+
+        def ngram(lst, n):
+            """
+            Input:
+                lst:清洗後的電文詞－＞ [[word,word,...],[word,word,...],[word,word,...]......]
+                n: 要多少gram(目前使用30)
+            """
+            if len(lst) < n:
+                n = len(lst)
+            nLst = []
+            for i in range(0, len(lst)):
+                ntmp = []
+                try:
+                    for j in range(n):
+                        ntmp.append(lst[i+j])
+                except:
+                    pass
+                if len(ntmp) == n:
+                    nLst.append(ntmp)
+            try:
+                nLst = [ele.remove(" ") for ele in nLst]
+            except:
+                pass
+            
+            
+            return nLst
+
+        segLeaves_str = " ".join(segLeaves_lst)
+       
+        ct = 0
+
+        for i in range(4, 0, -1):
+            
+            segLeaves_igram = ngram(segLeaves_lst, i)
+
+            for before_leaf in segLeaves_igram:
+
+                before_leaf = " ".join(before_leaf)
+
+                if before_leaf in leafConv_dict:
+                    if (" "+before_leaf+" ") in segLeaves_str:
+
+                        before = (" "+before_leaf+" ")
+                        after = (" "+str(leafConv_dict[before_leaf])+" ")
+                        segLeaves_str = segLeaves_str.replace(before, after)
+
+                    elif (before_leaf+" ") in segLeaves_str:
+                        if segLeaves_str.index(before_leaf) == 0:
+
+                            before = (before_leaf+" ")
+                            after = (str(leafConv_dict[before_leaf])+" ")
+                            segLeaves_str = segLeaves_str.replace(before, after)
+
+                    elif (" "+before_leaf) in segLeaves_str:
+                        if segLeaves_str.index(before_leaf) == (len(segLeaves_str) - len(before_leaf)):
+
+                            before = (" "+before_leaf)
+                            after = (" "+str(leafConv_dict[before_leaf]))
+                            segLeaves_str = segLeaves_str.replace(before, after)
+
+        segLeaves_str = segLeaves_str.replace("nan", "")
+        while "  " in segLeaves_str:
+            segLeaves_str = segLeaves_str.replace("  ", " ")
+
+        segLeaves_lst = []
+
+        for leaf in segLeaves_str.split(" "):
+            if leaf == '':
+                continue
+            try:
+                if leaf_idf_dict[leaf] < 10:
+                    continue
+                elif leaf_idf_dict[leaf] == 19:
+                    continue
+                elif leaf_idf_dict[leaf] == 20:
+                    continue
+                else:
+                    segLeaves_lst.append(leaf)
+            except Exception as e:
+                print(e)
+
+        
+        return segLeaves_lst
+
+    def all_preprocess(self, text):
+
+        text = self.remove_parenthesis(text)
+
+        text = seg.seg_one(text)
+
+        text = self.word_to_leaf(text)
+
+        # text = self.leaf_conversion(text)
+    
+        return text
+
+class PairingRule():
+
+    def __init__(self, leaf_IDF_dict, lower, middle, upper):
+        self.leaf_IDF_dict = leaf_IDF_dict
+        self.leaf_idf_dict = leaf_idf_dict
+
+        self.lower_thres = lower
+        self.middle_thres = middle
+        self.upper_thres = upper
+        
+    def top(self, law_leafIDF, rank):
+
+        if len(law_leafIDF) < rank:
+            rank = len(law_leafIDF)
+        result = set([leaf[0] for leaf in law_leafIDF[:rank]])
+
+        return result
+    
+    def sortingIDF_leaf(self, law):
+
+        for i in range(len(law)):
+            if law[i][0] in ('(', '{'):
+                if law[i][-1] in (')', '}'):
+                    law[i] = law[i][1:-1]
+
+        lawIDF = [self.leaf_IDF_dict[leaf] for leaf in law if (leaf in self.leaf_IDF_dict) and (leaf in self.leaf_idf_dict)]
+
+        law_leafIDF = dict(zip(law, lawIDF))
+
+        law_leafIDF = sorted(law_leafIDF.items(), key=lambda item: item[1], reverse = True)
+
+        return law_leafIDF
+
+    def IDFCA(self, outlaw, inlaw):
+
+        PN = ""
+        if not outlaw: return "N"
+        if not inlaw: return "N"
+        
+        # 先準備好 按照IDF大小的內外規leaf list
+        outlaw_leafIDF = self.sortingIDF_leaf(outlaw)
+        inlaw_leafIDF = self.sortingIDF_leaf(inlaw)
+
+        if not outlaw_leafIDF: return "N"
+        if not inlaw_leafIDF: return "N"
+
+        # 先準備好 前幾名IDF的leaf list
+        outlaw_top2IDF = self.top(outlaw_leafIDF, 2)
+        inlaw_top2IDF = self.top(inlaw_leafIDF, 2)
+
+        outlaw_top3IDF = self.top(outlaw_leafIDF, 3)
+        inlaw_top3IDF = self.top(inlaw_leafIDF, 3)
+
+        outlaw_top4IDF = self.top(outlaw_leafIDF, 4)
+        inlaw_top4IDF = self.top(inlaw_leafIDF, 4)
+
+        if len(outlaw) == 1:
+            if len(inlaw) in {1, 2}:
+                if outlaw_leafIDF[0][0] == inlaw_leafIDF[0][0]:
+                    PN = "P1"
+            elif len(inlaw) in {3, 4, 5, 6}:
+                if outlaw_leafIDF[0][0] in inlaw_top2IDF:
+                    PN = "P1"
+
+        elif len(outlaw) == 2:
+            if len(inlaw) == 1:
+                if outlaw_leafIDF[0][0] == inlaw_leafIDF[0][0]:
+                    PN = "P2"
+            elif len(inlaw) == 2:
+                if outlaw_leafIDF[0][0] in inlaw_top2IDF and inlaw_leafIDF[0][0] in outlaw_top2IDF:
+                    PN = "P2"
+            elif len(inlaw) >= 3:
+                if (len(set(outlaw_top2IDF).intersection(inlaw))  >= 2) and (len(set(inlaw_top3IDF).intersection(outlaw)) >= 2):
+                    PN = "P2"
+
+        elif len(outlaw) == 3:
+            if len(inlaw) == 1:
+                if inlaw_leafIDF[0][0] in outlaw_top2IDF:
+                    PN = "P3"
+            elif len(inlaw) == 2:
+                if (len(set(outlaw_top3IDF).intersection(inlaw)) >= 2) and (len(set(inlaw_top2IDF).intersection(outlaw)) >= 2):
+                    PN = "P3"
+            elif 3 <= len(inlaw) <= 5:
+                if (len(set(outlaw_top3IDF).intersection(inlaw))  >= 2) and (len(set(inlaw_top3IDF).intersection(outlaw)) >= 2):
+                    PN = "P3"
+            elif len(inlaw) >= 6:
+                if (len(set(outlaw_top3IDF).intersection(inlaw))  >= 2) and (len(set(inlaw_top4IDF).intersection(outlaw)) >= 2):
+                    PN = "P3"
+
+        elif len(outlaw) == 4:
+            if len(inlaw) == 1:
+                if inlaw_leafIDF[0][0] in outlaw_top2IDF:
+                    PN = "P4"
+            elif len(inlaw) == 2:
+                if (len(set(outlaw_top3IDF).intersection(inlaw)) >= 2) and (len(set(inlaw_top2IDF).intersection(outlaw)) == 2):
+                    PN = "P4"
+            elif 3 <= len(inlaw) <= 5:
+                if (len(set(outlaw_top3IDF).intersection(inlaw))  >= 2) and (len(set(inlaw_top3IDF).intersection(outlaw)) >= 2):
+                    PN = "P4"
+            elif len(inlaw) >= 6:
+                if (len(set(outlaw_top4IDF).intersection(inlaw))  >= 2) and (len(set(inlaw_top4IDF).intersection(outlaw)) >= 2):
+                    PN = "P4"
+        
+        elif len(outlaw) == 5:
+            if len(inlaw) == 1:
+                if inlaw_leafIDF[0][0] in outlaw_top2IDF:
+                    PN = "P5"
+            elif len(inlaw) == 2:
+                if (len(set(outlaw_top3IDF).intersection(inlaw)) >= 2) and (len(set(inlaw_top2IDF).intersection(outlaw)) == 2):
+                    PN = "P5"
+            elif 3 <= len(inlaw) <= 5:
+                if (len(set(outlaw_top3IDF).intersection(inlaw))  >= 2) and (len(set(inlaw_top3IDF).intersection(outlaw)) >= 2):
+                    PN = "P5"
+            elif len(inlaw) >= 6:
+                if (len(set(outlaw_top4IDF).intersection(inlaw))  >= 2) and (len(set(inlaw_top4IDF).intersection(outlaw)) >= 2):
+                    PN = "P5"
+
+        elif len(outlaw) >= 6:
+            if len(inlaw) == 1:
+                if inlaw_leafIDF[0][0] in outlaw_top2IDF:
+                    PN = "P6+"
+            elif len(inlaw) == 2:
+                if (len(set(outlaw_top3IDF).intersection(inlaw)) >= 2) and (len(set(inlaw_top2IDF).intersection(outlaw)) == 2):
+                    PN = "P6+"
+            elif len(inlaw) == 3:
+                if (len(set(outlaw_top4IDF).intersection(inlaw))  >= 2) and (len(set(inlaw_top3IDF).intersection(outlaw)) >= 2):
+                    PN = "P6+"
+            elif len(inlaw) >= 4:
+                if (len(set(outlaw_top4IDF).intersection(inlaw))  >= 2) and (len(set(inlaw_top4IDF).intersection(outlaw)) >= 2):
+                    PN = "P6+"
+
+        
+        if PN != "":
+            return PN
+        else:
+            return "N"
+    
+    def COLA(self, outlaw, inlaw):
+
+        PN = ""
+
+        def ngram(lst, n):
+            """
+            Input:
+                lst:清洗後的電文詞－＞ [[word,word,...],[word,word,...],[word,word,...]......]
+                n: 要多少gram(目前使用30)
+            """
+            if len(lst) < n:
+                n = len(lst)
+            nLst = []
+            for i in range(0, len(lst)):
+                ntmp = []
+                try:
+                    for j in range(n):
+                        ntmp.append(lst[i+j])
+                except:
+                    pass
+                if len(ntmp) == n:
+                    nLst.append(ntmp)
+            try:
+                nLst = [ele.remove(" ") for ele in nLst]
+            except:
+                pass
+            
+            
+            return nLst
+        
+        outlaw_leafIDF = self.sortingIDF_leaf(outlaw)
+        inlaw_leafIDF = self.sortingIDF_leaf(inlaw)
+
+        outlaw_top3IDF = self.top(outlaw_leafIDF, 3)
+        inlaw_top3IDF = self.top(inlaw_leafIDF, 3)
+
+        outlaw_3gram = ngram(outlaw, 3)
+        inlaw_3gram = ngram(inlaw, 3)
+
+        outlaw_4gram = ngram(outlaw, 4)
+        inlaw_4gram = ngram(inlaw, 4)
+
+        # (P4) 如果 外規 leaf 有連續 4 個 leaf 出現於內規當中而且也連續, 順序也相同
+        for out_grams in outlaw_4gram:
+            if out_grams in inlaw_4gram:
+                PN = "P4"
+
+        # (P3) 內規 leaf 為外規 leaf 子集合(所謂集合即不包含重複 leaf), 且內規至少一個 IDF 名列外規前3名 && 該 idf > 10
+        if set((inlaw)).issubset(outlaw):
+            check = set(inlaw).intersection(outlaw_top3IDF)
+            if len(check) > 0:
+                for leaf in check:
+                    if self.leaf_idf_dict[leaf] > 10:
+                        PN = "P3"
+                        break
+
+        # (P2) 如果 外規 leaf 全部出現在內規中
+        if set((outlaw)).issubset(inlaw):
+            PN = "P2"
+
+        # (P1) 如果 外規 leaf 有連續 3 個 leaf 出現於內規當中而且也連續, 順序可以不同，且其中至少一個 IDF 名列前3名(內規、外規皆須) && 該 idf > 10
+        for out_grams in outlaw_3gram:
+            for in_grams in inlaw_3gram:
+                if set((out_grams)).issubset(in_grams):
+                    if (len(set(out_grams).intersection(outlaw_top3IDF)) >= 1) and (len(set(in_grams).intersection(inlaw_top3IDF)) >= 1):
+                        PN = "P1"
+                        break
+            if PN != "":
+                break
+
+        if PN != "":
+            return PN
+        else:
+            return "N1"
+
+    def COSR(self, outlaw, inlaw, cos):
+
+        PN = ""
+
+        outlaw_leafIDF = self.sortingIDF_leaf(outlaw)
+        inlaw_leafIDF = self.sortingIDF_leaf(inlaw)
+        
+        # X = 內外規交集內 idf>=10 leaf 數量
+        law_intersection = set(outlaw).intersection(inlaw)
+        X = len([leaf for leaf in law_intersection if self.leaf_idf_dict[leaf] >= 10])
+
+        # Y = max( 內規交集外 idf>10 leaf 數量, 外規交集外 idf>10 leaf 數量)
+        out_difference = set(outlaw).difference(inlaw)
+        in_difference = set(inlaw).difference(outlaw)
+
+        out_idf10 = len([leaf for leaf in out_difference if self.leaf_idf_dict[leaf] > 10])
+        in_idf10 = len([leaf for leaf in in_difference if self.leaf_idf_dict[leaf] > 10])
+
+        Y = max(out_idf10, in_idf10)
+
+        if Y == 1:
+            if X >= 5:
+                PN = "P1"
+            elif X == 1:
+                PN = round(cos, 6)
+            elif 2 <= X <= 4:
+                PN = round(math.sqrt(cos), 6)
+                
+        elif Y == 2:
+            if X >= 5:
+                PN = "P2"
+            elif X == 1:
+                PN = round(cos ** 2, 6)
+            elif X == 2:
+                PN = round(cos, 6)
+            elif 3 <= X <= 4:
+                PN = round(math.sqrt(cos), 6)
+        
+        elif Y == 3:
+            if X >= 5:
+                PN = "P3"
+            elif 1 <= X <= 2:
+                PN = round(cos ** 2, 6)
+            elif X == 3:
+                PN = round(cos, 6)
+            elif X == 4:
+                PN == round(math.sqrt(cos), 6)
+        
+        elif Y == 4:
+            if X >= 5:
+                PN = "P4"
+            elif 1 <= X <= 3:
+                PN = round(cos ** 2, 6)
+            elif X == 4:
+                PN = round(cos, 6)
+        
+        elif Y >= 5:
+            if X >= 5:
+                if outlaw_leafIDF[0][0] in law_intersection:
+                    PN = "P5"
+                elif inlaw_leafIDF[0][0] in law_intersection:
+                    PN = "P5"
+                else:
+                    PN = "Z"
+
+            elif X == 1:
+                PN = "N1"
+            elif X == 2:
+                PN = "N2"
+            elif X == 3:
+                PN = "N3"
+            elif X == 4:
+                PN = "N4"
+
+
+        if PN != "":
+            return str(PN)
+        else:
+            return "N"
+
+    def TOPN(self, outlaw, inlaw):
+
+        PN = "N"
+        outlaw = [ele for ele in outlaw if leaf_idf_dict[ele] >= 10]
+        inlaw = [ele for ele in inlaw if leaf_idf_dict[ele] >= 10]
+
+        if not outlaw: return "N"
+        if not inlaw: return "N"
+
+        outlaw_leafIDF = self.sortingIDF_leaf(outlaw)
+        inlaw_leafIDF = self.sortingIDF_leaf(inlaw)
+
+        if not outlaw_leafIDF: return "N"
+        if not inlaw_leafIDF: return "N"
+
+        outlaw_top3IDF = self.top(outlaw_leafIDF, 3)
+        inlaw_top3IDF = self.top(inlaw_leafIDF, 3)
+
+        if (len(outlaw) >= 3) and (len(inlaw) >= 3):
+            if (set(outlaw_top3IDF).issubset(inlaw)) and (set(inlaw_top3IDF).issubset(outlaw)):
+                PN = "P1"
+            if (set(outlaw[:3]).issubset(inlaw)) and (set(inlaw[:3]).issubset(outlaw)):
+                PN = "P2"
+
+        # if len(outlaw) >= 3:
+        #     if set(outlaw_top3IDF).issubset(inlaw):
+                # PN = "P1"
+            # elif set(outlaw[:3]).issubset(inlaw):
+            #     PN = "P2"
+        # if len(inlaw) >= 3:
+        #     if set(inlaw_top3IDF).issubset(outlaw):
+        #         PN = "P1"
+            # elif set(inlaw[:3]).issubset(outlaw):
+            #     PN = "P2"
+
+        check = 0
+        if (len(outlaw) != 0) and (len(inlaw) != 0):
+            if (len(outlaw) < 3) and (len(inlaw) > 3):
+                if outlaw_leafIDF[0][0] == inlaw_leafIDF[0][0]:
+                    PN = "P3"
+
+
+                if len(inlaw_leafIDF) > 1:
+                    if outlaw_leafIDF[0][0] == inlaw_leafIDF[1][0]:
+                        if self.leaf_IDF_dict[inlaw_leafIDF[1][0]] > 2.5:
+                            check += 1
+            # elif len(inlaw) < 3:
+            #     if inlaw_leafIDF[0][0] == outlaw_leafIDF[0][0]:
+            #         PN = "P3"
+                if len(outlaw_leafIDF) > 1:
+                    if inlaw_leafIDF[0][0] == outlaw_leafIDF[1][0]:
+                        if self.leaf_IDF_dict[outlaw_leafIDF[1][0]] > 2.5:
+                            check += 1
+
+                if check == 2:
+                    PN = "P3"
+        
+
+        if PN[0] == "P":
+            return PN
+        else:
+            return "N"
+
+    def scoring(self, cos, IDFCA, COLA, COSR, TOPN):
+
+        PN = ""
+        score = 0
+        # upper_threshold = 0.85
+
+        if cos < self.lower_thres:
+            PN = "N"
+            score = "N/A"
+        
+        elif self.lower_thres <= cos < self.upper_thres:
+
+            if IDFCA[0] == "P":
+                score += 1
+            else:
+                score -= 1
+            
+            if COLA[0] == "P":
+                score += 2
+            else:
+                score += -1
+
+            if COSR[0] == "P":
+                score += 1
+            elif (COSR[0] not in {"P", "N", "Z", "E"}):
+                if (float(COSR) > cos):
+                    score += 1
+            else:
+                score -= 1
+
+            if TOPN[0] == "P":
+                score += 2
+            else:
+                score += 0
+
+
+            if self.lower_thres <= cos < self.middle_thres:
+                if score >= 4:
+                    PN = "P"
+            elif self.middle_thres <= cos < self.upper_thres:
+                if score >= 0:
+                    PN = "P"
+        
+        elif cos >= self.upper_thres:
+
+            check = 0
+            PN = "P"
+            if IDFCA[0] == "N":
+                check += 1
+                if COLA[0] == "N":
+                    check += 1
+                    if COSR[0] not in {"P", "N", "Z", "E"}:
+                        if (float(COSR) < 0.9):
+                            check += 1
+                            PN = "N"
+                    elif COSR[0] in {"N"}:
+                        PN = "N"
+                    
+            score = "N/A"
+        
+        if PN == "":
+            PN = "N"
+            score = "N/A"
+        
+        return PN, score
+
+    def level(self, outlaw, inlaw, cos, PN, score):
+
+        level = ""
+
+        if (cos > 0.98):
+            if (len(outlaw) >= 2) or ((len(outlaw) == 1) and (self.leaf_idf_dict[outlaw[0]] > 10)):
+                level = "L1"
+            elif (len(outlaw) == 1) and (self.leaf_idf_dict[outlaw[0]] > 10):
+                level = "L5"
+
+        elif PN[0] == "P":
+            if (len(outlaw) > 1) and (len(inlaw) > 1):
+                level = "L2"
+            elif (len(outlaw) == 1) or (len(inlaw) == 1):
+                level = "L3"
+
+        elif PN[0] == "N":
+            if cos >= 0.8:
+                level = "L6"
+            elif 0.7 <= cos < 0.8:
+                level = "L7"
+            elif cos < 0.7:
+                level = "L8"
+    
+        if level != "":
+            return level
+        else:
+            return "no_level"
+
+    def display_leaves(self, law_leaf):
+
+        # leaves = list(law_leaf)
+        leaves = copy.deepcopy(law_leaf)
+        for i in range(len(leaves)):
+            if leaves[i][0] in {'(', '{'}:
+                if leaves[i][-1] in {')', '}'}:
+                    continue
+            if self.leaf_idf_dict[leaves[i]] in {19.0, 20.0}:
+                continue
+            else:
+                if self.leaf_idf_dict[leaves[i]] == 10.0:
+                    leaves[i] = f"({leaves[i]})"
+                elif self.leaf_idf_dict[leaves[i]] > 10.0:
+                    leaves[i] = "["+str(leaves[i])+"]"
+        
+        leaves = " ".join(leaves)
+        
+        return leaves
+
+class FaissProcess():
+    """
+    預設是外規配對內規，因此把內規做成faiss index
+    """
+    def __init__(self):
+
+        self.ct = 0
+        pass
+    
+    def get_faissIndex(self, searched_vecs):
+
+        searched_sentenceVec = np.array(searched_vecs)
+        faiss.normalize_L2((searched_sentenceVec))
+        
+        dimension = 768
+        faissIndex = faiss.IndexFlatIP(dimension)
+        faissIndex.add(searched_sentenceVec)
+        self.ct += 1
+        faiss_dir = r"C:\Users\楊尚霖\暫存區\MetaEdge\ChatBot_prototype_testing_streamlit"
+        # faiss.write_index(faissIndex, os.path.join(faiss_dir, "chatbot_faissIndex1.index"))
+        # faiss.write_index(diffQ_faissIndex_model2, r"C:\Users\楊尚霖\暫存區\MetaEdge\ChatBot_prototype_testing_streamlit\chatbot_faissIndex2.index")
+
+        return faissIndex
+    
+    def get_faissResult(self, searching_vec, faissIndex, diffQ):
+
+        k = 10                         
+
+        searching_vec = np.array(searching_vec)
+        faiss.normalize_L2(searching_vec)
+
+        D, I = faissIndex.search(searching_vec, k)
+
+        # simQ_result = []
+        # cosine_result = []
+        # for i, index in enumerate(I[0]):
+
+            # simQ_result.append(diffQ[I[0][i]])
+            # cosine_result.append(round(D[0][i], 4))
+            # print(diffQ[I[0][i]])
+            # print(f"{round(D[0][i], 4)}\t{diffQ[I[0][i]]}")
+
+        return D, I
+
+
+@st.cache(suppress_st_warning=True)
+def prepare_diffQ_content():
+
+    PQA_path = os.path.join(data_dir, "PQA_bank_20220801.xlsx")
+    PQA_df = pd.read_excel(PQA_path)
+
+
+    diffQ_lst = [uni.normalize("NFKC", str(ele)) for ele in PQA_df["變化問題"]]
+    briefQ_lst = [uni.normalize("NFKC", str(ele)) for ele in PQA_df["問題簡述"]]
+    answer_lst = [uni.normalize("NFKC", str(ele)) for ele in PQA_df["回答"]]
+
+    for i, ans in enumerate(answer_lst):
+        if "\n" in ans:
+            answer_lst[i] = answer_lst[i].replace("\n", "")
+
+
+    diff_brief_dict = dict(zip(diffQ_lst, briefQ_lst))
+    qa_dict = dict(zip(briefQ_lst, answer_lst))
+
+    order_diff_path = os.path.join(data_dir, "order_diffQ.txt")
+    diffQ = []
+    with open(order_diff_path, mode = "r", encoding = "utf-8") as r:
+        for line in r:
+            tmp = uni.normalize("NFKC", line.strip())
+            diffQ.append(tmp)
+
+    return diff_brief_dict, diffQ, qa_dict
+
+@st.cache(suppress_st_warning=True)
+def prepare_diffQ_leaf(diffQ):
+
+    diffQ_leaf = []
+    diffQ_vec = []
+    for i, question in tqdm(enumerate(diffQ), total = len(diffQ)):
+        leaves = PreProc.all_preprocess(question)
+
+        # if mode == 1:
+        #     embedding = model1.encode(question, convert_to_numpy = True)
+        # else:
+        #     embedding = model2.encode(question, convert_to_numpy = True)
+
+        # vector = np.array(embedding).astype("float32")
+        
+        diffQ_leaf.append(leaves)
+        # diffQ_vec.append(vector)
+
+    # diffQ_faissIndex = FaissProc.get_faissIndex(diffQ_vec)
+
+    return diffQ_leaf
+
+@st.cache(suppress_st_warning=True)
+def prepare_diffQ_faissIndex(mode):
+    if mode == 1:
+        return faiss.read_index(os.path.join(data_dir, "faissIndex1_20220805.index"))
+    else:
+        return faiss.read_index(os.path.join(data_dir, "faissIndex2_20220805.index"))
+
+
+
+@st.cache(suppress_st_warning=True)
+def prepare_loan_diffQ_content():
+
+    PQA_path = os.path.join(data_dir, "信貸FAQ總表.xlsx")
+    PQA_df = pd.read_excel(PQA_path)
+
+
+    loan_diffQ_lst = [uni.normalize("NFKC", str(ele)) for ele in PQA_df["標準問題"]]
+    loan_briefQ_lst = [uni.normalize("NFKC", str(ele)) for ele in PQA_df["標準問題"]]
+    loan_answer_lst = [uni.normalize("NFKC", str(ele)) for ele in PQA_df["回答"]]
+
+    for i, ans in enumerate(loan_answer_lst):
+        if "\n" in ans:
+            loan_answer_lst[i] = loan_answer_lst[i].replace("\n", "")
+
+
+    loan_diff_brief_dict = dict(zip(loan_diffQ_lst, loan_briefQ_lst))
+    loan_qa_dict = dict(zip(loan_briefQ_lst, loan_answer_lst))
+
+    # order_diff_path = os.path.join(data_dir, "order_diffQ.txt")
+    # diffQ = []
+    # with open(order_diff_path, mode = "r", encoding = "utf-8") as r:
+    #     for line in r:
+    #         tmp = uni.normalize("NFKC", line.strip())
+    #         diffQ.append(tmp)
+
+    return loan_diff_brief_dict, loan_diffQ_lst, loan_qa_dict
+
+@st.cache(suppress_st_warning=True)
+def prepare_loan_diffQ_leaf(loan_diffQ):
+
+    loan_diffQ_leaf = []
+    for i, question in tqdm(enumerate(loan_diffQ), total = len(loan_diffQ)):
+        leaves = PreProc.all_preprocess(question)
+
+        loan_diffQ_leaf.append(leaves)
+
+
+    return loan_diffQ_leaf
+
+@st.cache(suppress_st_warning=True)
+def prepare_loan_diffQ_faissIndex(mode):
+    if mode == 1:
+        return faiss.read_index(os.path.join(data_dir, "chatbot_loan_faissIndex1.index"))
+    else:
+        return faiss.read_index(os.path.join(data_dir, "chatbot_loan_faissIndex2.index"))
+
+
+
+def pairing_search(userQ):
+
+    userQ_leaf = PreProc.all_preprocess(userQ)
+
+    if model_choose == "paraphrase-multilingual-mpnet-base-v2":
+        embedding = model1.encode(userQ, convert_to_numpy = True)
+    elif model_choose == "all-mpnet-base-v2":
+        embedding = model2.encode(userQ, convert_to_numpy = True)
+
+    userQ_vec = np.array(embedding).astype("float32")
+
+    if model_choose == "paraphrase-multilingual-mpnet-base-v2":
+        if data_choose == "銀行QA":
+            simDistance, simIndex = FaissProc.get_faissResult([userQ_vec], diffQ_faissIndex_model1, diffQ)
+        elif data_choose == "信貸QA":
+            simDistance, simIndex = FaissProc.get_faissResult([userQ_vec], loan_diffQ_faissIndex_model1, loan_diffQ)
+    elif model_choose == "all-mpnet-base-v2":
+        if data_choose == "銀行QA":
+            simDistance, simIndex = FaissProc.get_faissResult([userQ_vec], diffQ_faissIndex_model2, diffQ)
+        elif data_choose == "信貸QA":
+            simDistance, simIndex = FaissProc.get_faissResult([userQ_vec], loan_diffQ_faissIndex_model2, loan_diffQ)
+    
+    whole_result = []
+    bot_answer = []
+    for i, cos in enumerate(simDistance[0]):
+
+        if i == 5: break
+
+        cos = round(float(cos), 4)
+
+
+        if data_choose == "銀行QA":
+            tmp_diffQ = diffQ[simIndex[0][i]]
+            tmp_diffQ_leaf = diffQ_leaf[simIndex[0][i]]
+        elif data_choose == "信貸QA":
+            tmp_diffQ = loan_diffQ[simIndex[0][i]]
+            tmp_diffQ_leaf = loan_diffQ_leaf[simIndex[0][i]]
+
+        idfca = rule.IDFCA(tmp_diffQ_leaf, userQ_leaf)
+        cola = rule.COLA(tmp_diffQ_leaf, userQ_leaf)
+        cosr = rule.COSR(tmp_diffQ_leaf, userQ_leaf, cos)
+        topn = rule.TOPN(tmp_diffQ_leaf, userQ_leaf)
+
+        PN, score = rule.scoring(cos, idfca, cola, cosr, topn)
+        if PN == "P":
+            if data_choose == "銀行QA":
+                bot_answer.append(qa_dict[diff_brief_dict[tmp_diffQ]])
+            elif data_choose == "信貸QA":
+                bot_answer.append(loan_qa_dict[loan_diff_brief_dict[tmp_diffQ]])
+            
+
+        # print(f"{PN}\t{cos}\t{diffQ[simIndex[0][i]]}")
+        tmp_result = []
+        if data_choose == "銀行QA":
+            tmp_result.extend([userQ, rule.display_leaves(userQ_leaf), diffQ[simIndex[0][i]], rule.display_leaves(tmp_diffQ_leaf)])
+            tmp_result.append(diff_brief_dict[diffQ[simIndex[0][i]]])
+        elif data_choose == "信貸QA":
+            tmp_result.extend([userQ, rule.display_leaves(userQ_leaf), loan_diffQ[simIndex[0][i]], rule.display_leaves(tmp_diffQ_leaf)])
+            tmp_result.append(loan_diff_brief_dict[loan_diffQ[simIndex[0][i]]])
+        tmp_result.extend([cos, (idfca), (cola), (cosr), (topn), (score), (PN)])
+
+        whole_result.append(tmp_result)
+
+    result_columns = ["user問題", "user問題(leaf)", "變化問題", "變化問題(leaf)", "問題簡述", "cosine", "IDFCA", "COLA", "COSR", "TOPN", "score", "P/N"]
+    result_df = pd.DataFrame(columns = result_columns, data = whole_result)
+
+    try:
+        result_df = result_df.astype(str)
+        # st.subheader("回答")
+        # if bot_answer:
+        #     for a, ans in enumerate(bot_answer):
+        #         st.text(f"{a+1}.\t{ans}")
+        # else:
+        #     st.text("**沒有適合的回答**")
+        # st.subheader("搜尋結果")
+        # st.dataframe(result_df)
+    except Exception as e:
+        print(f"e: {e}")
+        print(f"type of result_df: {type(result_df)}")
+
+    return bot_answer, result_df
+
+def pairing_two_sentence(q1_input, q2_input):
+
+    q1_leaf = PreProc.all_preprocess(q1_input)
+    q2_leaf = PreProc.all_preprocess(q2_input)
+    
+    if model_choose == "paraphrase-multilingual-mpnet-base-v2":
+        q1_vec = model1.encode(q1_input, convert_to_tensor = True)
+        q2_vec = model1.encode(q2_input, convert_to_tensor = True)
+    elif model_choose == "all-mpnet-base-v2":
+        q1_vec = model2.encode(q1_input, convert_to_tensor = True)
+        q2_vec = model2.encode(q2_input, convert_to_tensor = True)
+
+    cosine = util.cos_sim(q1_vec, q2_vec)
+    cosine = round(float(cosine[0][0]), 4)
+
+    q1_display = rule.display_leaves(q1_leaf)
+    q2_display = rule.display_leaves(q2_leaf)
+
+    pairing_df = pd.DataFrame([[q1_display], [q2_display]], columns = ["Leaves"], index = ["配對語句1-leaf","配對語句2-leaf"])
+    # pairing_df = pairing_df.astype(str)
+
+    # st.subheader("文字 轉 Leaf")
+    # st.dataframe(pairing_df)
+
+    idfca = str(rule.IDFCA(q1_leaf, q2_leaf))
+    cola = str(rule.COLA(q1_leaf, q2_leaf))
+    cosr = str(rule.COSR(q1_leaf, q2_leaf, cosine))
+    topn = str(rule.TOPN(q1_leaf, q2_leaf))
+
+    PN, score = rule.scoring(cosine, idfca, cola, cosr, topn)
+
+    PN = str(PN)
+    score = str(score)
+
+    data_df = pd.DataFrame(
+        columns = ["Cosine", "IDFCA", "COLA", "COSR", "TOPN", "score", "PN"],
+        data = [[cosine, idfca, cola, cosr, topn, score, PN]],
+        index = ["數據結果"]
+    )
+    data_df = data_df.astype(str)
+    # st.subheader("配對結果")
+    # st.dataframe(data_df)
+
+    return pairing_df, data_df
+
+def clear_input():
+
+    st.session_state["text"] = ""
+
+def isChinese(word):
+    for ch in word:
+        if '\u4e00' <= ch <= '\u9fff':
+            return True
+    return False
+
+def format_chat(mode, sentence):
+
+    space_line = 0
+    full_ct = 0
+    half_ct = 0
+    tmp_i = 0
+    for i, char in enumerate(sentence):
+        if isChinese(char): full_ct += 1
+        else: half_ct += 1
+
+        if full_ct + half_ct/2 >= 22:
+            if mode == "user":
+                st.session_state.user_message.append(sentence[tmp_i:i+1])
+            else:
+                st.session_state.bot_message.append(sentence[tmp_i:i+1])
+
+            space_line += 1
+            tmp_i = i+1
+            full_ct = 0
+            half_ct = 0
+    if sentence[tmp_i:] != "":
+        if mode == "user":
+            st.session_state.user_message.append(sentence[tmp_i:])
+            
+        else:
+            st.session_state.bot_message.append(sentence[tmp_i:])
+
+        space_line += 1
+
+    # space_line = check_full_half(sentence)
+    # st.markdown(space_line)
+    
+    for i in range(space_line):
+        if mode == "user":
+            st.session_state.bot_message.append(f"|")
+        else:
+            st.session_state.user_message.append(f"|")
+
+def multi_chat(template, pre_answer):
+
+    if pre_answer == "退出":
+        st.session_state.multi_question_num = -1
+        st.session_state.multi_answer = dict()
+        st.session_state.multi_mode = ""
+        format_chat("bot", template["closing"])
+
+        return
+
+    q_num = st.session_state.multi_question_num
+
+    if st.session_state.multi_mode == "請假":
+        if q_num == 0:
+            format_chat("bot", template["opening"])
+            format_chat("bot", template[f"Q{q_num+1}"]["question"])
+            st.session_state.multi_question_num += 1
+
+        elif q_num == 1:
+            if pre_answer in template[f"Q{q_num}"]["ans_choice"]:
+                st.session_state.multi_answer[f"Q{q_num}"] = pre_answer
+                st.session_state.multi_question_num += 1
+                q_num += 1
+                format_chat("bot", template[f"Q{q_num}"]["question"])
+            else:
+                format_chat("bot", template[f"Q{q_num}"]["ans_warning"])
+                format_chat("bot", template[f"Q{q_num}"]["question"])
+
+        elif (q_num == 2) or (q_num == 3):
+            time_format = template[f"Q{q_num}"]["ans_format"]
+            try:
+                pre_answer_date = datetime.strptime(pre_answer, time_format)
+                st.session_state.multi_answer[f"Q{q_num}"] = pre_answer_date
+                st.session_state.multi_question_num += 1
+                q_num += 1
+                format_chat("bot", template[f"Q{q_num}"]["question"])
+            except Exception as e:
+                # st.write(e)
+                format_chat("bot", template[f"Q{q_num}"]["ans_warning"])
+                format_chat("bot", template[f"Q{q_num}"]["question"])
+
+        elif q_num == 4:
+            st.session_state.multi_answer[f"Q{q_num}"] = pre_answer
+            st.session_state.multi_question_num += 1
+            q_num += 1
+            format_chat("bot", template[f"Q{q_num}"]["question"])
+
+
+        elif q_num == 5:
+            st.session_state.multi_answer[f"Q{q_num}"] = pre_answer
+            
+            format_chat("bot", template["done"])
+            format_chat("bot", "請確認請假資訊")
+            
+            format_chat("bot", f"""請假類別:\t{st.session_state.multi_answer[f"Q1"]}""")
+            format_chat("bot", f"""請假開始時間:\t{st.session_state.multi_answer[f"Q2"]}""")
+            format_chat("bot", f"""請假結束時間:\t{st.session_state.multi_answer[f"Q3"]}""")
+            format_chat("bot", f"""職務代理人:\t{st.session_state.multi_answer[f"Q4"]}""")
+            format_chat("bot", f"""請假事由:\t{st.session_state.multi_answer[f"Q5"]}""")
+
+            st.session_state.multi_question_num = -1
+            st.session_state.multi_answer = dict()
+            st.session_state.multi_mode = ""
+        
+    elif st.session_state.multi_mode == "客戶資金及資產來源":
+
+        if q_num == 0:
+            format_chat("bot", template["opening"])
+
+            for ele in template[f"Q{q_num+1}"]["question"].split("<br>"):
+                format_chat("bot", ele)
+            # format_chat("bot", template[f"Q{q_num+1}"]["question"])
+            st.session_state.multi_question_num += 1
+        elif q_num == 1:
+            if pre_answer in template[f"Q{q_num}"]["ans_choice"]:
+                st.session_state.multi_answer[f"Q{q_num}"] = f"""{template[f"Q{q_num}"]["ans_choice"][pre_answer]}"""
+                st.session_state.multi_question_num += 1
+                q_num += 1
+                format_chat("bot", template[f"Q{q_num}"]["question"])
+            else:
+                format_chat("bot", template[f"Q{q_num}"]["ans_warning"])
+                for ele in template[f"Q{q_num}"]["question"].split("<br>"):
+                    format_chat("bot", ele)
+                # format_chat("bot", template[f"Q{q_num}"]["question"])
+        elif q_num == 2:
+            if pre_answer in template[f"Q{q_num}"]["ans_choice"]:
+                if pre_answer == "有":
+                    st.session_state.multi_answer[f"Q{q_num}"] = pre_answer
+                    st.session_state.multi_question_num += 1
+                    q_num += 1
+                    for ele in template[f"Q{q_num}"]["question"].split("<br>"):
+                        format_chat("bot", ele)
+                    # format_chat("bot", template[f"Q{q_num}"]["question"])
+                else:
+                    st.session_state.multi_answer[f"Q{q_num}"] = pre_answer
+
+                    format_chat("bot", template["done"])
+                    format_chat("bot", "請確認表單資訊")
+                    format_chat("bot", f"""年收入區間:\t{st.session_state.multi_answer[f"Q1"]}""")
+                    format_chat("bot", f"""無其他資金來源""")
+
+                    st.session_state.multi_question_num = -1
+                    st.session_state.multi_answer = dict()
+                    st.session_state.multi_mode = ""
+                    
+
+            else:
+                format_chat("bot", template[f"Q{q_num}"]["ans_warning"])
+                for ele in template[f"Q{q_num}"]["question"].split("<br>"):
+                    format_chat("bot", ele)
+
+        elif q_num == 3:
+            pre_answer_lst = pre_answer.split(",")
+            option_ok = True
+            for option in pre_answer_lst:
+                if option not in template[f"Q{q_num}"]["ans_choice"]:
+                    option_ok = False
+            
+            if option_ok:
+                answer = []
+                for option in pre_answer_lst:
+                    tmp_ans = template[f"Q{q_num}"]["ans_choice"][option]
+                    answer.append(tmp_ans)
+                st.session_state.multi_answer[f"Q{q_num}"] = "、".join(answer)
+
+                if "G" in pre_answer_lst:
+                    st.session_state.multi_question_num += 1
+                    q_num += 1
+                    format_chat("bot", template[f"Q{q_num}"]["question"])
+                else:
+                    st.session_state.multi_question_num += 2
+                    q_num += 2
+                    for ele in template[f"Q{q_num}"]["question"].split("<br>"):
+                        format_chat("bot", ele)
+                
+                
+            else:
+                format_chat("bot", template[f"Q{q_num}"]["ans_warning"])
+                for ele in template[f"Q{q_num}"]["question"].split("<br>"):
+                    format_chat("bot", ele)
+
+        elif q_num == 4:
+
+            st.session_state.multi_answer[f"Q{q_num}"] = pre_answer
+            st.session_state.multi_question_num += 1
+            q_num += 1
+            # format_chat("bot", template[f"Q{q_num}"]["question"])
+            for ele in template[f"Q{q_num}"]["question"].split("<br>"):
+                format_chat("bot", ele)
+            # format_chat("bot", template[f"Q{q_num}"]["question"])
+
+        elif q_num == 5:
+
+            if pre_answer in template[f"Q{q_num}"]["ans_choice"]:
+                st.session_state.multi_answer[f"Q{q_num}"] = f"""{template[f"Q{q_num}"]["ans_choice"][pre_answer]}"""
+                st.session_state.multi_question_num += 1
+                q_num += 1
+                format_chat("bot", template[f"Q{q_num}"]["question"])
+            else:
+                format_chat("bot", template[f"Q{q_num}"]["ans_warning"])
+                for ele in template[f"Q{q_num}"]["question"].split("<br>"):
+                    format_chat("bot", ele)
+                # format_chat("bot", template[f"Q{q_num}"]["question"])
+
+        elif q_num == 6:
+
+            st.session_state.multi_answer[f"Q{q_num}"] = pre_answer
+
+            format_chat("bot", template["done"])
+            format_chat("bot", "請確認表單資訊")
+            format_chat("bot", f"""年收入區間:\t{st.session_state.multi_answer[f"Q1"]}""")
+            
+            if "Q4" in st.session_state.multi_answer:
+                format_chat("bot", f"""其他資金來源:\t{st.session_state.multi_answer[f"Q3"]}({st.session_state.multi_answer[f"Q4"]})""")
+            else:
+                format_chat("bot", f"""其他資金來源:\t{st.session_state.multi_answer[f"Q3"]}""")
+            format_chat("bot", f"""其他資金來源總金額:\t{st.session_state.multi_answer[f"Q5"]}""")
+            format_chat("bot", f"""其他資金來源相關資訊:\t{st.session_state.multi_answer[f"Q6"]}""")
+            
+            
+            st.session_state.multi_question_num = -1
+            st.session_state.multi_answer = dict()
+            st.session_state.multi_mode = ""
+
+
+
+if __name__ == "__main__":
+
+    global PreProc
+    global FaissProc
+    global rule
+    global diff_brief_dict, diffQ
+    global diffQ_leaf
+    global diffQ_faissIndex_model1, diffQ_faissIndex_model2
+    global qa_dict
+    global multi_chat_template
+
+    PreProc = PreProcess()
+    FaissProc = FaissProcess()
+
+    diff_brief_dict, diffQ, qa_dict = prepare_diffQ_content()
+    diffQ_leaf = prepare_diffQ_leaf(diffQ)
+    diffQ_faissIndex_model1 = prepare_diffQ_faissIndex(1)
+    diffQ_faissIndex_model2 = prepare_diffQ_faissIndex(2)
+
+    loan_diff_brief_dict, loan_diffQ, loan_qa_dict = prepare_loan_diffQ_content()
+    loan_diffQ_leaf = prepare_loan_diffQ_leaf(loan_diffQ)
+    loan_diffQ_faissIndex_model1 = prepare_loan_diffQ_faissIndex(1)
+    loan_diffQ_faissIndex_model2 = prepare_loan_diffQ_faissIndex(2)
+
+    json_path = os.path.join(data_dir, "chatpot_multi-round.json")
+    with open(json_path, mode = "r", encoding = "utf-8") as r:
+        multi_chat_template = json.load(r)
+
+    with st.sidebar:
+        function_choose = option_menu("功能選擇", ["搜尋測試", "配對測試", "聊天測試"],
+                         icons=['question-circle', 'search', 'chat-dots'],
+                         menu_icon = "list", default_index=0,
+                         styles={
+                            "container": {"padding": "5!important", "background-color": "#fafafa"},
+                            "icon": {"color": "black", "font-size": "25px"}, 
+                            "nav-link": {"font-size": "20px", "text-align": "left", "margin":"0px", "--hover-color": "#eee"},
+                            "nav-link-selected": {"background-color": "#272ba8"},
+                            }  
+                        )
+
+        st.subheader("標準問答 資料")
+        data_choose = st.selectbox(
+            "QA 選單",
+            (
+                "銀行QA",
+                "信貸QA"
+            )
+        )
+
+        st.subheader("SBERT 模型")
+        model_choose = st.selectbox(
+            "模型選單",
+            (
+                "paraphrase-multilingual-mpnet-base-v2",
+                "all-mpnet-base-v2"
+            )
+        )
+        st.subheader("Cosine 調整")
+        lower_thres = st.slider('LOWER_threshold', 0.0, 1.0, 0.7)
+
+        default_mid = 0.75
+        if lower_thres > 0.75: default_mid = lower_thres
+        middle_thres = st.slider('MIDDLE_threshold', lower_thres, 1.0, default_mid)
+
+        default_up = 0.85
+        if middle_thres > 0.85: default_up = middle_thres
+        upper_thres = st.slider('UPPER_threshold', middle_thres, 1.0, default_up)
+
+    
+    rule = PairingRule(leaf_IDF_dict, lower_thres, middle_thres, upper_thres)
+
+
+    if function_choose == "搜尋測試":
+
+        st.header("搜尋測試")
+        form = st.form(key = 'Question pairing')
+
+        userQ_input = form.text_input(label = '輸入的問題將會與PQA的"變化問題"做匹配', placeholder = "請輸入要搜尋的問題")
+        submit_button = form.form_submit_button(label = 'Submit')
+
+        if submit_button:
+
+            bot_answer, result_df = pairing_search(str(userQ_input))
+
+            st.subheader("回答")
+            if bot_answer:
+                for a, ans in enumerate(bot_answer):
+                    st.text(f"{a+1}.\t{ans}")
+            else:
+                st.text("**沒有適合的回答**")
+            st.subheader("搜尋結果")
+            st.dataframe(result_df)
+
+    elif function_choose == "配對測試":
+
+        st.header("配對測試")
+        pairing_form =  st.form(key = 'input_pairing')
+
+        q1_input = pairing_form.text_input(label = "��對語句1")
+        q2_input = pairing_form.text_input(label = "配對語句2")
+
+        pair_button = pairing_form.form_submit_button(label = "Submit")
+        if pair_button:
+
+            pairing_df, data_df = pairing_two_sentence(q1_input, q2_input)
+
+            st.subheader("文字 轉 Leaf")
+            st.dataframe(pairing_df)
+
+            st.subheader("配對結果")
+            st.dataframe(data_df)
+
+    elif function_choose == "聊天測試":
+
+        st.header("聊天測試")
+
+        if "user_message" not in st.session_state:
+            st.session_state.user_message = []
+        if "bot_message" not in st.session_state:
+            st.session_state.bot_message = []
+        
+        if "multi_mode" not in st.session_state:
+            st.session_state.multi_mode = ""
+        if "multi_question_num" not in st.session_state:
+            st.session_state.multi_question_num = -1
+        if "multi_answer" not in st.session_state:
+            st.session_state.multi_answer = dict()
+        
+        reset_button = st.button(label = "清空聊天室")
+        
+        col1, col2 = st.columns(2)
+
+        form = st.form(key = 'Chatting', clear_on_submit = True)
+
+        input_ = form.text_input("USER:")
+        submit_button = form.form_submit_button(label = 'Submit')
+
+        if "請假" in input_:
+            
+            if st.session_state.multi_question_num == -1:
+                st.session_state.multi_question_num = 0
+            if st.session_state.multi_mode == "":
+                st.session_state.multi_mode = "請假"
+        elif "客戶資金及資產來源" in input_:
+            
+            if st.session_state.multi_question_num == -1:
+                st.session_state.multi_question_num = 0
+            if st.session_state.multi_mode == "":
+                st.session_state.multi_mode = "客戶資金及資產來源"
+            
+
+        if submit_button:
+            
+            if len(input_) == 0:
+                st.session_state.bot_message.append("請輸入文字後再送出")
+                st.session_state.user_message.append("|")
+            else:
+                format_chat("user", input_)
+                if st.session_state.multi_question_num == -1:
+                    
+
+                    bot_answer, result_df = pairing_search(str(input_))
+
+                    bot_reply = ""
+                    if bot_answer:
+                        bot_reply = bot_answer[0]
+                    else:
+                        bot_reply = "抱歉，我不清楚你的問題(沒有匹配的變化問題)"
+
+                    format_chat("bot", bot_reply)
+                        
+                else:
+
+                    multi_chat(multi_chat_template[st.session_state.multi_mode], input_)
+
+                        
+        if reset_button:
+
+            st.session_state.user_message = []
+            st.session_state.bot_message = []
+       
+
+        if len(st.session_state.user_message) > 0:
+
+            user_bot_max = max(len(st.session_state.user_message), len(st.session_state.bot_message))
+            
+            for i in range(user_bot_max):
+
+                try:
+                    col2.write(f"{st.session_state.user_message[i]}")
+                except: pass
+
+                try:
+                    col1.write(f"{st.session_state.bot_message[i]}")
+                except: pass
+ 
+        
+
+
+
+                
+