Update finetuned_model.py

finetuned_model.py

@@ -1,920 +1,60 @@
-```python
-# app.py
-import logging
-import os
-import time
+from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
+from peft import LoraConfig, get_peft_model
+from trl import SFTTrainer
+from datasets import load_dataset
 import torch
-import gradio as gr
-from transformers import AutoModelForCausalLM, AutoTokenizer
-import pandas as pd
-import re
-import numpy as np
-import json
-import difflib
-from difflib import SequenceMatcher
-from datetime import datetime
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-logger = logging.getLogger(__name__)
-
-# Define device
-device = torch.device("cpu")  # Explicitly set to CPU for HF free tier
-logger.info(f"Using device: {device}")
-
-# Load dataset
-csv_path = "stock_data.csv"
-try:
-    df = pd.read_csv(csv_path)
-    df['Date'] = pd.to_datetime(df['Date'])
-    df = df.sort_values('Date')
-    logger.info("Loaded dataset successfully")
-except Exception as e:
-    logger.error(f"Error loading dataset: {e}")
-    df = None
-
-# Precompute yearly aggregates
-STOCK_SYMBOLS = ["TSLA", "MSFT", "NVDA", "GOOG", "AMZN", "SPY"]
-if df is not None:
-    df_yearly = df.groupby(df['Date'].dt.year).agg({
-        **{f'Price_{symbol}': 'mean' for symbol in STOCK_SYMBOLS},
-        **{f'Return_{symbol}': 'mean' for symbol in STOCK_SYMBOLS},
-        **{f'Real_Return_{symbol}': 'mean' for symbol in STOCK_SYMBOLS},
-        **{f'Dividend_{symbol}': 'mean' for symbol in STOCK_SYMBOLS},
-        **{f'Earnings_{symbol}': 'mean' for symbol in STOCK_SYMBOLS},
-        **{f'PE10_{symbol}': 'mean' for symbol in STOCK_SYMBOLS}
-    }).reset_index()
-    df_yearly = df_yearly.rename(columns={'Date': 'Year'})
-else:
-    df_yearly = None
-
-# Symbol mapping for natural language queries
-symbol_map = {
-    "tesla": "TSLA",
-    "microsoft": "MSFT",
-    "nvidia": "NVDA",
-    "google": "GOOG",
-    "alphabet": "GOOG",
-    "amazon": "AMZN",
-    "s&p 500": "SPY",
-    "spy": "SPY"
-}
-
-# Response cache
-response_cache = {
-    "hi": "Hello! I'm FinChat, your financial advisor. How can I help with investing?",
-    "hello": "Hello! I'm FinChat, your financial advisor. How can I help with investing?",
-    "hey": "Hi there! Ready to discuss investment goals with FinChat?",
-    "what is better individual stocks or etfs?": (
-        "Here’s a comparison of individual stocks vs. ETFs:\n"
-        "1. **Individual Stocks**: High returns possible (e.g., TSLA up ~743% in 2020) but riskier due to lack of diversification. Require active research.\n"
-        "2. **ETFs**: Diversify risk by tracking indices (e.g., SPY, S&P 500, ~12% avg. return 2015–2024). Lower fees and less research needed.\n"
-        "3. **Recommendation**: Beginners should start with ETFs; experienced investors may add stocks like MSFT or AMZN.\n"
-        "Consult a financial planner."
-    ),
-    "is $100 per month enough to invest?": (
-        "Yes, $100 per month is enough to start investing. Here’s why and how:\n"
-        "1. **Feasibility**: Brokerages like Fidelity have no minimums, and commission-free trading eliminates fees.\n"
-        "2. **Options**: Buy fractional shares of ETFs (e.g., SPY, ~$622/share in 2025) or stocks like AMZN with $100.\n"
-        "3. **Strategy**: Use dollar-cost averaging to invest monthly, reducing market timing risks.\n"
-        "4. **Growth**: At 10% annual return, $100 monthly could grow to ~$41,000 in 20 years.\n"
-        "5. **Tips**: Ensure an emergency fund; diversify.\n"
-        "Consult a financial planner."
-    ),
-    "can i invest $100 a month?": (
-        "Yes, $100 a month is sufficient. Here’s how:\n"
-        "1. **Brokerage**: Open an account with Fidelity or Vanguard (no minimums).\n"
-        "2. **Investments**: Buy fractional shares of ETFs like SPY ($100 buys ~0.16 shares in 2025) or stocks like GOOG.\n"
-        "3. **Approach**: Use dollar-cost averaging for steady growth.\n"
-        "4. **Long-Term**: At 10% return, $100 monthly could reach ~$41,000 in 20 years.\n"
-        "5. **Tips**: Prioritize an emergency fund and diversify.\n"
-        "Consult a financial planner."
-    ),
-    "hi, give me step-by-step investing advice": (
-        "Here’s a step-by-step guide to start investing:\n"
-        "1. Open a brokerage account (e.g., Fidelity, Vanguard) if 18 or older.\n"
-        "2. Deposit an affordable amount, like $100, after an emergency fund.\n"
-        "3. Research and buy an ETF (e.g., SPY) or stock (e.g., MSFT) using Yahoo Finance.\n"
-        "4. Monitor monthly and enable dividend reinvesting.\n"
-        "5. Use dollar-cost averaging ($100 monthly) to reduce risk.\n"
-        "6. Diversify across sectors.\n"
-        "Consult a financial planner."
-    ),
-    "hi, pretend you are a financial advisor. now tell me how can i start investing in stock market?": (
-        "Here’s a guide to start investing:\n"
-        "1. Learn from Investopedia or 'The Intelligent Investor.'\n"
-        "2. Set goals (e.g., retirement) and assess risk.\n"
-        "3. Choose a brokerage (Fidelity, Vanguard).\n"
-        "4. Start with ETFs (e.g., SPY) or stocks (e.g., NVDA).\n"
-        "5. Use dollar-cost averaging ($100-$500 monthly).\n"
-        "6. Diversify and monitor.\n"
-        "Consult a financial planner."
-    ),
-    "do you have a list of companies you recommend?": (
-        "I can’t recommend specific companies without real-time data. Try ETFs like SPY (S&P 500, ~12% avg. return 2015–2024) or QQQ (Nasdaq-100). "
-        "Research stocks like MSFT (~26% avg. return 2015–2024) or AMZN on Yahoo Finance.\n"
-        "Consult a financial planner."
-    ),
-    "how do i start investing in stocks?": (
-        "Learn from Investopedia. Set goals and assess risk. Open a brokerage account (Fidelity, Vanguard) "
-        "and start with ETFs (e.g., SPY, ~12% avg. return 2015–2024) or stocks like GOOG. Consult a financial planner."
-    ),
-    "what's the difference between stocks and bonds?": (
-        "Stocks are company ownership with high risk and growth potential (e.g., TSLA ~743% in 2020). Bonds are loans to companies/governments "
-        "with lower risk and steady interest. Diversify for balance."
-    ),
-    "how much should i invest?": (
-        "Invest what you can afford after expenses and an emergency fund. Start with $100-$500 monthly "
-        "in ETFs like SPY (~12% avg. return 2015–2024) or stocks like NVDA. Consult a financial planner."
-    ),
-    "what is dollar-cost averaging?": (
-        "Dollar-cost averaging is investing a fixed amount regularly (e.g., $100 monthly) in ETFs like SPY or stocks like AMZN, "
-        "reducing risk by spreading purchases over time."
-    ),
-    "give me few investing idea": (
-        "Here are investing ideas:\n"
-        "1. Open a brokerage account (e.g., Fidelity) if 18 or older.\n"
-        "2. Deposit $100 or what you can afford.\n"
-        "3. Buy a researched ETF (e.g., SPY, ~12% avg. return 2015–2024) or stock (e.g., MSFT).\n"
-        "4. Check regularly and enable dividend reinvesting.\n"
-        "5. Use dollar-cost averaging (e.g., monthly buys).\n"
-        "Consult a financial planner."
-    ),
-    "give me investing tips": (
-        "Here are investing tips:\n"
-        "1. Educate yourself with Investopedia or books.\n"
-        "2. Open a brokerage account (e.g., Vanguard).\n"
-        "3. Start small with ETFs like SPY (~12% avg. return 2015–2024) or stocks like GOOG.\n"
-        "4. Invest regularly using dollar-cost averaging.\n"
-        "5. Diversify to manage risk.\n"
-        "Consult a financial planner."
-    ),
-    "how to start investing": (
-        "Here’s how to start investing:\n"
-        "1. Study basics on Investopedia.\n"
-        "2. Open a brokerage account (e.g., Fidelity).\n"
-        "3. Deposit $100 or more after securing savings.\n"
-        "4. Buy an ETF like SPY (~12% avg. return 2015–2024) or stock like AMZN after research.\n"
-        "5. Invest monthly with dollar-cost averaging.\n"
-        "Consult a financial planner."
-    ),
-    "investing advice": (
-        "Here’s investing advice:\n"
-        "1. Learn basics from Investopedia.\n"
-        "2. Open a brokerage account (e.g., Vanguard).\n"
-        "3. Start with $100 in an ETF like SPY (~12% avg. return 2015–2024) or stock like NVDA.\n"
-        "4. Use dollar-cost averaging for regular investments.\n"
-        "5. Monitor and diversify your portfolio.\n"
-        "Consult a financial planner."
-    ),
-    "steps to invest": (
-        "Here are steps to invest:\n"
-        "1. Educate yourself using Investopedia.\n"
-        "2. Open a brokerage account (e.g., Fidelity).\n"
-        "3. Deposit an initial $100 after savings.\n"
-        "4. Buy an ETF like SPY (~12% avg. return 2015–2024) or stock like MSFT after research.\n"
-        "5. Use dollar-cost averaging monthly.\n"
-        "Consult a financial planner."
-    ),
-    "what is the average growth rate for stocks?": (
-        "The average annual return for individual stocks varies widely, but broad market indices like the S&P 500 average 10–12% over the long term (1927–2025), including dividends. "
-        "Specific stocks like TSLA or NVDA may have higher volatility and returns. Consult a financial planner."
-    )
-}
-
-# Load persistent cache
-cache_file = "cache.json"
-try:
-    if os.path.exists(cache_file):
-        with open(cache_file, 'r') as f:
-            response_cache.update(json.load(f))
-        logger.info("Loaded persistent cache from cache.json")
-except Exception as e:
-    logger.warning(f"Failed to load cache.json: {e}")
 
 # Load model and tokenizer
-model_name = "./finetuned_model" if os.path.exists("./finetuned_model") else "distilgpt2"
-try:
-    logger.info(f"Loading tokenizer for {model_name}")
-    tokenizer = AutoTokenizer.from_pretrained(model_name, clean_up_tokenization_spaces=False)
-    tokenizer.pad_token = tokenizer.eos_token if tokenizer.pad_token is None else tokenizer.pad_token
-    logger.info(f"Loading model {model_name}")
-    model = AutoModelForCausalLM.from_pretrained(
-        model_name,
-        torch_dtype=torch.float32,  # Changed to float32 to avoid Half/Float mismatch
-        low_cpu_mem_usage=True
-    ).to(device)
-    logger.info(f"Successfully loaded model: {model_name}")
-except Exception as e:
-    logger.error(f"Error loading model/tokenizer: {e}")
-    raise RuntimeError(f"Failed to load model: {str(e)}")
-
-# Shortened prompt prefix for faster processing
-prompt_prefix = (
-    "You are FinChat, a financial advisor. Use provided data for historical returns and calculate accurately. Provide detailed advice with reasoning. Use compound calculations for returns. Avoid invented facts. Keep responses under 100 words.\n\n"
-    "Example:\n"
-    "Q: What was MSFT return 2010-2020?\n"
-    "A: MSFT CAGR ~16.8% from 2010-2020, including dividends. Tech growth drove this; dividends added to totals.\n\n"
-    "Q: "
+model_name = "HuggingFaceTB/SmolLM3-3B"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    device_map="auto",
+    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
 )
-prefix_tokens = tokenizer(prompt_prefix, return_tensors="pt", truncation=True, max_length=512).to(device)
-
-# Substring matching for cache with enhanced fuzzy matching
-def get_closest_cache_key(message, cache_keys):
-    message = re.sub(r'[^\w\s]', '', message.lower().strip())  # Remove punctuation and normalize
-    ratios = {k: SequenceMatcher(None, message, k).ratio() for k in cache_keys}
-    max_ratio = max(ratios.values())
-    if max_ratio >= 0.7:
-        return max(ratios, key=ratios.get)
-    return None
-
-# Parse period from user input with expanded regex for better coverage
-def parse_period(query):
-    query = query.lower()
-    # Match symbol with mapping
-    symbol_match = re.search(r'(tsla|msft|nvda|goog|amzn|s&p\s*500|tesla|microsoft|nvidia|google|alphabet|amazon|spy)', query)
-    symbol_key = symbol_match.group(1) if symbol_match else "spy"
-    symbol = symbol_map.get(symbol_key, symbol_key.upper())
-    if symbol == "S&P 500":
-        symbol = "SPY"
-    # Match specific year ranges (e.g., "between 2015 and 2020", "from 2010 to 2020", "over 2010-2020")
-    match = re.search(r'(?:average|growth|performance|return).*?(?:between|from|over|for|through)\s*(\d{4})\s*(?:and|to|-|–|through)\s*(\d{4})', query)
-    if match:
-        start_year, end_year = map(int, match.groups())
-        if start_year <= end_year:
-            return start_year, end_year, None, symbol
-    # Match duration-based queries (e.g., "5-year from 2020", "7-year growth rate from 2018")
-    match = re.search(r'(\d+)-year.*from\s*(\d{4})', query)
-    if match:
-        duration, start_year = map(int, match.groups())
-        end_year = start_year + duration - 1
-        return start_year, end_year, duration, symbol
-    # Match past/last X years (e.g., "past 5 years", "last 7 years return", "over the last 5 years")
-    match = re.search(r'(?:past|last|over\s*the\s*last)\s*(\d+)\s*(?:year|years).*?(?:return|growth|performance)?', query)
-    if match:
-        duration = int(match.group(1))
-        max_year = datetime.now().year
-        start_year = max_year - duration + 1
-        end_year = max_year
-        return start_year, end_year, duration, symbol
-    # Match single year (e.g., "return in 2020", "performance for 2019")
-    match = re.search(r'(?:return|performance)\s*(?:in|for)\s*(\d{4})', query)
-    if match:
-        year = int(match.group(1))
-        return year, year, 1, symbol
-    return None, None, None, symbol
-
-# Calculate average growth rate using CAGR
-def calculate_growth_rate(start_year, end_year, duration=None, symbol="SPY"):
-    if df is None or start_year is None or end_year is None:
-        return None, "Data not available or invalid period."
-    df_period = df[(df['Date'].dt.year >= start_year) & (df['Date'].dt.year <= end_year)]
-    if df_period.empty:
-        return None, f"No data available for {symbol} from {start_year} to {end_year}."
-    initial_price = df_period[df_period['Date'].dt.year == start_year][f'Price_{symbol}'].mean()
-    final_price = df_period[df_period['Date'].dt.year == end_year][f'Price_{symbol}'].mean()
-    avg_dividend = df_period[f'Dividend_{symbol}'].mean()
-    avg_real_return = df_period[f"Real_Return_{symbol}"].mean()
-    if np.isnan(initial_price) or np.isnan(final_price) or initial_price == 0:
-        return None, f"Insufficient data for {symbol} from {start_year} to {end_year}."
-    num_years = end_year - start_year + 1
-    cagr = ((final_price / initial_price) ** (1 / num_years) - 1) * 100
-    symbol_name = "S&P 500" if symbol == "SPY" else symbol
-    if duration == 1 and start_year == end_year:
-        response = f"The {symbol_name} returned approximately {cagr:.1f}% in {start_year}, including dividends. Inflation-adjusted real return averaged {avg_real_return:.1f}%. Dividends contributed {avg_dividend:.1f}% to total returns."
-    elif duration:
-        response = f"The {symbol_name} {duration}-year compounded annual growth rate (CAGR) from {start_year} to {end_year} was approximately {cagr:.1f}%, including dividends. Inflation-adjusted real return averaged {avg_real_return:.1f}%. Dividends contributed {avg_dividend:.1f}% to total returns."
-    else:
-        response = f"The {symbol_name} compounded annual growth rate (CAGR) from {start_year} to {end_year} was approximately {cagr:.1f}%, including dividends. Inflation-adjusted real return averaged {avg_real_return:.1f}%. Dividends contributed {avg_dividend:.1f}% to total returns."
-    return cagr, response
-
-# Parse investment return query
-def parse_investment_query(query):
-    match = re.search(r'\$(\d+).*\s(\d+)\s*years?.*\b(tsla|msft|nvda|goog|amzn|s&p\s*500)\b', query, re.IGNORECASE)
-    if match:
-        amount = float(match.group(1))
-        years = int(match.group(2))
-        symbol = match.group(3).upper()
-        if symbol == "S&P 500":
-            symbol = "SPY"
-        return amount, years, symbol
-    return None, None, None
-
-# Calculate future value
-def calculate_future_value(amount, years, symbol):
-    if df_yearly is None or amount is None or years is None:
-        return None, "Data not available or invalid input."
-    avg_annual_return = 10.0
-    future_value = amount * (1 + avg_annual_return / 100) ** years
-    symbol_name = "S&P 500" if symbol == "SPY" else symbol
-    return future_value, (
-        f"Assuming a 10% average annual return, a ${amount:,.0f} investment in {symbol_name} would grow to approximately ${future_value:,.0f} "
-        f"in {years} years with annual compounding. This is based on the historical average return of 10–12% for stocks. "
-        "Future returns vary and are not guaranteed. Consult a financial planner."
-    )
-
-# Chat function
-def chat_with_model(user_input, history=None, is_processing=False):
-    try:
-        start_time = time.time()
-        logger.info(f"Processing user input: {user_input}")
-        is_processing = True
-        logger.info("Showing loading animation")
-
-        # Normalize and check cache
-        cache_key = re.sub(r'[^\w\s]', '', user_input.lower().strip())  # Normalize for cache
-        cache_keys = list(response_cache.keys())
-        closest_key = cache_key if cache_key in response_cache else get_closest_cache_key(cache_key, cache_keys)
-        if closest_key:
-            logger.info(f"Cache hit for: {closest_key}")
-            response = response_cache[closest_key]
-            logger.info(f"Chatbot response: {response}")
-            history = history or []
-            history.append({"role": "user", "content": user_input})
-            history.append({"role": "assistant", "content": response})
-            end_time = time.time()
-            logger.info(f"Response time: {end_time - start_time:.2f} seconds")
-            return response, history, False, ""
-
-        # Check for investment return query
-        amount, years, symbol = parse_investment_query(user_input)
-        if amount and years:
-            future_value, response = calculate_future_value(amount, years, symbol)
-            if future_value is not None:
-                response_cache[cache_key] = response
-                logger.info(f"Investment query: ${amount} for {years} years in {symbol}, added to cache")
-                logger.info(f"Chatbot response: {response}")
-                history = history or []
-                history.append({"role": "user", "content": user_input})
-                history.append({"role": "assistant", "content": response})
-                end_time = time.time()
-                logger.info(f"Response time: {end_time - start_time:.2f} seconds")
-                return response, history, False, ""
-
-        # Check for period-specific query
-        start_year, end_year, duration, symbol = parse_period(user_input)
-        if start_year and end_year:
-            avg_return, response = calculate_growth_rate(start_year, end_year, duration, symbol)
-            if avg_return is not None:
-                response_cache[cache_key] = response
-                logger.info(f"Dynamic period query for {symbol}: {start_year}–{end_year}, added to cache")
-                logger.info(f"Chatbot response: {response}")
-                history = history or []
-                history.append({"role": "user", "content": user_input})
-                history.append({"role": "assistant", "content": response})
-                end_time = time.time()
-                logger.info(f"Response time: {end_time - start_time:.2f} seconds")
-                return response, history, False, ""
-
-        # Handle short prompts
-        if len(user_input.strip()) <= 5:
-            logger.info("Short prompt, returning default response")
-            response = "Hello! I'm FinChat, your financial advisor. Ask about investing in TSLA, MSFT, NVDA, GOOG, AMZN, or S&P 500!"
-            logger.info(f"Chatbot response: {response}")
-            history = history or []
-            history.append({"role": "user", "content": user_input})
-            history.append({"role": "assistant", "content": response})
-            end_time = time.time()
-            logger.info(f"Response time: {end_time - start_time:.2f} seconds")
-            return response, history, False, ""
-
-        # Construct and generate response
-        full_prompt = prompt_prefix + user_input + "\nA:"
-        try:
-            inputs = tokenizer(full_prompt, return_tensors="pt", truncation=True, max_length=512).to(device)
-        except Exception as e:
-            logger.error(f"Error tokenizing input: {e}")
-            response = f"Error: Failed to process input: {str(e)}"
-            logger.info(f"Chatbot response: {response}")
-            history = history or []
-            history.append({"role": "user", "content": user_input})
-            history.append({"role": "assistant", "content": response})
-            end_time = time.time()
-            logger.info(f"Response time: {end_time - start_time:.2f} seconds")
-            return response, history, False, ""
-
-        with torch.inference_mode():
-            logger.info("Generating response with model")
-            gen_start_time = time.time()
-            outputs = model.generate(
-                **inputs,
-                max_new_tokens=15,  # Further reduced for speed
-                do_sample=False,
-                repetition_penalty=2.0,
-                pad_token_id=tokenizer.eos_token_id
-                # Removed num_beams for faster greedy decoding
-            )
-            gen_end_time = time.time()
-            logger.info(f"Generation time: {gen_end_time - gen_start_time:.2f} seconds")
-        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        response = response[len(full_prompt):].strip() if response.startswith(full_prompt) else response
-        response = response[:response.rfind('.') + 1] if len(response.split()) > 100 else response  # Truncate if over 100 words
-        logger.info(f"Chatbot response: {response}")
-
-        # Update cache
-        response_cache[cache_key] = response
-        logger.info("Cache miss, added to in-memory cache")
-
-        # Update history
-        history = history or []
-        history.append({"role": "user", "content": user_input})
-        history.append({"role": "assistant", "content": response})
-        torch.cuda.empty_cache()  # Though on CPU, harmless
-        end_time = time.time()
-        logger.info(f"Response time: {end_time - start_time:.2f} seconds")
-        return response, history, False, ""
-
-    except Exception as e:
-        logger.error(f"Error generating response: {e}")
-        response = f"Error: {str(e)}"
-        logger.info(f"Chatbot response: {response}")
-        history = history or []
-        history.append({"role": "user", "content": user_input})
-        history.append({"role": "assistant", "content": response})
-        end_time = time.time()
-        logger.info(f"Response time: {end_time - start_time:.2f} seconds")
-        return response, history, False, ""
-
-# Save cache
-def save_cache():
-    try:
-        with open(cache_file, 'w') as f:
-            json.dump(response_cache, f, indent=2)
-        logger.info("Saved cache to cache.json")
-    except Exception as e:
-        logger.warning(f"Failed to save cache.json: {e}")
-
-# Gradio interface
-logger.info("Initializing Gradio interface")
-try:
-    with gr.Blocks(
-        title="FinChat: An LLM based on distilgpt2 model",
-        css="""
-        .loader {
-            border: 5px solid #f3f3f3;
-            border-top: 5px solid #3498db;
-            border-radius: 50%;
-            width: 30px;
-            height: 30px;
-            animation: spin 1s linear infinite;
-            margin: 10px auto;
-            display: block;
-        }
-        @keyframes spin {
-            0% { transform: rotate(0deg); }
-            100% { transform: rotate(360deg); }
-        }
-        .hidden { display: none; }
-        """
-    ) as interface:
-        gr.Markdown(
-            """
-            # FinChat: An LLM based on distilgpt2 model
-            FinChat provides financial advice using the lightweight distilgpt2 model, optimized for fast, detailed responses.
-            Ask about investing strategies, ETFs, or stocks like TSLA, MSFT, NVDA, GOOG, AMZN, or S&P 500 to get started!
-            """
-        )
-        chatbot = gr.Chatbot(type="messages")
-        msg = gr.Textbox(label="Your message")
-        submit = gr.Button("Send")
-        clear = gr.Button("Clear")
-        loading = gr.HTML('<div class="loader hidden"></div>', label="Loading")
-        is_processing = gr.State(value=False)
-
-        def submit_message(user_input, history, is_processing):
-            response, updated_history, new_processing, clear_input = chat_with_model(user_input, history, is_processing)
-            loader_html = '<div class="loader"></div>' if new_processing else '<div class="loader hidden"></div>'
-            return clear_input, updated_history, loader_html, new_processing
-
-        submit.click(
-            fn=submit_message,
-            inputs=[msg, chatbot, is_processing],
-            outputs=[msg, chatbot, loading, is_processing]
-        )
-        clear.click(
-            fn=lambda: ("", [], '<div class="loader hidden"></div>', False),
-            outputs=[msg, chatbot, loading, is_processing]
-        )
-    logger.info("Gradio interface initialized successfully")
-except Exception as e:
-    logger.error(f"Error initializing Gradio interface: {e}")
-    raise
 
-# Launch interface
-if __name__ == "__main__" and not os.getenv("HF_SPACE"):
-    logger.info("Launching Gradio interface locally")
-    try:
-        interface.launch(share=False, debug=True)
-    except Exception as e:
-        logger.error(f"Error launching interface: {e}")
-        raise
-    finally:
-        save_cache()
-else:
-    logger.info("Running in Hugging Face Spaces, interface defined but not launched")
-    import atexit
-    atexit.register(save_cache)
-```
-
-```python
-# finetuned_model.py
-import pandas as pd
-import yfinance as yf
-import requests
-from fredapi import Fred
-from datetime import datetime, timedelta
-import numpy as np
-import json
-from datasets import Dataset
-from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer
-import torch
-import logging
-import itertools
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-logger = logging.getLogger(__name__)
-
-# Configuration
-STOCK_SYMBOLS = ["TSLA", "MSFT", "NVDA", "GOOG", "AMZN", "SPY"]
-START_DATE = "2010-01-01"  # Expanded range
-END_DATE = datetime.now().strftime("%Y-%m-%d")  # Use current date
-FRED_API_KEY = "your_fred_api_key"  # Replace with your FRED API key
-OUTPUT_CSV = "stock_data.csv"
-MODEL_NAME = "distilgpt2"
-OUTPUT_DIR = "./finetuned_model"
-CACHE_FILE = "cache.json"  # Save QA pairs to cache for faster responses
-
-# Initialize FRED API
-try:
-    fred = Fred(api_key=FRED_API_KEY)
-    logger.info("Initialized FRED API")
-except Exception as e:
-    logger.error(f"Error initializing FRED API: {e}")
-    fred = None
-
-def fetch_cpi_data():
-    """Fetch CPI data from FRED for inflation adjustment."""
-    if fred is None:
-        logger.warning("FRED API not available; skipping CPI data")
-        return None
-    try:
-        cpi = fred.get_series("CPIAUCSL", start_date=START_DATE, end_date=END_DATE)
-        cpi = cpi.resample("M").last().ffill()
-        cpi_df = pd.DataFrame(cpi, columns=["CPI"])
-        cpi_df.index.name = "Date"
-        return cpi_df
-    except Exception as e:
-        logger.error(f"Error fetching CPI data: {e}")
-        return None
-
-def fetch_stock_data(symbol):
-    """Fetch historical price, dividend, and earnings data using yfinance."""
-    try:
-        ticker = yf.Ticker(symbol)
-        df = ticker.history(start=START_DATE, end=END_DATE, interval="1mo")
-        if df.empty:
-            raise ValueError(f"No data returned for {symbol}")
-        
-        df = df[["Close", "Dividends"]].copy()
-        df.rename(columns={"Close": f"Price_{symbol}", "Dividends": f"Dividend_{symbol}"}, inplace=True)
-        df.index = pd.to_datetime(df.index)
-        
-        try:
-            earnings = ticker.financials.loc["Net Income"].mean() / ticker.info.get("sharesOutstanding", 1)
-            df[f"Earnings_{symbol}"] = earnings
-        except Exception:
-            logger.warning(f"Earnings data unavailable for {symbol}; setting to 0")
-            df[f"Earnings_{symbol}"] = 0.0
-        
-        return df
-    except Exception as e:
-        logger.error(f"Error fetching stock data for {symbol}: {e}")
-        return None
-
-def calculate_pe10(price, earnings):
-    """Calculate PE10 (CAPE) ratio using price and average earnings."""
-    if earnings == 0:
-        return 0.0
-    try:
-        pe10 = price / earnings if earnings > 0 else 0.0
-        return pe10
-    except Exception as e:
-        logger.warning(f"Error calculating PE10: {e}")
-        return 0.0
-
-def adjust_for_inflation(df, cpi_df, symbol):
-    """Adjust prices for inflation using CPI data."""
-    if cpi_df is None:
-        logger.warning(f"CPI data unavailable for {symbol}; Real Price set to Price")
-        df[f"Real_Price_{symbol}"] = df[f"Price_{symbol}"]
-        return df
-    
-    try:
-        cpi_df = cpi_df.reindex(df.index, method="ffill")
-        latest_cpi = cpi_df["CPI"].iloc[-1]
-        df[f"Real_Price_{symbol}"] = df[f"Price_{symbol}"] * (latest_cpi / cpi_df["CPI"])
-        return df
-    except Exception as e:
-        logger.error(f"Error adjusting for inflation for {symbol}: {e}")
-        df[f"Real_Price_{symbol}"] = df[f"Price_{symbol}"]
-        return df
-
-def create_dataset(symbols):
-    """Create a combined dataset for all specified stocks/indices."""
-    cpi_df = fetch_cpi_data()
-    all_dfs = []
-    
-    for symbol in symbols:
-        logger.info(f"Fetching data for {symbol}")
-        df = fetch_stock_data(symbol)
-        if df is None or df.empty:
-            logger.error(f"Skipping {symbol} due to data fetch failure")
-            continue
-        
-        df = adjust_for_inflation(df, cpi_df, symbol)
-        df[f"Return_{symbol}"] = df[f"Price_{symbol}"].pct_change(12) * 100
-        df[f"Real_Return_{symbol}"] = df[f"Real_Price_{symbol}"].pct_change(12) * 100
-        df[f"PE10_{symbol}"] = df.apply(lambda row: calculate_pe10(row[f"Price_{symbol}"], row[f"Earnings_{symbol}"]), axis=1)
-        
-        df[[f"Return_{symbol}", f"Real_Return_{symbol}", f"Dividend_{symbol}", f"Earnings_{symbol}", f"PE10_{symbol}"]] = \
-            df[[f"Return_{symbol}", f"Real_Return_{symbol}", f"Dividend_{symbol}", f"Earnings_{symbol}", f"PE10_{symbol}"]].fillna(0.0)
-        
-        all_dfs.append(df)
-    
-    if not all_dfs:
-        logger.error("No data fetched for any symbol")
-        return None
-    
-    combined_df = all_dfs[0]
-    for df in all_dfs[1:]:
-        combined_df = combined_df.join(df, how="outer")
-    
-    combined_df.reset_index(inplace=True)
-    return combined_df
-
-def save_dataset(df, output_path):
-    """Save dataset to CSV."""
-    if df is not None:
-        try:
-            df.to_csv(output_path, index=False)
-            logger.info(f"Dataset saved to {output_path}")
-        except Exception as e:
-            logger.error(f"Error saving dataset: {e}")
-
-# Step 1: Create and Save Dataset
-logger.info(f"Creating dataset for {STOCK_SYMBOLS}")
-df = create_dataset(STOCK_SYMBOLS)
-if df is None:
-    logger.error("Dataset creation failed")
-    exit()
-save_dataset(df, OUTPUT_CSV)
-
-# Step 2: Preprocess Dataset for Training
-df['Date'] = pd.to_datetime(df['Date'])
-df_yearly = df.groupby(df['Date'].dt.year).mean().reset_index()
-df_yearly = df_yearly.rename(columns={'Date': 'Year'})
-
-# Step 3: Create Question-Answer Pairs with enhancements
-qa_pairs = []
-years = df_yearly['Year'].unique()
-min_year = int(years.min())
-max_year = int(years.max())
-
-for symbol in STOCK_SYMBOLS:
-    for _, row in df_yearly.iterrows():
-        year = int(row['Year'])
-        price = row.get(f"Price_{symbol}", 0.0)
-        dividend = row.get(f"Dividend_{symbol}", 0.0)
-        earnings = row.get(f"Earnings_{symbol}", 0.0)
-        return_val = row.get(f"Return_{symbol}", 0.0)
-        real_return = row.get(f"Real_Return_{symbol}", 0.0)
-        pe10 = row.get(f"PE10_{symbol}", 0.0)
-        
-        symbol_name = "S&P 500" if symbol == "SPY" else symbol
-        
-        qa_pairs.append({
-            "question": f"What was the {symbol_name} return in {year}?",
-            "answer": f"The {symbol_name} returned approximately {return_val:.1f}% in {year}, including dividends."
-        })
-        qa_pairs.append({
-            "question": f"What was the {symbol_name} price in {year}?",
-            "answer": f"The {symbol_name} averaged approximately {price:.2f} in {year}."
-        })
-        qa_pairs.append({
-            "question": f"What was the {symbol_name} real return in {year}?",
-            "answer": f"The {symbol_name} inflation-adjusted return was approximately {real_return:.1f}% in {year}."
-        })
-        if dividend > 0:
-            qa_pairs.append({
-                "question": f"What was the {symbol_name} dividend in {year}?",
-                "answer": f"The {symbol_name} dividend was approximately {dividend:.2f} in {year}."
-            })
-        if earnings > 0:
-            qa_pairs.append({
-                "question": f"What were the {symbol_name} earnings in {year}?",
-                "answer": f"The {symbol_name} earnings were approximately {earnings:.2f} in {year}."
-            })
-        if pe10 > 0:
-            qa_pairs.append({
-                "question": f"What was the {symbol_name} PE10 ratio in {year}?",
-                "answer": f"The {symbol_name} PE10 ratio was approximately {pe10:.2f} in {year}."
-            })
-        qa_pairs.append({
-            "summary": f"In {year}, the {symbol_name} averaged {price:.2f} with a {return_val:.1f}% annual return and a {real_return:.1f}% real return."
-        })
-
-    # Period-specific questions with CAGR
-    for start_year, end_year in itertools.combinations(years, 2):
-        if start_year < end_year:
-            df_period = df_yearly[(df_yearly['Year'] >= start_year) & (df_yearly['Year'] <= end_year)]
-            if not df_period.empty:
-                initial_price = df_period[df_period['Year'] == start_year][f'Price_{symbol}'].mean()
-                final_price = df_period[df_period['Year'] == end_year][f'Price_{symbol}'].mean()
-                num_years = end_year - start_year + 1
-                cagr = ((final_price / initial_price) ** (1 / num_years) - 1) * 100 if initial_price > 0 else 0.0
-                avg_real_return = df_period[f"Real_Return_{symbol}"].mean()
-                qa_pairs.append({
-                    "question": f"What was the average annual growth rate of {symbol_name} between {start_year} and {end_year}?",
-                    "answer": f"The {symbol_name} compounded annual growth rate (CAGR) from {start_year} to {end_year} was approximately {cagr:.1f}%, including dividends. This accounts for compounding, unlike simple averages, and includes market volatility risks."
-                })
-                qa_pairs.append({
-                    "question": f"What was the average annual return of {symbol_name} between {start_year} and {end_year}?",
-                    "answer": f"The {symbol_name} compounded annual growth rate (CAGR) from {start_year} to {end_year} was approximately {cagr:.1f}%, including dividends."
-                })
-                qa_pairs.append({
-                    "question": f"What was the {symbol_name} real return between {start_year} and {end_year}?",
-                    "answer": f"The {symbol_name} average annual inflation-adjusted return from {start_year} to {end_year} was approximately {avg_real_return:.1f}%."
-                })
-                qa_pairs.append({
-                    "question": f"What was the {num_years}-year average annual growth rate of {symbol_name} from {start_year}?",
-                    "answer": f"The {symbol_name} {num_years}-year compounded annual growth rate (CAGR) from {start_year} to {end_year} was approximately {cagr:.1f}%, including dividends."
-                })
-                qa_pairs.append({
-                    "question": f"What was the inflation-adjusted return for {symbol_name} from {start_year} to {end_year}?",
-                    "answer": f"The {symbol_name} average annual inflation-adjusted return from {start_year} to {end_year} was approximately {avg_real_return:.1f}%. This matters in high-inflation periods to reflect true purchasing power."
-                })
-                qa_pairs.append({
-                    "question": f"Explain the return for {symbol_name} between {start_year} and {end_year}",
-                    "answer": f"The {symbol_name} compounded annual growth rate (CAGR) from {start_year} to {end_year} was approximately {cagr:.1f}%, including dividends. Compared to S&P 500's 10–12% average, this shows relative performance but with greater volatility."
-                })
-
-    # Past X years questions with more variations to reduce hallucinations
-    for duration in range(1, max_year - min_year + 2):
-        for end_year in years:
-            start_year = end_year - duration + 1
-            if start_year >= min_year:
-                df_period = df_yearly[(df_yearly['Year'] >= start_year) & (df_yearly['Year'] <= end_year)]
-                if not df_period.empty:
-                    initial_price = df_period[df_period['Year'] == start_year][f'Price_{symbol}'].mean()
-                    final_price = df_period[df_period['Year'] == end_year][f'Price_{symbol}'].mean()
-                    num_years = end_year - start_year + 1
-                    cagr = ((final_price / initial_price) ** (1 / num_years) - 1) * 100 if initial_price > 0 else 0.0
-                    avg_real_return = df_period[f"Real_Return_{symbol}"].mean()
-                    qa_pairs.append({
-                        "question": f"What was the average annual growth rate of {symbol_name} in the past {duration} years from {end_year}?",
-                        "answer": f"The {symbol_name} compounded annual growth rate (CAGR) from {start_year} to {end_year} was approximately {cagr:.1f}%, including dividends."
-                    })
-                    qa_pairs.append({
-                        "question": f"What was the {duration}-year average annual growth rate of {symbol_name} ending in {end_year}?",
-                        "answer": f"The {symbol_name} {duration}-year compounded annual growth rate (CAGR) from {start_year} to {end_year} was approximately {cagr:.1f}%, including dividends."
-                    })
-                    qa_pairs.append({
-                        "question": f"What is the average return of {symbol_name} over the last {duration} years?",
-                        "answer": f"The average annual return of {symbol_name} from {start_year} to {end_year} was approximately {cagr:.1f}%, including dividends."
-                    })
-                    qa_pairs.append({
-                        "question": f"What was {symbol_name}'s performance in the past {duration} years?",
-                        "answer": f"{symbol_name} had a compounded annual growth rate (CAGR) of approximately {cagr:.1f}% from {start_year} to {end_year}, including dividends."
-                    })
-                    qa_pairs.append({
-                        "question": f"Calculate the average annual return for {symbol_name} in the last {duration} years.",
-                        "answer": f"The calculated compounded annual growth rate (CAGR) for {symbol_name} from {start_year} to {end_year} is approximately {cagr:.1f}%, including dividends."
-                    })
-                    qa_pairs.append({
-                        "question": f"What was {symbol_name}'s volatility in the past {duration} years?",
-                        "answer": f"{symbol_name}'s returns from {start_year} to {end_year} show high volatility typical of tech stocks; CAGR was {cagr:.1f}%, but diversify to mitigate risks."
-                    })
-
-# Investment return questions
-amounts = [1000, 5000, 10000]
-durations = [1, 3, 5, 10, 20]
-avg_annual_return = 10.0
-for symbol in STOCK_SYMBOLS:
-    symbol_name = "S&P 500" if symbol == "SPY" else symbol
-    for amount in amounts:
-        for n in durations:
-            future_value = amount * (1 + avg_annual_return / 100) ** n
-            qa_pairs.append({
-                "question": f"What will ${amount} be worth in {n} years if invested in {symbol_name}?",
-                "answer": f"Assuming a 10% average annual return, ${amount:,.0f} invested in {symbol_name} would grow to approximately ${future_value:,.0f} in {n} years with annual compounding."
-            })
-
-# General questions with nuances
-for symbol in STOCK_SYMBOLS:
-    symbol_name = "S&P 500" if symbol == "SPY" else symbol
-    df_10yr = df_yearly[(df_yearly['Year'] >= max_year-10) & (df_yearly['Year'] <= max_year)]
-    initial_10 = df_10yr[df_10yr['Year'] == max_year-10][f'Price_{symbol}'].mean()
-    final_10 = df_10yr[df_10yr['Year'] == max_year][f'Price_{symbol}'].mean()
-    cagr_10 = ((final_10 / initial_10) ** (1 / 10) - 1) * 100 if initial_10 > 0 else 0.0
-    qa_pairs.append({
-        "question": f"What is the average return rate of {symbol_name} in the past 10 years?",
-        "answer": f"The {symbol_name} compounded annual growth rate (CAGR) from {max_year-10} to {max_year} was approximately {cagr_10:.1f}%, including dividends."
-    })
-    df_5yr = df_yearly[(df_yearly['Year'] >= max_year-5) & (df_yearly['Year'] <= max_year)]
-    initial_5 = df_5yr[df_5yr['Year'] == max_year-5][f'Price_{symbol}'].mean()
-    final_5 = df_5yr[df_5yr['Year'] == max_year][f'Price_{symbol}'].mean()
-    cagr_5 = ((final_5 / initial_5) ** (1 / 5) - 1) * 100 if initial_5 > 0 else 0.0
-    qa_pairs.append({
-        "question": f"What is the average return rate of {symbol_name} in the last 5 years?",
-        "answer": f"The {symbol_name} compounded annual growth rate (CAGR) from {max_year-5} to {max_year} was approximately {cagr_5:.1f}%, including dividends."
-    })
-    df_7yr = df_yearly[(df_yearly['Year'] >= max_year-7) & (df_yearly['Year'] <= max_year)]
-    initial_7 = df_7yr[df_7yr['Year'] == max_year-7][f'Price_{symbol}'].mean()
-    final_7 = df_7yr[df_7yr['Year'] == max_year][f'Price_{symbol}'].mean()
-    cagr_7 = ((final_7 / initial_7) ** (1 / 7) - 1) * 100 if initial_7 > 0 else 0.0
-    qa_pairs.append({
-        "question": f"What is the average return rate of {symbol_name} in the past 7 years?",
-        "answer": f"The {symbol_name} compounded annual growth rate (CAGR) from {max_year-7} to {max_year} was approximately {cagr_7:.1f}%, including dividends."
-    })
-qa_pairs.append({
-    "question": "What is the average growth rate for stocks?",
-    "answer": "The average annual return for individual stocks varies widely, but broad market indices like the S&P 500 average 10–12% over the long term (1927–2025), including dividends. Specific stocks like TSLA or NVDA may have higher volatility and returns."
-})
-
-# Save QA pairs to cache.json for pre-populated cache
-cache_dict = {pair["question"].lower(): pair["answer"] for pair in qa_pairs if "question" in pair and "answer" in pair}
-try:
-    with open(CACHE_FILE, 'w') as f:
-        json.dump(cache_dict, f, indent=2)
-    logger.info(f"Saved {len(cache_dict)} QA pairs to {CACHE_FILE} for caching")
-except Exception as e:
-    logger.warning(f"Failed to save {CACHE_FILE}: {e}")
-
-# Save to JSON for dataset
-with open("financial_data.json", "w") as f:
-    json.dump(qa_pairs, f, indent=2)
-
-# Step 4: Load and Tokenize Dataset
-dataset = Dataset.from_json("financial_data.json")
-dataset = dataset.train_test_split(test_size=0.2, seed=42)
-train_dataset = dataset["train"]
-val_dataset = dataset["test"].train_test_split(test_size=0.5, seed=42)["train"]
-test_dataset = dataset["test"].train_test_split(test_size=0.5, seed=42)["test"]
-
-# Step 5: Load Model and Tokenizer
-tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-tokenizer.pad_token = tokenizer.eos_token if tokenizer.pad_token is None else tokenizer.pad_token
-
-def tokenize_function(examples):
-    inputs = []
-    for ex in zip(examples.get("question", []), examples.get("answer", []), examples.get("summary", [])):
-        if ex[0] and ex[1]:
-            inputs.append(ex[0] + " A: " + ex[1])
-        elif ex[2]:
-            inputs.append(ex[2])
-    return tokenizer(inputs, padding="max_length", truncation=True, max_length=512)
-
-tokenized_train = train_dataset.map(tokenize_function, batched=True)
-tokenized_val = val_dataset.map(tokenize_function, batched=True)
-tokenized_test = test_dataset.map(tokenize_function, batched=True)
-
-# Step 6: Load and Fine-Tune Model
-model = AutoModelForCausalLM.from_pretrained(
-    MODEL_NAME,
-    torch_dtype=torch.float32,  # Changed to float32 to avoid Half/Float issues during training
-    low_cpu_mem_usage=True
+# Prepare PEFT config for efficient fine-tuning
+peft_config = LoraConfig(
+    r=16,
+    lora_alpha=32,
+    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
+    lora_dropout=0.05,
+    bias="none",
+    task_type="CAUSAL_LM"
 )
+model = get_peft_model(model, peft_config)
+
+# Load dataset (example: assume 'financial_data.jsonl' with {'text': 'query ||| response'} format)
+dataset = load_dataset("json", data_files="financial_data.jsonl", split="train")
 
+# Training arguments
 training_args = TrainingArguments(
-    output_dir=OUTPUT_DIR,
-    evaluation_strategy="epoch",
-    learning_rate=1e-5,
-    per_device_train_batch_size=8,
-    per_device_eval_batch_size=8,
-    num_train_epochs=10,  # Kept as is; training is one-time
+    output_dir="./finetuned_smollm3",
+    num_train_epochs=3,
+    per_device_train_batch_size=4,
+    gradient_accumulation_steps=4,
+    learning_rate=2e-4,
+    fp16=True if torch.cuda.is_available() else False,
+    save_steps=500,
+    logging_steps=100,
+    optim="paged_adamw_8bit",
     weight_decay=0.01,
-    logging_steps=10,
-    save_strategy="epoch",
-    load_best_model_at_end=True,
-    metric_for_best_model="eval_loss",
-    fp16=False  # Disabled fp16 for CPU compatibility
+    warmup_steps=100,
 )
 
-trainer = Trainer(
+# Trainer
+trainer = SFTTrainer(
     model=model,
     args=training_args,
-    train_dataset=tokenized_train,
-    eval_dataset=tokenized_val,
+    train_dataset=dataset,
+    peft_config=peft_config,
+    dataset_text_field="text",  # Adjust based on your dataset
+    tokenizer=tokenizer,
+    max_seq_length=512,
 )
 
-# Step 7: Train and Evaluate
 trainer.train()
-eval_results = trainer.evaluate(tokenized_test)
-logger.info(f"Evaluation results: {eval_results}")
 
-# Step 8: Save Model
-trainer.save_model(OUTPUT_DIR)
-tokenizer.save_pretrained(OUTPUT_DIR)
-logger.info(f"Model and tokenizer saved to {OUTPUT_DIR}")
-```
+# Save fine-tuned model
+trainer.model.save_pretrained("./finetuned_smollm3")
+    tokenizer.save_pretrained("./finetuned_smollm3")