Create app.py

app.py

@@ -0,0 +1,523 @@
+import os
+import sqlite3
+import pandas as pd
+import numpy as np
+import gradio as gr
+import yfinance as yf
+import tensorflow as tf
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, MinMaxScaler
+from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
+from sklearn.metrics import mean_squared_error, accuracy_score
+import joblib
+from datetime import datetime, timedelta
+
+class AdvancedHedgeFundManagementSystem:
+    def __init__(self, db_path='data/advanced_hedge_fund_database.sqlite'): # path to database corrected
+        """
+        Initialize the Advanced Hedge Fund Management System
+        
+        Args:
+            db_path (str): Path to the SQLite database
+        """
+        self.db_path = db_path
+        self.conn = None
+        self.cursor = None
+        
+        # Investment Types
+        self.investment_types = [
+            'Stocks', 'Bonds', 'ETFs', 'Mutual Funds', 
+            'Real Estate', 'Cryptocurrencies', 'Commodities', 
+            'Private Equity', 'Hedge Funds', 'Derivatives'
+        ]
+        
+        # Market Indices for Benchmarking
+        self.market_indices = [
+            '^GSPC',  # S&P 500
+            '^DJI',   # Dow Jones Industrial Average
+            '^IXIC',  # NASDAQ Composite
+            '^RUT',   # Russell 2000
+        ]
+        
+        # Initialize database and create tables
+        self.initialize_database()
+        
+        # Load or train predictive models
+        self.load_or_train_models()
+
+        # Define some common Equity and Bond ETF
+        self.equity_etfs = ['SPY', 'QQQ', 'IWM', 'VOO', 'IVV'] # US equities
+        self.bond_etfs = ['BND', 'AGG', 'LQD', 'TLT', 'SHY']  # US bonds
+
+    
+    def initialize_database(self):
+        """
+        Create database connection and initialize tables
+        """
+        try:
+            self.conn = sqlite3.connect(self.db_path)
+            self.cursor = self.conn.cursor()
+            
+            # Enhanced clients table
+            self.cursor.execute('''
+            CREATE TABLE IF NOT EXISTS clients (
+                id INTEGER PRIMARY KEY,
+                name TEXT NOT NULL,
+                email TEXT UNIQUE,
+                age INTEGER,
+                income REAL,
+                risk_tolerance INTEGER,
+                total_investment REAL,
+                investment_goals TEXT,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+            ''')
+            
+            # Enhanced portfolios table
+            self.cursor.execute('''
+            CREATE TABLE IF NOT EXISTS portfolios (
+                id INTEGER PRIMARY KEY,
+                client_id INTEGER,
+                investment_type TEXT,
+                asset_symbol TEXT,
+                investment_amount REAL,
+                purchase_price REAL,
+                current_price REAL,
+                performance REAL,
+                risk_score REAL,
+                allocation_percentage REAL,
+                last_updated DATETIME DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (client_id) REFERENCES clients (id)
+            )
+            ''')
+            
+            # Transactions table with more details
+            self.cursor.execute('''
+            CREATE TABLE IF NOT EXISTS transactions (
+                id INTEGER PRIMARY KEY,
+                portfolio_id INTEGER,
+                transaction_type TEXT,
+                asset_symbol TEXT,
+                amount REAL,
+                quantity REAL,
+                price REAL,
+                date DATETIME DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (portfolio_id) REFERENCES portfolios (id)
+            )
+            ''')
+            
+            # Performance tracking table
+            self.cursor.execute('''
+            CREATE TABLE IF NOT EXISTS performance_tracking (
+                id INTEGER PRIMARY KEY,
+                client_id INTEGER,
+                total_investment REAL,
+                current_value REAL,
+                total_return REAL,
+                annual_return REAL,
+                last_updated DATETIME DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (client_id) REFERENCES clients (id)
+            )
+            ''')
+            
+            self.conn.commit()
+        except sqlite3.Error as e:
+            print(f"Database initialization error: {e}")
+    
+    def get_real_time_market_data(self, symbols):
+        """
+        Fetch real-time market data using Yahoo Finance
+        
+        Args:
+            symbols (list): List of stock/asset symbols
+        
+        Returns:
+            dict: Real-time market data
+        """
+        market_data = {}
+        for symbol in symbols:
+            try:
+                ticker = yf.Ticker(symbol)
+                # Fetch historical data and current info
+                hist = ticker.history(period="1mo")
+                market_data[symbol] = {
+                    'current_price': ticker.info.get('regularMarketPrice', 0),
+                    'previous_close': ticker.info.get('previousClose', 0),
+                    'volume': ticker.info.get('volume', 0),
+                    'market_cap': ticker.info.get('marketCap', 0),
+                    'beta': ticker.info.get('beta', 1.0),
+                    'volatility': hist['Close'].std() if not hist.empty else 0,
+                    'returns_1m': (hist['Close'][-1] / hist['Close'][0] - 1) * 100 if len(hist) > 1 else 0
+                }
+            except Exception as e:
+                print(f"Error fetching data for {symbol}: {e}")
+        return market_data
+    
+    def generate_advanced_training_data(self, n_samples=5000):
+        """
+        Generate advanced synthetic training data with more features
+        
+        Returns:
+            tuple: Features and target variables
+        """
+        np.random.seed(42)
+        
+        # More comprehensive feature generation
+        age = np.random.randint(25, 65, n_samples)
+        income = np.random.uniform(30000, 1000000, n_samples)
+        investment_experience = np.random.randint(0, 30, n_samples)
+        current_investments = np.random.uniform(0, 5000000, n_samples)
+        
+        # Additional features
+        education_level = np.random.randint(1, 5, n_samples)  # 1-4 education levels
+        family_size = np.random.randint(1, 6, n_samples)
+        debt_to_income = np.random.uniform(0, 0.5, n_samples)
+        
+        # Combine features
+        X = np.column_stack([
+            age, income, investment_experience, current_investments,
+            education_level, family_size, debt_to_income
+        ])
+        
+        # Advanced risk scoring with more nuanced calculation
+        y_risk = (
+            (income / 50000) + 
+            (investment_experience / 10) - 
+            (debt_to_income * 10) + 
+            (education_level * 0.5) - 
+            (current_investments / 500000)
+        )
+        y_risk = np.clip(y_risk, 1, 10)  # Risk score between 1-10
+        
+        # Portfolio performance with more complex calculation
+        y_portfolio_performance = (
+            (income / 25000) + 
+            (investment_experience / 5) + 
+            (current_investments / 250000) - 
+            (debt_to_income * 20)
+        )
+        y_portfolio_performance = np.clip(y_portfolio_performance, 0, 100)
+        
+        return X, y_risk, y_portfolio_performance
+    
+    def train_advanced_models(self):
+        """
+        Train advanced machine learning models for risk and portfolio prediction
+        """
+        # Generate training data
+        X, y_risk, y_portfolio_performance = self.generate_advanced_training_data()
+        
+        # Split the data
+        X_train, X_test, y_risk_train, y_risk_test, y_perf_train, y_perf_test = train_test_split(
+            X, y_risk, y_portfolio_performance, test_size=0.2, random_state=42
+        )
+        
+        # Scale features
+        scaler = StandardScaler()
+        X_train_scaled = scaler.fit_transform(X_train)
+        X_test_scaled = scaler.transform(X_test)
+        
+        # Risk Prediction Model (Regression)
+        risk_model = RandomForestRegressor(n_estimators=200, random_state=42)
+        risk_model.fit(X_train_scaled, y_risk_train)
+        y_risk_pred = risk_model.predict(X_test_scaled)
+        risk_mse = mean_squared_error(y_risk_test, y_risk_pred)
+        
+        # Portfolio Performance Model (Regression)
+        portfolio_model = RandomForestRegressor(n_estimators=200, random_state=42)
+        portfolio_model.fit(X_train_scaled, y_perf_train)
+        y_perf_pred = portfolio_model.predict(X_test_scaled)
+        perf_mse = mean_squared_error(y_perf_test, y_perf_pred)
+        
+        # Investment Type Recommendation Model (Classification)
+        # Create synthetic labels for investment type recommendation
+        y_investment_type = np.random.choice(len(self.investment_types), len(X))
+        X_type_train, X_type_test, y_type_train, y_type_test = train_test_split(
+            X, y_investment_type, test_size=0.2, random_state=42
+        )
+        X_type_train_scaled = scaler.transform(X_type_train)
+        X_type_test_scaled = scaler.transform(X_type_test)
+        
+        investment_type_model = RandomForestClassifier(n_estimators=200, random_state=42)
+        investment_type_model.fit(X_type_train_scaled, y_type_train)
+        y_type_pred = investment_type_model.predict(X_type_test_scaled)
+        type_accuracy = accuracy_score(y_type_test, y_type_pred)
+        
+        # Save models and scaler
+        joblib.dump({
+            'risk_model': risk_model,
+            'portfolio_model': portfolio_model,
+            'investment_type_model': investment_type_model,
+            'scaler': scaler
+        }, 'advanced_hedge_fund_models.joblib')
+        
+        # Print model performance
+        print(f"Risk Prediction MSE: {risk_mse}")
+        print(f"Portfolio Performance MSE: {perf_mse}")
+        print(f"Investment Type Recommendation Accuracy: {type_accuracy}")
+        
+        return risk_model, portfolio_model, investment_type_model, scaler
+    
+    def load_or_train_models(self):
+        """
+        Load existing models or train new predictive models
+        """
+        try:
+            # Try to load pre-trained models
+            models = joblib.load('advanced_hedge_fund_models.joblib')
+            self.risk_model = models['risk_model']
+            self.portfolio_model = models['portfolio_model']
+            self.investment_type_model = models['investment_type_model']
+            self.scaler = models['scaler']
+        except (FileNotFoundError, KeyError):
+            # Train new models if not found
+            (self.risk_model, 
+             self.portfolio_model, 
+             self.investment_type_model, 
+             self.scaler) = self.train_advanced_models()
+    
+    def recommend_portfolio_allocation(self, client_features, target_return=0.15):
+        """
+        Recommend portfolio allocation with 15% target return
+        
+        Args:
+            client_features (numpy.ndarray): Client features
+            target_return (float): Target annual return percentage
+        
+        Returns:
+            dict: Recommended portfolio allocation
+        """
+        # Scale client features
+        scaled_features = self.scaler.transform(client_features.reshape(1, -1))
+        
+        # Predict risk and investment type
+        risk_score = float(self.risk_model.predict(scaled_features)[0])
+        investment_type_index = int(self.investment_type_model.predict(scaled_features)[0])
+        recommended_investment_type = self.investment_types[investment_type_index]
+        
+        # Fetch real-time market data for market indices
+        market_data = self.get_real_time_market_data(self.market_indices)
+        
+        # Calculate portfolio allocation
+        base_allocation = {
+            'Stocks': 0.4,
+            'Bonds': 0.3,
+            'ETFs': 0.15,
+            'Real Estate': 0.1,
+            'Other Alternatives': 0.05
+        }
+        
+        # Adjust allocation based on risk tolerance
+        if risk_score <= 3:  # Conservative
+            base_allocation = {
+                'Bonds': 0.6,
+                'Stocks': 0.2,
+                'ETFs': 0.1,
+                'Real Estate': 0.05,
+                'Other Alternatives': 0.05
+            }
+        elif risk_score >= 8:  # Aggressive
+            base_allocation = {
+                'Stocks': 0.5,
+                'ETFs': 0.2,
+                'Real Estate': 0.1,
+                'Cryptocurrencies': 0.1,
+                'Other Alternatives': 0.1
+            }
+        
+        # Recommended portfolio details
+        portfolio_recommendation = {
+            'risk_score': risk_score,
+            'recommended_investment_type': recommended_investment_type,
+            'allocation': base_allocation,
+            'target_return': target_return,
+            'market_indices': market_data
+        }
+        
+        return portfolio_recommendation
+    
+    def analyze_equity_bonds(self, risk_tolerance, investment_amount, investment_timeframe, sector_preference = None):
+      """Analyze Equities and Bonds and recommend investments
+      Args:
+        risk_tolerance: (str) "Low", "Medium", "High"
+        investment_amount: (float) total investment amount
+        investment_timeframe: (str) "Short term", "Medium term", "Long term"
+        sector_preference: (str) for equities, can be "Tech", "Healthcare", "Finance", etc.
+      """
+      
+      # Step 1: Data Retrieval for equities
+      equity_data = self.get_real_time_market_data(self.equity_etfs)
+      equity_df = pd.DataFrame.from_dict(equity_data, orient='index')
+    
+      # Step 2: Data Retrieval for bonds
+      bond_data = self.get_real_time_market_data(self.bond_etfs)
+      bond_df = pd.DataFrame.from_dict(bond_data, orient='index')
+
+      # Additional data retrieval
+      for symbol in self.equity_etfs + self.bond_etfs:
+        ticker = yf.Ticker(symbol)
+        hist = ticker.history(period="1y")
+        if not hist.empty:
+          returns = hist['Close'].pct_change().dropna() # Daily returns, remove the first NAN value
+          equity_df.loc[symbol, 'annual_return'] = returns.mean() * 252 # Annualize returns 
+        else:
+          equity_df.loc[symbol, 'annual_return'] = 0
+
+      # Equity Analysis
+      equity_df['risk_adjusted_return'] = equity_df['annual_return'] / equity_df['volatility'] if equity_df['volatility'].any() > 0 else 0
+      if sector_preference:
+            # Fetch and match to sector specific ETFs
+            sector_etfs_dict = {
+                "Technology": ["XLK","VGT"],
+                "Healthcare":["XLV","VHT"],
+                "Finance": ["XLF", "VFH"]
+            }
+            sector_etfs = sector_etfs_dict.get(sector_preference, None)
+            if sector_etfs:
+              sector_data = self.get_real_time_market_data(sector_etfs)
+              sector_df = pd.DataFrame.from_dict(sector_data, orient='index')
+
+            # additional data retrieve for sector
+              for symbol in sector_etfs:
+                  ticker = yf.Ticker(symbol)
+                  hist = ticker.history(period="1y")
+                  if not hist.empty:
+                    returns = hist['Close'].pct_change().dropna() # Daily returns, remove the first NAN value
+                    sector_df.loc[symbol, 'annual_return'] = returns.mean() * 252 # Annualize returns 
+                  else:
+                    sector_df.loc[symbol, 'annual_return'] = 0
+              
+              sector_df['risk_adjusted_return'] = sector_df['annual_return'] / sector_df['volatility'] if sector_df['volatility'].any() > 0 else 0
+
+              # Concatenate the dataframes of the Sector data with the equity data
+              equity_df = pd.concat([equity_df, sector_df])
+      # Bond analysis
+      bond_df['risk_adjusted_return'] = bond_df['returns_1m'] / bond_df['volatility'] if bond_df['volatility'].any() > 0 else 0
+    
+      # Step 3: Asset selection based on risk tolerance
+
+      if risk_tolerance == "Low":
+        equity_recommendations = equity_df.sort_values(by=['volatility']).head(3).index.tolist()  # Lower vol
+        bond_recommendations = bond_df.sort_values(by=['risk_adjusted_return'], ascending=False).head(2).index.tolist() # Higher returns for low risk
+      elif risk_tolerance == "Medium":
+        equity_recommendations = equity_df.sort_values(by=['risk_adjusted_return'], ascending=False).head(3).index.tolist()
+        bond_recommendations = bond_df.sort_values(by=['risk_adjusted_return'], ascending=False).head(2).index.tolist()
+      else:  # High Risk
+        equity_recommendations = equity_df.sort_values(by=['risk_adjusted_return'], ascending=False).head(3).index.tolist()
+        bond_recommendations = bond_df.sort_values(by=['volatility'], ascending=False).head(2).index.tolist() # higher yield, volatile bonds
+
+      # Step 4: Recommended Investment with allocation
+
+      if investment_timeframe == 'Short term':
+        allocation = {'Bonds':0.6, 'Equities':0.4}
+      elif investment_timeframe == 'Medium term':
+        allocation = {'Bonds': 0.4, 'Equities':0.6}
+      else: # Long Term
+        allocation = {'Bonds':0.3, 'Equities':0.7}
+
+      formatted_output = f"Recommended allocation: Bonds {allocation['Bonds'] * 100:.2f}%, Equities: {allocation['Equities'] * 100:.2f}% \n"
+      formatted_output += f"Equity Recommendations: \n"
+      for rec in equity_recommendations:
+          formatted_output += f" - {rec}\n"
+      formatted_output += f"Bond Recommendations: \n"
+      for rec in bond_recommendations:
+          formatted_output += f" - {rec}\n"
+
+      return formatted_output
+
+
+    def create_gradio_interface(self):
+        """
+        Create Gradio interface for the Advanced Hedge Fund Management System
+        
+        Returns:
+            gr.Interface: Gradio web interface
+        """
+        def analyze_investment_profile(age, income, investment_experience, 
+                                       current_investments, education_level, 
+                                       family_size, debt_to_income):
+            """
+            Comprehensive investment profile analysis
+            """
+            # Prepare client features
+            client_features = np.array([
+                age, income, investment_experience, current_investments,
+                education_level, family_size, debt_to_income
+            ])
+            
+            # Get portfolio recommendation
+            recommendation = self.recommend_portfolio_allocation(client_features)
+            
+            # Format output
+            allocation_str = "\n".join([
+                f"{k}: {v*100:.2f}%" for k, v in recommendation['allocation'].items()
+            ])
+            
+            output = (
+                f"Risk Score: {recommendation['risk_score']:.2f}/10\n"
+                f"Recommended Investment Type: {recommendation['recommended_investment_type']}\n"
+                f"Target Annual Return: {recommendation['target_return']*100:.2f}%\n\n"
+                "Portfolio Allocation:\n" + allocation_str + "\n\n"
+                "Market Indices Performance:\n" + 
+                "\n".join([
+                    f"{symbol}: {data['returns_1m']:.2f}% (1M Return)" 
+                    for symbol, data in recommendation['market_indices'].items()
+                ])
+            )
+            
+            return output
+        
+        def analyze_equity_bond_investments(risk_tolerance, investment_amount, investment_timeframe, sector_preference):
+            """
+             Analyze equity and bond investments based on users preferences
+            """
+
+            return self.analyze_equity_bonds(risk_tolerance, investment_amount, investment_timeframe, sector_preference)
+        # Gradio interface with more comprehensive inputs
+        interface = gr.TabbedInterface(
+            [
+                gr.Interface(
+                    fn=analyze_investment_profile,
+                    inputs=[
+                        gr.Number(label="Age"),
+                        gr.Number(label="Annual Income"),
+                        gr.Number(label="Investment Experience (Years)"),
+                        gr.Number(label="Current Investments"),
+                        gr.Dropdown(label="Education Level", choices=[1, 2, 3, 4]),
+                        gr.Number(label="Family Size"),
+                        gr.Number(label="Debt-to-Income Ratio")
+                    ],
+                    outputs=gr.Textbox(label="Investment Profile Analysis"),
+                    title="Investment Profile Analysis",
+                    description="Get personalized recommendations based on your profile"
+                ),
+                gr.Interface(
+                    fn=analyze_equity_bond_investments,
+                    inputs=[
+                        gr.Dropdown(label="Risk Tolerance", choices=["Low", "Medium", "High"]),
+                        gr.Number(label="Investment Amount"),
+                        gr.Dropdown(label="Investment Timeframe", choices=["Short term", "Medium term", "Long term"]),
+                        gr.Dropdown(label="Sector Preference", choices = ["Technology","Healthcare", "Finance", None] )
+                    ],
+                    outputs=gr.Textbox(label="Equity and Bond Analysis"),
+                    title="Equity and Bond Analysis",
+                    description="Analyze and get recommended Equities and Bonds based on your parameters"
+                )
+            ],
+            tab_names=["Investment Profile","Equity and Bond Analyzer"],
+            title="Advanced Hedge Fund Management System",
+            # description="Enter your details to get personalized investment recommendations."  # Removed description here
+        )
+        
+        return interface
+    
+    def run_gradio_app(self):
+        """
+        Run the Gradio web application
+        """
+        interface = self.create_gradio_interface()
+        interface.launch()
+
+if __name__ == "__main__":
+    hedge_fund_system = AdvancedHedgeFundManagementSystem()
+    hedge_fund_system.run_gradio_app()