m1

Model_Result_Overview.py

@@ -107,287 +107,156 @@ if auth_status:
     if not is_state_initiaized:
         a=1
     
-    # st.header("")
-    # st.markdown("<h5 style='font-weight: normal;'>MMM Readout for Selected Period</h5>", unsafe_allow_html=True)
-    #### Input Select Start and End Date  
-    
-    # Create two columns for start date and end date input
-    col1, col2 = st.columns(2)
-
-    # now = datetime.now()
-    # us_format = now.strftime("%m/%d/%Y")
-
-    # Define the minimum and maximum dates
-    min_date,max_date = sf.get_date_range()
-    # st.write(min_date,max_date)
-    # min_date = datetime(2023, 1, 1)
-    # max_date = datetime(2024, 12, 31)
-    default_date1,default_date2 = sf.get_default_dates()   
-    # st.write(default_date1,default_date2)                                                       
-    with col1:
-        start_date = st.date_input("Start Date: ",value=default_date1,min_value=min_date,
-                                    max_value=max_date)
-        
-    with col2:
-        end_date = st.date_input("End Date: ",value = default_date2,min_value=min_date,
-                                    max_value=max_date)
-    
-    # col1, col2 = st.columns(2)
-    # with col1:
-    #     fig = sf.pie_spend(start_date,end_date)
-    #     st.plotly_chart(fig,use_container_width=True)
-    # with col2:
-    #     fig = sf.pie_contributions(start_date,end_date)
-    #     st.plotly_chart(fig,use_container_width=True)
-    # st.header("Distribution of Spends and Contributions")
-    fig = sf.pie_charts(start_date,end_date)
-    st.plotly_chart(fig,use_container_width=True)
-
-    # Dropdown menu options
-    st.markdown("<h1 style='font-size:28px;'>Change in MMM Estimated Prospect Contributions</h1>", unsafe_allow_html=True)
-    # st.header("Change in MMM Estimated Prospect Contributions")
-
-
-
-
-    options = [
-        "Month on Month",
-        "Year on Year"]
-    col1, col2 = st.columns(2)
-         # Create a dropdown menu
-    with col1:
-        selected_option = st.selectbox('Select a comparison', options)
-    with col2:
-        st.markdown("""</br>""",unsafe_allow_html=True)
-        if selected_option == "Month on Month" :
-
-            st.markdown(
-                f"""
-                <div style="padding: 5px; border-radius: 5px; background-color: #FFFFE0; width: fit-content; display: inline-block;">
-                    <strong> Comparision of current month spends to previous month spends</strong>
-                </div>
-                """,
-                unsafe_allow_html=True
-            )
-        else :
-            st.markdown(
-                f"""
-                <div style="padding: 5px; border-radius: 5px; background-color: #FFFFE0; width: fit-content; display: inline-block;">
-                    <strong> Comparision of current month spends to the same month in previous year</strong>
-                </div>
-                """,
-                unsafe_allow_html=True
-            )
-        # Waterfall chart
-    
-    def get_month_year_list(start_date, end_date):
-        # Generate a range of dates from start_date to end_date with a monthly frequency
-        dates = pd.date_range(start=start_date, end=end_date, freq='MS')  # 'MS' is month start frequency
-        
-        # Extract month and year from each date and create a list of tuples
-        month_year_list = [(date.month, date.year) for date in dates]
-        
-        return month_year_list
-    def get_start_end_dates(month, year):
-        start_date = datetime(year, month, 1).date()
-        
-        if month == 12:
-            end_date = datetime(year + 1, 1, 1).date() - timedelta(days=1)
-        else:
-            end_date = datetime(year, month + 1, 1).date() - timedelta(days=1)
-        
-        return start_date, end_date
-    
-    month_year_list = get_month_year_list(start_date, end_date)
-    dropdown_options = [f"{date.strftime('%B %Y')}" for date in pd.date_range(start=start_date, end=end_date, freq='MS')]
-    waterfall_option = st.selectbox("Select a month:", dropdown_options)
-    waterfall_date = datetime.strptime(waterfall_option, "%B %Y")
-    waterfall_month = waterfall_date.month 
-    waterfall_year = waterfall_date.year 
-    waterfall_start_date, waterfall_end_date = get_start_end_dates(waterfall_month, waterfall_year)
-
-    fig = sf.waterfall(waterfall_start_date,waterfall_end_date,selected_option)
-    st.plotly_chart(fig,use_container_width=True)
-        
-    # Waterfall table
-    shares_df = sf.shares_df_func(waterfall_start_date,waterfall_end_date)
-    st.table(sf.waterfall_table_func(shares_df).style.format("{:.0%}"))
-
-    ## Channel Contribution Bar Chart
-    st.plotly_chart(sf.channel_contribution(start_date,end_date),use_container_width=True)
-    st.plotly_chart(sf.chanel_spends(start_date,end_date),use_container_width=True)
-    # Format first three rows in percentage format
-    # styled_df = sf.shares_table_func(shares_df)
-    # # styled_df = styled_df.round(0).astype(int)
-    # styled_df.iloc[:3] = (styled_df.iloc[:3]).astype(int)
-
-        # # Round next two rows to two decimal places
-        # styled_df.iloc[3:5] = styled_df.iloc[3:5].round(0).astype(str)
-
-        # st.table(styled_df)
-    st.dataframe(sf.shares_table_func(shares_df),use_container_width=True)
-    
-    st.dataframe(sf.eff_table_func(shares_df).style.format({"TOTAL SPEND": "{:,.0f}", "TOTAL SUPPORT": "{:,.0f}", "TOTAL CONTRIBUTION": "{:,.0f}"}),use_container_width=True)
-
-        ### CPP CHART
-    st.plotly_chart(sf.cpp(start_date,end_date),use_container_width=True)
+    with st.expander("View Channel Wise Spend And Prospect Analysis "):
+        # Create two columns for start date and end date input
+        col1, col2 = st.columns(2) 
+        min_date,max_date = sf.get_date_range()
+        # st.write(min_date,max_date)
+        # min_date = datetime(2023, 1, 1)
+        # max_date = datetime(2024, 12, 31)
+        default_date1,default_date2 = sf.get_default_dates()   
+        # st.write(default_date1,default_date2)                                                       
+        with col1:
+            start_date = st.date_input("Start Date: ",value=default_date1,min_value=min_date,
+                                        max_value=max_date)
+        with col2:
+            end_date = st.date_input("End Date: ",value = default_date2,min_value=min_date,
+                                        max_value=max_date)
+        # col1, col2 = st.columns(2)
+        # with col1:
+        #     fig = sf.pie_spend(start_date,end_date)
+        #     st.plotly_chart(fig,use_container_width=True)
+        # with col2:
+        #     fig = sf.pie_contributions(start_date,end_date)
+        #     st.plotly_chart(fig,use_container_width=True)
+        # st.header("Distribution of Spends and Contributions")
+        fig = sf.pie_charts(start_date,end_date)
+        st.plotly_chart(fig,use_container_width=True)
+
+         ## Channel Contribution Bar Chart
+        st.plotly_chart(sf.channel_contribution(start_date,end_date),use_container_width=True)
+        st.plotly_chart(sf.chanel_spends(start_date,end_date),use_container_width=True)
+        # Format first three rows in percentage format
+        # styled_df = sf.shares_table_func(shares_df)
+        # # styled_df = styled_df.round(0).astype(int)
+        # styled_df.iloc[:3] = (styled_df.iloc[:3]).astype(int)
+
+            # # Round next two rows to two decimal places
+            # styled_df.iloc[3:5] = styled_df.iloc[3:5].round(0).astype(str)
+
+            # st.table(styled_df)
+        shares_df = sf.shares_df_func(start_date,end_date)
+        st.dataframe(sf.shares_table_func(shares_df),use_container_width=True)
         
