Update app.py

app.py

@@ -1,68 +1,67 @@
-import gradio as gr
-from transformers import AutoModelForCausalLM, AutoTokenizer
 import json
+from transformers import pipeline
+import nltk
+from nltk.corpus import stopwords
+from nltk.tokenize import word_tokenize
+from nltk.stem import WordNetLemmatizer
 
-# Load pre-trained model and tokenizer (replace with desired model if needed)
-model_name = "microsoft/DialoGPT-large"  # Replace with your preferred model
-model = AutoModelForCausalLM.from_pretrained(model_name)
-tokenizer = AutoTokenizer.from_pretrained(model_name)
+# Download NLTK resources
+nltk.download('punkt')
+nltk.download('wordnet')
+nltk.download('stopwords')
 
-# Function to process user input and generate response
-def chat(message, history):
-    # Preprocess user input
-    input_ids = tokenizer(message, return_tensors="pt")["input_ids"]
+# Load the JSON data from the file
+with open('uts_courses.json') as f:
+    data = json.load(f)
 
-    # Generate response with beam search to improve fluency
-    generated_outputs = model.generate(
-        input_ids,
-        max_length=512,  # Adjust max_length as needed for response length
-        num_beams=5,  # Experiment with num_beams for better phrasing
-        no_repeat_ngram_size=2,  # Prevent repetition in responses
-        early_stopping=True,  # Stop generation if response seems complete
-    )
+# Load the question-answering pipeline
+qa_pipeline = pipeline("question-answering")
 
-    # Decode generated tokens to text
-    response = tokenizer.batch_decode(generated_outputs, skip_special_tokens=True)[0]
+# Define stop words and lemmatizer
+stop_words = set(stopwords.words('english'))
+lemmatizer = WordNetLemmatizer()
 
-    # Access and process JSON files
-    json_files = {
-        "fileone.json": "your_key_in_fileone",
-        "filesecond.json": "your_key_in_filesecond",
-        "filethird.json": "your_key_in_filethird",
-        "filefourth.json": "your_key_in_filefourth",
-        "filefifth.json": "your_key_in_filefifth",
-    }
+# Function to preprocess user input
+def preprocess_input(user_input):
+    tokens = word_tokenize(user_input.lower())
+    filtered_tokens = [lemmatizer.lemmatize(word) for word in tokens if word.isalnum() and word not in stop_words]
+    return " ".join(filtered_tokens)
 
-    for filename, key in json_files.items():
-        if key.lower() in message.lower():
-            try:
-                with open(filename, "r") as f:
-                    data = json.load(f)
-                    relevant_info = data.get(key, "No relevant information found")
-                response += f"\nHere's some information I found in {filename}: {relevant_info}"
-            except FileNotFoundError:
-                response += f"\nCouldn't find the file: {filename}"
-            except json.JSONDecodeError:
-                response += f"\nError processing the JSON data in file: {filename}"
-
-    # Update history with current conversation (optional)
-    # history.append([message, response])  # Uncomment if you want conversation history
+# Function to find courses by field of study
+def find_courses_by_field(field):
+    if field in data['courses']:
+        return data['courses'][field]
+    else:
+        return []
 
+# Function to handle user input and generate responses
+def generate_response(user_input):
+    user_input = preprocess_input(user_input)
+    if user_input == 'exit':
+        return "Exiting the program."
+    elif "courses" in user_input and "available" in user_input:
+        field = user_input.split("in ")[1]
+        courses = find_courses_by_field(field)
+        if courses:
+            response = f"Courses in {field}: {', '.join(courses)}"
+        else:
+            response = f"No courses found in {field}."
+    else:
+        answer = qa_pipeline(question=user_input, context=data)
+        response = answer['answer']
     return response
 
-# Check Gradio version and handle catch_exceptions accordingly
-try:
-    # Option 1: Use catch_exceptions if Gradio supports it
-    interface = gr.Interface(chat, inputs="textbox", outputs="textbox", catch_exceptions=True)
-except TypeError:  # If catch_exceptions is not supported
-    # Option 2: Manual error handling within chat function
-    def chat_with_error_handling(message, history):
-        try:
-            return chat(message, history)
-        except Exception as e:
-            return f"An error occurred: {str(e)}"
+# Main function to interact with the user
+def main():
+    print("Welcome! I'm the UTS Course Chatbot. How can I assist you today?")
+    print("You can ask questions about UTS courses or type 'exit' to end the conversation.")
 
-    interface = gr.Interface(chat_with_error_handling, inputs="textbox", outputs="textbox")
+    while True:
+        user_input = input("You: ")
+        response = generate_response(user_input)
+        print("Bot:", response)
+        if response == "Exiting the program.":
+            break
 
-# Launch the Gradio app and share link
-interface.launch(share=True)
+if __name__ == "__main__":
+    main()