Update app.py

app.py

@@ -45,86 +45,29 @@ class AdvancedMLModels:
             Dropout(0.2),
             LSTM(50, return_sequences=False),
             Dropout(0.2),
-            Dense(25),
+            Dense(25, activation='relu'),
             Dense(1)
         ])
         model.compile(optimizer='adam', loss='mse')
         return model
 
     def prepare_lstm_data(self, X, y, look_back=60):
+        # Ensure X and y are numpy arrays
+        X = np.array(X)
+        y = np.array(y)
+        
+        # Reshape X to be 3D for LSTM (samples, timesteps, features)
+        if len(X.shape) == 2:
+            X = X.reshape((X.shape[0], 1, X.shape[1]))
+        
+        # Prepare sequences
         X_lstm = []
         y_lstm = []
         for i in range(look_back, len(X)):
             X_lstm.append(X[i-look_back:i])
             y_lstm.append(y[i])
-        return np.array(X_lstm), np.array(y_lstm)
-
-class PortfolioOptimizer:
-    def __init__(self, assets, returns):
-        self.assets = assets
-        self.returns = returns
-        
-    def portfolio_performance(self, weights):
-        returns = np.sum(self.returns.mean() * weights) * 252
-        volatility = np.sqrt(np.dot(weights.T, np.dot(self.returns.cov() * 252, weights)))
-        sharpe = returns / volatility
-        return returns, volatility, sharpe
-    
-    def optimize_portfolio(self, risk_free_rate=0.01):
-        num_assets = len(self.assets)
-        constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
-        bounds = tuple((0, 1) for _ in range(num_assets))
-        
-        def objective(weights):
-            returns, volatility, sharpe = self.portfolio_performance(weights)
-            return -sharpe  # Maximize Sharpe ratio
-            
-        initial_weights = np.array([1/num_assets] * num_assets)
-        result = minimize(objective, initial_weights, method='SLSQP',
-                        bounds=bounds, constraints=constraints)
         
-        return result.x
-
-class AlertSystem:
-    def __init__(self):
-        self.alert_types = {
-            'price_threshold': self.check_price_threshold,
-            'rsi_extreme': self.check_rsi_extreme,
-            'volume_spike': self.check_volume_spike,
-            'trend_reversal': self.check_trend_reversal
-        }
-    
-    def check_price_threshold(self, data, params):
-        current_price = data['Close'].iloc[-1]
-        if current_price >= params['upper']:
-            return f"Price above upper threshold: ${current_price:,.2f}"
-        elif current_price <= params['lower']:
-            return f"Price below lower threshold: ${current_price:,.2f}"
-        return None
-    
-    def check_rsi_extreme(self, data, params):
-        current_rsi = data['RSI'].iloc[-1]
-        if current_rsi >= 70:
-            return f"RSI in overbought territory: {current_rsi:.2f}"
-        elif current_rsi <= 30:
-            return f"RSI in oversold territory: {current_rsi:.2f}"
-        return None
-    
-    def check_volume_spike(self, data, params):
-        current_volume = data['Volume'].iloc[-1]
-        avg_volume = data['Volume'].rolling(window=20).mean().iloc[-1]
-        if current_volume > avg_volume * params['threshold']:
-            return f"Volume spike detected: {current_volume:,.0f}"
-        return None
-    
-    def check_trend_reversal(self, data, params):
-        if data['SMA20'].iloc[-1] < data['SMA50'].iloc[-1] and \
-           data['SMA20'].iloc[-2] > data['SMA50'].iloc[-2]:
-            return "Potential downward trend reversal detected"
-        elif data['SMA20'].iloc[-1] > data['SMA50'].iloc[-1] and \
-             data['SMA20'].iloc[-2] < data['SMA50'].iloc[-2]:
-            return "Potential upward trend reversal detected"
-        return None
+        return np.array(X_lstm), np.array(y_lstm)
 
 class CryptoAnalyzer:
     def __init__(self, symbol, period='1y'):
@@ -133,7 +76,6 @@ class CryptoAnalyzer:
         self.data = self.fetch_data()
         self.preprocess_data()
         self.ml_models = AdvancedMLModels()
-        self.alert_system = AlertSystem()
     
     def fetch_data(self):
         return yf.download(self.symbol, period=self.period, interval='1d')