+        st.dataframe(sf.eff_table_func(shares_df).style.format({"TOTAL SPEND": "{:,.0f}", "TOTAL SUPPORT": "{:,.0f}", "TOTAL CONTRIBUTION": "{:,.0f}"}),use_container_width=True)
+
+            ### CPP CHART
+        st.plotly_chart(sf.cpp(start_date,end_date),use_container_width=True)
+    data_selection_type = st.radio("Select Input Type",["Compare Monthly Change", "Compare Custom Range"])
+    waterfall_start_date,waterfall_end_date = start_date,end_date
+    with st.expander("View Change in MMM Estimated Prospect Contributions Analysis"):
+        # Dropdown menu options
+        st.markdown("<h1 style='font-size:28px;'>Change in MMM Estimated Prospect Contributions</h1>", unsafe_allow_html=True)
+        if data_selection_type == "Compare Monthly Change":
+            options = [
+                "Month on Month",
+                "Year on Year"]
+            col1, col2 = st.columns(2)
+                # Create a dropdown menu
+            with col1:
+                selected_option = st.selectbox('Select a comparison', options)
+            with col2:
+                st.markdown("""</br>""",unsafe_allow_html=True)
+                if selected_option == "Month on Month" :
+
+                    st.markdown(
+                        f"""
+                        <div style="padding: 5px; border-radius: 5px; background-color: #FFFFE0; width: fit-content; display: inline-block;">
+                            <strong> Comparision of current month spends to previous month spends</strong>
+                        </div>
+                        """,
+                        unsafe_allow_html=True
+                    )
+                else :
+                    st.markdown(
+                        f"""
+                        <div style="padding: 5px; border-radius: 5px; background-color: #FFFFE0; width: fit-content; display: inline-block;">
+                            <strong> Comparision of current month spends to the same month in previous year</strong>
+                        </div>
+                        """,
+                        unsafe_allow_html=True
+                    )
+                # Waterfall chart
+            
+            def get_month_year_list(start_date, end_date):
+                # Generate a range of dates from start_date to end_date with a monthly frequency
+                dates = pd.date_range(start=start_date, end=end_date, freq='MS')  # 'MS' is month start frequency
+                
+                # Extract month and year from each date and create a list of tuples
+                month_year_list = [(date.month, date.year) for date in dates]
+                
+                return month_year_list
+            def get_start_end_dates(month, year):
+                start_date = datetime(year, month, 1).date()
+                
+                if month == 12:
+                    end_date = datetime(year + 1, 1, 1).date() - timedelta(days=1)
+                else:
+                    end_date = datetime(year, month + 1, 1).date() - timedelta(days=1)
+                
+                return start_date, end_date
+            
+            month_year_list = get_month_year_list(start_date, end_date)
+            dropdown_options = [f"{date.strftime('%B %Y')}" for date in pd.date_range(start=start_date, end=end_date, freq='MS')]
+            waterfall_option = st.selectbox("Select a month:", dropdown_options)
+            waterfall_date = datetime.strptime(waterfall_option, "%B %Y")
+            waterfall_month = waterfall_date.month 
+            waterfall_year = waterfall_date.year 
+            waterfall_start_date, waterfall_end_date = get_start_end_dates(waterfall_month, waterfall_year)
+            # st.write("abc")
+            # figw = sf.waterfall(waterfall_start_date,waterfall_end_date)
+            figw= sf.waterfall(waterfall_start_date,waterfall_end_date,selected_option)
+            st.plotly_chart(figw,use_container_width=True)
+
+        elif data_selection_type == "Compare Custom Range": 
+            col1, col2 = st.columns(2)
+            min_date,max_date = sf.get_date_range() 
+            with col1:
+                st.write("Select Time Period 1")
+                sc1,sc2 = st.columns(2)
+                with sc1:
+                    waterfall_start_date1 = st.date_input("Start Date 1: ",value=start_date,min_value=min_date,
+                                            max_value=max_date)
+                with sc2:
+                    waterfall_end_date1 = st.date_input("End Date 1: ",value = end_date,min_value=min_date,
+                                            max_value=max_date)
+            with col2:
+                st.write("Select Time Period 2")
+                ec1,ec2 = st.columns(2)
+                with ec1:
+                    waterfall_start_date2 = st.date_input("Start Date 2: ",value=end_date-timedelta(days = -1),min_value=min_date,
+                                            max_value=max_date)
+                with ec2:
+                    diff = min((start_date-end_date).days,-30)
+                    waterfall_end_date2 = st.date_input("End Date 2: ",value = start_date,min_value=min_date,
+                                            max_value=max_date)
+            try:
+                figw= sf.waterfall2(waterfall_start_date1,waterfall_end_date1,waterfall_start_date2,waterfall_end_date2)
+                st.plotly_chart(figw,use_container_width=True)
+            except:
+                st.warning("Previous data does not exist")
+
+
+
+        # Waterfall table
+        # shares_df = sf.shares_df_func(waterfall_start_date,waterfall_end_date)
+        st.table(sf.waterfall_table_func(shares_df).style.format("{:.0%}"))
+
+   
+    with st.expander("View Decomposition Analysis"):    
         ### Base decomp CHART
