intial commit-descriptive analysis

app.py

@@ -0,0 +1,264 @@
+# app.py
+import streamlit as st
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+import statsmodels.api as sm
+st.set_option('deprecation.showPyplotGlobalUse', False)
+
+uploaded_file = st.file_uploader("Upload a CSV file", type=["csv"])
+
+st.title("EDA: Descriptive Analyzer")
+# Read the dataset
+if uploaded_file is not None:
+    df = pd.DataFrame()
+    intial_df = pd.read_csv(uploaded_file)
+    df=intial_df
+
+        
+
+def descriptive_analysis():
+    global df
+    groups = {
+            "Descriptive Statistics": ["count", "sum", "mean", "median", "min", "max", "std", "var", "quantile"],
+            "Aggregation": ["sum", "mean", "median", "std"], #"agg"
+            # "Cumulative Statistics": ["cumsum", "cumprod", "cummax", "cummin"],# all
+            # "Correlation and Covariance": ["corr", "cov"],#all
+            "Value Counts": [ "nunique"], #["value_counts", "unique"]
+            "Quantiles and Percentiles": ["quantile"], # showing only 0.5
+            "Miscellaneous Statistics": ["prod", "skew", "kurt"], # mad
+            # "Histograms": ["hist"],# all
+            # "Central Tendency": ["mode"],# all
+            # "Missing Data Statistics": ["isna", "notna", "dropna"],# all
+            # "Categorical Statistics": ["describe", "count_categorical"] #all
+        }
+    selected_group = st.sidebar.selectbox("Select Analysis Type", list(groups.keys()))
+
+    # Create separate dropdowns and result tables for the selected group
+    st.write(f"## {selected_group}")
+
+    # Multi-select for selecting functions in the group
+    selected_functions = st.multiselect(f"Select functions in {selected_group}", groups[selected_group])
+
+    if not selected_functions:
+        st.info("Please select at least one function.")
+    else:
+        # Create an empty DataFrame to store the results
+        results_df = pd.DataFrame()
+        function_list=[]
+
+        # Compute and concatenate results based on user selection
+        for function in selected_functions:
+            if function == "quantile":
+                # For quantile_series, user needs to provide a list of quantiles
+                #quantiles = st.text_input(f"Enter quantiles for {function} (comma-separated):", "0.25,0.5,0.75")
+                quantiles = [0.25,0.5,0.75]
+                result_25 = df.quantile(0.25)
+                result_5 = df.quantile(0.5)
+                result_75 = df.quantile(0.75)
+                result = pd.concat([result_25, result_5, result_75], axis=1)
+                function_list.append('Quantite-0.25')
+                function_list.append('Quantite-0.5')
+                function_list.append('Quantite-0.75')
+            else:
+                # For other functions, apply the selected function to the DataFrame
+                result = getattr(df, function)()
+                function_list.append(function)
+
+            # Concatenate the result along columns
+            results_df = pd.concat([results_df, result], axis=1)
+           
+
+        # Transpose the result table
+        results_df = results_df.transpose()
+        results_df['Function'] = function_list
+        results_df = results_df[['Function'] + [col for col in results_df.columns if col != 'Function']]
+
+        # Display the transposed results
+        st.write("### Results:")
+        st.dataframe(results_df, hide_index = True)
+
+def data_visualization():
+    global df
+    visuals=["Line Plot", "Bar Chart", "Histogram","Scatter Plot", "Box Plot", "Violin Plot","Heatmap", "Pair Plot", "Pie Chart"]
+    data=pd.DataFrame(df)
+    selected_chart = st.sidebar.selectbox("Select Visualization Type", list(visuals))
+    sns.boxplot(x=df['Age'])
+    st.pyplot()
+
+    # Display selected chart
+    if selected_chart == "Line Plot":
+        st.subheader("Line Plot")
+        x_col=st.selectbox("Select column for x-axis:",df.columns)
+        y_col=st.selectbox("Select column for y-axis:",df.columns)
+        plt.scatter(df[x_col],df[y_col])
+        st.pyplot()
+
+    elif selected_chart == "Bar Chart":
+        col=st.multiselect("Select columns for bar-chart",df.columns)
+        plt.bar(col,height=[range(len(col))])
+        st.pyplot()
+
+    elif selected_chart == "Histogram":
+        st.subheader("Histogram")
+        plt.hist(data['value'], bins=10)
+        st.pyplot()
+
+    elif selected_chart == "Scatter Plot":
+        st.subheader("Scatter Plot")
+        sm.qqplot(data, line='45')
+        st.pyplot()
+
+    elif selected_chart == "Box Plot":
+        st.subheader("Box Plot")
+        sns.boxplot(x='category', y='value', data=data)
+        st.pyplot()
+
+    elif selected_chart == "Violin Plot":
+        st.subheader("Violin Plot")
+        sns.violinplot(x='category', y='value', data=data)
+        st.pyplot()
+
+
+    elif selected_chart == "Pair Plot":
+        st.subheader("Pair Plot")
+        sns.pairplot(data)
+        st.pyplot()
+
+    elif selected_chart == "Pie Chart":
+        st.subheader("Pie Chart")
+        sizes = [15, 30, 45]
+        labels = ['Category A', 'Category B', 'Category C']
+        plt.pie(sizes, labels=labels, autopct='%1.1f%%')
+        st.pyplot()
+
+def collinearity_pairs():
+    global df
+    st.write("### Collinearity")
+    st.sidebar.markdown("[Collinearity](#collinearity)")
+    # Set your collinearity threshold (e.g., 0.7)
+    st.subheader("Heatmap")
+    sns.heatmap(df.corr(), annot=True, cmap='coolwarm')
+    st.pyplot()
+    collinearity_threshold = st.number_input("Enter collinearity threshold from range [0 1]:")
+
+    # Calculate the correlation matrix
+    correlation_matrix = df.corr()
+
+    # Find distinct column pairs with collinearity above the threshold
+    high_collinear_pairs = (
+        (correlation_matrix.abs() > collinearity_threshold) & (correlation_matrix < 1)
+    ).stack().reset_index()
+
+    # Rename the columns for clarity
+    high_collinear_pairs.columns = ['Column1', 'Column2', 'Collinearity']
+
+    # Filter for pairs with collinearity above the threshold
+    high_collinear_pairs = high_collinear_pairs[high_collinear_pairs['Collinearity']]
+
+    # Create a list to store the column pairs and their collinearity
+    df_col = []
+    distinct_col = set()
+    for index, row in high_collinear_pairs.iterrows():
+        col1, col2 = row['Column1'], row['Column2']
+        df_col.append([col1, col2])
+        distinct_col.add(col1)
+        distinct_col.add(col2)
+
+    df_col = pd.DataFrame(df_col)
+    st.write(f"Number of distinct pairs: {len(distinct_col)}")
+    st.write("Collinearity Pairs")
+    st.dataframe(df_col)
+
+def missing_values():
+    global df
+    st.write("### Missing Values")
+    st.sidebar.markdown("[Missing Values](#missing-values)")
+    methods=["None","dropna","Value","mean","Previous Value","Next Value","interpolate"]
+    selected_missing = st.selectbox("Select Missing Values handling method",methods)
+    
+    if selected_missing == "None":
+        df=df
+    elif selected_missing == "dropna":
+        df.dropna(inplace=True)
+    elif selected_missing == "Value":
+        value = st.text_input("Enter value:")
+        df.fillna(value, inplace=True)
+    elif selected_missing == "mean":
+        df.fillna(df.mean(), inplace=True)
+    elif selected_missing == "Previous Value":
+        df.ffill(inplace=True)
+    elif selected_missing == "Next Value":
+        df.bfill(inplace=True)
+    elif selected_missing == "interpolate":
+        df.interpolate(inplace=True)
+    
+    
+def replace_value():
+    global df
+    st.write("### Replace Value")
+    st.sidebar.markdown("[Replace Value](#replace-value)")
+    prev = st.text_input("Enter value to be changed")
+    change = st.text_input("Enter new value")
+    st.text("Data Type:")
+    intD = st.button("Int")
+    floatD = st.button("Float")
+    if intD:
+        prev=int(prev)
+        new=int(prev)
+    elif floatD:
+        prev=float(prev)
+        new=float(prev)
+    
+    df=df.replace(prev, change, inplace=True)
+    
+
+def display_df():
+    global df
+    st.dataframe(df)
+
+
+def reset_df():
+    global df
+    global intial_df
+    st.write("### Reset Data Set")
+    st.sidebar.markdown("[Reset Data Set](#reset-data-set)")
+    result = st.button("Reset Data Set")
+    if result:
+        st.write("Data Set reset complete.")
+        df = intial_df
+    
+
+def main():
+    global df
+    global intial_df
+    st.sidebar.title("EDA Stages")
+    reset_df()
+
+    st.sidebar.markdown("[Drop columns](#drop-columns)")
+    # drop columns
+    st.write("### Drop columns")
+    data_cols = df.columns
+    selected_cols = st.multiselect("Select any columns to be dropped", data_cols)
+    if selected_cols:
+        df=df.drop(columns=selected_cols)
+        st.write(f"Columns Dropped:{selected_cols}")
+    st.sidebar.markdown("[Dataset](#dataset)")
+    st.write("### Dataset")
+    res = st.button("Show Dataset")
+    if res:
+        display_df()
+    descriptive_analysis()
+    # replace_value()
+    # missing_values()
+    # collinearity_pairs()
+    # data_visualization()
+        
+      
+
+# File upload
+
+if uploaded_file is not None:
+    main()
+        
+