@@ -142,38 +84,34 @@ class CryptoAnalyzer:
         # Add technical indicators
         df = self.data.copy()
         
+        # Add technical indicators
         df['RSI'] = ta.momentum.RSIIndicator(df['Close']).rsi()
         macd = ta.trend.MACD(df['Close'])
         df['MACD'] = macd.macd()
-        df['MFI'] = ta.volume.MFIIndicator(df['High'], df['Low'], df['Close'], df['Volume']).money_flow_index()
-        df['ATR'] = ta.volatility.AverageTrueRange(df['High'], df['Low'], df['Close']).average_true_range()
-        df['OBV'] = ta.volume.OnBalanceVolumeIndicator(df['Close'], df['Volume']).on_balance_volume()
         
-        df['SMA20'] = df['Close'].rolling(window=20).mean()
-        df['SMA50'] = df['Close'].rolling(window=50).mean()
+        # Ensure all columns are numeric and handle potential NaNs
+        numeric_columns = ['Close', 'Open', 'High', 'Low', 'Volume', 'RSI', 'MACD']
+        df[numeric_columns] = df[numeric_columns].apply(pd.to_numeric, errors='coerce')
         
-        # Bollinger Bands
-        bb = ta.volatility.BollingerBands(df['Close'])
-        df['BB_upper'] = bb.bollinger_hband()
-        df['BB_lower'] = bb.bollinger_lband()
+        # Fill NaN values
+        df.fillna(method='ffill', inplace=True)
         
         self.data = df
     
     def train_prediction_model(self):
         df = self.data.copy()
         
-        feature_columns = [
-            'RSI', 'MACD', 'MFI', 'ATR', 'OBV',
-            'SMA20', 'SMA50', 'BB_upper', 'BB_lower',
-            'Volume'
-        ]
+        # Select and prepare features
+        feature_columns = ['Close', 'Volume', 'RSI', 'MACD']
         
         # Prepare features and target
-        X = df[feature_columns].dropna()
-        y = df['Close'].shift(-prediction_days).dropna()
+        X = df[feature_columns].values
+        y = df['Close'].values
         
-        # Align data
-        X = X[:len(y)]
+        # Remove NaN values
+        mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y)
+        X = X[mask]
+        y = y[mask]
         
         # Train-test split
         train_size = int(len(X) * (backtesting_split / 100))
@@ -185,43 +123,25 @@ class CryptoAnalyzer:
         X_train_scaled = scaler.fit_transform(X_train)
         X_test_scaled = scaler.transform(X_test)
         
-        # Train multiple models
-        predictions = {}
-        for name, model in self.ml_models.models.items():
-            if name == 'lstm':
-                # Prepare LSTM data
-                X_lstm_train, y_lstm_train = self.ml_models.prepare_lstm_data(X_train_scaled, y_train)
-                X_lstm_test, y_lstm_test = self.ml_models.prepare_lstm_data(X_test_scaled, y_test)
-                
-                # Create and train LSTM model
-                model = self.ml_models.create_lstm_model((X_lstm_train.shape[1], X_lstm_train.shape[2]))
-                model.fit(X_lstm_train, y_lstm_train, epochs=50, batch_size=32, verbose=0)
-                predictions[name] = model.predict(X_lstm_test)
-            else:
-                model.fit(X_train_scaled, y_train)
-                predictions[name] = model.predict(X_test_scaled)
+        # Prepare LSTM data
+        X_lstm_train, y_lstm_train = self.ml_models.prepare_lstm_data(X_train_scaled, y_train)
+        X_lstm_test, y_lstm_test = self.ml_models.prepare_lstm_data(X_test_scaled, y_test)
         
-        # Ensemble predictions (weighted average)
-        weights = {
-            'random_forest': 0.3,
-            'gradient_boost': 0.3,
-            'ada_boost': 0.2,
-            'lstm': 0.2
-        }
+        # Create and train LSTM model
+        lstm_model = self.ml_models.create_lstm_model((X_lstm_train.shape[2], X_lstm_train.shape[1]))
+        lstm_model.fit(X_lstm_train, y_lstm_train, epochs=50, batch_size=32, verbose=0)
         
