How to Build a Chatbot Using Python

How to Build a Chatbot Using Python
chatbot, Python, tutorial, guide, artificial intelligence, natural language processing.

Chatbots have become a popular way for businesses to communicate with their customers. They can provide 24/7 support, handle repetitive tasks, and even personalize the experience for each user. In this article, we will explore how to build a chatbot using Python.

To build a chatbot, we need to first understand the natural language processing (NLP) concept. NLP is a field of computer science and artificial intelligence that deals with the interaction between computers and humans using natural language. The chatbot uses NLP to understand the user’s input and provide a response.

Here are the steps to build a chatbot using Python:

Step 1: Install the necessary packages

We need to install the following packages:

  • nltk
  • numpy
  • tensorflow
  • tflearn

You can install these packages using pip:

pip install nltk numpy tensorflow tflearn
Step 2: Import the necessary packages and data

We need to import the necessary packages and data:

import nltk
from nltk.stem.lancaster import LancasterStemmer
stemmer = LancasterStemmer()

import numpy
import tflearn
import tensorflow as tf
import random

import json
with open('intents.json') as file:
    data = json.load(file)

In the code above, we import the necessary packages such as nltk, numpy, tflearn, and tensorflow. We also import the data from a JSON file named intents.json. This file contains the intents (or the topics) and the corresponding responses that our chatbot will use.

Step 3: Preprocess the data

We need to preprocess the data by tokenizing the words and stemming them. Tokenizing means splitting the sentence into individual words, while stemming means reducing each word to its root form. For example, “running” and “ran” are both reduced to “run”.

words = []
labels = []
docs_x = []
docs_y = []

for intent in data['intents']:
    for pattern in intent['patterns']:
        # Tokenize and stem the words
        wrds = nltk.word_tokenize(pattern)
        words.extend(wrds)
        docs_x.append(wrds)
        docs_y.append(intent['tag'])
    
    if intent['tag'] not in labels:
        labels.append(intent['tag'])
        
# Stem and lower the words
words = [stemmer.stem(w.lower()) for w in words if w != '?']
words = sorted(list(set(words)))

labels = sorted(labels)

In the code above, we loop through each intent and pattern in the data, tokenize and stem the words, and add them to our words, docs_x, and docs_y lists. We also add each tag to our labels list. Finally, we stem and lowercase our words and sort them.

Step 4: Create the training data

We need to create the training data using a bag-of-words approach. A bag-of-words is a representation of the text that counts the frequency of each word. We will use this representation to train our chatbot.

training = []
output = []

out_empty = [0 for _ in range(len(labels))]

for x, doc in enumerate(docs_x):
    bag = []
    
    wrds = [stemmer.stem(w.lower()) for w in doc]
    
    for w in words:
        if w in wrds:
            bag.append(1)
        else:
            bag.append(0)
    
    output_row = out_empty[:]
    output_row[labels.index(docs_y[x])] = 1
    
    training.append(bag)
    output.append(output_row)
    
training = numpy.array(training)
output = numpy.array
Step 5: Create the neural network

We need to create a neural network using the training data that we created in the previous step. We will use a three-layer neural network with one input layer, one hidden layer, and one output layer. We will use the softmax activation function for the output layer.

tf.reset_default_graph()

net = tflearn.input_data(shape=[None, len(training[0])])
net = tflearn.fully_connected(net, 8)
net = tflearn.fully_connected(net, 8)
net = tflearn.fully_connected(net, len(output[0]), activation='softmax')
net = tflearn.regression(net)

model = tflearn.DNN(net)

model.fit(training, output, n_epoch=1000, batch_size=8, show_metric=True)
model.save('model.tflearn')

In the code above, we reset the TensorFlow graph, define the input layer, add two hidden layers with eight neurons each, and an output layer with the softmax activation function. We also define the regression function and create a DNN object.

Step 6: Create the chatbot

We need to create the chatbot function that will take the user’s input, preprocess it, and use the neural network to provide a response.

def bag_of_words(s, words):
    bag = [0 for _ in range(len(words))]
    
    s_words = nltk.word_tokenize(s)
    s_words = [stemmer.stem(word.lower()) for word in s_words]
    
    for se in s_words:
        for i, w in enumerate(words):
            if w == se:
                bag[i] = 1
                
    return numpy.array(bag)

def chat():
    print("Start talking with the bot (type 'quit' to exit)")
    while True:
        inp = input("You: ")
        if inp.lower() == 'quit':
            break
            
        results = model.predict([bag_of_words(inp, words)])[0]
        results_index = numpy.argmax(results)
        tag = labels[results_index]
        
        if results[results_index] > 0.7:
            for tg in data['intents']:
                if tg['tag'] == tag:
                    responses = tg['responses']
            print(random.choice(responses))
        else:
            print("I didn't understand that, please try again.")

In the code above, we define a bag_of_words function that takes a sentence and the words list and returns a bag-of-words representation of the sentence. We also define a chat function that loops through the user’s input, preprocesses it, and uses the neural network to provide a response.

Step 7: Test the chatbot

We can now test our chatbot by calling the chat function.

chat()

Congratulations, you have successfully built a chatbot using Python! You can now customize the intents and responses in the intents.json file to create your own chatbot.

Spread the love

Similar Posts