Update app.py

app.py

@@ -1,3 +1,373 @@
+import os
+import sys
+import subprocess
+import re
+import multiprocessing
+from collections.abc import Iterator
+import gradio as gr
+from huggingface_hub import hf_hub_download, login
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Install llama-cpp-python if not present
+try:
+    from llama_cpp import Llama
+except ModuleNotFoundError:
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "llama-cpp-python"])
+from llama_cpp import Llama
+
+# Install yfinance if not present (for CAGR calculations)
+try:
+    import yfinance as yf
+except ModuleNotFoundError:
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "yfinance"])
+import yfinance as yf
+
+# Import pandas for handling DataFrame column structures
+import pandas as pd
+
+# Additional imports for visualization and file handling
+try:
+    import matplotlib.pyplot as plt
+    from PIL import Image
+    import io
+except ModuleNotFoundError:
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "matplotlib", "pillow"])
+
+import matplotlib.pyplot as plt
+from PIL import Image
+import io
+
+# Additional imports for PEFT fine-tuning
+try:
+    import torch
+    from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, TrainingArguments
+    from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+    from trl import SFTTrainer
+    from datasets import load_dataset
+    import accelerate
+except ModuleNotFoundError:
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "torch", "transformers", "peft", "trl", "datasets", "accelerate", "bitsandbytes"])
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, TrainingArguments
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from trl import SFTTrainer
+from datasets import load_dataset
+
+MAX_MAX_NEW_TOKENS = 512
+DEFAULT_MAX_NEW_TOKENS = 128
+MAX_INPUT_TOKEN_LENGTH = int(os.getenv("MAX_INPUT_TOKEN_LENGTH", "256"))
+
+DESCRIPTION = """\
+# FinChat: Investing Q&A (CPU-Only, Ultra-Fast Optimization)
+This application delivers an interactive chat interface powered by a highly efficient, small AI model adapted for addressing investing and finance inquiries through specialized prompt engineering. It ensures rapid, reasoned responses to user queries. Duplicate this Space for customization or queue-free deployment.
+<p>Running on CPU 🥶 Inference is heavily optimized for responses in under 10 seconds for simple queries, with output limited to 128 tokens maximum. For longer responses, increase 'Max New Tokens' in Advanced Settings. Brief delays may occur in free-tier environments due to shared resources, but typical generation speeds reach 20-40 tokens per second. CAGR calculations for stocks are computed accurately using historical data.</p>
+"""
+
+LICENSE = """\
+<p/>
+---
+This application employs the Llama-2-7B-Chat model, fine-tuned on financial Q&A data, governed by Meta AI's Terms of Use. Refer to the [model card](https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF) for details.
+"""
+
+# Define paths
+base_model_id = "meta-llama/Llama-2-7b-chat-hf"
+fine_tuned_model_path = "fine_tuned_llama2.gguf"
+quantized_model_path = "llama-2-7b-chat-finetuned.Q4_K_M.gguf"
+lora_adapter_path = "lora_adapter"
+
+# Hugging Face login (required for fine-tuning)
+hf_token = os.getenv("HF_TOKEN")
+if hf_token:
+    login(hf_token)
+else:
+    logger.warning("HF_TOKEN not set. Fine-tuning may fail if authentication is required.")
+
+# One-time fine-tuning process if the fine-tuned GGUF does not exist
+if not os.path.exists(quantized_model_path):
+    logger.info("Attempting one-time PEFT fine-tuning on Finance-Alpaca dataset...")
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(base_model_id)
+        model = AutoModelForCausalLM.from_pretrained(
+            base_model_id,
+            torch_dtype=torch.bfloat16,
+            device_map="cpu"
+        )
+        dataset = load_dataset("gbharti/finance-alpaca", split="train[0:500]")
+        
+        def formatting_func(example):
+            text = f"<s>[INST] {example['instruction']}\n{example['input']} [/INST] {example['output']} </s>"
+            return {"text": text}
+        
+        dataset = dataset.map(formatting_func)
+        
+        lora_config = LoraConfig(
+            r=8,
+            lora_alpha=16,
+            target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM"
+        )
+        
+        model = prepare_model_for_kbit_training(model)
+        model = get_peft_model(model, lora_config)
+        
+        training_args = TrainingArguments(
+            output_dir=lora_adapter_path,
+            num_train_epochs=1,
+            per_device_train_batch_size=1,
+            gradient_accumulation_steps=4,
+            learning_rate=2e-4,
+            fp16=False,
+            save_steps=100,
+            logging_steps=10,
+            optim="adamw_torch",
+            report_to="none"
+        )
+        
+        trainer = SFTTrainer(
+            model=model,
+            tokenizer=tokenizer,
+            train_dataset=dataset,
+            dataset_text_field="text",
+            max_seq_length=512,
+            args=training_args
+        )
+        
+        trainer.train()
+        
+        model = model.merge_and_unload()
+        model.save_pretrained("merged_model")
+        tokenizer.save_pretrained("merged_model")
+        
+        subprocess.check_call(["git", "clone", "https://github.com/ggerganov/llama.cpp"])
+        os.chdir("llama.cpp")
+        subprocess.check_call(["make"])
+        subprocess.check_call([sys.executable, "convert_hf_to_gguf.py", "--outfile", "../" + fine_tuned_model_path, "--outtype", "f16", "../merged_model"])
+        subprocess.check_call(["./quantize", "../" + fine_tuned_model_path, "../" + quantized_model_path, "Q4_K_M"])
+        os.chdir("..")
+        
+        logger.info("Fine-tuning and conversion complete. Using fine-tuned model.")
+    except Exception as e:
+        logger.error(f"Error during fine-tuning: {str(e)}")
+        print("Falling back to the pre-trained model without fine-tuning.")
+
+# Load the model
+try:
+    model_path = quantized_model_path if os.path.exists(quantized_model_path) else hf_hub_download(
+        repo_id="TheBloke/Llama-2-7B-Chat-GGUF",
+        filename="llama-2-7b-chat.Q4_K_M.gguf"
+    )
+    llm = Llama(
+        model_path=model_path,
+        n_ctx=256,
+        n_batch=512,
+        n_threads=multiprocessing.cpu_count(),
+        n_gpu_layers=0,
+        chat_format="llama-2"
+    )
+    logger.info("Model loaded successfully.")
+except Exception as e:
+    logger.error(f"Error loading model: {str(e)}")
+    raise
+
+DEFAULT_SYSTEM_PROMPT = """You are FinChat, a knowledgeable AI assistant specializing in investing and finance. Provide accurate, helpful, reasoned, and concise answers to investing questions. Always base responses on reliable information and advise users to consult professionals for personalized advice.
+Always respond exclusively in English. Use bullet points for clarity.
+Example:
+User: average return for TSLA between 2010 and 2020
+Assistant: 
+- TSLA CAGR (2010-2020): ~63.01%
+- Represents average annual return with compounding
+- Past performance not indicative of future results
+- Consult a financial advisor"""
+
+def generate(
+    message: str,
+    chat_history: list[dict],
+    system_prompt: str = DEFAULT_SYSTEM_PROMPT,
+    max_new_tokens: int = DEFAULT_MAX_NEW_TOKENS,
+    temperature: float = 0.6,
+    top_p: float = 0.9,
+    top_k: int = 50,
+    repetition_penalty: float = 1.2,
+) -> Iterator[str]:
+    logger.info(f"Generating response for message: {message}")
+    
+    lower_message = message.lower().strip()
+    if lower_message in ["hi", "hello"]:
+        response = "I'm FinChat, your financial advisor. Ask me anything finance-related!"
+        logger.info("Quick response for 'hi'/'hello' generated.")
+        yield response
+        return
+    
+    # Check for CAGR/average return queries
+    match = re.match(r'(?:average return|cagr) for ([\w\s,]+(?:and [\w\s,]+)?) between (\d{4}) and (\d{4})', lower_message)
+    if match:
+        tickers_str, start_year, end_year = match.groups()
+        tickers = [t.strip().upper() for t in re.split(r',|\band\b', tickers_str) if t.strip()]
+        responses = []
+        if int(end_year) <= int(start_year):
+            yield "The specified time period is invalid (end year must be after start year)."
+            return
+        for ticker in tickers:
+            try:
+                data = yf.download(ticker, start=f"{start_year}-01-01", end=f"{end_year}-12-31")
+                if not data.empty:
+                    if isinstance(data.columns, pd.MultiIndex):
+                        data = data.droplevel('Ticker', axis=1)
+                    initial = data['Close'].iloc[0]
+                    final = data['Close'].iloc[-1]
+                    start_date = data.index[0]
+                    end_date = data.index[-1]
+                    days = (end_date - start_date).days
+                    years = days / 365.25
+                    if years > 0:
+                        cagr = ((final / initial) ** (1 / years) - 1) * 100
+                        responses.append(f"- {ticker}: ~{cagr:.2f}%")
+                    else:
+                        responses.append(f"- {ticker}: Invalid period (no elapsed time).")
+                else:
+                    responses.append(f"- {ticker}: No historical data available between {start_year} and {end_year}.")
+            except Exception as e:
+                responses.append(f"- {ticker}: Error calculating CAGR - {str(e)}")
+        full_response = f"CAGR for the requested stocks from {start_year} to {end_year}:\n" + "\n".join(responses) + "\n- Represents average annual returns with compounding\n- Past performance not indicative of future results\n- Consult a financial advisor"
+        logger.info("CAGR response generated.")
+        yield full_response
+        return
+    
+    # Build conversation messages
+    conversation = [{"role": "system", "content": system_prompt}]
+    for msg in chat_history[-5:]:  # Limit history to last 5 exchanges
+        if msg["role"] == "user":
+            conversation.append({"role": "user", "content": msg["content"]})
+        elif msg["role"] == "assistant":
+            conversation.append({"role": "assistant", "content": msg["content"]})
+    conversation.append({"role": "user", "content": message})
+    
+    # Approximate token length check
+    prompt_text = "\n".join(d["content"] for d in conversation)
+    input_tokens = llm.tokenize(prompt_text.encode("utf-8"), add_bos=False)
+    
+    # Generate response
+    try:
+        response = ""
+        stream = llm.create_chat_completion(
+            messages=conversation,
+            max_tokens=max_new_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            top_k=top_k,
+            repeat_penalty=repetition_penalty,
+            stream=True
+        )
+        for chunk in stream:
+            delta = chunk["choices"][0]["delta"]
+            if "content" in delta and delta["content"] is not None:
+                response += delta["content"]
+                yield response
+            if chunk["choices"][0]["finish_reason"] is not None:
+                break
+        logger.info("Response generation completed.")
+    except Exception as e:
+        logger.error(f"Error during response generation: {str(e)}")
+        yield f"Error generating response: {str(e)}"
+
+def process_portfolio(ticker1, shares1, cost1, price1, ticker2, shares2, cost2, price2, ticker3, shares3, cost3, price3, growth_rate):
+    portfolio = {}
+    if ticker1:
+        value1 = shares1 * price1
+        portfolio[ticker1.upper()] = {'shares': shares1, 'cost': cost1, 'price': price1, 'value': value1}
+    if ticker2:
+        value2 = shares2 * price2
+        portfolio[ticker2.upper()] = {'shares': shares2, 'cost': cost2, 'price': price2, 'value': value2}
+    if ticker3:
+        value3 = shares3 * price3
+        portfolio[ticker3.upper()] = {'shares': shares3, 'cost': cost3, 'price': price3, 'value': value3}
+    if not portfolio:
+        return "", None
+    
+    total_value_now = sum(v['value'] for v in portfolio.values())
+    allocations = {k: v['value'] / total_value_now for k, v in portfolio.items()} if total_value_now > 0 else {}
+    
+    fig_alloc, ax_alloc = plt.subplots()
+    ax_alloc.pie(allocations.values(), labels=allocations.keys(), autopct='%1.1f%%')
+    ax_alloc.set_title('Portfolio Allocation')
+    buf_alloc = io.BytesIO()
+    fig_alloc.savefig(buf_alloc, format='png')
+    buf_alloc.seek(0)
+    chart_alloc = Image.open(buf_alloc)
+    plt.close(fig_alloc)  # Close the figure to free memory
+    
+    def project_value(value, years, rate):
+        return value * (1 + rate / 100) ** years
+    
+    total_value_1yr = sum(project_value(v['value'], 1, growth_rate) for v in portfolio.values())
+    total_value_2yr = sum(project_value(v['value'], 2, growth_rate) for v in portfolio.values())
+    total_value_5yr = sum(project_value(v['value'], 5, growth_rate) for v in portfolio.values())
+    total_value_10yr = sum(project_value(v['value'], 10, growth_rate) for v in portfolio.values())
+    
+    data_str = (
+        "User portfolio:\n" +
+        "\n".join(f"- {k}: {v['shares']} shares, avg cost {v['cost']}, current price {v['price']}, value ${v['value']:,.2f}" for k, v in portfolio.items()) +
+        f"\nTotal value now: ${total_value_now:,.2f}\nProjected (at {growth_rate}% annual growth):\n"
+        f"- 1 year: ${total_value_1yr:,.2f}\n- 2 years: ${total_value_2yr:,.2f}\n- 5 years: ${total_value_5yr:,.2f}\n- 10 years: ${total_value_10yr:,.2f}"
+    )
+    return data_str, chart_alloc
+
+# Gradio interface setup
+with gr.Blocks(css="""#chatbot {height: 800px; overflow: auto;}""") as demo:
+    gr.Markdown(DESCRIPTION)
+    chatbot = gr.Chatbot(label="FinChat", type="messages")
+    msg = gr.Textbox(label="Ask a finance question", placeholder="e.g., 'What is CAGR?' or 'Average return for AAPL between 2010 and 2020'")
+    
+    with gr.Row():
+        with gr.Column():
+            ticker1 = gr.Textbox(label="Ticker 1")
+            shares1 = gr.Number(label="Shares 1")
+            cost1 = gr.Number(label="Avg Cost/Share 1")
+            price1 = gr.Number(label="Current Price 1")
+        with gr.Column():
+            ticker2 = gr.Textbox(label="Ticker 2")
+            shares2 = gr.Number(label="Shares 2")
+            cost2 = gr.Number(label="Avg Cost/Share 2")
+            price2 = gr.Number(label="Current Price 2")
+        with gr.Column():
+            ticker3 = gr.Textbox(label="Ticker 3")
+            shares3 = gr.Number(label="Shares 3")
+            cost3 = gr.Number(label="Avg Cost/Share 3")
+            price3 = gr.Number(label="Current Price 3")
+    
+    growth_rate = gr.Slider(minimum=5, maximum=50, step=5, value=10, label="Annual Growth Rate (%)", interactive=True, info="Selected Growth Rate: 10%")
+    growth_rate_label = gr.Markdown("**Selected Growth Rate: 10%**")
+    
+    with gr.Row():
+        submit = gr.Button("Submit")
+        clear = gr.Button("Clear")
+    
+    with gr.Accordion("Advanced Settings", open=False):
+        system_prompt = gr.Textbox(label="System Prompt", value=DEFAULT_SYSTEM_PROMPT, lines=6)
+        temperature = gr.Slider(label="Temperature", value=0.6, minimum=0.0, maximum=1.0, step=0.05)
+        top_p = gr.Slider(label="Top P", value=0.9, minimum=0.0, maximum=1.0, step=0.05)
+        top_k = gr.Slider(label="Top K", value=50, minimum=1, maximum=100, step=1)
+        repetition_penalty = gr.Slider(label="Repetition Penalty", value=1.2, minimum=1.0, maximum=2.0, step=0.05)
+        max_new_tokens = gr.Slider(label="Max New Tokens", value=DEFAULT_MAX_NEW_TOKENS, minimum=1, maximum=MAX_MAX_NEW_TOKENS, step=1)
+    
+    gr.Markdown(LICENSE)
+    
+    def update_growth_rate_label(growth_rate):
+        return f"**Selected Growth Rate: {growth_rate}%**"
+    
+    def user(message, history):
+        if not message:
+            return "", history
+        return "", history + [{"role": "user", "content": message}]
+    
+    def bot(history, sys_prompt, temp, tp, tk, rp, mnt, ticker1, shares1, cost1, price1, ticker2, shares2, cost2, price2, ticker3, shares3, cost3, price3, growth_rate):
         if not history:
             logger.warning("History is empty, initializing with user message.")
             history = [{"role": "user", "content": ""}]