LSTM error solved

app.py

@@ -15,11 +15,14 @@ warnings.filterwarnings('ignore')
 try:
     from statsmodels.tsa.arima.model import ARIMA
     import tensorflow as tf
-    from tensorflow.keras.models import load_model
+    from tensorflow.keras.models import Sequential, load_model
+    from tensorflow.keras.layers import LSTM, Dense, Dropout
+    from tensorflow.keras.optimizers import Adam
+    from tensorflow.keras.callbacks import EarlyStopping
     MODELS_AVAILABLE = True
-except ImportError:
+except ImportError as e:
     MODELS_AVAILABLE = False
-    st.error("Required libraries not installed. Please install statsmodels and tensorflow.")
+    st.error(f"Required libraries not installed. Please install statsmodels and tensorflow. Error: {e}")
 
 st.set_page_config(
     page_title="Stock Price Forecasting: ARIMA vs LSTM",
@@ -127,73 +130,153 @@ if uploaded_file is not None:
                 
                 if model_choice in ["LSTM", "Both Models"] and MODELS_AVAILABLE:
                     try:
-                        # LSTM Model (simplified for demo)
-                        st.info("Training LSTM model...")
+                        # LSTM Model (Real Neural Network Implementation)
                         
-                        # Set random seed for reproducibility
-                        np.random.seed(42)
+                        # Create a cache key for this dataset
+                        cache_key = f"lstm_model_{selected_company}_{len(ts_data)}"
                         
                         # Prepare LSTM data
                         scaler = MinMaxScaler()
                         scaled_data = scaler.fit_transform(ts_data.values.reshape(-1, 1))
+                        sequence_length = min(60, len(scaled_data) // 4)
                         
-                        # Simple LSTM prediction (using last 60 days)
-                        sequence_length = min(60, len(scaled_data) - 1)
+                        if len(scaled_data) <= sequence_length + 10:
+                            st.warning("Insufficient data for LSTM training. Need at least 70 data points.")
+                            # Fallback to simple trend method
+                            last_values = ts_data.tail(10)
+                            trend = np.polyfit(range(len(last_values)), last_values, 1)[0]
+                            lstm_forecast = [ts_data.iloc[-1] + trend * i for i in range(1, forecast_days + 1)]
+                            
+                            results['LSTM (Trend Fallback)'] = {
+                                'forecast': np.array(lstm_forecast),
+                                'scaler': None
+                            }
                         
-                        if len(scaled_data) > sequence_length:
-                            # Create a simple LSTM forecast
-                            last_sequence = scaled_data[-sequence_length:]
+                        elif cache_key not in st.session_state:
+                            # Train new LSTM model
+                            st.info("Training LSTM model (this may take a minute)...")
+                            
+                            # Set seeds for reproducibility
+                            np.random.seed(42)
+                            tf.random.set_seed(42)
+                            
+                            def create_sequences(data, seq_length):
+                                X, y = [], []
+                                for i in range(len(data) - seq_length):
+                                    X.append(data[i:(i + seq_length)])
+                                    y.append(data[i + seq_length])
+                                return np.array(X), np.array(y)
+                            
+                            # Create training sequences
+                            X, y = create_sequences(scaled_data, sequence_length)
+                            
+                            # Split data for training (use 80% for training)
+                            train_size = int(len(X) * 0.8)
+                            X_train, X_test = X[:train_size], X[train_size:]
+                            y_train, y_test = y[:train_size], y[train_size:]
+                            
+                            # Build LSTM model
+                            model = Sequential([
+                                LSTM(50, return_sequences=True, input_shape=(sequence_length, 1)),
+                                Dropout(0.2),
+                                LSTM(50, return_sequences=False),
+                                Dropout(0.2),
+                                Dense(25),
+                                Dense(1)
+                            ])
                             
-                            # Simple trend-based forecast for demo (more robust)
-                            # Calculate moving average trend over last 10 values
-                            recent_values = last_sequence[-10:].flatten()
-                            if len(recent_values) > 1:
-                                # Use linear regression for trend
-                                x = np.arange(len(recent_values))
-                                z = np.polyfit(x, recent_values, 1)
-                                trend_slope = z[0]
-                            else:
-                                trend_slope = 0
+                            model.compile(optimizer=Adam(learning_rate=0.001), loss='mse')
+                            
+                            # Training with early stopping
+                            early_stopping = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)
+                            
+                            # Train the model
+                            with st.spinner("Training LSTM neural network..."):
+                                history = model.fit(
+                                    X_train, y_train,
+                                    batch_size=32,
+                                    epochs=50,
+                                    validation_data=(X_test, y_test),
+                                    callbacks=[early_stopping],
+                                    verbose=0
+                                )
+                            
+                            # Calculate model performance on test set
+                            test_predictions = model.predict(X_test, verbose=0)
+                            test_predictions = scaler.inverse_transform(test_predictions)
+                            y_test_actual = scaler.inverse_transform(y_test)
+                            
+                            lstm_test_rmse = np.sqrt(mean_squared_error(y_test_actual, test_predictions))
+                            st.success(f"LSTM Training Complete - Test RMSE: ${lstm_test_rmse:.2f}")
+                            
+                            # Cache the trained model and related data
+                            st.session_state[cache_key] = {
+                                'model': model,
+                                'scaler': scaler,
+                                'test_rmse': lstm_test_rmse,
+                                'sequence_length': sequence_length
+                            }
                             
-                            # Generate forecast with some randomness and trend
+                            # Generate forecast
+                            st.info("Generating LSTM predictions...")
+                            last_sequence = scaled_data[-sequence_length:].reshape(1, sequence_length, 1)
                             lstm_forecast_scaled = []
-                            last_value = scaled_data[-1][0]
                             
-                            # Add some bounds checking
-                            last_value = max(0.0, min(1.0, last_value))
+                            current_sequence = last_sequence.copy()
                             
-                            for i in range(forecast_days):
-                                # Apply trend with diminishing effect over time
-                                trend_effect = trend_slope * (i + 1) * 0.05
-                                # Add small random walk component
-                                random_walk = np.random.normal(0, 0.01)
-                                next_val = last_value + trend_effect + random_walk
-                                
-                                # Keep values within reasonable bounds
-                                next_val = max(0.0, min(1.0, next_val))
-                                lstm_forecast_scaled.append([next_val])
-                                last_value = next_val
+                            for _ in range(forecast_days):
+                                next_pred = model.predict(current_sequence, verbose=0)[0, 0]
+                                lstm_forecast_scaled.append(next_pred)
+                                current_sequence = np.roll(current_sequence, -1, axis=1)
+                                current_sequence[0, -1, 0] = next_pred
                             
-                            lstm_forecast_scaled = np.array(lstm_forecast_scaled)
+                            lstm_forecast_scaled = np.array(lstm_forecast_scaled).reshape(-1, 1)
                             lstm_forecast = scaler.inverse_transform(lstm_forecast_scaled).flatten()
                             
-                            # Check for NaN values and replace with reasonable estimates
-                            if np.any(np.isnan(lstm_forecast)) or np.any(np.isinf(lstm_forecast)):
-                                st.warning("LSTM forecast contained invalid values, using fallback method")
-                                # Fallback: use last known price with small random variations
-                                last_price = ts_data.iloc[-1]
-                                lstm_forecast = np.array([last_price * (1 + np.random.normal(0, 0.02)) 
-                                                        for _ in range(forecast_days)])
+                            results['LSTM'] = {
+                                'forecast': lstm_forecast,
+                                'model': model,
+                                'scaler': scaler,
+                                'test_rmse': lstm_test_rmse
+                            }
+                            
+                        else:
+                            # Use cached model
+                            st.info("Using cached LSTM model...")
+                            cached_data = st.session_state[cache_key]
+                            model = cached_data['model']
+                            scaler = cached_data['scaler']
+                            lstm_test_rmse = cached_data['test_rmse']
+                            sequence_length = cached_data['sequence_length']
+                            
+                            # Prepare data for cached model
+                            scaled_data = scaler.transform(ts_data.values.reshape(-1, 1))
+                            
+                            # Generate forecast with cached model
+                            st.info("Generating LSTM predictions...")
+                            last_sequence = scaled_data[-sequence_length:].reshape(1, sequence_length, 1)
+                            lstm_forecast_scaled = []
+                            
+                            current_sequence = last_sequence.copy()
+                            
+                            for _ in range(forecast_days):
+                                next_pred = model.predict(current_sequence, verbose=0)[0, 0]
+                                lstm_forecast_scaled.append(next_pred)
+                                current_sequence = np.roll(current_sequence, -1, axis=1)
+                                current_sequence[0, -1, 0] = next_pred
+                            
+                            lstm_forecast_scaled = np.array(lstm_forecast_scaled).reshape(-1, 1)
+                            lstm_forecast = scaler.inverse_transform(lstm_forecast_scaled).flatten()
                             
                             results['LSTM'] = {
                                 'forecast': lstm_forecast,
-                                'scaler': scaler
+                                'model': model,
+                                'scaler': scaler,
+                                'test_rmse': lstm_test_rmse
                             }
                     
                     except Exception as e:
-                        st.error(f"LSTM model error: {str(e)}")
-                
-                # Display results
+                        st.error(f"LSTM model error: {str(e)}")                # Display results
                 if results:
                     # Create forecast dates
                     last_date = stock_data.index[-1]