Update app.py

app.py

@@ -1,137 +1,54 @@
-import pandas as pd
-import numpy as np
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.metrics.pairwise import cosine_similarity
-from sklearn.model_selection import train_test_split
-from tensorflow.keras.preprocessing.text import Tokenizer
-from tensorflow.keras.preprocessing.sequence import pad_sequences
-from tensorflow.keras.models import load_model
-import nltk
 import gradio as gr
 import os
+import google.generativeai as genai
 import logging
-import tensorflow as tf
 
-# Suppress TensorFlow warnings and set logging level
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'  # Suppress TensorFlow info/warning logs
-logging.getLogger('tensorflow').setLevel(logging.ERROR)
+# Suppress unnecessary logs
+logging.getLogger().setLevel(logging.ERROR)
 
-# Download NLTK data
-nltk.download('punkt', quiet=True)
+# Load the Gemini API key from Hugging Face secrets
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
 
-# Load the dataset
-def load_data():
-    file_path = "zomato_data.csv"
-    try:
-        zomato_data = pd.read_csv(file_path)
-    except FileNotFoundError:
-        print("Warning: zomato_data.csv not found. Using dummy dataset.")
-        zomato_data = pd.DataFrame({
-            'name': ['Sample Restaurant'],
-            'online_order': ['Yes'],
-            'book_table': ['No'],
-            'rate': [4.0],
-            'approx_cost': [1000.0],
-            'listed_in(type)': ['Dining']
-        })
-    return zomato_data
+# Configure Gemini API
+if GEMINI_API_KEY:
+    genai.configure(api_key=GEMINI_API_KEY)
+else:
+    print("Error: Gemini API key not found. Please set GEMINI_API_KEY in Hugging Face secrets.")
 
-# Preprocess data
-def preprocess_data(zomato_data):
-    zomato_data.rename(columns={'approx_cost(for two people)': 'approx_cost'}, inplace=True)
-    zomato_data['approx_cost'] = zomato_data['approx_cost'].astype(str).str.replace(',', '', regex=True).astype(float)
-    zomato_data['rate'] = zomato_data['rate'].astype(str).str.split('/').str[0].replace(['NEW', '-', 'nan'], None).astype(float)
-    zomato_data.fillna("Unknown", inplace=True)
-    zomato_data['search_text'] = (
-        "Name: " + zomato_data['name'] + " | " +
-        "Online Order: " + zomato_data['online_order'] + " | " +
-        "Book Table: " + zomato_data['book_table'] + " | " +
-        "Rate: " + zomato_data['rate'].astype(str) + " | " +
-        "Cost for Two: ₹" + zomato_data['approx_cost'].astype(str) + " | " +
-        "Cuisine Type: " + zomato_data['listed_in(type)']
-    )
-    return zomato_data
+# Initialize Gemini model
+model = None
+try:
+    model = genai.GenerativeModel('gemini-1.5-flash')
+except Exception as e:
+    print(f"Error initializing Gemini model: {e}")
 
-# Generate Q&A pairs
-def generate_qa_pairs(zomato_data):
-    qa_pairs = []
-    for _, row in zomato_data.iterrows():
-        qa_pairs.append((f"Can I order online at {row['name']}?", 
-                         f"{'Yes' if row['online_order'] == 'Yes' else 'No'}, online ordering is {'available' if row['online_order'] == 'Yes' else 'not available'} at {row['name']}."))
-        qa_pairs.append((f"Can I book a table at {row['name']}?", 
-                         f"{'Yes' if row['book_table'] == 'Yes' else 'No'}, table booking is {'available' if row['book_table'] == 'Yes' else 'not available'} at {row['name']}."))
-        qa_pairs.append((f"What is the rating of {row['name']}?", f"The rating of {row['name']} is {row['rate']}/5."))
-        qa_pairs.append((f"What is the cost for two people at {row['name']}?", 
-                         f"The approximate cost for two people at {row['name']} is ₹{row['approx_cost']}."))
-        qa_pairs.append((f"What type of cuisine does {row['name']} serve?", 
-                         f"{row['name']} is listed in {row['listed_in(type)']}."))
-    return qa_pairs
+# Chatbot function using Gemini
+def gradio_chatbot(user_query):
+    if not user_query.strip():
+        return "Please enter a valid query."
+
+    if not model:
+        return "Error: Gemini model not initialized. Check API key and try again."
 
