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()