Chatbots are extremely helpful for business organizations and also the customers. The majority of people prefer to talk directly from a chatbox instead of calling service centers. Facebook released data that proved the value of bots. More than 2 billion messages are sent between people and companies monthly. The HubSpot research tells that 71% of the people want to get customer support from messaging apps. It is a quick way to get their problems solved so chatbots have a bright future in organizations. Today we are going to build an exciting project on Chatbot. We will implement a chatbot from scratch that will be able to understand what the user is talking about and give an appropriate response. Prerequisites To implement the chatbot we will be using Keras which is a Deep Learning library, NLTK which is a Natural Language Processing Toolkit and some helpful libraries. Run the below command to make sure all the libraries are installed pip tensorflow keras pickle nltk install Python Cheat Sheet - . Master guide to learn Python for free How do Chatbots work? Chatbots are nothing but an intelligent piece of software that can interact and communicate with people just like humans. Interesting isn’t it! So now let us understand how they actually work. All the chatbot comes under the NLP (Natural Language Processing) concepts. NLP is composed of two things: NLU(Natural Language Understanding): The ability of machines to understand human language like English. NLG(Natural Language Generation): The ability of a machine to generate text similar to human written sentences. Image a user asking a question to a chatbot “Hey, What’s on the news today? ” The chatbot will break down the user sentence into two things: Intent and an Entity. The intent for this sentence could be get_news as it refers to an action the user wants to perform. The entity tells specific details about the intent, so here ‘today’ will be the entity. So this way a machine learning model is used to recognize the intents and entities of the chat. Project file structure After the project is complete, you will be left with all these files. Lets quickly go through each of them, it will give you an idea of how the project will be implemented. In this file, we will build and train the deep learning model that can classify and identify what the user is asking to the bot. Train_chatbot.py - This file is where we will build a graphical user interface to chat with our trained chatbot. Gui_Chatbot.py - The intents file has all the data that we will use to train the model. It contains a collection of tags with their corresponding patterns and responses. Intents.json - This is a hierarchical data format file in which we have stored the weights and the architecture of our trained model. Chatbot_model.h5 - The pickle file can be used to store all the tag names to classify when we are predicting the message. Classes.pkl - The words.pkl pickle file contains all the unique words that are the vocabulary of our model. Words.pkl - Download the source code and the dataset How to build your own chatbot? I’ve simplified the building of this chatbot in 5 steps: - Create a new python file and name it as train_chatbot and then we are going to import all the required modules. After that, we will read the JSON data file in our python program. Step 1.  Import libraries and load the data numpy np keras.models Sequential keras.layers Dense, Activation, Dropout keras.optimizers SGD random nltk nltk.stem WordNetLemmatizer
lemmatizer = WordNetLemmatizer() json pickle
intents_file = open( ).read()
intents = json.loads(intents_file) import as from import from import from import import import from import import import 'intents.json' Here’s how our intents file looks like. Step 2. Preprocessing the data The model cannot take the raw data. It has to go through a lot of pre-processing for machine to easily understand. For a textual data, there are many preprocessing techniques available. The first technique is Tokenizing in which we break the sentences into words. By observing the intents file we can see that each tag contains a list of patterns and responses. We tokenize each pattern and add the words in a list. Also, we create a list of classes and documents to add all the intents associated with patterns. words=[]
classes = []
documents = []
ignore_letters = [ , , , ] intent intents[ ]: pattern intent[ ]: word = nltk.word_tokenize(pattern)
        words.extend(word) documents.append((word, intent[ ])) intent[ ] classes:
            classes.append(intent[ ])