-# Initialize vectorizer
-def init_vectorizer(zomato_data):
-    vectorizer = TfidfVectorizer()
-    vectorized_data = vectorizer.fit_transform(zomato_data['search_text'])
-    return vectorizer, vectorized_data
+    # Prompt to restrict Gemini to restaurant-related responses
+    prompt = (
+        "You are a restaurant information assistant. You can only respond to questions about restaurants, their features (e.g., online ordering, table booking), ratings, costs, cuisine types, or other restaurant-related details. "
+        "Do not answer questions unrelated to restaurants. If the query is not restaurant-related, respond with: 'Sorry, I can only answer questions about restaurants.' "
+        f"User query: {user_query}\nAnswer:"
+    )
 
-# Load tokenizer and model
-def load_model_and_tokenizer(zomato_data):
-    model = None
-    tokenizer = None
     try:
-        model = load_model("chatbot_model.h5")
-        tokenizer = Tokenizer()
-        qa_pairs = generate_qa_pairs(zomato_data)
-        questions, answers = zip(*qa_pairs)
-        tokenizer.fit_on_texts(questions + answers)
-        print("Successfully loaded model and initialized tokenizer.")
-    except FileNotFoundError:
-        print("Warning: chatbot_model.h5 not found. Falling back to TF-IDF-based responses.")
+        response = model.generate_content(prompt)
+        return response.text.strip()
     except Exception as e:
-        print(f"Error loading model: {e}. Falling back to TF-IDF-based responses.")
-    return model, tokenizer
-
-# Chatbot query using TF-IDF
-def chatbot_query(query, vectorizer, vectorized_data, zomato_data):
-    query_vector = vectorizer.transform([query])
-    similarities = cosine_similarity(query_vector, vectorized_data)
-    most_similar_idx = np.argmax(similarities)
-    return zomato_data['search_text'].iloc[most_similar_idx]
-
-# Chatbot response using LSTM model
-def chatbot_response(input_text, model, tokenizer, vectorizer, vectorized_data, zomato_data, max_len=20):
-    if model and tokenizer:
-        input_seq = tokenizer.texts_to_sequences([input_text])
-        input_seq = pad_sequences(input_seq, maxlen=max_len, padding='post')
-        try:
-            pred = model.predict([input_seq, input_seq], verbose=0)
-            pred_idx = np.argmax(pred[0], axis=1)
-            response = " ".join([tokenizer.index_word.get(idx, "") for idx in pred_idx if idx > 0])
-            if response.strip():
-                return response
-        except Exception as e:
-            print(f"Model prediction failed: {e}")
-    # Fallback to TF-IDF
-    return chatbot_query(input_text, vectorizer, vectorized_data, zomato_data)
-
-# Initialize everything
-zomato_data = load_data()
-zomato_data = preprocess_data(zomato_data)
-vectorizer, vectorized_data = init_vectorizer(zomato_data)
-model, tokenizer = load_model_and_tokenizer(zomato_data)
-
-# Gradio interface
-def gradio_chatbot(user_query):
-    if not user_query.strip():
-        return "Please enter a valid query."
-    response = chatbot_response(user_query, model, tokenizer, vectorizer, vectorized_data, zomato_data)
-    return response
+        return f"Error generating response: {e}"
 
 # Create Gradio interface
 iface = gr.Interface(
     fn=gradio_chatbot,
-    inputs=gr.Textbox(lines=2, placeholder="Ask about a restaurant (e.g., 'Can I order online at Cafe XYZ?')"),
+    inputs=gr.Textbox(lines=2, placeholder="Ask about a restaurant (e.g., 'What are the features of Cafe Delight?')"),
     outputs="text",
-    title="Zomato Restaurant Chatbot",
+    title="Restaurant Chatbot",
     description="Ask questions about restaurants, such as online ordering, table booking, ratings, costs, or cuisine types."
 )