DeepLearning-Chatbot/testing.py at main · MohdSarar/DeepLearning-Chatbot · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
# Projet de chatbot Madel
import nltk, random, json , pickle
#nltk.download('punkt');nltk.download('wordnet')
from nltk.stem import WordNetLemmatizer
from nltk.tokenize import word_tokenize
import numpy as np
from tensorflow.keras.models import load_model
from sklearn.feature_extraction.text import CountVectorizer

lemmatizer=WordNetLemmatizer()
context={};
class Testing:
    def __init__(self):
        # charger le fichier d’intentions
        with open('intents.json', encoding='utf-8') as f:
            self.intents = json.load(f)
        # charger le fichier training_data contenant les données d'entraînement
        data=pickle.load(open("training_data","rb"))
        self.words=data['words']
        self.classes=data['classes']
        self.model=load_model('chatbot_model.h5')
        # définir le seuil minimal de probabilité pour qu'une réponse soit acceptée
        self.ERROR_THRESHOLD=0.5
        self.ignore_words=list("!@#$%^&*?")

    def clean_up_sentence(self,sentence):
        # tokeniser chaque phrase saisie par l'utilisateur
        sentence_words=word_tokenize(sentence.lower())
        # lemmatiser les mots et filtrer les caractères non pertinents
        sentence_words=list(map(lemmatizer.lemmatize,sentence_words))
        sentence_words=list(filter(lambda x:x not in self.ignore_words,sentence_words))
        return set(sentence_words)

    def wordvector(self,sentence):
        # initialiser le CountVectorizer
        # txt.split permet de découper chaque mot
        cv=CountVectorizer(tokenizer=lambda txt: txt.split())
        sentence_words=' '.join(self.clean_up_sentence(sentence))
        words=' '.join(self.words)

        # entraîner le vecteur sur les mots appris et transformer la phrase en vecteur one-hot
        vectorize=cv.fit([words])
        word_vector=vectorize.transform([sentence_words]).toarray().tolist()[0]
        return(np.array(word_vector))

    def classify(self,sentence):
        # prédire à quelle classe (tag) appartient la phrase de l’utilisateur
        results=self.model.predict(np.array([self.wordvector(sentence)]))[0]
        # stocker le nom de la classe et la probabilité associée
        results = list(map(lambda x: [x[0],x[1]], enumerate(results)))
        # conserver uniquement les classes dont la probabilité est supérieure au seuil
        results = list(filter(lambda x: x[1]>self.ERROR_THRESHOLD ,results))

        # trier les probabilités en ordre décroissant
        results.sort(key=lambda x: x[1], reverse=True)
        return_list = []

        for i in results:
            return_list.append((self.classes[i[0]],str(i[1])))
        return return_list

    def results(self,sentence,userID):
        # si un contexte est maintenu, filtrer la classe (tag) en fonction du contexte
        if sentence.isdecimal():
            if context[userID]=="historydetails":
                return self.classify('ordernumber')
        return self.classify(sentence)

    def response(self,sentence,userID='Madel'):
        # récupérer la classe de la phrase utilisateur
        results=self.results(sentence,userID)
        print(sentence,results)
        # choisir une réponse aléatoire à cette question
        ans=""
        if results:
            while results:
                for i in self.intents['intents']:
                    # vérifier si le tag correspond à la classe prédite
                    if i['tag'] == results[0][0]:

                        # si l'intention contient une clé "set"
                        # alors stocker cette valeur dans le contexte utilisateur
                        if 'set' in i and not 'filter' in i:
                            context[userID] = i['set']
                        # si l’intention n’a pas de filtre, retourner une réponse
                        if not 'filter' in i:
                            ans=random.choice(i['responses'])
                            print("Question :",sentence)
                            print("Bot :",ans)

                        # si l’intention a un filtre, vérifier que le contexte utilisateur correspond
                        # et retourner une réponse
                        if userID in context and 'filter' in i and i['filter']==context[userID]:
                            if 'set' in i:
                                context[userID] = i['set']
                            ans=random.choice(i['responses'])

                results.pop(0)
        # si une réponse est trouvée, la retourner, sinon message par défaut
        return ans if ans!="" else "Désolé, j'apprends encore, tu peux m'enrichir en ajoutant de nouvelle data."