print(documents) '!' '?' ',' '.' for in 'intents' for in 'patterns' #tokenize each word #add documents in the corpus 'tag' # add to our classes list if 'tag' not in 'tag' Another technique is the Lemmatization. We can convert words into the lemma form so that we can reduce all the canonical words. For example, the words play, playing, plays, played, etc will all be replaced with play. This way we can reduce the number of total words in our vocabulary. So now we lemmatize each word and remove the duplicate words. words = [lemmatizer.lemmatize(w.lower()) w words w ignore_letters]
words = sorted(list(set(words))) classes = sorted(list(set(classes))) (len(documents), ) (len(classes), , classes) (len(words), , words)
pickle.dump(words,open( , ))
pickle.dump(classes,open( , )) # lemmaztize and lower each word and remove duplicates for in if not in # sort classes # documents = combination between patterns and intents print "documents" # classes = intents print "classes" # words = all words, vocabulary print "unique lemmatized words" 'words.pkl' 'wb' 'classes.pkl' 'wb' In the end, the words contain the vocabulary of our project and classes contain the total entities to classify. To save the python object in a file we used the method. These files will be helpful after the training is done and we predict the chats. pickle.dump() Step 3. Create training and testing data To train the model we will convert each input pattern into numbers. First, we will lemmatize each word of the pattern and create a list of zeroes of the same length as the total number of words. We will set value 1 to only those index that contains the word in the patterns. Same way we will create the output by setting 1 to the class input pattern belongs to. training = [] output_empty = [ ] * len(classes) doc documents: bag = [] word_patterns = doc[ ] word_patterns = [lemmatizer.lemmatize(word.lower()) word word_patterns] word words:
        bag.append( ) word word_patterns bag.append( ) output_row = list(output_empty)
    output_row[classes.index(doc[ ])] = training.append([bag, output_row]) random.shuffle(training)
training = np.array(training) train_x = list(training[:, ])
train_y = list(training[:, ])
print( ) # create the training data # create empty array for the output 0 # training set, bag of words for every sentence for in # initializing bag of words # list of tokenized words for the pattern 0 # lemmatize each word - create base word, in attempt to represent related words for in # create the bag of words array with 1, if word is found in current pattern for in 1 if in else 0 # output is a '0' for each tag and '1' for current tag (for each pattern) 1 1 # shuffle the features and make numpy array # create training and testing lists. X - patterns, Y - intents 0 1 "Training data is created" Step 4. Training the model The architecture of our model will be a neural network consisting of 3 Dense layers. The first layer has 128 neurons, second one has 64 and the last layer will have the same neurons as the number of classes. The dropout layers are introduced to reduce overfitting of the model. We have used SGD optimizer and fit the data to start training of the model. After the training of 200 epochs is completed we then save the trained model using Keras model.save(“chatbot_model.h5”) function. model = Sequential()
model.add(Dense( , input_shape=(len(train_x[ ]),), activation= ))
model.add(Dropout( ))
model.add(Dense( , activation= ))
model.add(Dropout( ))
model.add(Dense(len(train_y[ ]), activation= )) sgd = SGD(lr= , decay= , momentum= , nesterov= )
model.compile(loss= , optimizer=sgd, metrics=[ ]) hist = model.fit(np.array(train_x), np.array(train_y), epochs= , batch_size= , verbose= )
model.save( , hist)
print( ) # deep neural networds model 128 0 'relu' 0.5 64 'relu' 0.5 0 'softmax' # Compiling model. SGD with Nesterov accelerated gradient gives good results for this model 0.01 1e-6 0.9 True 'categorical_crossentropy' 'accuracy' #Training and saving the model 200 5 1 'chatbot_model.h5' "model is created" Step 5. Interacting with the chatbot Our model is ready to chat so now let’s create a nice graphical user interface for our chatbot in a new file. You can name the file as gui_chatbot.py In our GUI file, we will be using the Tkinter module to build the structure of the desktop application and then we will capture the user message and again perform some preprocessing before we input the message into our trained model. The model will then predict the tag of the user’s message and we will randomly select the response from the list of responses in our intents file. Here’s the full source code for the GUI file. nltk nltk.stem WordNetLemmatizer
lemmatizer = WordNetLemmatizer() pickle numpy np keras.models load_model
model = load_model( ) json random
intents = json.loads(open( ).read())
words = pickle.load(open( , ))
classes = pickle.load(open( , )) sentence_words = nltk.word_tokenize(sentence) sentence_words = [lemmatizer.lemmatize(word.lower()) word sentence_words] sentence_words sentence_words = clean_up_sentence(sentence) bag = [ ]*len(words) s sentence_words: i,word enumerate(words): word == s: bag[i] = show_details: ( % word) (np.array(bag)) p = bag_of_words(sentence, words,show_details= )
    res = model.predict(np.array([p]))[ ]
    ERROR_THRESHOLD = results = [[i,r] i,r enumerate(res) r>ERROR_THRESHOLD] results.sort(key= x: x[ ], reverse= )
    return_list = [] r results:
        return_list.append({ : classes[r[ ]], : str(r[ ])}) return_list tag = ints[ ][ ]
    list_of_intents = intents_json[ ] i list_of_intents: (i[ ]== tag):
            result = random.choice(i[ ]) result tkinter tkinter * msg = EntryBox.get( , ).strip()
    EntryBox.delete( ,END) msg != :
        ChatBox.config(state=NORMAL)
        ChatBox.insert(END, + msg + )
        ChatBox.config(foreground= , font=( , ))
        ints = predict_class(msg)
        res = getResponse(ints, intents)
        ChatBox.insert(END, + res + )
        ChatBox.config(state=DISABLED)
        ChatBox.yview(END)
