init forecaster

app.py

@@ -1,8 +1,193 @@
+from forecast.page_config import APP_PAGE_HEADER
+
 import streamlit as st
+import pandas as pd
+
+APP_PAGE_HEADER()
+
+
+class InputData:
+    @classmethod
+    def get_data(cls) -> pd.DataFrame:
+        """
+        Datasets sources:
+           avg_daily_air_temp_celsius_helsinki:  http://shorturl.at/gBR06
+
+        Returns:
+
+        """
+        sample = st.selectbox(
+            "Sample datasets",
+            options=["", "sample1", "sample2", "avg_daily_air_temp_celsius_helsinki"],
+        )
+        if sample:
+            file_ = f"data/{sample}.csv"
+            return pd.read_csv(file_)
+
+        uploaded_data = cls.read_file()
+        if uploaded_data is not None:
+            return uploaded_data
+
+    @classmethod
+    def read_file(cls):
+        global DATE_FORMATTER
+
+        file_ = st.file_uploader("Upload your dataset (csv file)")
+        if not file_:
+            st.stop()
+
+        if file_:
+            sep = st.selectbox("column sep", options=[",", ";", "|"])
+            df = pd.read_csv(file_, sep=sep)
+
+            cols = df.columns.tolist()
+
+            # -- choose date/target columns
+            st1, st3, st2 = st.columns(3)
+            date_col = st1.selectbox(
+                "Date column (x-axis / index)", options=[""] + cols
+            )
+            st.session_state.date_formatter = st2.text_input(
+                "Optional: Date format e.g. %Y-%m-%d"
+            )
+            target = st3.selectbox(
+                "Target column (y-axis / target variable)", options=[""] + cols
+            )
+
+            # -- display
+            if date_col and target:
+                df = df[[date_col, target]]
+                return df
+            st.write(df)
+            st.stop()
+
+        return file_
+
+    @classmethod
+    def preprocess_data(cls, df: pd.DataFrame) -> pd.DataFrame:
+        df.columns = ["ds", "y"]
+        # -- date column
+        try:
+            if st.session_state.date_formatter:
+                df["ds"] = pd.to_datetime(
+                    df["ds"], format=st.session_state.date_formatter
+                )
+            else:
+                df["ds"] = pd.to_datetime(df["ds"]).dt.date
+        except:
+            st.error("Date column is not in correct format")
+            st.write(df["ds"])
+            st.stop()
+        # -- target column
+        df["y"] = df["y"].apply(lambda x: float(str(x).replace(",", "")))
+        df["y"] = df["y"].astype(float)
+
+        return df
+
+
+class PredictionApp:
+    @staticmethod
+    def run_prediction(df: pd.DataFrame) -> pd.DataFrame:
+        # -- prepare data and user input
+
+        st1, st2 = st.columns(2)
+        st1.write(df)
+        st2.line_chart(df.set_index("ds"))
+
+        segmented_df = PredictionApp.split_df_by_date(df)
+
+        # -- future date picker
+        n = segmented_df.shape[0]
+        future = st.slider("Number of days to predict", 7, n * 2, value=int(n / 2))
+
+        params = PredictionApp.user_input_model_params()
+        run = st.button("Run")
+        PredictionApp.display_prophet_docs()
+
+        if not run:
+            return
+
+        # -- run prediction
+        with st.spinner("running prediction engine .."):
+            from forecast.fbprophet.model import ProphetModel
+
+            model = ProphetModel()
+            pred = model.predict(segmented_df, period=future, **params)
+            return pred
+
+    @staticmethod
+    def split_df_by_date(df: pd.DataFrame) -> pd.DataFrame:
+        # -- split dataframe by date
+        st.caption("Choose the target fitting period")
+        st1, st2 = st.columns(2)
+
+        from_ = st1.date_input(
+            "from", min_value=df.ds.min(), max_value=df.ds.max(), value=df.ds.min()
+        )
+        to_ = st2.date_input(
+            "to", min_value=df.ds.min(), max_value=df.ds.max(), value=df.ds.max()
+        )
+        ix1 = df.index[df.ds == from_][0]
+        ix2 = df.index[df.ds == to_][0]
+        new_df = PredictionApp._displayed_segmented_dataframe(df, from_=ix1, to_=ix2)
+
+        new_df.reset_index(inplace=True)
+        st1.write(f"{new_df['ds'].min()}")
+        st2.write(f"{new_df['ds'].max()}")
+        return new_df
+
+    @classmethod
+    def _displayed_segmented_dataframe(
+        cls, df: pd.DataFrame, from_: int, to_: int
+    ) -> pd.DataFrame:
+        df = df.set_index("ds")
+        df_ = df[from_ : to_ + 1]
+        st.line_chart(df_)
+        return df_
+
+    @classmethod
+    def user_input_model_params(cls):
+        raw_params = st.text_input(
+            "Model params. Type param name and its value e.g. growth=logistic"
+        )
+
+        if raw_params:
+            in_params = [x.strip() for x in raw_params.split(",")]
+            params = {}
+            for param in in_params:
+                k, v = param.split("=")
+                params[k] = float(v) if v.isdigit() else v
+
+            if "growth" in params and params["growth"] == "logistic":
+                cap = st.text_input("cap")
+                if cap:
+                    params["cap"] = float(cap)
+                else:
+                    st.warning("Cap is required for logistic growth")
+                    st.stop()
+            st.write("Your input params:")
+            st.write(params)
+            return params
+        return {}
+
+    @classmethod
+    def display_prophet_docs(cls):
+        from prophet import Prophet
+
+        with st.expander("View model params"):
+
+            st.write(Prophet.__doc__)
+            st.markdown(
+                "> more details: [visit](https://facebook.github.io/prophet/)",
+                unsafe_allow_html=True,
+            )
 
 
 def app():
