app.py

import os
import re
import cv2,tempfile
import numpy as np
import streamlit as st
from zipfile import ZipFile
from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator
from tensorflow.keras.preprocessing.image import img_to_array, load_img
import zipfile
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from tensorflow.keras.layers import LSTM, Bidirectional, Dropout, Dense
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.feature_extraction.text import TfidfVectorizer
import tensorflow as tf
from dateutil.parser import parse
from sklearn.linear_model import LinearRegression, SGDRegressor, LogisticRegression, SGDClassifier
from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier
from sklearn.ensemble import RandomForestRegressor, AdaBoostRegressor, RandomForestClassifier, AdaBoostClassifier
from xgboost import XGBRegressor, XGBClassifier
from sklearn.metrics import accuracy_score, mean_squared_error
import json
from sklearn.preprocessing import LabelEncoder
import joblib

from tensorflow.keras.utils import plot_model

global epochs, batchs, drops, returseqs, bidis
epochs = 0
batchs = 0
drops = 0
returseqs = 0
bidis = 0

# Global variables from the second code

global epoch, batch, drop, returseq, bidi
epoch = 0
batch = 0
drop = 0
returnseq = 0
bidi = 0
os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'

def extract_zip(zip_file_path, extract_dir):
    with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:
        zip_ref.extractall(extract_dir)

def count_images_in_folders(zip_file_path):
    image_counts = {}
    with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:
        for file_info in zip_ref.infolist():
            if file_info.is_dir():
                folder_name = os.path.dirname(file_info.filename)
                if folder_name not in image_counts:
                    image_counts[folder_name] = 0
            else:
                folder_name = os.path.dirname(file_info.filename)
                if folder_name not in image_counts:
                    image_counts[folder_name] = 1
                else:
                    image_counts[folder_name] += 1
    return image_counts