-    st.plotly_chart(sf.base_decomp(),use_container_width=True)
+        st.plotly_chart(sf.base_decomp(),use_container_width=True)
 
         ### Media decomp CHART
-    st.plotly_chart(sf.media_decomp(),use_container_width=True)
+        st.plotly_chart(sf.media_decomp(),use_container_width=True)
      
-    
-    # st.write(fig.columns)
-    # st.dataframe(fig)
-
-    # def panel_fetch(file_selected):
-    #     raw_data_mmm_df = pd.read_excel(file_selected, sheet_name="RAW DATA MMM")
-
-    #     if "Panel" in raw_data_mmm_df.columns:
-    #         panel = list(set(raw_data_mmm_df["Panel"]))
-    #     else:
-    #         raw_data_mmm_df = None
-    #         panel = None
-
-    #     return panel
-
-    # def rerun():
-    #     st.rerun()
-
-    # metrics_selected='prospects'
-
-    # file_selected = (
-    #         f"Overview_data_test_panel@#{metrics_selected}.xlsx"
-    #     )
-    # panel_list = panel_fetch(file_selected)
-
-    # if "selected_markets" not in st.session_state:
-    #     st.session_state['selected_markets']='DMA1'
-
-
-    # st.header('Overview of previous spends')
-
-    # selected_market= st.selectbox(
-    #         "Select Markets",
-    #         ["Total Market"] + panel_list
-    #     )
-
-
-
-    # initialize_data(target_col,selected_market)
-    # scenario = st.session_state['scenario']
-    # raw_df = st.session_state['raw_df']
-    # st.write(scenario.actual_total_spends)
-    # st.write(scenario.actual_total_sales)
-    # columns = st.columns((1,1,3))
-
-    # with columns[0]:
-    #     st.metric(label='Spends', value=format_numbers(float(scenario.actual_total_spends)))
-    # #### print(f"##################### {scenario.actual_total_sales} ##################")
-    # with columns[1]:
-    #     st.metric(label=target, value=format_numbers(float(scenario.actual_total_sales),include_indicator=False))
-
-
-    # actual_summary_df = create_channel_summary(scenario)
-    # actual_summary_df['Channel'] = actual_summary_df['Channel'].apply(channel_name_formating) 
-
-    # columns = st.columns((2,1))
-    # #with columns[0]:
-    # with st.expander('Channel wise overview'):
-    #     st.markdown(actual_summary_df.style.set_table_styles(
-    #     [{
-    #         'selector': 'th',
-    #         'props': [('background-color', '#FFFFF')]
-    #     },
-    #         {
-    #         'selector' : 'tr:nth-child(even)',
-    #         'props' : [('background-color', '#FFFFF')]
-    #         }]).to_html(), unsafe_allow_html=True)
-            
-    # st.markdown("<hr>",unsafe_allow_html=True)
-    # ##############################
-
-    # st.plotly_chart(create_contribution_pie(scenario),use_container_width=True)
-    # st.markdown("<hr>",unsafe_allow_html=True)
-
-
-    # ################################3
-    # st.plotly_chart(create_contribuion_stacked_plot(scenario),use_container_width=True)
-    # st.markdown("<hr>",unsafe_allow_html=True)
-    # #######################################
-
-    # selected_channel_name = st.selectbox('Channel', st.session_state['channels_list'] + ['non media'], format_func=channel_name_formating)
-    # selected_channel = scenario.channels.get(selected_channel_name,None)
-
-    # st.plotly_chart(create_channel_spends_sales_plot(selected_channel), use_container_width=True)
-
-    # st.markdown("<hr>",unsafe_allow_html=True)
-
-# elif auth_status == False:
-#     st.error('Username/Password is incorrect')
-    
-# if auth_status != True:
-#     try:
-#         username_forgot_pw, email_forgot_password, random_password = authenticator.forgot_password('Forgot password')
-#         if username_forgot_pw:
-#             st.success('New password sent securely')
-#             # Random password to be transferred to user securely
-#         elif username_forgot_pw == False:
-#             st.error('Username not found')
-#     except Exception as e:
-#         st.error(e)
-# st.header("")
-# st.markdown("<h5 style='font-weight: normal;'>MMM Readout for Selected Period</h5>", unsafe_allow_html=True)
-# #### Input Select Start and End Date
-    
-# # Create two columns for start date and end date input
-# col1, col2 = st.columns(2)
-    
-# with col1:
-#     start_date = st.date_input("Start Date: ")
-    
-# with col2:
-#     end_date = st.date_input("End Date: ")
-# # Dropdown menu options
-# options = [
-#     "Month on Month",
-#     "Year on Year"]
-# col1, col2 = st.columns(2)
-#      # Create a dropdown menu
-# with col1:
-#     selected_option = st.selectbox('Select a comparison', options)
-# with col2:
-#     st.write("")
-#     # Waterfall chart
-# fig = sf.waterfall(start_date,end_date,selected_option)
-# st.plotly_chart(fig)
-    
-# # Waterfall table
-# shares_df = sf.shares_df_func(start_date,end_date)
-# st.table(sf.waterfall_table_func(shares_df).style.format("{:.0%}"))
-
-# ## Channel Contribution Bar Chart
-# st.plotly_chart(sf.channel_contribution(start_date,end_date))
-# # Format first three rows in percentage format
-# # styled_df = sf.shares_table_func(shares_df)
-# # # styled_df = styled_df.round(0).astype(int)
-# # styled_df.iloc[:3] = (styled_df.iloc[:3]).astype(int)
-
-#     # # Round next two rows to two decimal places
-#     # styled_df.iloc[3:5] = styled_df.iloc[3:5].round(0).astype(str)
-
-#     # st.table(styled_df)
-# st.dataframe(sf.shares_table_func(shares_df))
-
-# st.dataframe(sf.eff_table_func(shares_df))
-
-#     ### CPP CHART
-# st.plotly_chart(sf.cpp(start_date,end_date))
-    
-#     ### Base decomp CHART
-# st.plotly_chart(sf.base_decomp())
-
-#     ### Media decomp CHART
-#     st.plotly_chart(sf.media_decomp())

