Create app.py

app.py

@@ -0,0 +1,235 @@
+import gradio as gr
+import random
+from huggingface_hub import InferenceClient
+
+import pandas as pd
+
+from sentence_transformers import SentenceTransformer
+import torch
+
+# LOAD FILES
+
+def load_files(path):
+    with open(path, "r", encoding = "utf-8") as f:
+        return f.read()
+
+        
+charities_text = load_files("charities.txt")
+financial_advice_text = load_files("financial_advice.txt")
+
+
+# 
+
+### 
+def preprocess_text(text):
+    # Strip extra whitespace from the beginning and the end of the text
+    cleaned_text = text.strip()
+
+    # Split the cleaned_text by every newline character (\n)
+    chunks = cleaned_text.split("\n")
+
+    # Create an empty list to store cleaned chunks
+    cleaned_chunks = []
+
+    # Write your for-in loop below to clean each chunk and add it to the cleaned_chunks list
+    for chunk in chunks:
+        stripped_chunk = chunk.strip()
+        if len(stripped_chunk) > 0:
+            cleaned_chunks.append(stripped_chunk)
+
+    
+    # Print the length of cleaned_chunks
+    num_of_chunks = len(cleaned_chunks)
+   # print(num_of_chunks)
+
+ 
+    return cleaned_chunks
+
+cleaned_charities = preprocess_text(charities_text)
+cleaned_finance = preprocess_text(financial_advice_text)
+
+# Load the pre-trained embedding model that converts text to vectors
+model = SentenceTransformer('all-MiniLM-L6-v2')
+
+### STEP 4
+def create_embeddings(text_chunks):
+    # Convert each text chunk into a vector embedding and store as a tensor
+    chunk_embeddings = model.encode(text_chunks, convert_to_tensor=True) # Replace ... with the text_chunks list
+
+    # Print the chunk embeddings
+    print(chunk_embeddings)
+
+    # Print the shape of chunk_embeddings
+    print(chunk_embeddings.shape)
+
+    # Return the chunk_embeddings
+    return chunk_embeddings
+
+charity_embeddings = create_embeddings(cleaned_charities)
+finance_embeddings = create_embeddings(cleaned_finance)
+
+###STEP 5
+# Define a function to find the most relevant text chunks for a given query, chunk_embeddings, and text_chunks
+def get_top_chunks(query, chunk_embeddings, text_chunks):
+    # Convert the query text into a vector embedding
+    query_embedding = model.encode(query, convert_to_tensor = True) # Complete this line
+
+    # Normalize the query embedding to unit length for accurate similarity comparison
+    query_embedding_normalized = query_embedding / query_embedding.norm()
+
+    # Normalize all chunk embeddings to unit length for consistent comparison
+    chunk_embeddings_normalized = chunk_embeddings / chunk_embeddings.norm(dim=1, keepdim=True)
+
+    # Calculate cosine similarity between query and all chunks using matrix multiplication
+    similarities = torch.matmul(chunk_embeddings_normalized, query_embedding_normalized) # Complete this line
+
+   
+
+    # Find the indices of the 3 chunks with highest similarity scores
+    top_indices = torch.topk(similarities, k=3).indices
+
+    # Create an empty list to store the most relevant chunks
+    top_chunks = []
+
+    # Loop through the top indices and retrieve the corresponding text chunks
+    for i in top_indices:
+        relevant_info = text_chunks[i]
+        top_chunks.append(relevant_info)
+
+    # Return the list of most relevant chunks
+    return top_chunks
+
+#CSV files
+columns = ["TransactionID", "UserID", "Date", "Description", "Amount", "Type", "Extra1", "Extra2"]
+spendings = pd.read_csv("september_transactions_detailed.csv", names = columns)
+spendings['Amount'] = pd.to_numeric(spendings['Amount'], errors='coerce').fillna(0)
+
+def get_advice(user_id):
+    user_data = spendings[spendings['UserID'] == user_id]
+    
+    if user_data.empty:
+        return "No spending data found for this user."
+    
+    # Only consider expenses
+    expenses = user_data[user_data['Type'].str.lower() == "expense"]
+    total_spent = expenses['Amount'].sum()
+    category_spent = expenses.groupby('Description')['Amount'].sum().to_dict()
+    
+    advice = []
+    for cat, amt in category_spent.items():
+        if amt > total_spent * 0.3:
+            advice.append(f"You spend a lot on {cat}. Consider budgeting here.")
+    
+    advice_text = " | ".join(advice) if advice else "Your spending looks balanced across categories."
+    
+    summary_text = f"Total spent: ${total_spent:.2f}. Category breakdown: {category_spent}. Advice: {advice_text}"
+    
+    return summary_text
+    
+#AI API being used
+client= InferenceClient("openai/gpt-oss-20b")
+#defining role of AI and user
+
+information=""
+
+def respond(message, history, chatbot_topic_values, chatbot_mode_values, user_id=1):
+    topic_chunks = []
+    if chatbot_topic_values and "Helping Charities" in chatbot_topic_values:
+        topic_chunks = get_top_chunks(message, charity_embeddings, cleaned_charities)
+    elif chatbot_topic_values and "Financial Aid" in chatbot_topic_values:
+        topic_chunks = get_top_chunks(message, finance_embeddings, cleaned_finance)
+
+    csv_advice = get_advice(user_id)
+    
+    if chatbot_mode_values and "General Advice" in chatbot_mode_values:
+        role_message = (
+            "You are a helpful and insightful chatbot who acts like a financial "
+            "advisor of a university student. Respond in under five bullet points, "
+            f"under 500 characters, using this context: {topic_chunks}"
+        )
+    elif chatbot_mode_values and "Personal Advice" in chatbot_mode_values:
+        role_message = (
+            "You are a helpful and insightful chatbot who acts like a financial "
+            "DO NOT ask the user for additional numbers or input"
+            f"Use the following spending data from the CSV file to provide advice {csv_advice}"
+        )
+    else:
+        role_message = f"You are a helpful chatbot. Use this context: {topic_chunks}"
+    messages = [{"role": "assistant", "content": role_message}]
+    if history:
+        messages.extend(history)
+    messages.append({"role": "user", "content": message})
+
+    response = client.chat_completion(messages, temperature=0.2)
+    return response['choices'][0]['message']['content'].strip()
+
+
+### STEP 6
+# Call the preprocess_text function and store the result in a cleaned_chunks variable
+cleaned_chunks = preprocess_text(financial_advice_text) # Complete this line
+top_results = get_top_chunks("What financial advice you give me?", finance_embeddings, cleaned_finance) 
+
+
+#Defining chatbot giving user a UI to interact, see their conversation history, and see new messages using built in gr feature
+#ChatInterface requires at least one parameter(a function)
+chatbot = gr.ChatInterface(respond,type="messages", title="Finance Management Hub", theme="Taithrah/Minimal")
+
+def save_chat_history(history, username):
+            if not username:
+                username = "anonymous"
+            
+            timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+            filename = f"chat_history_{username}_{timestamp}.txt"
+            
+            with open(filename, "w", encoding="utf-8") as f:
+                f.write(f"Chat History for {username} - {timestamp}\n\n")
+                for exchange in history:
+                    if isinstance(exchange, tuple) and len(exchange) == 2:
+                        user_msg, bot_msg = exchange
+                        f.write(f"User: {user_msg}\n")
+                        f.write(f"Bot: {bot_msg}\n\n")
+                    elif isinstance(exchange, dict):
+                        # Handle dictionary format if needed
+                        role = exchange.get("role", "unknown")
+                        content = exchange.get("content", "")
+                        f.write(f"{role.capitalize()}: {content}\n\n")  
+
+            return filename
+
+with gr.Blocks(
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="fuchsia",
+        neutral_hue="gray",
+        text_size="lg",
+    
+    ).set(
+        background_fill_primary='*neutral_200',
+        background_fill_secondary='neutral_100',
+        background_fill_secondary_dark='secondary_500',
+        border_color_accent='*secondary_400',
+        border_color_accent_dark='*secondary_800',
+        color_accent='*secondary_600',
+        color_accent_soft='*secondary_200',
+        color_accent_soft_dark='*secondary_800',
+        button_primary_background_fill='*secondary_400',
+        button_primary_background_fill_dark='*secondary_600', 
+        button_primary_text_color='white', 
+        button_primary_border_color='*secondary_700',
+        button_primary_border_color_dark='*secondary_900'
+    )
+) as demo:
+        with gr.Row(scale=1):
+            chatbot_topic=gr.CheckboxGroup(["Helping Charities", "Financial Aid"], label="What would you like advice about?")
+        with gr.Row(scale=1):
+            chatbot_mode=gr.CheckboxGroup(["General Advice", "Personal Advice"], label="How would you like the chatbot to respond?")
+
+        gr.ChatInterface(
+            fn=lambda msg, hist, topic_vals, mode_vals: respond(msg, hist, topic_vals, mode_vals),
+            title="Finance Management Hub",
+            description="Ask about your personal finance",
+            type="messages",
+            additional_inputs=[chatbot_topic, chatbot_mode]
+    )
+#launching chatbot
+demo.launch()