-        final_predictions = np.zeros_like(y_test)
-        for name, pred in predictions.items():
-            final_predictions += pred.flatten() * weights[name]
+        # Make predictions
+        lstm_predictions = lstm_model.predict(X_lstm_test).flatten()
         
-        return final_predictions, y_test
+        return lstm_predictions, y_lstm_test
 
 def main():
-    st.set_page_config(page_title="Advanced Crypto Analysis Pro", layout="wide")
-    st.title("Advanced Cryptocurrency Analysis Pro")
+    st.set_page_config(page_title="Crypto Price Prediction", layout="wide")
+    st.title("Cryptocurrency Price Prediction")
     
-    # Sidebar for asset selection
-    st.sidebar.header("Crypto Asset Selection")
-    selected_crypto = st.sidebar.selectbox(
+    # Cryptocurrency selection
+    selected_crypto = st.selectbox(
         "Select Cryptocurrency",
         list(TRADING_PAIRS.keys()),
         index=0
@@ -232,6 +152,7 @@ def main():
     
     # Initialize Crypto Analyzer
     try:
+        # Fetch and analyze data
         analyzer = CryptoAnalyzer(symbol)
         df = analyzer.data
         
@@ -246,68 +167,35 @@ def main():
         )])
         st.plotly_chart(fig)
         
-        # Portfolio Optimization
-        st.subheader("Portfolio Optimization")
-        selected_assets = st.multiselect(
-            "Select assets for portfolio",
-            list(TRADING_PAIRS.keys()),
-            default=[selected_crypto]
-        )
-        
-        if len(selected_assets) > 1:
-            # Fetch historical data for selected assets
-            portfolio_data = {}
-            for asset in selected_assets:
-                symbol = TRADING_PAIRS[asset]
-                data = yf.download(symbol, period='1y', interval='1d')
-                portfolio_data[asset] = data['Close'].pct_change().dropna()
-            
-            # Create returns DataFrame
-            returns_df = pd.DataFrame(portfolio_data)
-            
-            # Optimize portfolio
-            optimizer = PortfolioOptimizer(selected_assets, returns_df)
-            optimal_weights = optimizer.optimize_portfolio()
-            
-            # Display optimal allocation
-            st.write("Optimal Portfolio Allocation:")
-            for asset, weight in zip(selected_assets, optimal_weights):
-                st.write(f"{asset}: {weight:.2%}")
-        
-        # Real-time Alerts
-        st.subheader("Real-time Alerts")
-        alert_settings = {}
-        
-        with st.expander("Configure Alerts"):
-            alert_settings['price_threshold'] = {
-                'upper': st.number_input("Upper Price Threshold", value=float(df['Close'].iloc[-1] * 1.1)),
-                'lower': st.number_input("Lower Price Threshold", value=float(df['Close'].iloc[-1] * 0.9))
-            }
-            alert_settings['volume_spike'] = {
-                'threshold': st.slider("Volume Spike Threshold", 1.5, 5.0, 2.0)
-            }
-        
-        # Check for alerts
-        current_alerts = []
-        for alert_type, check_func in analyzer.alert_system.alert_types.items():
-            if alert_type in alert_settings:
-                alert = check_func(df, alert_settings[alert_type])
-                if alert:
-                    current_alerts.append(alert)
-        
-        if current_alerts:
-            for alert in current_alerts:
-                st.warning(alert)
-        
         # Price Prediction
         st.subheader("Price Prediction")
         try:
             predictions, actual = analyzer.train_prediction_model()
+            
+            # Create DataFrame for comparison
             pred_df = pd.DataFrame({
                 'Predicted Price': predictions,
                 'Actual Price': actual
             })
+            
+            # Plotting predictions vs actual
+            fig_pred = go.Figure()
+            fig_pred.add_trace(go.Scatter(
+                x=list(range(len(predictions))), 
+                y=predictions, 
+                mode='lines', 
+                name='Predicted Price'
+            ))
+            fig_pred.add_trace(go.Scatter(
+                x=list(range(len(actual))), 
+                y=actual, 
+                mode='lines', 
+                name='Actual Price'
+            ))
+            
+            st.plotly_chart(fig_pred)
             st.dataframe(pred_df)
+        
         except Exception as pred_error:
             st.error(f"Prediction error: {pred_error}")