Rename time_series_analyzer.py to time_series_forecasting.py

time_series_analyzer.py

@@ -1,72 +0,0 @@
-import streamlit as st
-import pandas as pd
-import plotly.express as px
-from statsmodels.tsa.seasonal import seasonal_decompose
-from statsmodels.tsa.arima.model import ARIMA
-from prophet import Prophet
-
-class TimeSeriesAnalyzer:
-    def analyze(self, df):
-        date_columns = df.select_dtypes(include=['datetime64']).columns
-        if len(date_columns) > 0:
-            date_column = st.selectbox("Select date column", date_columns)
-            value_column = st.selectbox("Select value column", df.columns)
-            
-            df[date_column] = pd.to_datetime(df[date_column])
-            df = df.sort_values(date_column)
-            
-            st.subheader("Time Series Plot")
-            fig = px.line(df, x=date_column, y=value_column)
-            st.plotly_chart(fig)
-            
-            analysis_type = st.selectbox("Select analysis type", ["Decomposition", "ARIMA Forecasting", "Prophet Forecasting"])
-            
-            if analysis_type == "Decomposition":
-                self.perform_decomposition(df, date_column, value_column)
-            elif analysis_type == "ARIMA Forecasting":
-                self.perform_arima_forecast(df, date_column, value_column)
-            elif analysis_type == "Prophet Forecasting":
-                self.perform_prophet_forecast(df, date_column, value_column)
-        else:
-            st.write("No datetime columns found in the dataset.")
-
-    def perform_decomposition(self, df, date_column, value_column):
-        df_temp = df.set_index(date_column)
-        result = seasonal_decompose(df_temp[value_column], model='additive', period=30)
-        
-        st.subheader("Time Series Decomposition")
-        fig = px.line(x=result.seasonal.index, y=result.seasonal, title="Seasonal")
-        st.plotly_chart(fig)
-        fig = px.line(x=result.trend.index, y=result.trend, title="Trend")
-        st.plotly_chart(fig)
-        fig = px.line(x=result.resid.index, y=result.resid, title="Residual")
-        st.plotly_chart(fig)
-
-    def perform_arima_forecast(self, df, date_column, value_column):
-        df_temp = df.set_index(date_column)
-        model = ARIMA(df_temp[value_column], order=(1,1,1))
-        results = model.fit()
-        
-        forecast_steps = st.slider("Select number of steps to forecast", min_value=1, max_value=365, value=30)
-        forecast = results.forecast(steps=forecast_steps)
-        
-        st.subheader("ARIMA Forecast")
-        fig = px.line(x=df_temp.index, y=df_temp[value_column], title="Original Data with Forecast")
-        fig.add_scatter(x=forecast.index, y=forecast, mode='lines', name='Forecast')
-        st.plotly_chart(fig)
-
-    def perform_prophet_forecast(self, df, date_column, value_column):
-        df_prophet = df[[date_column, value_column]].rename(columns={date_column: 'ds', value_column: 'y'})
-        model = Prophet()
-        model.fit(df_prophet)
-        
-        future_dates = st.slider("Select number of days to forecast", min_value=1, max_value=365, value=30)
-        future = model.make_future_dataframe(periods=future_dates)
-        forecast = model.predict(future)
-        
-        st.subheader("Prophet Forecast")
-        fig = px.line(x=df_prophet['ds'], y=df_prophet['y'], title="Original Data with Forecast")
-        fig.add_scatter(x=forecast['ds'], y=forecast['yhat'], mode='lines', name='Forecast')
-        fig.add_scatter(x=forecast['ds'], y=forecast['yhat_lower'], mode='lines', name='Lower Bound')
-        fig.add_scatter(x=forecast['ds'], y=forecast['yhat_upper'], mode='lines', name='Upper Bound')
-        st.plotly_chart(fig)

time_series_forecasting.py

@@ -0,0 +1,62 @@
+import pandas as pd
+import numpy as np
+from statsmodels.tsa.arima.model import ARIMA
+from statsmodels.tsa.seasonal import seasonal_decompose
+from prophet import Prophet
+
+class TimeSeriesForecaster:
+    def __init__(self):
+        self.model = None
+
+    def forecast(self, data, date_column, value_column, periods=30, method='auto'):
+        # Ensure data is sorted by date
+        data = data.sort_values(date_column)
+        data = data.set_index(date_column)
+        
+        if method == 'auto':
+            # Automatically choose between ARIMA and Prophet based on data characteristics
+            if self._has_seasonality(data[value_column]):
+                method = 'prophet'
+            else:
+                method = 'arima'
+
+        if method == 'arima':
+            return self._forecast_arima(data[value_column], periods)
+        elif method == 'prophet':
+            return self._forecast_prophet(data.reset_index(), date_column, value_column, periods)
+        else:
+            raise ValueError("Invalid method. Choose 'arima', 'prophet', or 'auto'.")
+
+    def _has_seasonality(self, series, threshold=0.1):
+        result = seasonal_decompose(series, model='additive', extrapolate_trend='freq')
+        return np.abs(result.seasonal).mean() > threshold * np.abs(result.trend).mean()
+
+    def _forecast_arima(self, series, periods):
+        model = ARIMA(series, order=(1, 1, 1))
+        self.model = model.fit()
+        forecast = self.model.forecast(steps=periods)
+        return pd.DataFrame({'date': forecast.index, 'forecast': forecast.values})
+
+    def _forecast_prophet(self, df, date_column, value_column, periods):
+        df = df.rename(columns={date_column: 'ds', value_column: 'y'})
+        model = Prophet()
+        self.model = model.fit(df)
+        future = model.make_future_dataframe(periods=periods)
+        forecast = model.predict(future)
+        return forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']]
+
+    def plot_forecast(self, original_data, forecast_data):
+        import matplotlib.pyplot as plt
+
+        plt.figure(figsize=(12, 6))
+        plt.plot(original_data.index, original_data, label='Original Data')
+        plt.plot(forecast_data['date'], forecast_data['forecast'], label='Forecast', color='red')
+        plt.fill_between(forecast_data['date'], 
+                         forecast_data['forecast'] - forecast_data['forecast'].std(),
+                         forecast_data['forecast'] + forecast_data['forecast'].std(),
+                         color='red', alpha=0.2)
+        plt.legend()
+        plt.title('Time Series Forecast')
+        plt.xlabel('Date')
+        plt.ylabel('Value')
+        return plt