Streamlit_functions.py

@@ -254,7 +254,160 @@ def pie_contributions(start_date,end_date):
 
     # Show the figure
     return fig
+def waterfall2(start_date1,end_date1,start_date2,end_date2):
+    btn_chart = "Month on Month" 
+    # if pd.isnull(start_date) == True :
+    #     start_date = datetime(2024, 1, 28)
+    # if pd.isnull(end_date) == True :
+    #     end_date = datetime(2024, 2, 24)
+    # start_date = datetime.strptime(start_date, "%Y-%m-%d")
+    # end_date = datetime.strptime(end_date, "%Y-%m-%d")
+    # start_date = start_date.datetime.data
+    # end_date = end_date.datetime.data
+    start_date1 = pd.to_datetime(start_date1)
+    end_date1 = pd.to_datetime(end_date1)
+    start_date2 = pd.to_datetime(start_date2)
+    end_date2 = pd.to_datetime(end_date2)
+
+    # if btn_chart == "Month on Month":
+    #     start_date_prev =  start_date +timedelta(weeks=-4)   
+    #     end_date_prev = start_date +timedelta(days=-1)   
+    # else:
+    #     start_date_prev =  start_date +timedelta(weeks=-52)   
+    #     end_date_prev = start_date_prev +timedelta(weeks=4) +timedelta(days=-1) 
+        
+
+    if start_date1 < df['Date'].min() : 
+        return "a"
+
+    cur_data = df[(df['Date'] >= start_date2) & (df['Date'] <= end_date2)]
+    prev_data = df[(df['Date'] >= start_date1) & (df['Date'] <= end_date1)]
+
+
+    # Example data for the waterfall chart
+    data = [
+        {'label': 'Previous Period', 'value': round(prev_data[contribution_cols].values.sum())},
+        {'label': 'Broadcast TV', 'value': round(cur_data['Broadcast TV_Prospects'].sum()-prev_data['Broadcast TV_Prospects'].sum())},
+        {'label': 'Cable TV', 'value': round(cur_data['Cable TV_Prospects'].sum()-prev_data['Cable TV_Prospects'].sum())},
+        {'label': 'Connected & OTT TV', 'value': round(cur_data['Connected & OTT TV_Prospects'].sum()-prev_data['Connected & OTT TV_Prospects'].sum())}, 
+        {'label': 'Video', 'value': round(cur_data['Video_Prospects'].sum()-prev_data['Video_Prospects'].sum())}, 
+        {'label': 'Display Prospecting', 'value': round(cur_data['Display Prospecting_Prospects'].sum()-prev_data['Display Prospecting_Prospects'].sum())},
+        {'label': 'Display Retargeting', 'value': round(cur_data['Display Retargeting_Prospects'].sum()-prev_data['Display Retargeting_Prospects'].sum())},
+        {'label': 'Social Prospecting', 'value': round(cur_data['Social Prospecting_Prospects'].sum()-prev_data['Social Prospecting_Prospects'].sum())},
+        {'label': 'Social Retargeting', 'value': round(cur_data['Social Retargeting_Prospects'].sum()-prev_data['Social Retargeting_Prospects'].sum())},
+        {'label': 'Search Brand', 'value': round(cur_data['Search Brand_Prospects'].sum()-prev_data['Search Brand_Prospects'].sum())}, 
+        {'label': 'Search Non-brand', 'value': round(cur_data['Search Non-brand_Prospects'].sum()-prev_data['Search Non-brand_Prospects'].sum())}, 
+        {'label': 'Digital Partners', 'value': round(cur_data['Digital Partners_Prospects'].sum()-prev_data['Digital Partners_Prospects'].sum())}, 
+        {'label': 'Audio', 'value': round(cur_data['Audio_Prospects'].sum()-prev_data['Audio_Prospects'].sum())}, 
+        {'label': 'Email', 'value': round(cur_data['Email_Prospects'].sum()-prev_data['Email_Prospects'].sum())},
+        {'label': 'Current Period', 'value': round(cur_data[contribution_cols].values.sum())}
+    ]
+
+    # Calculate cumulative values for the waterfall chart
+    cumulative = [0]
+    for i in range(len(data)):
+        cumulative.append(cumulative[-1] + data[i]['value'])
+
+    # Adjusting values to start from zero for both first and last columns
+    cumulative[-1] = 0  # Set the last cumulative value to zero
+
+    # Extracting labels and values
+    labels = [item['label'] for item in data]
+    values = [item['value'] for item in data]
+
+    # Plotting the waterfall chart using go.Bar
+    bars = []
+    for i in range(len(data)):
+        color = '#4A88D9' if i == 0 or i == len(data) - 1 else '#DC5537'  # Blue for first and last, gray for others
+        hover_text = f"<b>{labels[i]}</b><br>Value: {abs(values[i])}"
+
+        bars.append(go.Bar(
+            x=[labels[i]],
+            y=[cumulative[i+1] - cumulative[i]],
+            base=[cumulative[i]],
+            text=[f"{abs(values[i]):,}"],
+            textposition='auto',
+            hovertemplate=hover_text,
+            marker=dict(color=color),
+            showlegend=False
+        ))
 
