Update app.py

app.py

@@ -14,6 +14,15 @@ import torch
 import yfinance as yf
 from datetime import datetime, timedelta
 from math import sqrt
+import time
+import base64
+import io
+import numpy as np
+try:
+    import scipy.optimize as opt
+except ModuleNotFoundError:
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "scipy"])
+    import scipy.optimize as opt
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)
@@ -48,21 +57,20 @@ try:
     from PIL import Image
     import io
 except ModuleNotFoundError:
-    subprocess.check_call([sys.executable, "-m", "pip", "install", "matplotlib", "pillow"])
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "matplotlib", "pillow", "numpy"])
     import matplotlib.pyplot as plt
     from PIL import Image
     import io
+    import numpy as np
 
 MAX_MAX_NEW_TOKENS = 512
 DEFAULT_MAX_NEW_TOKENS = 512
 MAX_INPUT_TOKEN_LENGTH = int(os.getenv("MAX_INPUT_TOKEN_LENGTH", "1024"))
 
 DESCRIPTION = """# FinChat: Investing Q&A (Optimized for Speed)
-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 or GPU if available. Using Phi-2 model for faster inference. Inference is heavily optimized for responses in under 10 seconds for simple queries, with output limited to 250 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 are improved with the smaller model.</p>"""
+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 or GPU if available. Using Phi-2 model for faster inference. Inference is heavily optimized for responses in under 10 seconds for simple queries, with output limited to 250 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 are improved with the smaller model.</p>"""
 
-LICENSE = """<p/>
----
+LICENSE = """<p/>---
 This application employs the Phi-2 model, governed by Microsoft's Terms of Use. Refer to the [model card](https://huggingface.co/TheBloke/phi-2-GGUF) for details."""
 
 # Load the model (skip fine-tuning for faster startup)
@@ -75,12 +83,12 @@ try:
     llm = Llama(
         model_path=model_path,
         n_ctx=1024,
-        n_batch=1024, # Increased for faster processing
+        n_batch=1024,  # Increased for faster processing
         n_threads=multiprocessing.cpu_count(),
         n_gpu_layers=n_gpu_layers,
-        chat_format="chatml" # Phi-2 uses ChatML format in llama.cpp
+        chat_format="chatml"  # Phi-2 uses ChatML format in llama.cpp
     )
-    logger.info(f"Model loaded successfully with n_gpu_layers= {n_gpu_layers}.")
+    logger.info(f"Model loaded successfully with n_gpu_layers={n_gpu_layers}.")
     # Warm up the model for faster initial inference
     llm("Warm-up prompt", max_tokens=1, echo=False)
     logger.info("Model warm-up completed.")