def train_model(zip_file_path):
    extract_dir = 'extracted_images'
    extract_zip(zip_file_path, extract_dir)

    datagen = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1./255, validation_split=0.2)

    train_generator = datagen.flow_from_directory(
        extract_dir,
        target_size=(224, 224),
        batch_size=32,
        class_mode='categorical',
        subset='training'
    )

    
    validation_generator = datagen.flow_from_directory(
        extract_dir,
        target_size=(224, 224),
        batch_size=32,
        class_mode='categorical',
        subset='validation'
    )

    base_model = tf.keras.applications.MobileNetV2(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

    for layer in base_model.layers:
        layer.trainable = False

    model = tf.keras.Sequential([
        base_model,
        tf.keras.layers.GlobalAveragePooling2D(),
        tf.keras.layers.Dense(len(train_generator.class_indices), activation='softmax')
    ])

    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

    st.write("Training progress:")
    progress_bar = st.progress(0)

    for epoch in range(10):
        model.fit(
            train_generator,
            steps_per_epoch=train_generator.samples // train_generator.batch_size,
            epochs=1,
            validation_data=validation_generator,
            validation_steps=validation_generator.samples // validation_generator.batch_size
        )
        progress_bar.progress((epoch + 1) / 10)

    os.system(f'rm -rf {extract_dir}')

    return model, train_generator

def detect_objects(model, img):
    # Perform object detection
    results = model.predict(img)

    # Initialize annotator
    annotator = Annotator(img)

    # List to store cropped images
    cropped_images = []

    # Loop through the detections and annotate the image
    for r in results:
        boxes = r.boxes
        for box in boxes:
            b = box.xyxy[0]  # get box coordinates in (left, top, right, bottom) format
            result = results[0]
            class_id = result.names[box.cls[0].item()]
            annotator.box_label(b, str(class_id))

            # Crop the object from the image
            x1, y1, x2, y2 = map(int, b)
            cropped_img = img[y1:y2, x1:x2]
            cropped_images.append((cropped_img, class_id))

    # Get annotated image
    annotated_img = annotator.result()

    return annotated_img, cropped_images

def main():
    st.sidebar.title("Contents")

    # Create a dropdown for selecting the section
    selection = st.sidebar.selectbox("Select Section", ["Introduction", "Image Segmentation", "Dynamic Image Classification", "LSTM Datasets", "CSV Datasets", "Results", "About"])

    if selection == "Introduction":
        st.title("Project Overview")
        st.header("Problem Statement:")
        st.write("""
            Our project addresses the challenge of efficiently analyzing large volumes of unstructured data, including images and text. Traditional methods struggle with this task, leading to time-consuming and error-prone manual processing.
            We aim to develop an intelligent data analysis platform using machine learning and deep learning techniques along with training models. Our goal is to enable users to extract valuable insights from complex data sets, facilitating informed decision-making. Our platform will offer functionalities such as image segmentation, dynamic classification, and natural language processing, empowering users to unlock the full potential of their data.
                """)
        st.header("Target Audience:")
        st.write("""
            - **Data Scientist:** Explore machine learning techniques for data analysis and predictive modeling.
            - **Python Developer:** Enhance Python skills and learn about its applications in various domains.
            - **Machine Learning Practitioner:** Master machine learning algorithms and applications through practical examples.
            - **Computer Vision Engineer:** Delve into the field of computer vision and image processing.
            """)


    elif selection == "Image Segmentation":
        st.title("Image Segmentation App")

        uploaded_file = st.file_uploader("Upload a zip file", type="zip")

        if uploaded_file is not None:
            st.write("Counting images in each class...")
            image_counts = count_images_in_folders(uploaded_file)
            st.write("Number of images in each class:")
            for folder, count in image_counts.items():
                st.write(f"- {folder}: {count} images")

            st.write("Sit tight !!!")
            model, train_generator = train_model(uploaded_file)
            st.write("Training done!")

            uploaded_image = st.file_uploader("Upload an image to test the model", type=["jpg", "jpeg", "png"])

            if uploaded_image is not None:
                st.write("Testing Image:")
                st.image(uploaded_image, caption='Uploaded Image', use_column_width=True)
                img = load_img(uploaded_image, target_size=(224, 224))
                img_array = img_to_array(img)
                img_array = np.expand_dims(img_array, axis=0)
                img_array = img_array / 255.0  

                prediction = model.predict(img_array)

                st.write("Class probabilities:")
                class_indices = train_generator.class_indices
                for class_name, prob in zip(class_indices.keys(), prediction[0]):
                    st.write(f"- {class_name}: {prob*100:.2f}%")

                predicted_class = list(class_indices.keys())[np.argmax(prediction)]
                st.write(f"The image is predicted to belong to class: {predicted_class}")


    elif selection == "Dynamic Image Classification":
        st.title("Dynamic Image Classification")

        model = YOLO('yolov8n.pt')  

        # File uploader for zip file
        uploaded_zip_file = st.file_uploader("Upload a zip file containing images...", type="zip")

        if uploaded_zip_file is not None:
            # Create a temporary directory to extract images
            temp_dir = 'temp'
            os.makedirs(temp_dir, exist_ok=True)

            try:
                # Extract the uploaded zip file
                with ZipFile(uploaded_zip_file, 'r') as zip_ref:
                    zip_ref.extractall(temp_dir)

                # Perform object detection on each image in the zip file
                annotated_images = []
                classwise_cropped_images = {}
                for root, _, files in os.walk(temp_dir):
                    for image_file in files:
                        image_path = os.path.join(root, image_file)
                        img = cv2.imread(image_path)
                        if img is not None:
                            annotated_img, cropped_images = detect_objects(model, img)
                            annotated_images.append((annotated_img, image_file))
                
                            # Save cropped images classwise
                            for cropped_img, class_id in cropped_images:
                                class_dir = os.path.join(temp_dir, class_id)
                                os.makedirs(class_dir, exist_ok=True)
                                # Saving the cropped images with the appropriate extension
                                cv2.imwrite(os.path.join(class_dir, f"{image_file}_{class_id}.jpg"), cropped_img)
                                if class_id in classwise_cropped_images:
                                    classwise_cropped_images[class_id].append(cropped_img)
                                else:
                                    classwise_cropped_images[class_id] = [cropped_img]
                        else:
                            st.warning(f"Failed to read image file: {image_file}")


                if annotated_images:
                    # Create a zip file with annotated images
                    annotated_zip_file = 'annotated_images.zip'
                    with ZipFile(annotated_zip_file, 'w') as zip_output:
                        for annotated_img, image_file in annotated_images:
                            zip_output.writestr(image_file, cv2.imencode('.jpg', annotated_img)[1].tobytes())

                    # Provide download link for the zip file
                    st.download_button(label="Download Annotated Images", data=open(annotated_zip_file, 'rb').read(), file_name=annotated_zip_file)

                    # Create zip files for classwise cropped images
                    for class_id, images in classwise_cropped_images.items():
                        class_zip_file = f'{class_id}_cropped_images.zip'
                        with ZipFile(class_zip_file, 'w') as zip_output:
                            for i, image in enumerate(images):
                                zip_output.writestr(f"{class_id}_{i}.jpg", cv2.imencode('.jpg', image)[1].tobytes())

                        # Provide download link for classwise cropped images
                        st.download_button(label=f"Download {class_id} Cropped Images", data=open(class_zip_file, 'rb').read(), file_name=class_zip_file)

                    # Create a zip file containing all the zip files
                    all_zip_file = 'all_files.zip'
                    with ZipFile(all_zip_file, 'w') as zip_output:
                        zip_output.write(annotated_zip_file)
                        for class_id in classwise_cropped_images.keys():
                            class_zip_file = f'{class_id}_cropped_images.zip'
                            zip_output.write(class_zip_file)

                    # Provide download link for all zip files
                    st.header("Download All Zip Files")
                    st.download_button(label="Download All Files", data=open(all_zip_file, 'rb').read(), file_name=all_zip_file)

            except Exception as e:
                st.error(f"Error: {str(e)}")

            finally:
                # Clean up temporary directory
                if os.path.exists(temp_dir):
                    for root, dirs, files in os.walk(temp_dir, topdown=False):
                        for name in files:
                            os.remove(os.path.join(root, name))
                        for name in dirs:
                            os.rmdir(os.path.join(root, name))
                    os.rmdir(temp_dir)

    elif selection == "LSTM Datasets":
        
        url = "https://raw.githubusercontent.com/sidd2305/DynamicLSTM/5e054d621262f5971ba1a5b54d8e7ec6b9573baf/hu.csv"
        dataset = pd.read_csv(url)

        class KNNUnsupervised:
            def __init__(self, k):
                self.k = k

            def fit(self, X, y):
                self.X_train = tf.constant(X, dtype=tf.float32)
                self.y_train = tf.constant(y, dtype=tf.float32)

            def predict(self, X):
                X_test = tf.constant(X, dtype=tf.float32)
                distances = tf.reduce_sum(tf.square(tf.expand_dims(X_test, axis=1) - self.X_train), axis=2)
                top_k_indices = tf.argsort(distances, axis=1)[:, :self.k]
                nearest_neighbor_labels = tf.gather(self.y_train, top_k_indices, axis=0)

                # Calculate average values of specified columns for nearest neighbors
                avg_values = tf.reduce_mean(nearest_neighbor_labels, axis=1)

                return avg_values.numpy()

        class KNNUnsupervisedLSTM:
            def __init__(self, k):
                self.k = k

            def fit(self, X, y):
                # Convert string representation of LSTM units to numeric arrays
                max_layers = 0
                y_processed = []
                for units in y[:, 5]:  # Assuming LSTM units are in the 5th column
                    units_array = eval(units) if isinstance(units, str) else [units]
                    max_layers = max(max_layers, len(units_array))
                    y_processed.append(units_array)
                
                # Pad arrays with zeros to ensure uniform length
                for i in range(len(y_processed)):
                    y_processed[i] += [0] * (max_layers - len(y_processed[i]))

                # Convert input and output arrays to TensorFlow constant tensors
                self.X_train = tf.constant(X, dtype=tf.float32)
                self.y_train = tf.constant(y_processed, dtype=tf.float32)

            def predict(self, X):
                X_test = tf.constant(X, dtype=tf.float32)
                distances = tf.reduce_sum(tf.square(tf.expand_dims(X_test, axis=1) - self.X_train), axis=2)
                top_k_indices = tf.argsort(distances, axis=1)[:, :self.k]
                nearest_neighbor_labels = tf.gather(self.y_train, top_k_indices, axis=0)
                neighbor_indices = top_k_indices.numpy()

                # Calculate average values of specified columns for nearest neighbors
                avg_values = tf.reduce_mean(nearest_neighbor_labels, axis=1)
                
                return avg_values.numpy(), neighbor_indices


        def split_data(sequence, n_steps):
            X, Y = [], []
            for i in range(len(sequence) - n_steps):
                x_seq = sequence[i:i + n_steps]
                y_seq = sequence.iloc[i + n_steps]
                X.append(x_seq)
                Y.append(y_seq)
            return np.array(X), np.array(Y)

        def handle_date_columns(dat, col):
            # Convert the column to datetime
            dat[col] = pd.to_datetime(dat[col], errors='coerce')
            # Extract date components
            dat[f'{col}_year'] = dat[col].dt.year
            dat[f'{col}_month'] = dat[col].dt.month
            dat[f'{col}_day'] = dat[col].dt.day
            # Extract time components
            dat[f'{col}_hour'] = dat[col].dt.hour
            dat[f'{col}_minute'] = dat[col].dt.minute
            dat[f'{col}_second'] = dat[col].dt.second
        def is_date(string):
            try:
                # Check if the string can be parsed as a date
                parse(string)
                return True
            except ValueError:
                # If parsing fails, also check if the string matches a specific date format
                return bool(re.match(r'^\d{2}-\d{2}-\d{2}$', string))

        def analyze_csv(df):
            # Get the number of records
            num_records = len(df)

            # Get the number of columns
            num_columns = len(df.columns)

            # Initialize counters for textual, numeric, and date columns
            num_textual_columns = 0
            num_numeric_columns = 0
            num_date_columns = 0

            # Identify textual, numeric, and date columns
            for col in df.columns:
                if pd.api.types.is_string_dtype(df[col]):
                    if all(df[col].apply(is_date)):
                        handle_date_columns(df, col)
                        num_date_columns += 1
                    else:
                        num_textual_columns += 1
                elif pd.api.types.is_numeric_dtype(df[col]):
                    num_numeric_columns += 1

            # Find highly dependent columns (you may need to define what "highly dependent" means)
            # For example, you can use correlation coedfficients or other statistical measures

            # In this example, let's assume highly dependent columns are those with correlation coefficient above 0.8
            highly_dependent_columns = set()
            correlation_matrix = df.corr()
            for i in range(len(correlation_matrix.columns)):
                for j in range(i):
                    if abs(correlation_matrix.iloc[i, j]) > 0.8:
                        col1 = correlation_matrix.columns[i]
                        col2 = correlation_matrix.columns[j]
                        highly_dependent_columns.add(col1)
                        highly_dependent_columns.add(col2)

            num_highly_dependent_columns = len(highly_dependent_columns)

            # Output the results
            st.write("Number Of Records:", num_records)
            st.write("Number Of Columns:", num_columns)
            st.write("Number of Date Columns:", num_date_columns)

            st.write("Number of Textual Columns:", num_textual_columns)
            st.write("Number of Numeric Columns:", num_numeric_columns)

            st.write("Total Number of highly dependent columns:", num_highly_dependent_columns)
            X = dataset[['Number Of Records', 'Number Of Columns',
                        'Number of Textual Columns', 'Number of Numeric Columns', 'Total Number of highly dependent columns']].values
            y = dataset[['Bidirectional', 'Return Sequence=True', 'Dropout', 'Epochs', 'Batch Size']].values

            knn = KNNUnsupervised(k=3)
            knn.fit(X, y)

            # Input data for which we want to predict the average values
            q1 = np.array([[num_records,num_columns,num_textual_columns,num_numeric_columns,num_highly_dependent_columns]])  # Example input data, 1 row, 6 columns
            avg_neighbors = knn.predict(q1)

            # Apply sigmoid to the first two elements
            for i in range(len(avg_neighbors)):
                # avg_neighbors[i][0] = 1 / (1 + np.exp(-avg_neighbors[i][0]))
                # avg_neighbors[i][1] = 1 / (1 + np.exp(-avg_neighbors[i][1]))
                avg_neighbors[i][0] = 1 if avg_neighbors[i][0] >= 0.5 else 0
                avg_neighbors[i][1] = 1 if avg_neighbors[i][1] >= 0.5 else 0

            # st.write("Output using KNN of info 1-Bidirectional,Return Sequence,Dropout,Epochs,BatchSize:")
            # st.write(avg_neighbors)
            # st.write(avg_neighbors.shape)
            global epoch,batch,drop,returseq,bidi
            #poch,batch,drop,returseq,bidi
            epoch=avg_neighbors[0][3]
            batch=avg_neighbors[0][4]
            drop=avg_neighbors[0][2]
            bidi=avg_neighbors[0][0]
            returnseq=avg_neighbors[0][1]
            # st.write("epoch is",epoch)



            #LSTM Layer
            X = dataset[['Number Of Records', 'Number Of Columns', 
                        'Number of Textual Columns', 'Number of Numeric Columns', 'Total Number of highly dependent columns']].values
            y = dataset[['Bidirectional', 'Return Sequence=True', 'Dropout', 'Epochs', 'Batch Size', 'LSTM Layers']].values
            knn1 = KNNUnsupervisedLSTM(k=3)
            knn1.fit(X, y)
            
        
            avg_neighbors, neighbor_indices = knn1.predict(q1)

            # Extract LSTM units of k-nearest neighbors
            lstm_units = y[neighbor_indices[:, 0], 5]  # Extract LSTM units corresponding to the indices of k-nearest neighbors
            lstm_units_array = []
            for units in lstm_units:
                units_list = [int(x) for x in units.strip('[]').split(',')]
                lstm_units_array.append(units_list)

            # Get the maximum length of nested lists
            max_length = max(len(units) for units in lstm_units_array)

            # Pad shorter lists with zeros to match the length of the longest list
            padded_lstm_units_array = [units + [0] * (max_length - len(units)) for units in lstm_units_array]

            # Convert the padded list of lists to a numpy array
            lstm_units_array_transpose = np.array(padded_lstm_units_array).T

            # Calculate the average of each element in the nested lists
            avg_lstm_units = np.mean(lstm_units_array_transpose, axis=1)

            global output_array_l
            output_array_l = np.array(list(avg_lstm_units))
            # st.write("LSTM Layer Output")
            # st.write(output_array_l)

            #Dense Layer thing
            X = dataset[['Number Of Records', 'Number Of Columns', 
                        'Number of Textual Columns', 'Number of Numeric Columns', 'Total Number of highly dependent columns']].values
            y = dataset[['Bidirectional', 'Return Sequence=True', 'Dropout', 'Epochs', 'Batch Size', 'LSTM Layers', 'Dense Layers']].values
            knn = KNNUnsupervisedLSTM(k=3)
            knn.fit(X, y)
            
            
            avg_neighbors, neighbor_indices = knn.predict(q1)

            # Extract Dense layers of k-nearest neighbors
            dense_layers = y[neighbor_indices[:, 0], 6]  # Extract Dense layers corresponding to the indices of k-nearest neighbors
            dense_layers_array = []
            for layers in dense_layers:
                layers_list = [int(x) for x in layers.strip('[]').split(',')]
                dense_layers_array.append(layers_list)

            # Get the maximum length of nested lists
            max_length = max(len(layers) for layers in dense_layers_array)

            # Pad shorter lists with zeros to match the length of the longest list
            padded_dense_layers_array = [layers + [0] * (max_length - len(layers)) for layers in dense_layers_array]

            # Convert the padded list of lists to a numpy array
            dense_layers_array_transpose = np.array(padded_dense_layers_array).T

            # Calculate the average of each element in the nested lists
            avg_dense_layers = np.mean(dense_layers_array_transpose, axis=1)

            global output_array_d
            # Print the output in the form of an array
            output_array_d = np.array(list(avg_dense_layers))
            # st.write("Dense layer output:")
            # st.write(output_array_d)


        def load_data(file):
            df = pd.read_csv(file)
            st.subheader("1. Show first 10 records of the dataset")
            st.dataframe(df.head(10))
            analyze_csv(df)
            # Call analyze_csv function here

            return df

        def show_correlation(df):
            st.subheader("2. Show the correlation matrix and heatmap")
            numeric_columns = df.select_dtypes(include=['number']).columns
            correlation_matrix = df[numeric_columns].corr()
            st.dataframe(correlation_matrix)

            fig, ax = plt.subplots(figsize=(10, 8))
            sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', linewidths=.5, ax=ax)
            st.pyplot(fig)

        def show_missing_values(df):
            st.subheader("3. Show the number of missing values in each column")
            missing_values = df.isnull().sum()
            st.dataframe(missing_values)
            st.write(output_array_d)

        def handle_missing_values(df):
            st.subheader("4. Handle missing values")
            numeric_columns = df.select_dtypes(include=['number']).columns

            fill_option = st.radio("Choose a method to handle missing values:", ('Mean', 'Median', 'Mode', 'Drop'))

            if fill_option == 'Drop':
                df = df.dropna(subset=numeric_columns)
            else:
                fill_value = (
                    df[numeric_columns].mean() if fill_option == 'Mean'
                    else (df[numeric_columns].median() if fill_option == 'Median'
                        else df[numeric_columns].mode().iloc[0])
                )
                df[numeric_columns] = df[numeric_columns].fillna(fill_value)

            st.dataframe(df)

            return df

        def drop_column(df):
            st.subheader("5. Drop a column")
            columns_to_drop = st.multiselect("Select columns to drop:", df.columns)
            if columns_to_drop:
                df = df.drop(columns=columns_to_drop)
                st.dataframe(df)

            return df

        def build_model(layer_sizes, dense_layers, return_sequence, bidirectional, dropout):
            model = tf.keras.Sequential()
            
            for i, size in enumerate(layer_sizes):
                size = int(size) 
                if i == 0:
                    # For the first layer, we need to specify input_shape
                    # model.add(LSTM(size, return_sequences=bool(return_sequence))) then did  model.add(LSTM(size,input_shape=(c,d), return_sequences=True))
                    model.add(LSTM(size,input_shape=(X_train.shape[1], 1), return_sequences=True))
                    
                else:
                    if bool(bidirectional):  # Bidirectional layer
                        model.add(Bidirectional(LSTM(size, return_sequences=True)))
                    else:
                        model.add(LSTM(size,return_sequences=True))

                if dropout > 0:  # Dropout
                    model.add(Dropout(dropout))

            for nodes in dense_layers:
                model.add(Dense(nodes, activation='relu'))

            model.add(Dense(1))  # Example output layer, adjust as needed

            model.compile(optimizer='adam', loss='mse')  # Compile the model
              # Explicitly build the model
            # plot_model(model, to_file='model_architecture.png', show_shapes=True, show_layer_names=True)
            # img = mpimg.imread('model_architecture.png')
            # plt.imshow(img)
            # plt.axis('off') 
            # plt.show()
            model.build()
            return model

        def train_regression_model(df):
            st.subheader("6. Train a Custom Time Series model")

            if df.empty:
                st.warning("Please upload a valid dataset.")
                return

            st.write("Select columns for X (features):")
            st.write("Please DO NOT select your date column.We have automatically pre processed it into date,month,year(hour,min,sec if applicable)")
            st.write("Please do select our preproccesed date columns")
            x_columns = st.multiselect("Select columns for X:", df.columns)

            if not x_columns:
                st.warning("Please select at least one column for X.")
                return

            st.write("Select the target column for Y:")
            y_column = st.selectbox("Select column for Y:", df.columns)

            if not y_column:
                st.warning("Please select a column for Y.")
                return

            df = df.dropna(subset=[y_column])

            X = df[x_columns]
            y = df[y_column]

            # Handle textual data
            textual_columns = X.select_dtypes(include=['object']).columns
            if not textual_columns.empty:
                for col in textual_columns:
                    X[col] = X[col].fillna("")  # Fill missing values with empty strings
                    vectorizer = TfidfVectorizer()  # You can use any other vectorization method here
                    X[col] = vectorizer.fit_transform(X[col])

            numeric_columns = X.select_dtypes(include=['number']).columns
            scaler_option = st.selectbox("Choose a scaler for numerical data:", ('None', 'StandardScaler', 'MinMaxScaler'))

            if scaler_option == 'StandardScaler':
                scaler = StandardScaler()
                X[numeric_columns] = scaler.fit_transform(X[numeric_columns])
            elif scaler_option == 'MinMaxScaler':
                scaler = MinMaxScaler()
                X[numeric_columns] = scaler.fit_transform(X[numeric_columns])
            global X_train,y_train,a,b,c,d
            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
            a = X_train.shape
            b = y_train.shape

            c=a[0]
            d=b[0]
            
            st.subheader("6.1-Information About Training")
            
            st.write("We have dynamically determined the Architecture of your model using an KNN model trained on our CSV properties vs architecture dataset ")
            lstm = [int(x) for x in output_array_l]
            dense = [int(x) for x in output_array_d]
            model = build_model(lstm,dense,returnseq,bidi,drop)
            model.summary()
            print(model.summary())
        
            st.write("We are going to be training your dataset from our dynamically determined hyperparameters!")
            st.write("The Parameters for your CSV are:")
            st.write("Batch Size",int(batch)) 
            st.write("Epochs",int(epoch))
            st.write("Dropout Value",drop)
            st.write("Bidirectional is",bool(bidi))
            st.write("LSTM Layers",output_array_l)
            st.write("Dense Layers",output_array_d)

            st.write("While we train,here's a video that should keep you entertained while our algorithm works behind the scenes🎞️!")
            st.write("I mean,who doesn`t like a friends episode?🤔👬🏻👭🏻🫂")
            video_url = "https://www.youtube.com/watch?v=nvzkHGNdtfk&pp=ygUcZnJpZW5kcyBlcGlzb2RlIGZ1bm55IHNjZW5lcw%3D%3D"  # Example YouTube video URL
            st.video(video_url)


            # Train the model
        
            n_steps = 7

        # Call the split_data function with X_train and Y_train
            X_train_split, Y_train_split = split_data(X_train, n_steps), split_data(y_train, n_steps)
            history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=int(epoch), batch_size=int(batch))
            global train_loss
            global val_loss
            train_loss = history.history['loss']
            val_loss = history.history['val_loss']

            st.subheader("Training Information➕➖")
            st.write("Final Training loss is-",train_loss[-1])
            st.write("Final Validation loss is-",val_loss[-1])
            st.write("Training losses",train_loss)
            st.write("Validation losses",val_loss)
            # st.write(f"LSTM Model: {model_option}")

            # # Evaluate the model
            # loss, accuracy = model.evaluate(X_test, y_test)
            # st.write(f"Loss: {loss}")
        

        # Assuming history is available with the 'loss' and 'val_loss' keys
        
            train_loss = history.history['loss']
            val_loss = history.history['val_loss']
            
            ploty()

            model_filename = "model.h5"
            model.save(model_filename)
            st.success(f"Model saved as {model_filename}")

            st.subheader("8.Download the trained model")
            st.download_button(label="Download Model", data=open(model_filename, "rb").read(), file_name=model_filename)

        def ploty():
            st.subheader("7.Plotting the loss vs epoch graph")
            epochsi = range(1, len(train_loss) + 1)

            plt.plot(epochsi, train_loss, 'bo', label='Training loss') # 'bo' = blue dots
            plt.plot(epochsi, val_loss, 'r', label='Validation loss') # 'r' = red line   
            plt.title('Training and Validation Loss')
            plt.xlabel('Epochs')
            plt.ylabel('Loss')
            plt.legend()
            st.write("Yayyyy yipeee!! Now we`re done with processing and training the model!🥳🎉")

            # Optionally, you can save the plot or display it
            # plt.savefig('loss_plot.png')  # Save the plot as a PNG file
            # plt.show()  # Display the plot
            #newest
            st.pyplot(plt)


        def download_updated_dataset(df):
            st.subheader("9. Download the updated dataset")
            csv_file = df.to_csv(index=False)
            st.download_button("Download CSV", csv_file, "Updated_Dataset.csv", key="csv_download")

        
        st.title("LSTM Time Series Dataset Analysis and Model Training App")
        uploaded_file = st.file_uploader("Upload a CSV file", type=["csv"])

        if uploaded_file is not None:
            st.info("File uploaded successfully!")
            df = load_data(uploaded_file)

            if not df.select_dtypes(include=['number']).empty:
                show_correlation(df)
                show_missing_values(df)
                df = handle_missing_values(df)

            df = drop_column(df)
            train_regression_model(df)
    
            download_updated_dataset(df)
        

    elif selection == "CSV Datasets":
        url = "sisi.csv"
        dataset = pd.read_csv(url)
        

        class LazyPredict:
            def __init__(self, df, x_columns, y_column):
                self.data = df
                self.target_column = y_column
                self.X = self.data[x_columns]
                self.y = self.data[y_column]
                self.is_regression = self.is_regression()
                self.models = {}  # Dictionary to store trained models

            def is_regression(self):
                # Calculate the number of unique values in the target column
                num_unique_values = self.y.nunique()
                
                # If the number of unique values is below a threshold, consider it as classification
                classification_threshold = 10  # You can adjust this threshold as needed
                if num_unique_values <= classification_threshold:
                    return False  # It's a classification problem
                else:
                    return True 

            def fit_predict(self):
                if self.is_regression:
                    models = {
                        "Linear Regression": LinearRegression(),
                        "Decision Tree": DecisionTreeRegressor(),
                        "Random Forest": RandomForestRegressor(),
                        "XGBoost": XGBRegressor(),
                        "AdaBoost": AdaBoostRegressor(),
                        "SGDRegressor": SGDRegressor()
                    }
                    results = {}
                    for name, model in models.items():
                        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=0.2, random_state=42)
                        model.fit(X_train, y_train)
                        y_pred = model.predict(X_test)
                        mse = mean_squared_error(y_test, y_pred)
                        variance = np.var(y_test)
                        accuracy = (1 - (mse / variance))*100
                        results[name] = accuracy

                        if accuracy > 80:  # Save the model if accuracy is greater than 80%
                            self.models[name] = model
                else:
                    models = {
                        "Logistic Regression": LogisticRegression(),
                        "Decision Tree": DecisionTreeClassifier(),
                        "Random Forest": RandomForestClassifier(),
                        "XGBoost": XGBClassifier(),
                        "AdaBoost": AdaBoostClassifier(),
                        "SGDClassifier": SGDClassifier()
                    }
                    results = {}
                    for name, model in models.items():
                        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=0.2, random_state=42)
                        model.fit(X_train, y_train)
                        y_pred = model.predict(X_test)
                        accuracy = accuracy_score(y_test, y_pred)*100
                        results[name] = accuracy

                        if accuracy > 80:  # Save the model if accuracy is greater than 80%
                            self.models[name] = model

                return results

            


            def predict_new_data(self, new_data):
                if self.is_regression:
                    model = LinearRegression()
                else:
                    model = LogisticRegression()

                model.fit(self.X, self.y)
                predictions = model.predict(new_data)

                return predictions


        class KNNUnsupervised:
            def __init__(self, k):
                self.k = k

            def fit(self, X, y):
                self.X_train = tf.constant(X, dtype=tf.float32)
                self.y_train = tf.constant(y, dtype=tf.float32)

            def predict(self, X):
                X_test = tf.constant(X, dtype=tf.float32)
                distances = tf.reduce_sum(tf.square(tf.expand_dims(X_test, axis=1) - self.X_train), axis=2)
                top_k_indices = tf.argsort(distances, axis=1)[:, :self.k]
                nearest_neighbor_labels = tf.gather(self.y_train, top_k_indices, axis=0)

                # Calculate average values of specified columns for nearest neighbors
                avg_values = tf.reduce_mean(nearest_neighbor_labels, axis=1)

                return avg_values.numpy()

        class KNNUnsupervisedLSTM:
            def __init__(self, k):
                self.k = k

            def fit(self, X, y):
                # Convert string representation of LSTM units to numeric arrays
                max_layers = 0
                y_processed = []
                for units in y[:, 0]:  # Assuming LSTM units are in the 5th column
                    units_array = eval(units) if isinstance(units, str) else [units]
                    max_layers = max(max_layers, len(units_array))
                    y_processed.append(units_array)
                
                # Pad arrays with zeros to ensure uniform length
                for i in range(len(y_processed)):
                    y_processed[i] += [0] * (max_layers - len(y_processed[i]))

                # Convert input and output arrays to TensorFlow constant tensors
                self.X_train = tf.constant(X, dtype=tf.float32)
                self.y_train = tf.constant(y_processed, dtype=tf.float32)

            def predict(self, X):
                X_test = tf.constant(X, dtype=tf.float32)
                distances = tf.reduce_sum(tf.square(tf.expand_dims(X_test, axis=1) - self.X_train), axis=2)
                top_k_indices = tf.argsort(distances, axis=1)[:, :self.k]
                nearest_neighbor_labels = tf.gather(self.y_train, top_k_indices, axis=0)
                neighbor_indices = top_k_indices.numpy()

                # Calculate average values of specified columns for nearest neighbors
                avg_values = tf.reduce_mean(nearest_neighbor_labels, axis=1)
                
                return avg_values.numpy(), neighbor_indices

        def handle_date_columns(dat, col):
            # Convert the column to datetime
            dat[col] = pd.to_datetime(dat[col], errors='coerce')
            # Extract date components
            dat[f'{col}_year'] = dat[col].dt.year
            dat[f'{col}_month'] = dat[col].dt.month
            dat[f'{col}_day'] = dat[col].dt.day
            # Extract time components
            dat[f'{col}_hour'] = dat[col].dt.hour
            dat[f'{col}_minute'] = dat[col].dt.minute
            dat[f'{col}_second'] = dat[col].dt.second
        def is_date(string):
            try:
                # Check if the string can be parsed as a date
                parse(string)
                return True
            except ValueError:
                # If parsing fails, also check if the string matches a specific date format
                return bool(re.match(r'^\d{2}-\d{2}-\d{2}$', string))

        def analyze_csv(df):
            # Get the number of records
            num_records = len(df)

            # Get the number of columns
            num_columns = len(df.columns)
            
            # Initialize counters for textual, numeric, and date columns
            num_textual_columns = 0
            num_numeric_columns = 0
            num_date_columns = 0

            # Identify textual, numeric, and date columns
            for col in df.columns:
                if pd.api.types.is_string_dtype(df[col]):
                    if all(df[col].apply(is_date)):
                        handle_date_columns(df, col)
                        num_date_columns += 1
                    else:
                        num_textual_columns += 1
                elif pd.api.types.is_numeric_dtype(df[col]):
                    num_numeric_columns += 1
            
            textual_columns = df.select_dtypes(include=['object']).columns
            label_encoders = {}
            for col in textual_columns:
                if col not in df.columns:
                    continue
                le = LabelEncoder()
                df[col] = df[col].fillna("")  # Fill missing values with empty strings
                df[col] = le.fit_transform(df[col])
                # Store the label encoder for inverse transformation
                label_encoders[col] = le

                # Add another column for reverse inverse label encoding
                #df[f'{col}_inverse'] = le.inverse_transform(df[col])

        

            
            highly_dependent_columns = set()
            correlation_matrix = df.corr()
            for i in range(len(correlation_matrix.columns)):
                for j in range(i):
                    if abs(correlation_matrix.iloc[i, j]) > 0.8:
                        col1 = correlation_matrix.columns[i]
                        col2 = correlation_matrix.columns[j]
                        highly_dependent_columns.add(col1)
                        highly_dependent_columns.add(col2)

            num_highly_dependent_columns = len(highly_dependent_columns)

                ##Output the results
            st.write("Number Of Records:", num_records)
            st.write("Number Of Columns:", num_columns)
            st.write("Number of Date Columns:", num_date_columns)

            st.write("Number of Textual Columns:", num_textual_columns)
            st.write("Number of Numeric Columns:", num_numeric_columns)

            st.write("Total Number of highly dependent columns:", num_highly_dependent_columns)
            X = dataset[['Number Of Records', 'Number Of Columns',
                        'Number of Textual Columns', 'Number of Numeric Columns', 'Total Number of highly dependent columns']].values
            y = dataset[['Optimizer','Dropout', 'Epochs', 'Batch Size']].values

            knn = KNNUnsupervised(k=3)
            knn.fit(X, y)

            # Input data for which we want to predict the average values
            q1 = np.array([[num_records,num_columns,num_textual_columns,num_numeric_columns,num_highly_dependent_columns]])  # Example input data, 1 row, 6 columns
            avg_neighbors = knn.predict(q1)

            # Apply sigmoid to the first two elements
            for i in range(len(avg_neighbors)):
                # avg_neighbors[i][0] = 1 / (1 + np.exp(-avg_neighbors[i][0]))
                # avg_neighbors[i][1] = 1 / (1 + np.exp(-avg_neighbors[i][1]))
                avg_neighbors[i][0] = 1 if avg_neighbors[i][0] >= 0.5 else 0
                # avg_neighbors[i][1] = 1 if avg_neighbors[i][1] >= 0.5 else 0

            # st.write("Output using KNN of info 1-Bidirectional,Return Sequence,Dropout,epochss,BatchSize:")
            # st.write(avg_neighbors)
            # st.write(avg_neighbors.shape)
            global epochs,batchs,drops,returseqs,bidis,opi
            #poch,batch,drops,returseq,bidi
            epochs=avg_neighbors[0][2]
            batchs=avg_neighbors[0][3]
            drops=avg_neighbors[0][1]
            opi=avg_neighbors[0][0]

        

            # #Dense Layer thing
            X = dataset[['Number Of Records', 'Number Of Columns', 
                        'Number of Textual Columns', 'Number of Numeric Columns', 'Total Number of highly dependent columns']].values
            y = dataset[['Hidden units']].values
            knn = KNNUnsupervisedLSTM(k=3)
            knn.fit(X, y)
            
            
            avg_neighbors, neighbor_indices = knn.predict(q1)

            # Extract Dense layers of k-nearest neighbors
            dense_layers = y[neighbor_indices[:, 0], 0]  # Extract Dense layers corresponding to the indices of k-nearest neighbors
            dense_layers_array = []
            for layers in dense_layers:
                layers_list = [int(x) for x in layers.strip('[]').split(',')]
                dense_layers_array.append(layers_list)

            # Get the maximum length of nested lists
            max_length = max(len(layers) for layers in dense_layers_array)

            # Pad shorter lists with zeros to match the length of the longest list
            padded_dense_layers_array = [layers + [0] * (max_length - len(layers)) for layers in dense_layers_array]

            # Convert the padded list of lists to a numpy array
            dense_layers_array_transpose = np.array(padded_dense_layers_array).T

            # Calculate the average of each element in the nested lists
            avg_dense_layers = np.mean(dense_layers_array_transpose, axis=1)

            global output_array_d
            # Print the output in the form of an array
            output_array_d = np.array(list(avg_dense_layers))
            # st.write("Dense layer output:")
            # st.write(output_array_d)





        def load_data(file):
            df = pd.read_csv(file)
            st.subheader("1. Show first 10 records of the dataset")
            st.dataframe(df.head(10))
            analyze_csv(df)
            df.dropna(inplace=True)
            
            # Handle textual columns using label encoding
        
            # Call analyze_csv function here

            return df

        def show_correlation(df):
            st.subheader("3. Show the correlation matrix and heatmap")
            numeric_columns = df.select_dtypes(include=['number']).columns
            correlation_matrix = df[numeric_columns].corr()
            st.dataframe(correlation_matrix)

            fig, ax = plt.subplots(figsize=(10, 8))
            sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', linewidths=.5, ax=ax)
            st.pyplot(fig)

        def show_missing_values(df):
            st.subheader("2. Show the number of missing values in each column")
            missing_values = df.isnull().sum()
            st.dataframe(missing_values)
        # st.write(output_array_d)

        def handle_missing_values(df):
            st.subheader("4. Handle missing values")
            numeric_columns = df.select_dtypes(include=['number']).columns
        
            textual_columns = df.select_dtypes(include=['object']).columns

            fill_option = st.radio("Choose a method to handle missing values:", ('Mean', 'Median', 'Mode', 'Drop'))

            if fill_option == 'Drop':
                df = df.dropna(subset=numeric_columns)
            else:
                fill_value = (
                    df[numeric_columns].mean() if fill_option == 'Mean'
                    else (df[numeric_columns].median() if fill_option == 'Median'
                        else df[numeric_columns].mode().iloc[0])
                )
                df[numeric_columns] = df[numeric_columns].fillna(fill_value)

        
            return df

        def drop_column(df):
            st.subheader("5. Drop a column")
            columns_to_drop = st.multiselect("Select columns to drop:", df.columns)
            if columns_to_drop:
                df = df.drop(columns=columns_to_drop)
                st.dataframe(df)

            return df

        def build_model(dense_layers,dropout):
            model = tf.keras.Sequential()
            
            for i, size in enumerate(dense_layers):
                size = int(size) 
                if i == 0:
                    # For the first layer, we need to specify input_shape
                    # model.add(LSTM(size, return_sequences=bool(return_sequence))) then did  model.add(LSTM(size,input_shape=(c,d), return_sequences=True))
                    model.add(Dense(size,input_shape=(X_train.shape[1], 1)))
                else:
                    model.add(Dense(size))
                
                
                    
                
        
                if dropout > 0:  # Dropout
                    model.add(Dropout(dropout))

            for nodes in dense_layers:
                model.add(Dense(nodes, activation='relu'))

            model.add(Dense(1))  # Example output layer, adjust as needed
            if(opi==0):
                model.compile(optimizer='adam', loss='mse')  # Compile the model
            else:
                model.compile(optimizer='sgd', loss='mse') 

            model.build()  # Explicitly build the model
            # plot_model(model, to_file='model_architecture.png', show_shapes=True, show_layer_names=True)
            # img = mpimg.imread('model_architecture.png')
            # plt.imshow(img)
            # plt.axis('off') 
            # plt.show()
            return model

        def train_regression_model(df):
            st.subheader("6. Train a model")

            if df.empty:
                st.warning("Please upload a valid dataset.")
                return

            st.write("Select columns for X (features):")
            x_columns = st.multiselect("Select columns for X:", df.columns)

            if not x_columns:
                st.warning("Please select at least one column for X.")
                return

            st.write("Select the target column for Y:")
            y_column = st.selectbox("Select column for Y:", df.columns)

            if not y_column:
                st.warning("Please select a column for Y.")
                return
            lp = LazyPredict(df, x_columns, y_column)
            results = lp.fit_predict()

            # Check if any model's accuracy is less than 80 percent
            proceed_with_ann = any(accuracy >= 80.0 for accuracy in results.values())

            df = df.dropna(subset=[y_column])

            X = df[x_columns]
            y = df[y_column]

            # Handle textual data
            textual_columns = X.select_dtypes(include=['object']).columns
            if not textual_columns.empty:
                for col in textual_columns:
                    X[col] = X[col].fillna("")  # Fill missing values with empty strings
                    vectorizer = TfidfVectorizer()  # You can use any other vectorization method here
                    X[col] = vectorizer.fit_transform(X[col])

            numeric_columns = X.select_dtypes(include=['number']).columns
            scaler_option = st.selectbox("Choose a scaler for numerical data:", ('None', 'StandardScaler', 'MinMaxScaler'))

            if scaler_option == 'StandardScaler':
                scaler = StandardScaler()
                X[numeric_columns] = scaler.fit_transform(X[numeric_columns])
            elif scaler_option == 'MinMaxScaler':
                scaler = MinMaxScaler()
                X[numeric_columns] = scaler.fit_transform(X[numeric_columns])
            global X_train,y_train,a,b,c,d
            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
            a = X_train.shape
            b = y_train.shape

            c=a[0]
            d=b[0]
            
            st.subheader("6.1-Information About Training")
            
            st.write("We have dynamically determined the Architecture of your model using an KNN model trained on our CSV properties vs architecture dataset ")
            # lstm = [int(x) for x in output_array_l]
            dense = [int(x) for x in output_array_d]
            
            # Use LazyPredict to get model accuracies
        
            if proceed_with_ann:
                st.write("One or more models from LazyPredict have accuracy more than 80%. Skipping ANN training.")
                sorted_results = {k: v for k, v in sorted(results.items(), key=lambda item: item[1], reverse=True)}
            
                for model, accuracy in sorted_results.items():
                    st.write(f"- {model}: {accuracy:.2f}%")
                max_accuracy_model = max(results, key=results.get)
                best_lp_model = lp.models[max_accuracy_model]

                # Save the best LazyPredict model
                lp_model_filename = f"best_lp_model.pkl"
                joblib.dump(best_lp_model, lp_model_filename)
                st.write("Yayyyy yipeee!! Now we`re done with processing and training the model!🥳🎉")
                # Provide a download button for the best LazyPredict model
                st.subheader("7.Download Best LazyPredict Model")
                st.write("Click the button below to download the best LazyPredict model:")
                st.download_button(label="Download LazyPredict Model", data=open(lp_model_filename, "rb").read(), file_name=lp_model_filename)
                
                
            else:
                model = build_model(dense, drops)
                model.summary()
                st.write("We are going to be training your dataset from our dynamically determined hyperparameters!")
                st.write("The Parameters for your CSV are:")
                st.write("Batch Size", int(batchs)) 
                st.write("Epochs", int(epochs))
                st.write("Dropout Value", drops)
                if opi == 0:
                    st.write("Adam Optimizer Chosen")
                else:
                    st.write("SGD Optimizer Chosen")
                st.write("Dense Layers", output_array_d)
                st.write("While we train, here`s a video that should keep you entertained while our algorithm works behind the scenes🎞️!")
                st.write("I mean, who doesn`t like a friends episode?🤔👬🏻👭🏻🫂")
                video_url = "https://www.youtube.com/watch?v=nvzkHGNdtfk&pp=ygUcZnJpZW5kcyBlcGlzb2RlIGZ1bm55IHNjZW5lcw%3D%3D"  # Example YouTube video URL
                st.video(video_url)

                history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=int(epochs), batch_size=int(batchs))

                global train_loss
                global val_loss
                train_loss = history.history['loss']
                val_loss = history.history['val_loss']

                st.subheader("Training Information➕➖")
                st.write("Final Training loss is-", train_loss[-1])
                st.write("Final Validation loss is-", val_loss[-1])
                st.write("Training losses", train_loss)
                st.write("Validation losses", val_loss)
            

                ploty()

                model_filename = "model.h5"
                model.save(model_filename)
                st.success(f"Model saved as {model_filename}")

                st.subheader("7.Download the trained model")
                st.download_button(label="Download Model", data=open(model_filename, "rb").read(), file_name=model_filename)
                # Save LazyPredict models


        def ploty():
            st.subheader("Plotting the loss vs epoch graph")
            epochsi = range(1, len(train_loss) + 1)

            plt.plot(epochsi, train_loss, 'bo', label='Training loss') # 'bo' = blue dots
            plt.plot(epochsi, val_loss, 'r', label='Validation loss') # 'r' = red line   
            plt.title('Training and Validation Loss')
            plt.xlabel('Epochs')
            plt.ylabel('Loss')
            plt.legend()
            st.write("Yayyyy yipeee!! Now we`re done with processing and training the model!🥳🎉")


            st.pyplot(plt)


        def download_updated_dataset(df):
            st.subheader("8. Download the updated dataset")
            csv_file = df.to_csv(index=False)
            st.download_button("Download CSV", csv_file, "Updated_Dataset.csv", key="csv_download")

        
        st.title("CSV Dataset Analysis and Model Training App")
        uploaded_file = st.file_uploader("Upload a CSV file", type=["csv"])

        if uploaded_file is not None:
            st.info("File uploaded successfully!")
            df = load_data(uploaded_file)
            
            if not df.select_dtypes(include=['number']).empty or df.select_dtypes(include=['object']).empty :
                show_missing_values(df)#hi
                show_correlation(df)
                df = handle_missing_values(df)
                
            
            
            df = drop_column(df)
            train_regression_model(df)
    
            download_updated_dataset(df)
        

    elif selection == "Results":
        
        
        st.write("### LSTM Analysis")
        df_lstm = pd.DataFrame({
            'S.No': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
            'Testing Loss Tabulation': ["Tesla Dataset","Traffic Dataset","Air Passengers","Panama Electricity","Google Train","Apple","Netflix","London Bike","Electricity_dah","LSTM-Multivariate_pollution"],
            'X Columns': ["Date_year,Date_month,Open,High,Low","Date_year,Date_month","Date_year,Date_month","datetime_year,datetime_month,T2M_toc","Date_year,Open,High,Volume","Date_year,Date_month,Open,High,Volume","Date_year,Date_month,Open,High,Volume","timestamp_year,timestamp_month,wind_speed,weather_code,is_holiday,is_weekend","date_year,date_month,date_day","date_day,date_hour,wnd_spd,pressdew,pollution"],
            'Y Columns': ["Close","Vehicles","Passengers","T2M_san","Close","Close","Close","hum","France","temp"],
            'Initial Loss': [1745838.125,952.472,96211.2266,204.77,3683.0974,908.415,187812.625,5417.0169,90821.7969,300.1845],
            'Final Loss': [475.4735,639.267,51822.6016,6.1987,3336.0879,10.7328,23196.4355,3242.8433,15822.5752,173.9059],
            'Decrease in Loss': [1745362.652,313.205,44388.625,198.5713,347.0095,897.6822,164616.1895,2174.1736,74999.2217,126.2786],
            'Percent Decrease %': [99.97276532,32.88338135,46.13663766,96.97284759,9.421675897,98.81851356,87.6491607,40.13599441,82.5784385,42.06699546]
        })
        st.write(df_lstm)
        st.write("Average Reduction In Loss % : 63.66364104 ")

        st.write("### CSV Results")
        csv_data = pd.DataFrame({
            "Sno.": [1, 2, 3, 4, 5, 6, 7],
            "Datasets": ["Heart failure", "Electricity", "Twitter dataset", "Mushrooms", "Insurace", "Diabetes risk prediction", "Bank Churning Model"],
            "X_columns": ["age, anaemia, creatinine_phospokinase", "power_consumed, weather_index, holiday_index, humidity", "tweet", "cap-shape, cap-surface, habitat, veil-color", "age, bmi, children, smoker", "Age, Gender, Polyuria, Polydipsia, sudden weight loss, weakness", "Row Number, Customer ID, Credit Score"],
            "Y_column": ["DEATH_EVENT", "maximum_temperature", "label", "class", "charges", "class", "IsActiveMember"],
            "Lazy Predict(Yes/No)": ["No", "Yes", "Yes", "No", "Yes", "Yes", "No"],
            "LP model and max accuracy": ["Null", "AdaBoost-91.3%", "XGBoost-93.10%", "Null", "Random Forest-85.13%", "Decision Tree-95.19%", "Null"],
            "Initial ann loss": ["0.2825", "Null", "Null", "0.384", "Null", "Null", "0.366"],
            "Final ann loss": ["0.2073", "Null", "Null", "0.249", "Null", "Null", "0.2499"],
            "Percentage Loss": ["26.60%", "Null", "Null", "35.10%", "Null", "Null", "31.72%"]})
        st.write(csv_data)
        st.write("Avg Accuracy % : 91.19%")
        st.write("Avg Decrease % : 31.14%")
        st.write("### Image Segmentation Analysis")
        df_performance = pd.DataFrame({
        'Dataset Name': ["Dogs vs Cats", "Medical Images", "Autonomous Driving", "Satellite Imagery", "Histopathology", "Semantic Segmentation Benchmark", "Lung Nodule Detection", "Plant Disease Identification"],
        'Accuracy': ["90%", "95%", "85%", "91%", "88%", "90%", "91%", "92%"],
        'Precision': ["86%", "90%", "84%", "88%", "87%", "89%", "88%", "82%"],
        'Recall': ["88%", "91%", "87%", "90%", "89%", "92%", "91%", "87%"],
        'Intersection over Union': ["82%", "85%", "79%", "84%", "81%", "86%", "85%", "78%"],
        'Dice Coefficient': ["84%", "87%", "82%", "86%", "83%", "88%", "87%", "80%"]
        })
        st.write(df_performance)
        st.write("Average Accuracy % : 90")

    elif selection == "About":
        st.title("The Team")

        # Define information for each person
        people_info = [
            {
                "name": "Siddhanth Sridhar",
                "intro":"Meet Siddhanth Sridhar, a fervent Computer Science Engineering (CSE) undergraduate at PES University, deeply immersed in the realm of Machine Learning. Fueled by curiosity and boundless enthusiasm, he continuously delves into the intricacies of artificial intelligence. He staunchly believes in technology's potential to reshape industries and enhance livelihoods, propelling him to the forefront of this exhilarating revolution.",
                "linkedin": "https://www.linkedin.com/in/siddhanth-sridhar-4aa9aa222/",
                "github": "https://github.com/sidd2305",
                "image": "Sid_profile.jpeg"
            },
            {
                "name": "Swaraj Khan",
                "intro": "Meet Swaraj Khan, a driven B.Tech student at Dayananda Sagar University, immersing himself in the realm of Computer Science with a special focus on machine learning. With an unwavering commitment to tackling real-world challenges, Swaraj harnesses the power of technology to unravel complexities and pave the way for innovative solutions.",
                "linkedin": "https://www.linkedin.com/in/swaraj-khan/",
                "github": "https://github.com/swaraj-khan",
                "image": "Swaraj_profile.jpeg" 
            },
            {
                "name": "Shreya Chaurasia",
                "intro": "Introducing Shreya Chaurasia, a B.Tech Computer Science scholar driven by an insatiable curiosity for Machine Learning. Ambitious, passionate, and self-motivated, she finds the potential of ML to revolutionize industries utterly captivating. Delving into data to reveal patterns and derive insights, she thrives on crafting innovative solutions. Challenges are her stepping stones to growth, and she relentlessly pursues excellence in all her pursuits.",
                "linkedin": "https://www.linkedin.com/in/shreya-chaurasia-4b5407266/",
                "github": "https://github.com/shreyyasiaa",
                "image": "Shreya_profile.jpeg"
            }
        ]

        # Display information for each person
        for person in people_info:
            st.write(f"### {person['name']}")

            # Display profile image
            st.image(person['image'], caption=f"Profile Image - {person['name']}", width=150)

            # Display introduction text
            st.write(person['intro'])

            # Display LinkedIn and GitHub links.
            st.markdown(f"**LinkedIn:** [{person['name']}'s LinkedIn Profile]({person['linkedin']})")
            st.markdown(f"**GitHub:** [{person['name']}'s GitHub Profile]({person['github']})")


if __name__ == "__main__":
    main()