+    # Creating the figure
+    fig = go.Figure(data=bars)
+
+    # Updating layout for black background and gray gridlines
+    if btn_chart == "Month on Month":
+        fig.update_layout(
+            title=f"Change In MMM Estimated Prospect Contribution"
+            ,showlegend=False,
+            # plot_bgcolor='black',
+            # paper_bgcolor='black',
+            # font=dict(color='white'),  # Changing font color to white for better contrast
+            xaxis=dict(
+                showgrid=False,
+                zeroline=False,  # Hiding the x-axis zero line
+            ),
+            yaxis=dict(
+                title="Prospects",
+                showgrid=True,
+                gridcolor='lightgray',
+                griddash='dot',  # Setting y-axis gridline color to gray
+                zeroline=False,  # Hiding the y-axis zero line
+                # range=[18000, max(max(cumulative), max(values)) + 1000] # Setting the y-axis range from 19k to slightly above the maximum value
+            )
+            )
+        fig.add_annotation(
+        text=f"{start_date2.strftime('%m-%d-%Y')} to {end_date2.strftime('%m-%d-%Y')} vs. {start_date1.strftime('%m-%d-%Y')} To {end_date1.strftime('%m-%d-%Y')}",
+        x=0,
+        y=1.15,
+        xref="x domain",
+        yref="y domain",
+        showarrow=False,
+        font=dict(size=16),
+        # align='left'
+    )
+        # fig.update_xaxes(
+        #         tickmode="array",
+        #         # categoryorder="total ascending",
+        #         tickvals=[f"{abs(values[i])}"],
+        #         ticktext=[f"{abs(values[i])}"],
+        #         ticklabelposition="outside",
+        #         tickfont=dict(color="white"),
+        # )
+    else :
+        fig.update_layout(
+            showlegend=False,
+            # plot_bgcolor='black',
+            # paper_bgcolor='black',
+            # font=dict(color='white'),  # Changing font color to white for better contrast
+            xaxis=dict(
+                showgrid=False,
+                zeroline=False,  # Hiding the x-axis zero line
+            ),
+            yaxis=dict(
+                title="Prospects",
+                showgrid=True,
+                gridcolor='lightgray',
+                griddash='dot',  # Setting y-axis gridline color to gray
+                zeroline=False,  # Hiding the y-axis zero line
+                # range=[10000, max(cumulative)+1000]  # Setting the y-axis range from 19k to slightly above the maximum value
+            )
+        
+        )
+        fig.add_annotation(
+        text=f"{start_date_prev.strftime('%m-%d-%Y')} to {end_date_prev.strftime('%m-%d-%Y')} vs. {start_date.strftime('%m-%d-%Y')} To {end_date.strftime('%m-%d-%Y')}",
+        x=0,
+        y=1.15,
+        xref="x domain",
+        yref="y domain",
+        showarrow=False,
+        font=dict(size=16),
+        # align='left'
+    )
+    # # print(cur_data)
+    # # print(prev_data)
+    # fig.show()
+    return fig
 def waterfall(start_date,end_date,btn_chart):
     # if pd.isnull(start_date) == True :
     #     start_date = datetime(2024, 1, 28)
@@ -1314,7 +1467,7 @@ def scenario_spend_forecasting2(delta_df,start_date,end_date):
             return "Invalid month number"
     
     data2["Month year"] = data2["Month"].apply(get_month_name) + ' ' +(data2["Date"].dt.year+1).astype(str)   