@@ -101,6 +109,8 @@ Assistant:
 - Represents average annual return with compounding
 - Past performance is not indicative of future results."""
 
+logs = []
+
 # Function to calculate CAGR using yfinance
 def calculate_cagr(ticker, start_date, end_date):
     try:
@@ -116,7 +126,7 @@ def calculate_cagr(ticker, start_date, end_date):
         logger.error(f"Error calculating CAGR for {ticker}: {str(e)}")
         return None
 
-# New function to calculate risk metrics using yfinance
+# Function to calculate risk metrics using yfinance
 def calculate_risk_metrics(ticker, years=5):
     try:
         end_date = datetime.now().strftime('%Y-%m-%d')
@@ -134,6 +144,68 @@ def calculate_risk_metrics(ticker, years=5):
         logger.error(f"Error calculating risk metrics for {ticker}: {str(e)}")
         return None, None
 
+# Function for inline plot
+def generate_plot(ticker, period='5y'):
+    try:
+        data = yf.download(ticker, period=period)
+        if data.empty:
+            return "Unable to fetch data for plotting."
+        plt.figure(figsize=(10, 5))
+        plt.plot(data['Adj Close'], label='Adjusted Close')
+        plt.title(f'{ticker} Price History ({period})')
+        plt.xlabel('Date')
+        plt.ylabel('Price (USD)')
+        plt.legend()
+        plt.grid(True)
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png', bbox_inches='tight')
+        buf.seek(0)
+        b64 = base64.b64encode(buf.read()).decode('utf-8')
+        plt.close()
+        return f"![{ticker} Price Chart](data:image/png;base64,{b64})"
+    except Exception as e:
+        logger.error(f"Error generating plot for {ticker}: {str(e)}")
+        return "Error generating plot."
+
+# Function for portfolio optimization using scipy
+def portfolio_optimization(tickers, target_return=None):
+    try:
+        data = yf.download(tickers, period='5y')['Adj Close']
+        returns = data.pct_change().dropna()
+        mean_returns = returns.mean() * 252
+        cov_matrix = returns.cov() * 252
+        num_assets = len(tickers)
+
+        def portfolio_volatility(weights):
+            return np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
+
+        constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
+        bounds = tuple((0, 1) for _ in range(num_assets))
+        initial_guess = np.array(num_assets * [1. / num_assets])
+
+        if target_return:
+            # Maximize Sharpe or min vol for target return
+            def objective(weights):
+                ret = np.sum(mean_returns * weights)
+                vol = portfolio_volatility(weights)
+                return - (ret - 0.02) / vol if vol != 0 else np.inf  # Neg Sharpe
+            cons = [{'type': 'eq', 'fun': lambda x: np.sum(x) - 1},
+                    {'type': 'eq', 'fun': lambda x: np.sum(mean_returns * x) - target_return}]
+            result = opt.minimize(objective, initial_guess, method='SLSQP', bounds=bounds, constraints=cons)
+        else:
+            # Minimize volatility
+            result = opt.minimize(portfolio_volatility, initial_guess, method='SLSQP',
+                                  bounds=bounds, constraints=constraints)
+
+        if result.success:
+            weights = dict(zip(tickers, result.x))
+            return weights
+        else:
+            return {ticker: 1/len(tickers) for ticker in tickers}  # Fallback equal weights
+    except Exception as e:
+        logger.error(f"Error in portfolio optimization: {str(e)}")
+        return {ticker: 1/len(tickers) for ticker in tickers}
+
 # Assuming the generate function handles the chat logic (extended to include risk comparison)
 def generate(
     message: str,
@@ -143,10 +215,13 @@ def generate(
     temperature: float,
     top_p: float,
     top_k: int,
-) -> Iterator[str]:
+    logs_state: list
+) -> tuple[Iterator[str], list]:
+    start_time = time.time()
     if not system_prompt:
         system_prompt = DEFAULT_SYSTEM_PROMPT
 
+    full_response = ""
     # Detect CAGR query
     cagr_match = re.search(r'average return for (\w+) between (\d{4}) and (\d{4})', message.lower())
     if cagr_match:
@@ -157,11 +232,23 @@ def generate(
         end_date = f"{end_year}-12-31"
         cagr = calculate_cagr(ticker, start_date, end_date)
         if cagr is not None:
-            yield f"- {ticker} CAGR ({start_year}-{end_year}): ~{cagr:.2f}%\n- Represents average annual return with compounding\n- Past performance is not indicative of future results.\n- Consult a financial advisor for personalized advice."
-            return
+            response = f"- {ticker} CAGR ({start_year}-{end_year}): ~{cagr:.2f}%\n- Represents average annual return with compounding\n- Past performance is not indicative of future results.\n- Consult a financial advisor for personalized advice."
+            yield response
+            full_response = response
         else:
-            yield "Unable to calculate CAGR for the specified period."
-            return
+            response = "Unable to calculate CAGR for the specified period."
+            yield response
+            full_response = response
+        end_time = time.time()
+        logs_state.append({
+            'timestamp': datetime.now().isoformat(),
+            'query': message,
+            'response': full_response,
+            'response_length': len(full_response.split()),
+            'generation_time': end_time - start_time,
+            'token_efficiency': len(full_response.split()) / max_new_tokens
+        })
+        return iter([]), logs_state  # No more yield
 
     # Detect risk comparison query
     risk_match = re.search(r'which stock is riskier (\w+) or (\w+)', message.lower())
@@ -171,29 +258,120 @@ def generate(
         vol1, sharpe1 = calculate_risk_metrics(ticker1)
         vol2, sharpe2 = calculate_risk_metrics(ticker2)
         if vol1 is None or vol2 is None:
-            yield "Unable to fetch risk metrics for one or both tickers."
-            return
-        if vol1 > vol2:
-            riskier = ticker1
-            less_risky = ticker2
-            higher_vol = vol1
-            lower_vol = vol2
-            riskier_sharpe = sharpe1
-            less_sharpe = sharpe2
+            response = "Unable to fetch risk metrics for one or both tickers."
+            yield response
+            full_response = response
         else:
-            riskier = ticker2
-            less_risky = ticker1
-            higher_vol = vol2
-            lower_vol = vol1
-            riskier_sharpe = sharpe2
-            less_sharpe = sharpe1
-        yield f"- {riskier} is riskier compared to {less_risky}.\n- It has a higher annualized standard deviation ({higher_vol:.2f}% vs {lower_vol:.2f}%) and a lower Sharpe ratio ({riskier_sharpe:.2f} vs {less_sharpe:.2f}), indicating greater volatility and potentially lower risk-adjusted returns.\n- Calculations based on the past 5 years of data.\n- Past performance is not indicative of future results. Consult a financial advisor for personalized advice."
-        return
+            if vol1 > vol2:
+                riskier = ticker1
+                less_risky = ticker2
+                higher_vol = vol1
+                lower_vol = vol2
+                riskier_sharpe = sharpe1
+                less_sharpe = sharpe2
+            else:
+                riskier = ticker2
+                less_risky = ticker1
+                higher_vol = vol2
+                lower_vol = vol1
+                riskier_sharpe = sharpe2
+                less_sharpe = sharpe1
+            response = f"- {riskier} is riskier compared to {less_risky}.\n- It has a higher annualized standard deviation ({higher_vol:.2f}% vs {lower_vol:.2f}%) and a lower Sharpe ratio ({riskier_sharpe:.2f} vs {less_sharpe:.2f}), indicating greater volatility and potentially lower risk-adjusted returns.\n- Calculations based on the past 5 years of data.\n- Past performance is not indicative of future results. Consult a financial advisor for personalized advice."
+            yield response
+            full_response = response
+        end_time = time.time()
+        logs_state.append({
+            'timestamp': datetime.now().isoformat(),
+            'query': message,
+            'response': full_response,
+            'response_length': len(full_response.split()),
+            'generation_time': end_time - start_time,
+            'token_efficiency': len(full_response.split()) / max_new_tokens
+        })
+        return iter([]), logs_state
+
+    # Detect plot/chart query
+    plot_match = re.search(r'(plot|chart)\s+(\w+)(?:\s+(historical|price|volatility))?', message.lower())
+    if plot_match:
+        ticker = plot_match.group(2).upper()
+        plot_type = plot_match.group(3) if plot_match.group(3) else 'price'
+        if plot_type == 'volatility':
+            # Simple volatility plot (returns histogram)
+            try:
+                data = yf.download(ticker, period='1y')
+                returns = data['Adj Close'].pct_change().dropna()
+                plt.figure(figsize=(10, 5))
+                plt.hist(returns, bins=50, alpha=0.7)
+                plt.title(f'{ticker} Daily Returns Distribution (1Y)')
+                plt.xlabel('Return')
+                plt.ylabel('Frequency')
+            except:
+                plot_type = 'price'  # Fallback
+        if plot_type != 'volatility':
+            plot_md = generate_plot(ticker)
+            response = f"Price chart for {ticker}:\n{plot_md}\n- This visualizes the historical adjusted close prices.\n- Past performance is not indicative of future results. Consult a financial advisor."
+            yield response
+            full_response = response
+        else:
+            # For volatility, similar
+            buf = io.BytesIO()
+            plt.savefig(buf, format='png', bbox_inches='tight')
+            buf.seek(0)
+            b64 = base64.b64encode(buf.read()).decode('utf-8')
+            plt.close()
+            plot_md = f"![{ticker} Volatility](data:image/png;base64,{b64})"
+            response = f"Volatility chart for {ticker}:\n{plot_md}\n- Histogram of daily returns over the past year."
+            yield response
+            full_response = response
+        end_time = time.time()
+        logs_state.append({
+            'timestamp': datetime.now().isoformat(),
+            'query': message,
+            'response': full_response,
+            'response_length': len(full_response.split()),
+            'generation_time': end_time - start_time,
+            'token_efficiency': len(full_response.split()) / max_new_tokens
+        })
+        return iter([]), logs_state
+
+    # Detect portfolio optimization query
+    port_match = re.search(r'optimize\s+portfolio\s+for\s+([\w,\s]+)(?:\s+with\s+(risk|return)\s+tolerance\s+([\d.]+))?', message.lower())
+    if port_match:
+        tickers_str = port_match.group(1).strip()
+        tickers = [t.strip().upper() for t in re.split(r'[,;]', tickers_str) if t.strip()]
+        target = None
+        if port_match.group(3):
+            target = float(port_match.group(3))
+            if port_match.group(2) == 'risk':
+                # For risk tolerance, min vol with vol <= target (but simplify to min vol)
+                pass  # Use default min vol
+            else:
+                target_return = target
+        weights = portfolio_optimization(tickers, target_return=target if 'return' in (port_match.group(2) or '') else None)
+        df = pd.DataFrame(list(weights.items()), columns=['Ticker', 'Weight'])
+        df['Weight'] = df['Weight'].round(4)
+        table_md = df.to_markdown(index=False)
+        response = f"- Suggested portfolio weights for {', '.join(tickers)}:\n{table_md}\n- Based on minimum variance optimization (or target return if specified).\n- Assumes 5-year historical data for means and covariances.\n- Past performance is not indicative of future results. Consult a financial advisor for personalized advice."
+        yield response
+        full_response = response
+        end_time = time.time()
+        logs_state.append({
+            'timestamp': datetime.now().isoformat(),
+            'query': message,
+            'response': full_response,
+            'response_length': len(full_response.split()),
+            'generation_time': end_time - start_time,
+            'token_efficiency': len(full_response.split()) / max_new_tokens
+        })
+        return iter([]), logs_state
 
     # For other queries, fall back to LLM generation
     conversation = [{"role": "system", "content": system_prompt}]
     for user, assistant in history:
-        conversation.extend([{"role": "user", "content": user}, {"role": "assistant", "content": assistant}])
+        conversation.extend([
+            {"role": "user", "content": user},
+            {"role": "assistant", "content": assistant}
+        ])
     conversation.append({"role": "user", "content": message})
 
     # Generate response using LLM (streamed)
@@ -205,35 +383,73 @@ def generate(
         top_k=top_k,
         stream=True
     )
-
     partial_text = ""
     for chunk in response:
         if "content" in chunk["choices"][0]["delta"]:
             partial_text += chunk["choices"][0]["delta"]["content"]
             yield partial_text
+            full_response = partial_text
+    end_time = time.time()
+    logs_state.append({
+        'timestamp': datetime.now().isoformat(),
+        'query': message,
+        'response': full_response,
+        'response_length': len(full_response.split()),
+        'generation_time': end_time - start_time,
+        'token_efficiency': len(full_response.split()) / max_new_tokens
+    })
+    return iter([]), logs_state
 
-# Gradio interface setup (assuming this is part of the original code)
+def update_logs(logs_state):
+    if logs_state:
+        df = pd.DataFrame(logs_state)
+        return df
+    return pd.DataFrame()
+
+# Gradio interface setup
 with gr.Blocks(theme=themes.Default()) as demo:
     gr.Markdown(DESCRIPTION)
     gr.Markdown(LICENSE)
-
-    chatbot = gr.Chatbot()
-    msg = gr.Textbox(label="Enter your question")
-    with gr.Row():
-        submit = gr.Button("Submit")
-        clear = gr.Button("Clear")
-
-    advanced = gr.Accordion("Advanced Settings", open=False)
-    with advanced:
-        system_prompt = gr.Textbox(label="System Prompt", value=DEFAULT_SYSTEM_PROMPT, lines=6)
-        max_new_tokens = gr.Slider(minimum=1, maximum=MAX_MAX_NEW_TOKENS, value=DEFAULT_MAX_NEW_TOKENS, step=1, label="Max New Tokens")
-        temperature = gr.Slider(minimum=0.0, maximum=1.0, value=0.7, step=0.1, label="Temperature")
-        top_p = gr.Slider(minimum=0.0, maximum=1.0, value=0.9, step=0.1, label="Top P")
-        top_k = gr.Slider(minimum=1, maximum=100, value=50, step=1, label="Top K")
-
-    submit.click(generate, [msg, chatbot, system_prompt, max_new_tokens, temperature, top_p, top_k], chatbot, queue=False).then(
-        lambda: "", None, msg
+    
+    with gr.Tabs():
+        with gr.TabItem("Chat"):
+            chatbot = gr.Chatbot()
+            msg = gr.Textbox(label="Enter your question")
+            with gr.Row():
+                submit = gr.Button("Submit")
+                clear = gr.Button("Clear")
+            advanced = gr.Accordion("Advanced Settings", open=False)
+            with advanced:
+                system_prompt = gr.Textbox(label="System Prompt", value=DEFAULT_SYSTEM_PROMPT, lines=6)
+                max_new_tokens = gr.Slider(minimum=1, maximum=MAX_MAX_NEW_TOKENS, value=DEFAULT_MAX_NEW_TOKENS, step=1, label="Max New Tokens")
+                temperature = gr.Slider(minimum=0.0, maximum=1.0, value=0.7, step=0.1, label="Temperature")
+                top_p = gr.Slider(minimum=0.0, maximum=1.0, value=0.9, step=0.1, label="Top P")
+                top_k = gr.Slider(minimum=1, maximum=100, value=50, step=1, label="Top K")
+        
+        with gr.TabItem("Metrics"):
+            metrics_df = gr.Dataframe(headers=['timestamp', 'query', 'response', 'response_length', 'generation_time', 'token_efficiency'])
+    
+    logs_state = gr.State(logs)
+    
+    def submit_fn(msg, history, system_prompt, max_new_tokens, temperature, top_p, top_k, logs_state):
+        gen, new_logs = generate(msg, history, system_prompt, max_new_tokens, temperature, top_p, top_k, logs_state)
+        history.append((msg, ""))
+        for partial in gen:
+            history[-1] = (history[-1][0], partial)
+            yield history, "", new_logs
+        return history, "", new_logs
+    
+    submit.click(
+        submit_fn,
+        inputs=[msg, chatbot, system_prompt, max_new_tokens, temperature, top_p, top_k, logs_state],
+        outputs=[chatbot, msg, logs_state],
+        queue=False
+    ).then(
+        update_logs,
+        inputs=[logs_state],
+        outputs=[metrics_df]
     )
-    clear.click(lambda: None, None, chatbot)
+    
+    clear.click(lambda: ([], []), None, (chatbot, logs_state))
 
-    demo.launch()
+demo.launch()