adding project app folder, index page, and requirements.txt file.

chatbotlib/chatbot_demo.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python
+
+"""The chatbot demo app is the "Demo the chatbot page" in the main page"""
+
+# the code for the page
+def run_app():
+    """
+    Application code for the Chatbot demo
+    """
+    ############################
+    # :: IMPORTS AND CONSTANTS #
+    ############################
+
+    import nltk
+    from nltk.stem import WordNetLemmatizer
+    lemmatizer = WordNetLemmatizer()
+
+    import pickle
+    import numpy as np
+    import pandas as pd
+
+    import time
+    import json
+    import random
+    import datetime
+
+    import streamlit as st
+    from streamlit_chat import message
+
+    from keras.models import load_model
+    chatbot_model = load_model('chatbot_model.h5')
+
+    # Load commands and preprocessed data
+    commands = json.loads(open('commands.json').read())
+    words = pickle.load(open('words.pkl', 'rb'))
+    classes = pickle.load(open('classes.pkl', 'rb'))
+
+    ######################################
+    # :: HELPER FUNCTIONS FOR PROCESSING #
+    ######################################
+
+    def clean_up_sentence(sentence):
+        """
+        Tokenize and lemmatize the input sentence.
+    
+        Args:
+            sentence (str): The input sentence to be preprocessed.
+        
+        Returns:
+            list: The list of preprocessed words.
+        """
+        sentence_words = nltk.word_tokenize(sentence)
+        sentence_words = [lemmatizer.lemmatize(word.lower()) for word in sentence_words]
+        return sentence_words
+
+    def bag_of_words(sentence):
+        """Converts a sentence into a bag of words representation.
+    
+        Args:
+            sentence (str): The input sentence to convert.
+        
+        Returns:
+            numpy.ndarray: The bag of words representation as a NumPy array.
+        
+        """
+        sentence_words = clean_up_sentence(sentence)
+        bag = np.zeros(len(words), dtype=np.float32)
+        indices = np.where(np.isin(words, sentence_words))
+        bag[indices] = 1
+        return bag
+
+    def predict_class(sentence):
+        """
+        Predicts the intent based on the input sentence.
+
+        Args:
+            sentence (str): The input sentence.
+
+        Returns:
+            list: A list of dictionaries containing the predicted intents and their probabilities, sorted by probability.
+
+        """
+        p = bag_of_words(sentence)
+        res = chatbot_model.predict(np.array([p]))[0]
+        ERROR_THRESHOLD = 0.25
+
+        threshold_indices = np.where(res > ERROR_THRESHOLD)[0]
+        results = [{"intent": classes[i], "probability": str(res[i])} for i in threshold_indices]
+        results.sort(key=lambda x: x["probability"], reverse=True)
+        return results
+
+    def get_random_response(commands_json, tag):
+        """
+        Retrieves a random response for the given tag from the commands JSON.
+
+        Args:
+            commands_json (dict): The JSON object containing the commands.
+            tag (str): The tag associated with the intent.
+
+        Returns:
+            str: A random response for the given tag.
+
+        """
+        list_of_commands = commands_json["intents"]
+        for i in list_of_commands:
+            if i["tag"] == tag:
+                result = random.choice(i["responses"])
+                return result
+        return "I'm sorry, I don't understand."
+
+
+    def chatbot_response(text):
+        """
+        Generate a response from the chatbot based on the user input.
+    
+        Args:
+            text (str): The user input message.
+        
+        Returns:
+            tuple: A tuple containing the generated response from the chatbot and the execution time.
+        """
+        start_time = time.time()
+        ints = predict_class(text)
+        elapsed_time = time.time() - start_time
+
+        if ints:
+            tag = ints[0]['intent']
+            res = get_random_response(commands, tag)
+            return res, elapsed_time
+        else:
+            return "I'm sorry, I don't understand.", elapsed_time
+
+    def get_text():
+        """
+        Displays a text input box and returns the user input.
+
+        Returns:
+            str: The user input.
+        """
+        input_text = st.text_input("You: ", "Hello, how are you?", key="input")
+        return input_text 
+
+    def get_chat_history_df():
+        """
+        Retrieve the chat history from the session state and create a DataFrame.
+
+        Returns:
+            pd.DataFrame: The DataFrame containing the chat history with columns 'User Input' and 'Bot Response'.
+        """
+        # Get the chat history from the session state
+        chat_history = zip(st.session_state['past'], st.session_state['generated_responses'])
+        # Convert chat history to a list
+        chat_history_list = list(chat_history)
+        # Create a dataframe from the chat history list
+        chat_history_df = pd.DataFrame(chat_history_list, columns=['User Input', 'Bot Response'])
+
+        return chat_history_df
+
+    def export_chat_history(chat_history_df):
+        """
+        Export the chat history DataFrame to a CSV file and provide a download link.
+
+        Args:
+            chat_history_df (pd.DataFrame): The DataFrame containing the chat history.
+
+        Returns:
+            bool: True if the export is successful, False otherwise.
+        """
+        try:
+            # Get the current datetime
+            current_datetime = datetime.datetime.now().strftime("%m/%d/%Y_%I_%M_%S_%p")
+
+            # Define the CSV file path
+            chat_history_filename = f'chat_history_{current_datetime}.csv'
+
+            # Write the dataframe to a CSV file
+            chat_history_csv = chat_history_df.to_csv(index=False).encode("utf-8")
+        
+            # Provide a download link for the CSV file
+            st.download_button(
+                label="Download Chat History",
+                data=chat_history_csv,
+                file_name=chat_history_filename,
+                mime="text/csv",
+                help="Download the chat history session to a CSV file."
+            )
+
+            return True
+        except Exception as e:
+            st.error(f"Export failed: {str(e)}")
+            return False
+
+    def clear_session_state():
+        """
+        Clear the session state variables related to chat history.
+
+        This function clears the session state variables 'generated_responses' and 'past',
+        which store the generated responses and user inputs in the chat history.
+
+        """
+        # Clear the session state variables
+        st.session_state['generated_responses'] = []
+        st.session_state['past'] = []
+
+    ###############
+    # :: MAIN APP #
+    ###############
+
+    st.markdown("<h1 style='text-align: left;'>NLP Chatbot Demo 💬</h1>", unsafe_allow_html=True)
+    st.subheader(
+    """
+    NLP Chatbot is a conversational chat bot. Begin by entering in a prompt below. 
+    """
+    )
+    # Explanation of code using st.markdown with bullet points
+    st.markdown("""
+    - This chatbot app offers the following options:
+    - Option 1: Clear Chat Log
+    - Option 2: Preview the Chat History
+    - Option 3: Export Chat History
+
+    - To manage these options, three columns are created using `st.columns(3)`.
+        - Column 1 contains a checkbox labeled 'Clear Chat Log'. Selecting it will clear the chat log. Make sure to leave the text input box empty as well.
+        - Column 2 contains a checkbox labeled 'Preview the Chat History'. Selecting it will display the chat history.
+        - Column 3 contains a checkbox labeled 'Export Chat History'. Selecting it will export the chat history as a CSV file.
+
+    - Please interact with the checkboxes to perform the desired actions.
+    """)
+    st.write("---")
+    # Create a container for the columns
+    container = st.container()
+
+    # Add the columns inside the container
+    with container:
+        col1, col2, col3 = st.columns(3)
+
+    # Add a button to clear session state
+    if col1.checkbox("Clear Chat Log"):
+        clear_session_state()
+
+    if col2.checkbox("Preview the Chat History"):
+        chat_history_df = get_chat_history_df()
+        st.write(chat_history_df)
+
+    # Add a button to export chat history in the third column
+    if col3.checkbox("Export Chat History"):
+        chat_history_df = get_chat_history_df()
+        export_chat_history(chat_history_df)
+
+    # Initialize session states
+    if 'generated_responses' not in st.session_state:
+        st.session_state['generated_responses'] = []
+
+    if 'execution_times' not in st.session_state:
+        st.session_state['execution_times'] = []
+
+    if 'past' not in st.session_state:
+        st.session_state['past'] = []
+
+    #st.subheader(
+    #"""
+    #NLP Bot is an NLP conversational chat bot. Begin by entering in a prompt below. 
+    #"""
+    #)
+    #st.write("---")
+
+    # Get user input
+    user_input = get_text()
+
+    if user_input:
+        # Generate response
+        response, exec_time = chatbot_response(user_input)
+
+        # Update session states
+        st.session_state.past.append(user_input)
+        st.session_state.generated_responses.append(response)
+        st.session_state.execution_times.append(exec_time)
+
+        # Display the execution time of the response as a metric
+        st.metric("Execution Time", f"{exec_time:.2f} seconds")
+
+    if st.session_state['generated_responses']:
+        # Display generated responses and user inputs
+        for i in range(len(st.session_state['generated_responses']) - 1, -1, -1):
+            # Unique key for each generated response widget
+            message(f"Bot: {st.session_state['generated_responses'][i]}",
+                    is_user=False, 
+                    avatar_style='bottts-neutral',
+                    seed=10, 
+                    key=f"response_{i}"
+            )  
+            # Unique key for each user input widget
+            message(f"You: {st.session_state['past'][i]}", 
+                    is_user=True, 
+                    avatar_style="open-peeps", 
+                    seed=1, 
+                    key=f"user_{i}"
+            )  
+            
+# End of app
+if __name__ == "__main__":
+
+    run_app()

chatbotlib/train_chatbot.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python
+
+"""The chatbot model training app is the "Train the chatbot model page" in the main page"""
+
+# the code for the page
+def run_app():
+    """
+    Application code for the Chatbot Training app
+    """
+    ############################
+    # :: IMPORTS AND CONSTANTS #
+    ############################
+
+    # machine learning modules
+    import numpy as np
+    import random
+
+    # Deep Learning modules
+    from keras.models import Sequential
+    from keras.layers import Dense, Dropout
+    from keras.optimizers import SGD
+
+    import streamlit as st
+
+    # suppress warnings
+    import warnings
+    warnings.filterwarnings('ignore')
+
+    # for file processing
+    import json
+    import pickle
+
+    # natural language processiong modules
+    import nltk
+    from nltk.stem import WordNetLemmatizer
+    lemmatizer = WordNetLemmatizer()
+
+    # Load NLTK dependencies
+    nltk.download('punkt')
+    nltk.download('wordnet')
+
+    ######################################
+    # :: HELPER FUNCTIONS FOR PROCESSING #
+    ######################################
+
+    def read_json_file(uploaded_file):
+        """
+        Reads a JSON file and returns its contents.
+
+        Args:
+            uploaded_file (_UploadedFile): The uploaded JSON file.
+
+        Returns:
+            dict: The contents of the JSON file.
+        """
+        data = json.loads(uploaded_file.read().decode("utf-8"))
+        return data
+
+    def preprocess_data(data):
+        """
+        Preprocesses the JSON data.
+
+        Args:
+            data (dict): The JSON data.
+
+        Returns:
+            tuple: The pre-processed data (words, classes, documents).
+        """
+
+        # creating lists for NLP
+        words=[]
+        classes = []
+        documents = []
+        ignore_words = ['?', '!']
+
+        lemmatizer = WordNetLemmatizer()
+        for command in data['intents']:
+            for pattern in command['patterns']:
+                # Tokenize each word
+                w = nltk.word_tokenize(pattern)
+                words.extend(w)
+                # Add documents to the corpus
+                documents.append((w, command['tag']))
+                # Add to classes list
+                if command['tag'] not in classes:
+                    classes.append(command['tag'])
+
+        # Lemmatize, convert to lowercase, and remove duplicates
+        words = [lemmatizer.lemmatize(w.lower()) for w in words if w not in ignore_words]
+        words = sorted(list(set(words)))
+        classes = sorted(list(set(classes)))
+
+        return words, classes, documents
+
+    def load_pickle_data():
+        """
+        Loads the pickle data.
+
+        Returns:
+            tuple: The loaded pickle data (words, classes, documents).
+        """
+        with open('words.pkl', 'rb') as f:
+            words = pickle.load(f)
+        with open('classes.pkl', 'rb') as f:
+            classes = pickle.load(f)
+        with open('documents.pkl', 'rb') as f:
+            documents = pickle.load(f)
+        return words, classes, documents
+
+    def create_training_data(words, classes, documents):
+        """
+        Create the training data for the chatbot model.
+
+        Args:
+            words (list): List of words in the vocabulary.
+            classes (list): List of classes/intents.
+            documents (list): List of (pattern, intent) pairs.
+
+        Returns:
+            tuple: Tuple containing the training data as NumPy arrays (train_x, train_y).
+        """
+        training = []
+        output_empty = np.zeros(len(classes), dtype=int)
+
+        for doc in documents:
+            bag = np.zeros(len(words), dtype=int)
+            pattern_words = doc[0]
+            pattern_words = [lemmatizer.lemmatize(word.lower()) for word in pattern_words]
+
+            for i, w in enumerate(words):
+                if w in pattern_words:
+                    bag[i] = 1
+
+            output_row = np.copy(output_empty)
+            output_row[classes.index(doc[1])] = 1
+
+            training.append([bag, output_row])
+
+        random.shuffle(training)
+        training = np.array(training)
+
+        train_x = list(training[:, 0])
+        train_y = list(training[:, 1])
+
+        return np.array(train_x), np.array(train_y)
+
+    ###############
+    # :: MAIN APP #
+    ###############
+
+    st.markdown("<h1 style='text-align: left;'>Train the chatbot model ⚙️</h1>", unsafe_allow_html=True)
+    st.subheader(
+    """
+    Let's train the chatbot model by following the sequence of steps provided below:
+    """
+    )
+    #st.markdown("<div style='text-align: center;'>Let's train the chatbot model by following the sequence of steps provided below:</div>", unsafe_allow_html=True)
+    # Summary of steps
+    st.markdown(
+        """
+        **Summary of Steps:**
+        - Upload the `commands.json` file for processing. The file should contain the commands and their corresponding tags.
+        - Load the preprocessed data from pickle files (optional if you have already processed the data previously).
+        - Create the training data by converting the commands into numerical vectors.
+        - Build the model by specifying the number of layers, epochs, batch size, and activation function.
+
+        Once the model is built, the training loss and accuracy will be displayed.
+        """
+    )
+    st.write("---")
+
+    if st.checkbox("Upload the commands.json file for processing"):
+        st.subheader("JSON File Uploader")
+        uploaded_file = st.file_uploader("Upload JSON file", type="json")
+
+        if uploaded_file is not None:
+            try:
+                data = read_json_file(uploaded_file)
+
+                st.json(data)
+
+                # Preprocess the data
+                words, classes, documents = preprocess_data(data)
+
+                # Save the preprocessed data as pickle files
+                with open('words.pkl', 'wb') as f:
+                    pickle.dump(words, f)
+                with open('classes.pkl', 'wb') as f:
+                    pickle.dump(classes, f)
+                with open('documents.pkl', 'wb') as f:
+                    pickle.dump(documents, f)
+
+                # Display the processed data
+                st.write("Preprocessing Results:")
+                st.write(len(documents), "documents")
+                st.write(len(classes), "classes", classes)
+                st.write(len(words), "unique lemmatized words", words)
+
+            except json.JSONDecodeError:
+                st.error("Invalid JSON file.")
+    
+    if st.checkbox("Load pickle data"):
+        # Initialize the progress bar
+        progress_bar = st.progress(0) 
+        
+        with st.spinner("Creating training data ..."):
+
+            words, classes, documents = load_pickle_data()
+            
+        # Update the progress bar
+        progress_bar.progress(100)
+
+        st.write("Words:")
+        st.write(words)
+
+        st.write("Classes:")
+        st.write(classes)
+
+        st.write("Documents:")
+        st.write(documents)
+
+    if st.checkbox("Create training data"):
+        try:
+            # Initialize the progress bar
+            progress_bar = st.progress(0)  
+
+            with st.spinner("Creating training data ..."):
+                train_x, train_y = create_training_data(words, classes, documents)
+
+            # Update the progress bar
+            progress_bar.progress(100)
+
+            st.success("Training data created")
+
+            st.write(f"Training data (train_x): {len(train_x)} samples")
+            st.write(f"Training data (train_y): {len(train_y)} samples")
+    
+        except Exception as e:
+            st.error("An error occurred during training data creation.")
+            st.error(str(e))
+
+    if st.checkbox("Build the model"):
+        # Get user inputs
+        num_layers = st.number_input("Number of layers", min_value=1, max_value=10, value=3)
+        epochs = st.number_input("Number of epochs", min_value=1, max_value=1000, value=200)
+        batch_size = st.number_input("Batch size", min_value=1, max_value=100, value=5)
+        activation_functions = ['relu', 'sigmoid', 'softmax']
+        activation_function = st.selectbox("Activation function", options=activation_functions)
+
+        try:
+            # Initialize the progress bar
+            progress_bar = st.progress(0)  
+
+            with st.spinner("Building the model ..."):
+                # Create model
+                model = Sequential()
+
+                # Add layers to the model based on user input
+                for i in range(num_layers):
+                    if i == 0:
+                        # Input layer
+                        model.add(Dense(128, input_shape=(len(train_x[0]),), activation=activation_function))
+                    else:
+                        # Hidden layers
+                        model.add(Dense(64, activation=activation_function))
+                    model.add(Dropout(0.5))
+
+                # Output layer
+                model.add(Dense(len(train_y[0]), activation='softmax'))
+
+                # Compile model
+                sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
+                model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
+
+                # Fit the model
+                hist = model.fit(np.array(train_x), np.array(train_y), epochs=epochs, batch_size=batch_size, verbose=1)
+
+                # Save the model
+                model.save('chatbot_model.h5', hist)
+
+            # Update the progress bar
+            progress_bar.progress(100)
+
+            st.success("The chatbot model is created")
+
+            # Display training loss and accuracy summary
+            st.subheader("Training Summary")
+            st.write("Training Loss:", hist.history['loss'][-1])
+            st.write("Training Accuracy:", hist.history['accuracy'][-1])
+    
+        except Exception as e:
+            st.error("An error occurred during model building.")
+            st.error(str(e))
+
+# End of app
+if __name__ == "__main__":
+
+    run_app()

index.py

@@ -0,0 +1,43 @@
+import streamlit as st
+from streamlit_option_menu import option_menu
+from chatbotlib import (train_chatbot, chatbot_demo)
+
+# displaying the icon image on streamlit app and set the page config.
+st.set_page_config(
+    layout="wide",
+    page_title="NLP Chatbot Main Page",
+    page_icon="💬"
+)
+
+# Create sidebar
+with st.sidebar:
+
+    # icons are located at bootstrap's website: https://icons.getbootstrap.com
+    page_selection = option_menu(
+        "NLP Chatbot App",
+        ["Train the Chatbot Model", "Demo the Chatbot"],
+        icons=["gear", "chat-dots"],
+        menu_icon="emoji-smile",
+        default_index=0,
+        orientation="vertical",
+        styles={
+            "container": {"padding": "5!important", "background-color": "#fafafa"},
+            "icon": {"color": "orange", "font-size": "25px"},
+            "nav-link": {
+                "font-size": "16px",
+                "text-align": "left",
+                "margin": "0px",
+                "--hover-color": "#eee",
+            },
+            "nav-link-selected": {"background-color": "#0068B5"},
+        },
+    )
+
+# Run the chosen app when selected from the option menu.
+match page_selection:
+
+    case "Train the Chatbot Model":
+        train_chatbot.run_app()
+
+    case "Demo the Chatbot":
+        chatbot_demo.run_app()

requirements.txt

@@ -0,0 +1,7 @@
+nltk
+keras
+numpy
+pandas
+streamlit==1.22.0
+streamlit-chat==0.0.2.2
+streamlit-option-menu==0.3.5