-    print(data2.columns)
+    # print(data2.columns)
     data2 = data2[['Month year' ,'BROADCAST TV', 'CABLE TV',
        'CONNECTED & OTT TV', 'VIDEO', 'DISPLAY PROSPECTING',
        'DISPLAY RETARGETING', 'SOCIAL PROSPECTING', 'SOCIAL RETARGETING',

classes.py

@@ -100,7 +100,7 @@ class Channel:
         self.modified_total_sales = self.modified_sales.sum()
         self.delta_spends = self.modified_total_spends - self.actual_total_spends
         self.delta_sales = self.modified_total_sales - self.actual_total_sales
-
+        # print(self.actual_total_spends)
     def update_penalty(self, penalty):
         self.penalty = penalty
 
@@ -111,29 +111,39 @@ class Channel:
         self.modified_spends = (
             self.modified_spends * total_spends / self.modified_spends.sum()
         )
+        print("modified spends")
+        print(self.modified_spends)
 
     def calculate_sales(self):
-        # # print("in calc_sales")
+        print("in calc_sales")
+        print(self.modified_spends)
         return self.response_curve(self.modified_spends)
 
     def hill_equation(x, Kd, n):
         return x**n / (Kd**n + x**n)
     def response_curve(self, x):
-        if self.penalty:
-            x = np.where(
-                x < self.upper_limit,
-                x,
-                self.upper_limit + (x - self.upper_limit) * self.upper_limit / x,
-            )
+        print(x)
+        # if self.penalty:
+        #     print("in penalty")
+        #     x = np.where(
+        #         x < self.upper_limit,
+        #         x,
+        #         self.upper_limit + (x - self.upper_limit) * self.upper_limit / x,
+        #     )
         if self.response_curve_type == "hill-eq":
             # dividing_parameter = check_dividing_parameter()
-            # # print("lalala")
-            # # print(self.name)
+            # print("lalala")
+            # # print(self.name)\
+            # print(len(x))
+            print("in response curve function")
+            print(x)
             if len(x) == 1:
-                dividing_rate = 104
+                dividing_rate = self.response_curve_params["num_pos_obsv"]
+                # print(dividing_rate)
                 # x = np.sum(x)
             else:
                 dividing_rate = 1
+            # dividing_rate = self.response_curve_params["num_pos_obsv"]
                 # x = np.sum(x)
             # dividing_rate = 104
             Kd= self.response_curve_params["Kd"]
@@ -160,6 +170,9 @@ class Channel:
             # # print(sales) 
             # # print(np.sum(sales))
             # # print("sales",sales)
+            print("aa")
+            print(sales)
+            print("aa1")
         if self.response_curve_type == "s-curve":
             if self.power >= 0:
                 x = x / 10**self.power
@@ -260,7 +273,7 @@ class Scenario:
     def calculate_modified_total_spends(self):
         total_actual_spends = 0.0
         for channel in self.channels.values():
-            total_actual_spends += channel.actual_total_spends * channel.conversion_rate
+            total_actual_spends += channel.actual_total_spends * 1.0
         return total_actual_spends
 
     def calculate_modified_total_spends(self):
@@ -269,13 +282,14 @@ class Scenario:
             # import streamlit as st
             # st.write(channel.modified_total_spends )
             total_modified_spends += (
-                channel.modified_total_spends * channel.conversion_rate
+                channel.modified_total_spends * 1.0
+               
             )
         return total_modified_spends
 
     def calculate_actual_total_sales(self):
         total_actual_sales = 0#self.constant.sum()  + self.correction.sum()
-        print("a")
+        # print("a")
         for channel in self.channels.values():
             total_actual_sales += channel.actual_total_sales
             # # print(channel.actual_total_sales)
@@ -343,16 +357,7 @@ class Scenario:
 
     #     return zip(channels_list, res.x)
 
-    def hill_equation(x, Kd, n):
-        return x**n / (Kd**n + x**n)
-    
-    def cost_func(channel,x):
-        x_inp = (x/104 - param_dicts["x_min"][channel]) / (param_dicts["x_max"][channel] - param_dicts["x_min"][channel])
-    #     # print(x_inp)
-        x_out = hill_equation(x_inp, param_dicts["Kd"][channel], param_dicts["n"][channel])
-    #     # print(x_out)
-    #    
-        return (param_dicts["y_max"][channel] - param_dicts["y_min"][channel])*(x_out + param_dicts["y_min"][channel])*104
+
     
     
     
@@ -393,10 +398,10 @@ class Scenario:
 
         for channel_name, modified_spends in zip(channels_list, res.x):
             self.update(channel_name, modified_spends)
-
+            
         return zip(channels_list, res.x)
     
-
+    
 
     def optimize(self, spends_percent, channels_list):
         # channels_list = self.channels.keys()
@@ -406,17 +411,18 @@ class Scenario:
         for channel_name in channels_list:
             # spends_constraint += self.channels[channel_name].modified_total_spends
             spends_constant.append(self.channels[channel_name].conversion_rate)
+            # print(spends_constant)
             spends_constraint += (
                 self.channels[channel_name].actual_total_spends
-                * self.channels[channel_name].conversion_rate
+                * 1.0
             )
         spends_constraint = spends_constraint * (1 + spends_percent / 100)
-        # constraint= LinearConstraint(np.ones((num_channels,)), lb = spends_constraint, ub = spends_constraint)
-        constraint = LinearConstraint(
-            np.array(spends_constant),
-            lb=spends_constraint,
-            ub=spends_constraint,
-        )
+        constraint= LinearConstraint(np.ones((num_channels,)), lb = spends_constraint, ub = spends_constraint)
+        # constraint = LinearConstraint(
+        #     np.array(spends_constant),
+        #     lb=spends_constraint,
+        #     ub=spends_constraint,
+        # )
         bounds = []
         old_spends = []
         for channel_name in channels_list:
@@ -426,14 +432,41 @@ class Scenario:
                 (1 + spends_percent / 100)
             )
             old_spends.append(channel_actual_total_spends)
-            bounds.append((1+ channel_bounds / 100) * channel_actual_total_spends)
-
+            # bounds.append((1+ channel_bounds / 100) * channel_actual_total_spends)
+            lb = (1- _channel_class.channel_bounds_min / 100) * channel_actual_total_spends
+            ub = (1+ _channel_class.channel_bounds_max / 100) * channel_actual_total_spends
+            bounds.append((lb,ub))
+            # _channel_class.channel_bounds_min
+            # _channel_class.channel_bounds_max
+        def cost_func1(channel,x):
+            response_curve_params = pd.read_excel("response_curves_parameters.xlsx",index_col = "channel")
+            param_dicts = {col: response_curve_params[col].to_dict() for col in response_curve_params.columns}
+
+            Kd= param_dicts["Kd"][channel]
+            n= param_dicts["n"][channel]
+            x_min= param_dicts["x_min"][channel]
+            x_max= param_dicts["x_max"][channel]
+            y_min= param_dicts["y_min"][channel]
+            y_max= param_dicts['y_max'][channel] 
+            division_parameter = param_dicts['num_pos_obsv'][channel] 
+            x_inp = ( x/division_parameter- x_min) / (x_max - x_min)
+        #     print(x_inp)
+            x_out = x_inp**n / (Kd**n + x_inp**n)
+            x_val_inv = (x_out*x_max + (1 - x_out) * x_min)
+            sales = (x_val_inv*y_min/y_max)*division_parameter
+            if np.isnan(sales):
+        #         print(sales,channel)
+                sales = 0
+            # print(sales,channel)
+            return sales
         def objective_function(x):
+            modified_total_sales = 0
             for channel_name, modified_spends in zip(channels_list, x):
-                self.update(channel_name, modified_spends)
+                modified_total_sales = modified_total_sales + cost_func1(channel_name,modified_spends)
+                # self.update(channel_name, modified_spends)
             return -1 * self.modified_total_sales
 
-        # # print(bounds)
+        print(bounds)
         # # print("$"*100)
         res = minimize(
             lambda x: objective_function(x)  / 1e3,
@@ -441,7 +474,7 @@ class Scenario:
             x0=old_spends,
             constraints=constraint,
             bounds=bounds,
-            options={"maxiter": int(1e7), "xtol": 50},
+            options={"maxiter": int(1e7), "xtol": 0.1},
         )
         # res = dual_annealing(
         # objective_function,
@@ -454,6 +487,7 @@ class Scenario:
         # # print(res)
         for channel_name, modified_spends in zip(channels_list, res.x):
             self.update(channel_name, modified_spends)
+            print(channel_name, modified_spends,cost_func1(channel_name, modified_spends))
 
         return zip(channels_list, res.x)
     
@@ -461,18 +495,7 @@ class Scenario:
     def hill_equation(self,x, Kd, n):
         return x**n / (Kd**n + x**n)
     
-    def cost_func(self ,channel,x):
-
-        response_curve_params = pd.read_excel("response_curves_parameters.xlsx",index_col = "channel")
-        param_dicts = {col: response_curve_params[col].to_dict() for col in response_curve_params.columns}
-        
-        x_inp = (x/104 - param_dicts["x_min"][channel]) / (param_dicts["x_max"][channel] - param_dicts["x_min"][channel])
-    #     # print(x_inp)
-        x_out = self.hill_equation(x_inp, param_dicts["Kd"][channel], param_dicts["n"][channel])
-    #     # print(x_out)
-    #    
-        return (param_dicts["y_max"][channel] - param_dicts["y_min"][channel])*(x_out + param_dicts["y_min"][channel])*104
-        
+    
 
     # def spends_optimisation(self, spends_percent,channels_list):
     #     m = GEKKO(remote=False)

pages/1_Model_Quality.py

@@ -16,7 +16,7 @@ st.plotly_chart(sf.mmm_model_quality(),use_container_width=True)
     
 media_df = sf.media_data()
     # Create two columns for start date and end date input
-col1, col2 , col3 = st.columns([1,1,1])
+col1, col2 , col3 = st.columns([1,0.2,1])
 df1 = sf.model_metrics_table_func()
 st.dataframe(df1,hide_index  = True,use_container_width=True) 
 

pages/2_Scenario_Planner.py

@@ -98,6 +98,9 @@ def optimize(key, status_placeholder):
                         # result = st.session_state["scenario"].spends_optimisation(
                         # st.session_state["total_spends_change"], channel_list
                     )
+                    print("")
+                    print(list(zip(*result)))
+
     
 
         # elif key.lower() == "revenue":
@@ -111,7 +114,7 @@ def optimize(key, status_placeholder):
         for channel_name, modified_spends in result:
 
             st.session_state[channel_name] = numerize(
-                modified_spends * scenario.channels[channel_name].conversion_rate,
+                modified_spends * 1.0,
                 1,
             )
             prev_spends = (

pages/5_Glossary.py

@@ -5,29 +5,32 @@ import streamlit as st
 # )
 
 def glossary_run():
-    st.subheader("Glossary of MMM Terminology")
-    st.write("**• Model R-squared \(R\)\:** This is a statistical measure used to determine the percentage of variation in the dependent variable that the independent variables explain collectively. It ranges between 0 and 1, where 1 indicates a perfect fit and 0 indicates no linear relationship. An R2 greater than 0.8 usually indicates a great model fit.")
+    st.header("Glossary")
+    with st.expander("Model MMM Terminology"):
+        st.subheader("Glossary of MMM Terminology")
+        st.write("**• Model R-squared \(R\)\:** This is a statistical measure used to determine the percentage of variation in the dependent variable that the independent variables explain collectively. It ranges between 0 and 1, where 1 indicates a perfect fit and 0 indicates no linear relationship. An R2 greater than 0.8 usually indicates a great model fit.")
 
-    st.write("**• Mean Absolute Percentage Error \(MAPE\):** This is a measure used to determine the accuracy of a predictive model. It calculates the average absolute percentage difference between the actual and predicted values, expressing the result as a percentage to provide a sense of scale for the error.")
+        st.write("**• Mean Absolute Percentage Error \(MAPE\):** This is a measure used to determine the accuracy of a predictive model. It calculates the average absolute percentage difference between the actual and predicted values, expressing the result as a percentage to provide a sense of scale for the error.")
 
-    st.write("**• Media & Baseline Elasticity:** It refers to the percentage change in the number of prospects in response to a percentage change in a marketing input \(media channel spends\) or a baseline factor \(like seasonality. macro factors, competitors spending, etc.\). It is a measure of the responsiveness of the number of prospects to changes in the marketing input or the baseline factor")
+        st.write("**• Media & Baseline Elasticity:** It refers to the percentage change in the number of prospects in response to a percentage change in a marketing input \(media channel spends\) or a baseline factor \(like seasonality. macro factors, competitors spending, etc.\). It is a measure of the responsiveness of the number of prospects to changes in the marketing input or the baseline factor")
 
-    st.write("**• Media Half-Life:** This represents the time it takes for a media spend's impact to reduce to half of its initial impact. It is a key aspect of media decay rates, which represent how the effect of advertising diminishes over time \(in weeks\). This term refers to a curve that illustrates the relationship between media spend and the resulting number of prospects.")
+        st.write("**• Media Half-Life:** This represents the time it takes for a media spend's impact to reduce to half of its initial impact. It is a key aspect of media decay rates, which represent how the effect of advertising diminishes over time \(in weeks\). This term refers to a curve that illustrates the relationship between media spend and the resulting number of prospects.")
 
-    st.write("**• Support:** Equivalent to Impression or Click depending on the media channel.")
+        st.write("**• Support:** Equivalent to Impression or Click depending on the media channel.")
 
-    st.write("**• Contribution Share:** Unit is %. It refers to the percentage contribution of a specific marketing channel to the number of prospects. It is calculated by dividing the contribution from a particular channel by the total number of prospects from all media channels \(not including base contributions\).")
+        st.write("**• Contribution Share:** Unit is %. It refers to the percentage contribution of a specific marketing channel to the number of prospects. It is calculated by dividing the contribution from a particular channel by the total number of prospects from all media channels \(not including base contributions\).")
 
-    st.write("**• Spend Share:** Unit is %. It refers to the percentage of the total marketing budget that is allocated to a specific marketing channel. It is calculated by dividing the amount spent on a particular channel by the total marketing spend")
+        st.write("**• Spend Share:** Unit is %. It refers to the percentage of the total marketing budget that is allocated to a specific marketing channel. It is calculated by dividing the amount spent on a particular channel by the total marketing spend")
 
-    st.write("**• Support Share:** Unit is %. It refers to the percentage of the total media impression that is allocated to a specific marketing channel. It is calculated by dividing support on a particular channel by the total marketing spend")
+        st.write("**• Support Share:** Unit is %. It refers to the percentage of the total media impression that is allocated to a specific marketing channel. It is calculated by dividing support on a particular channel by the total marketing spend")
 
-    st.write("**• Efficiency Index:** it is a metric that measures the cost-effectiveness of a campaign. It is calculated by dividing Contribution Share by Spend Share. An efficiency index above 1 suggests that a channel is more cost-effective than the benchmark, while an efficiency index below 1 suggests it is less cost-effective. The higher the efficiency index, the more cost-effective its channel is")
+        st.write("**• Efficiency Index:** it is a metric that measures the cost-effectiveness of a campaign. It is calculated by dividing Contribution Share by Spend Share. An efficiency index above 1 suggests that a channel is more cost-effective than the benchmark, while an efficiency index below 1 suggests it is less cost-effective. The higher the efficiency index, the more cost-effective its channel is")
 
-    st.write("**• Effectiveness Index:** It is a metric that measures how well a particular marketing channel is performing relative to its support/impression. It is calculated by dividing the Contribution Share by the Spend Share for each channel")
+        st.write("**• Effectiveness Index:** It is a metric that measures how well a particular marketing channel is performing relative to its support/impression. It is calculated by dividing the Contribution Share by the Spend Share for each channel")
 
-    st.write("**• Estimated CPM \(Cost Per Thousand Impressions\):** This is an estimation of the cost for every thousand impressions \(or views\) of its advertisement via that media channel. The default values are generated from historical averages.")
-
-    st.write("**• Estimated CPC \(Cost Per Click\):** This is an estimation of the cost for each time someone clicks on its advertisement via that media channel. The default values are generated from historical averages.")
+        st.write("**• Estimated CPM \(Cost Per Thousand Impressions\):** This is an estimation of the cost for every thousand impressions \(or views\) of its advertisement via that media channel. The default values are generated from historical averages.")
 
+        st.write("**• Estimated CPC \(Cost Per Click\):** This is an estimation of the cost for each time someone clicks on its advertisement via that media channel. The default values are generated from historical averages.")
+    with st.expander("Deployment Plan"):
+        st.image(r"C:\Users\PragyaJatav\Downloads\image (2).png")
 glossary_run()

summary_df.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ea149846bb9c8341d1a26a5e74dfbfea9df62ce4a7bd05ff07922a9169932a5d
+oid sha256:02f8f23713eadad9c91bae3af6649f9f2e7e2aa8d73fb28986bd48903cb74f38
 size 1822

utilities.py

@@ -335,7 +335,7 @@ def initialize_data(
             spends=spends,
             sales= y.copy(),
             # conversion_rate = np.mean(list(conv_rates[inp_col].values())),
-            conversion_rate=conv_rates[inp_col],
+            conversion_rate=1.0 ,#conv_rates[inp_col],
             response_curve_type="hill-eq",
             response_curve_params={
                 "Kd": param_dicts["Kd"][inp_col],
@@ -343,7 +343,8 @@ def initialize_data(
                 "x_min": param_dicts["x_min"][inp_col],
                 "x_max": param_dicts["x_max"][inp_col],
                 "y_min": param_dicts["y_min"][inp_col],
-                "y_max": param_dicts["y_max"][inp_col]
+                "y_max": param_dicts["y_max"][inp_col],
+                "num_pos_obsv":param_dicts["num_pos_obsv"][inp_col]
             },
             bounds=np.array([-10, 10]),
             channel_bounds_min = 10,
@@ -387,7 +388,7 @@ def initialize_data(
 
     for channel in channels.values():
         st.session_state[channel.name] = numerize(
-            channel.actual_total_spends * channel.conversion_rate, 1
+            channel.actual_total_spends * 1.0, 1
         )
 
     st.session_state["xlsx_buffer"] = io.BytesIO()