Update app.py

app.py

@@ -1,70 +1,85 @@
 import gradio as gr
-import os
-import spacy
-import torch
-from transformers import pipeline
-import speech_recognition as sr
-from gtts import gTTS
-import tempfile
-import base64
+import pandas as pd
+import numpy as np
+from transformers import BlenderbotTokenizer, BlenderbotForConditionalGeneration, M2M100ForConditionalGeneration, M2M100Tokenizer
+from datasets import load_dataset
+from deep_translator import GoogleTranslator
 
-# Install required Spacy model
-os.system("python -m spacy download en_core_web_sm")
-nlp = spacy.load("en_core_web_sm")
+# Load Chatbot (BlenderBot 3B)
+model_name = "facebook/blenderbot-3B"
+tokenizer = BlenderbotTokenizer.from_pretrained(model_name)
+chatbot_model = BlenderbotForConditionalGeneration.from_pretrained(model_name)
 
-# Load Hugging Face model (Example: Bloom or other LLM from Hugging Face)
-chat_model = pipeline("text-generation", model="bigscience/bloom-560m")
+# Load Translation Model (Multilingual)
+translate_model_name = "facebook/m2m100_418M"
+translate_tokenizer = M2M100Tokenizer.from_pretrained(translate_model_name)
+translate_model = M2M100ForConditionalGeneration.from_pretrained(translate_model_name)
 
-# Speech-to-Text function
-def transcribe_audio(audio_path):
-    recognizer = sr.Recognizer()
-    with sr.AudioFile(audio_path) as source:
-        audio_data = recognizer.record(source)
-        try:
-            return recognizer.recognize_google(audio_data)
-        except sr.UnknownValueError:
-            return "Could not understand the audio."
+# Load Hugging Face Dataset (Amazon Reviews)
+dataset = load_dataset("amazon_us_reviews", split="train")
+df = pd.DataFrame(dataset)
 
-# AI Chat Response
-def chat_with_ai(user_input):
-    response = chat_model(user_input, max_length=150, do_sample=True, temperature=0.7)
-    return response[0]['generated_text']
+# Keep necessary columns
+df = df[["product_category", "product_title", "star_rating", "review_body"]].dropna()
+df["star_rating"] = df["star_rating"].astype(float)
 
-# Text-to-Speech function
-def generate_speech(text):
-    tts = gTTS(text=text, lang='en')
-    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
-    tts.save(temp_file.name)
-    with open(temp_file.name, "rb") as audio_file:
-        encoded_audio = base64.b64encode(audio_file.read()).decode("utf-8")
-    os.unlink(temp_file.name)
-    return encoded_audio
+# Function to translate text
+def translate_text(text, target_lang="en"):
+    if target_lang == "en":
+        return text  # No translation needed for English
+    inputs = translate_tokenizer(text, return_tensors="pt", src_lang="en")
+    translated_tokens = translate_model.generate(**inputs, forced_bos_token_id=translate_tokenizer.get_lang_id(target_lang))
+    return translate_tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]
 
-# Chat Interface
-def chat_interface(user_input, audio_file=None):
-    if audio_file is not None:
-        user_input = transcribe_audio(audio_file)
+# Function to recommend products based on user input with filters
+def recommend_products(user_query, min_rating=3.5):
+    keywords = user_query.lower().split()
     
-    ai_response = chat_with_ai(user_input)
-    audio_response = generate_speech(ai_response)
+    # Filter based on keywords & minimum rating
+    recommended = df[(df["product_category"].str.lower().isin(keywords)) & (df["star_rating"] >= min_rating)]
     
-    return ai_response, f"data:audio/mp3;base64,{audio_response}"
+    if recommended.empty:
+        return "No recommendations found. Try searching for 'Electronics', 'Books', or 'Beauty products'."
+    
+    # Sort by highest rating
+    recommended = recommended.sort_values(by="star_rating", ascending=False).head(5)
+    
+    return recommended[["product_title", "star_rating"]].to_string(index=False)
 
-# Create Gradio UI
-gui = gr.Interface(
-    fn=chat_interface,
-    inputs=[
-        gr.Textbox(lines=2, placeholder="Type your message here..."),
-        gr.Audio(sources=["microphone", "upload"], type="filepath")
+# Chatbot Response Function with improved answers
+def chatbot_response(user_input, language="en", min_rating=3.5):
+    # Translate input if not in English
+    if language != "en":
+        user_input = translate_text(user_input, target_lang="en")
+    
+    # Generate chatbot response
+    inputs = tokenizer([user_input], return_tensors="pt")
+    reply_ids = chatbot_model.generate(**inputs, max_length=100)
+    response = tokenizer.decode(reply_ids[0], skip_special_tokens=True)
 
+    # Get product recommendations
+    recommendations = recommend_products(user_input, min_rating)
+
+    # Translate output if needed
+    if language != "en":
+        response = translate_text(response, target_lang=language)
+        recommendations = translate_text(recommendations, target_lang=language)
+    
+    return f"🤖 AI: {response}\n\n🔍 Recommended Products:\n{recommendations}"
+
+# Gradio UI with Filters & Multi-Language
+iface = gr.Interface(
+    fn=chatbot_response,
+    inputs=[
+        gr.Textbox(label="Ask me about products!"),
+        gr.Dropdown(["en", "es", "fr", "de", "hi"], label="Language", value="en"),  # Supports English, Spanish, French, German, Hindi
+        gr.Slider(1, 5, value=3.5, step=0.5, label="Minimum Star Rating")
     ],
-    outputs=[
-        gr.Textbox(label="AI Response"),
-        gr.Audio(label="AI Voice Response")
-    ],
-    title="AI Chat Assistant",
-    description="An AI-powered chat assistant with text & voice input/output.",
-    theme="huggingface"
+    outputs="text",
+    title="🛍️ AI Shopping Assistant",
+    description="Chat with an AI to get product recommendations with filters & multilingual support!",
+    theme="default"
 )
 
-gui.launch()
+# Launch the App
+iface.launch()