root = Tk()
root.title( )
root.geometry( )
root.resizable(width=FALSE, height=FALSE) ChatBox = Text(root, bd= , bg= , height= , width= , font= ,)
ChatBox.config(state=DISABLED) scrollbar = Scrollbar(root, command=ChatBox.yview, cursor= )
ChatBox[ ] = scrollbar.set SendButton = Button(root, font=( , , ), text= , width= , height= ,
                    bd= , bg= , activebackground= ,fg= ,
                    command= send ) EntryBox = Text(root, bd= , bg= ,width= , height= , font= ) scrollbar.place(x= ,y= , height= )
ChatBox.place(x= ,y= , height= , width= )
EntryBox.place(x= , y= , height= , width= )
SendButton.place(x= , y= , height= )
root.mainloop() import from import import import as from import 'chatbot_model.h5' import import 'intents.json' 'words.pkl' 'rb' 'classes.pkl' 'rb' : def clean_up_sentence (sentence) # tokenize the pattern - splitting words into array # stemming every word - reducing to base form for in return # return bag of words array: 0 or 1 for words that exist in sentence : def bag_of_words (sentence, words, show_details=True) # tokenizing patterns # bag of words - vocabulary matrix 0 for in for in if # assign 1 if current word is in the vocabulary position 1 if print "found in bag: %s" return : def predict_class (sentence) # filter below  threshold predictions False 0 0.25 for in if # sorting strength probability lambda 1 True for in "intent" 0 "probability" 1 return : def getResponse (ints, intents_json) 0 'intent' 'intents' for in if 'tag' 'responses' break return #Creating tkinter GUI import from import : def send () "1.0" 'end-1c' "0.0" if '' "You: " '\n\n' "#446665" "Verdana" 12 "Bot: " '\n\n' "Chatbot" "400x500" #Create Chat window 0 "white" "8" "50" "Arial" #Bind scrollbar to Chat window "heart" 'yscrollcommand' #Create Button to send message "Verdana" 12 'bold' "Send" "12" 5 0 "#f9a602" "#3c9d9b" '#000000' #Create the box to enter message 0 "white" "29" "5" "Arial" #EntryBox.bind("<Return>", send) #Place all components on the screen 376 6 386 6 6 386 370 128 401 90 265 6 401 90 Running the chatbot Now we have two separate files, one is the train_chatbot.py which we will use first to train the model. train_chatbot. python py Explore more @ . Python Projects with Source Code

Facebook

Top 10 Data Science Project Ideas for 2020

Sneak peek into my roller-coaster ride with Data Science

How To Build Chatbot Project Using Python

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

Top 10 Data Science Project Ideas for 2020

The Noonification: How Often Do NFTs Pass The Howey Test? (1/13/2023)

Darwin's Hybrid Intelligence to Align AI & Human Goals for Startups & VCs

The Noonification: White Man (11/26/2022)

The Noonification: The Metaverse is a Sh*tshow (11/2/2022)

Top 10 Data Science Project Ideas for 2020

The Noonification: How Often Do NFTs Pass The Howey Test? (1/13/2023)

Darwin's Hybrid Intelligence to Align AI & Human Goals for Startups & VCs

The Noonification: White Man (11/26/2022)

The Noonification: The Metaverse is a Sh*tshow (11/2/2022)

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps