Update app.py

app.py

@@ -1,70 +1,101 @@
-import streamlit as st
+import json
+import re
+import nltk
+from flask import Flask, render_template, request
 from transformers import BertTokenizer, TFBertForSequenceClassification
-import tensorflow as tf
-import numpy as np
-import requests
-import os
+import logging
+import random
+import time
 
-# Ensure PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION is set to "python"
-os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"
+nltk.download('punkt')
+nltk.download('wordnet')
 
-# Paths to your models hosted on Hugging Face
-basic_model_url = "https://huggingface.co/anshupatel4298/bert-chatbot-model/resolve/main/basic_chatbot_model.h5"
-local_model_path = "basic_chatbot_model.h5"
-bert_model_name = "anshupatel4298/bert-chatbot-model"
+app = Flask(__name__)
 
-# Define the model architecture that matches the original one
-def create_model():
-    model = tf.keras.Sequential([
-        tf.keras.layers.InputLayer(input_shape=(1825,)),  # Adjust input shape to match the original model
-        tf.keras.layers.Dense(128, activation='relu'),
-        tf.keras.layers.Dropout(0.5),
-        tf.keras.layers.Dense(64, activation='relu'),
-        tf.keras.layers.Dropout(0.5),
-        tf.keras.layers.Dense(40, activation='softmax')  # Adjust the number of classes to match the original model
-    ])
-    return model
+# Set up logging
+logging.basicConfig(level=logging.DEBUG)
 
-# Create the model
-basic_model = create_model()
+# Load the BERT tokenizer and model
+model_name = "bert-base-uncased"
+tokenizer = BertTokenizer.from_pretrained(model_name)
+bert_model = TFBertForSequenceClassification.from_pretrained(model_name)
 
-# Download the Basic Model weights from the URL if not already downloaded
-if not os.path.exists(local_model_path):
-    response = requests.get(basic_model_url)
-    with open(local_model_path, 'wb') as f:
-        f.write(response.content)
+# Function to preprocess input text
+def preprocess_input(text):
+    inputs = tokenizer(text, return_tensors='tf', max_length=512, truncation=True, padding='max_length')
+    return inputs
 
-# Load the weights into the model
-basic_model.load_weights(local_model_path)
+# Function to predict the class using BERT model
+def predict_class(sentence, model):
+    inputs = preprocess_input(sentence)
+    outputs = model(inputs)
+    logits = outputs.logits
+    predicted_class = np.argmax(logits, axis=-1)[0]  # The predicted class (index)
 
-# Load BERT Model and Tokenizer
-bert_model = TFBertForSequenceClassification.from_pretrained(bert_model_name)
-bert_tokenizer = BertTokenizer.from_pretrained(bert_model_name)
+    logging.debug(f"Logits: {logits}")
+    logging.debug(f"Predicted class: {predicted_class}")
+    
+    return predicted_class
 
-# Set your MAX_SEQUENCE_LENGTH here
-MAX_SEQUENCE_LENGTH = 100
+# Function to normalize text
+def normalize_text(text):
+    text = text.lower()
+    text = re.sub(r'\s+', ' ', text)  # Replace multiple spaces with single space
+    text = re.sub(r'[^\w\s]', '', text)  # Remove punctuation
+    return text
 
-# Streamlit UI
-st.sidebar.title("Select Model")
-model_choice = st.sidebar.selectbox("Choose a model:", ["Basic Model", "BERT Model"])
+# Function to find the intent based on user message
+def find_intent(user_message, intents_json):
+    normalized_message = normalize_text(user_message)
+    
+    for intent in intents_json["intents"]:
+        for pattern in intent["patterns"]:
+            normalized_pattern = normalize_text(pattern)
+            if normalized_pattern in normalized_message:
+                return intent
+    return None
 
-st.title("Chatbot Interface")
-
-user_input = st.text_input("You:")
-if st.button("Send"):
-    if user_input:
-        if model_choice == "Basic Model":
-            # Preprocess input for basic model
-            tokenizer = tf.keras.preprocessing.text.Tokenizer(num_words=1825)
-            tokenizer.fit_on_texts([user_input])
-            tokenized_input = tokenizer.texts_to_sequences([user_input])
-            input_data = tf.keras.preprocessing.sequence.pad_sequences(tokenized_input, maxlen=1825)  # Ensure padding to match the input shape
-            prediction = basic_model.predict(input_data)
-            response = np.argmax(prediction, axis=-1)[0]
+# Function to get the response based on the found intent
+def getResponse(user_message, intents_json):
+    intent = find_intent(user_message, intents_json)
+    
+    if intent:
+        responses = intent.get("responses", [])
+        if responses:
+            result = random.choice(responses)
+            logging.debug(f"Response chosen: {result}")  # Log the chosen response
+            return result
         else:
-            # Preprocess input for BERT model
-            inputs = bert_tokenizer(user_input, return_tensors="tf", max_length=MAX_SEQUENCE_LENGTH, truncation=True, padding="max_length")
-            outputs = bert_model(**inputs)
-            response = tf.argmax(outputs.logits, axis=-1).numpy()[0]
+            logging.debug(f"No responses found for intent.")
+            return "I'm not sure what to say about that!"
+    
+    return "Sorry, I didn't understand that."
+
+# Route for the home page
+@app.route("/")
+def index():
+    return render_template('chat.html')
+
+# Route to handle the chat messages
+@app.route("/get", methods=["GET", "POST"])
+def chat():
+    msg = request.form["msg"]
+    response = chatbot_response(msg)
+    return response
+
+# Function to generate the chatbot response
+def chatbot_response(user_message):
+    # Simulate model processing time
+    time.sleep(random.uniform(0.5, 1.5))  # Simulate delay
+    
+    # Use the "model" to get a response from the intents
+    data_file = open('intents.json').read()
+    intents = json.loads(data_file)
+    
+    # Use pattern matching to get response from intents
+    res = getResponse(user_message, intents)
+    logging.debug(f"Final chatbot response: {res}")
+    return res
 
-        st.write(f"Bot: {response}")
+if __name__ == "__main__":
+    app.run(debug=True)