-    st.write("Hello, World!")
+    data = InputData.get_data()
+    data = InputData.preprocess_data(data)
+
+    PredictionApp.run_prediction(data)
 
 
 if __name__ == "__main__":

forecast/fbprophet/model.py

@@ -0,0 +1,55 @@
+import streamlit as st
+import pandas as pd
+from prophet import Prophet
+
+
+@st.experimental_singleton
+class ProphetModel:
+    @staticmethod
+    def predict(df: pd.DataFrame, **kwargs) -> pd.DataFrame:
+        st1, st2 = st.columns(2)
+        params = {
+            "growth": kwargs.get("growth", "linear"),
+            "interval_width": kwargs.get("interval_width", 0.95),
+        }
+        # st.write(params)
+        st.write(kwargs)
+        if "cap" in kwargs:
+            df["cap"] = float(kwargs.get("cap"))
+        period = kwargs.get("period", 7)
+
+        # -- train model
+        m = Prophet(**params)
+        m.fit(df)
+
+        future = m.make_future_dataframe(periods=period)
+        if "cap" in kwargs:
+            future["cap"] = float(kwargs.get("cap"))
+        forecast = m.predict(future)
+
+        # -- display output
+        cols = ["ds", "yhat", "yhat_lower", "yhat_upper"]
+
+        temp_ = forecast.copy()
+        temp_["ds"] = temp_["ds"].apply(lambda x: x.strftime("%Y-%m-%d"))
+        st.write(f"future={period}days")
+        st.write(temp_[cols])
+
+        fig1 = m.plot(forecast)
+        fig2 = m.plot_components(forecast)
+
+        from prophet.plot import plot_plotly, plot_components_plotly
+
+        st1.markdown("> forecasts")
+        st1.plotly_chart(plot_plotly(m, forecast, trend=True), use_container_width=True)
+        st2.markdown("> forecast components")
+        st2.plotly_chart(plot_components_plotly(m, forecast), use_container_width=True)
+
+        # -- download results
+        from forecast.utils import get_table_download_link
+
+        st.markdown(get_table_download_link(forecast), unsafe_allow_html=True)
+
+        st.success("Forecast completed ✨")
+
+        return df

forecast/page_config.py

@@ -0,0 +1,34 @@
+import datetime
+from datetime import date
+
+import streamlit as st
+
+
+def APP_PAGE_HEADER():
+    st.set_page_config(
+        page_title="Simple Forecaster",
+        page_icon=":camel:",
+        layout="wide",
+        initial_sidebar_state="collapsed",
+    )
+
+    hide_style = """
+                    <style>
+                    #MainMenu {visibility: hidden;}
+                    footer {visibility: hidden;}
+                    </style>
+                    """
+    st.markdown(hide_style, unsafe_allow_html=True)
+    HEADER()
+
+
+def HEADER():
+    st_ = st.columns(3)
+    st_[0].markdown("> ## Simple Time-Series Forecast")
+    today = date.today()
+
+    st_[1].image(
+        "./assets/logo.png",
+        caption=f"{today.strftime('%B %d, %Y')}",
+        use_column_width=True,
+    )

forecast/utils.py

@@ -0,0 +1,38 @@
+from datetime import datetime
+
+import pandas as pd
+
+
+def get_table_download_link(df: pd.DataFrame) -> str:
+    """Generates a link for download the `df` locally as a csv file.
+
+    Args:
+        df: the dataframe to download
+
+    Returns:
+        href link
+    """
+    import base64
+
+    csv = df.to_csv(index=False)
+    b64 = base64.b64encode(csv.encode()).decode()
+    return f'<a href="data:file/csv;base64,{b64}" download="data_{datetime.now()}.csv">download</a>'
+
+
+def filter_df(df: pd.DataFrame, filter_: str) -> pd.DataFrame:
+    """Takes a dataframe and a `filter_` keyword, returns all the rows that contain the value `filter_` in any column
+
+    Args:
+        df: pandas dataframe
+        filter_: the string to search in the dataframe
+
+    Returns:
+        filtered dataframe
+    """
+    import numpy as np
+
+    mask = np.column_stack(
+        [df[col].astype(str).str.contains(filter_, na=False) for col in df]
+    )
+    filtered_df = df.loc[mask.any(axis=1)]
+    return filtered_df

requirements.txt

@@ -1 +1,11 @@
-streamlit
+# Python3.8
+
+# -- data and processing
+pandas
+
+# -- UI
+streamlit==1.2.0
+
+# -- model
+pystan==2.19.1.1
+prophet