Add additional content

Genetic_Algorithm.py

@@ -0,0 +1,70 @@
+import streamlit as st
+
+def main():
+    st.set_page_config(page_title="Genetic Algorithm for Feature Selection", layout="wide")
+
+    st.title("Genetic Algorithm for Feature Selection")
+    
+    # Introduction and Description
+    st.header("Genetic Algorithm")
+    st.markdown("""
+    <div style='text-align: justify;'>
+    The Genetic Algorithm (GA) is an evolutionary algorithm (EA) inspired by Charles Darwin’s theory of natural selection which espouses Survival of the fittest. As per the natural selection theory, the fittest individuals are selected to produce offsprings. The fittest parents' characteristics are then passed on to their offsprings using cross-over and mutation to ensure better chances of survival. Genetic algorithms are randomized search algorithms that generate high-quality optimization solutions by imitating the biologically inspired natural selection process such as selection, cross-over, and mutation.
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Terminology
+    st.header("Terminology for Genetic Algorithm")
+    st.image("Terminology for Genetic Algorithm.png")
+    st.markdown("""
+    - **Population**: A set of possible solutions for the stochastic search process to begin. GA iterates over multiple generations till it finds an acceptable and optimized solution. The first generation is randomly generated.
+    - **Chromosome**: Represents one candidate solution present in the generation or population, also referred to as a Genotype. A chromosome is composed of Genes that contain the value for the optimal variables.
+    - **Phenotype**: The decoded parameter list for the genotype that is processed by the Genetic Algorithm. Mapping is applied to the genotype to convert to a phenotype.
+    - **Fitness Function**: Or the objective function evaluates the individual solution or phenotypes for every generation to identify the fittest members.
+    """, unsafe_allow_html=True)
+
+    # Genetic Operators
+    st.header("Different Genetic Operators")
+    st.markdown("""
+    - **Selection**: The process of selecting the fittest solution from a population. The fittest solutions act as parents for the next generation. Selection can be performed using Roulette Wheel Selection or Ranked Selection based on the fitness value.
+    """, unsafe_allow_html=True)
+    st.markdown("""
+    - **Cross-over or Recombination**: Happens when genes from the two fittest parents are randomly exchanged to form a new genotype or solution. Cross over can be a One-point cross over or Multi-Point Cross over based on the parent's segments of genes exchanged.
+    """, unsafe_allow_html=True)
+    st.image("Cross-over.png")
+    
+    st.markdown("""
+    - **Mutation**: After a new population is created through selection and crossover, it is randomly modified through mutation to promote diversity in the population to find better and optimized solutions.
+    """, unsafe_allow_html=True)
+    st.image("Mutation.png")
+
+    # Usage in AI
+    st.header("Usage of Genetic Algorithm in Artificial Intelligence")
+    st.markdown("""
+    A Genetic Algorithm is used for Search and Optimization using an iterative process to arrive at the best solution out of multiple solutions. For instance:
+    1. Finding an appropriate set of hyperparameters for a deep learning model to increase its performance.
+    2. Determining the best amount of features to include in a machine learning model for predicting the target variable.
+    """, unsafe_allow_html=True)
+
+    # Working of Genetic Algorithm
+    st.header("Working of Genetic Algorithm")
+    st.image("Working of Genetic Algorithm.png")
+
+    # Implementation
+    st.header("Implementation of Genetic Algorithm for Feature Selection")
+    st.markdown("""
+    The implementation involves several steps:
+    1. Initializing a random population.
+    2. Running the population through a fitness function to return the best parents (highest accuracy).
+    3. Selection from these best parents will occur depending on the n-parent parameter.
+    4. These parents are then put through the crossover and mutation functions respectively.
+    5. A new generation is created by selecting the fittest parents from the previous generation and applying cross-over and mutation.
+    6. This process is repeated for a specified number of generations.
+    """, unsafe_allow_html=True)
+
+    # Add a footer
+    st.markdown("---")
+    st.write("Made with ❤️ by Viga, Hanum, & Robit")
+
+if __name__ == "__main__":
+    main()

pages/1_Heart_Disease.py

@@ -0,0 +1,42 @@
+import streamlit as st
+
+def main():
+    st.set_page_config(page_title="Heart Disease")
+
+    # Page title and subtitle with styling
+    st.title("Heart Disease")
+    st.markdown("*Donated on 6/30/1988*")
+
+    # Load and display an image
+    st.image("heart_image.jpg")
+
+    # Dataset information
+    st.header("Dataset Information")
+    st.write("This dataset contains information from 4 databases: Cleveland, Hungary, Switzerland, and the VA Long Beach")
+
+    # Dataset characteristics
+    st.header("Dataset Characteristics")
+    st.write("This dataset is multivariate")
+
+    # Subject area
+    st.header("Subject Area")
+    st.write("This dataset falls under the category of Health and Medicine")
+
+    # Associated tasks
+    st.header("Associated Tasks")
+    st.write("This dataset is commonly used for Classification tasks")
+
+    # Feature types
+    st.header("Feature Type")
+    st.write("This dataset contains a mix of Categorical, Integer, and Real features")
+
+    # Instances and Features
+    st.write("**Number of Instances:** 303")
+    st.write("**Number of Features:** 13")
+
+    # Add a footer
+    st.markdown("---")
+    st.write("Made with ❤️ by Viga, Hanum, & Robit")
+
+if __name__ == "__main__":
+    main()

pages/2_Dataset_Information.py

@@ -0,0 +1,21 @@
+import streamlit as st
+
+def run():
+    st.set_page_config(page_title="Dataset Information")
+
+    st.title("Dataset Information")
+    
+    # Additional Information
+    st.header("Additional Information")
+    st.markdown('<div style="text-align: justify;">This database contains 76 attributes, but all published experiments refer to using a subset of 14 of them. In particular, the Cleveland database is the only one that has been used by ML researchers to date. The "goal" field refers to the presence of heart disease in the patient. It is integer valued with 0 as no presence of heart disease and 1 for presence of heart disease. Experiments with the Cleveland database have concentrated on simply attempting to distinguish presence (values 1) from absence (value 0). The names and social security numbers of the patients were recently removed from the database, replaced with dummy values. One file has been "processed", that one containing the Cleveland database. All four unprocessed files also exist in this directory.</div>', unsafe_allow_html=True)
+    
+    # Missing Values
+    st.header("Missing Values")
+    st.write("Yes")
+
+    # Add a footer
+    st.markdown("---")
+    st.write("Made with ❤️ by Viga, Hanum, & Robit")
+
+if __name__ == "__main__":
+    run()

pages/3_Variables_Table.py

@@ -0,0 +1,31 @@
+import streamlit as st
+import pandas as pd
+
+def run():
+    st.set_page_config(page_title="Variables Table", layout="wide")
+                       
+    st.title("Variables Table")
+    
+    # Define the data for the variables table
+    data = {
+        "Variable Name": ["age", "sex", "cp", "trestbps", "chol", "fbs", "restecg", "thalach", "exang", "oldpeak", "slope", "ca", "thal", "num"],
+        "Role": ["Feature", "Feature", "Feature", "Feature", "Feature", "Feature", "Feature", "Feature", "Feature", "Feature", "Feature", "Feature", "Feature", "Target"],
+        "Type": ["Integer", "Categorical", "Categorical", "Integer", "Integer", "Categorical", "Categorical", "Integer", "Categorical", "Integer", "Categorical", "Integer", "Categorical", "Integer"],
+        "Demographic": ["Age", "Sex", None, None, None, None, None, None, None, None, None, None, None, None],
+        "Description": [None, None, None, "Resting blood pressure (on admission to the hospital)", "Serum cholestoral", "Fasting blood sugar > 120 mg/dl", None, "Maximum heart rate achieved", "Exercise induced angina", "ST depression induced by exercise relative to rest", None, "Number of major vessels (0-3) colored by flourosopy", None, "Diagnosis of heart disease"],
+        "Units": ["years", None, None, "mm Hg", "mg/dl", None, None, "beats per minute", None, None, None, None, None, None],
+        "Missing Values": ["no", "no", "no", "no", "no", "no", "no", "no", "no", "no", "no", "yes", "yes", "no"]
+    }
+    
+    # Create DataFrame from the data
+    df = pd.DataFrame(data)
+    
+    # Display the DataFrame as a table with larger size
+    st.table(df.style.set_table_styles([{'selector': 'tr:hover','props': [('background-color', '#95caff')]}]))
+
+    # Add a footer
+    st.markdown("---")
+    st.write("Made with ❤️ by Viga, Hanum, & Robit")
+
+if __name__ == "__main__":
+    run()

pages/4_Decision_Tree_Classification.py

@@ -0,0 +1,68 @@
+import streamlit as st
+
+def main():
+    st.set_page_config(page_title="Decision Tree Classification", layout="wide")
+
+    st.title("Decision Tree Classification")
+
+    # Introduction to Decision Tree
+    st.header("The Decision Tree Algorithm")
+    st.markdown("""
+    A decision tree is a flowchart-like tree structure where an internal node represents a feature (or attribute), the branch represents a decision rule, and each leaf node represents the outcome.
+    
+    The topmost node in a decision tree is known as the root node. It learns to partition on the basis of the attribute value. It partitions the tree in a recursive manner called recursive partitioning. This flowchart-like structure helps you in decision-making. It's visualization like a flowchart diagram which easily mimics the human level thinking. That is why decision trees are easy to understand and interpret.
+    """)
+    
+    st.image("The Decision Tree Algorithm.png")
+    
+    st.markdown("""
+    A decision tree is a white box type of ML algorithm. It shares internal decision-making logic, which is not available in the black box type of algorithms such as with a neural network. Its training time is faster compared to the neural network algorithm.
+    
+    The time complexity of decision trees is a function of the number of records and attributes in the given data. The decision tree is a distribution-free or non-parametric method which does not depend upon probability distribution assumptions. Decision trees can handle high-dimensional data with good accuracy.
+    """)
+
+    # How Does the Decision Tree Algorithm Work?
+    st.header("How Does the Decision Tree Algorithm Work?")
+    st.markdown("""
+    The basic idea behind any decision tree algorithm is as follows:
+    
+    - Select the best attribute using Attribute Selection Measures (ASM) to split the records.
+    - Make that attribute a decision node and breaks the dataset into smaller subsets.
+    - Start tree building by repeating this process recursively for each child until one of the conditions will match:
+        - All the tuples belong to the same attribute value.
+        - There are no more remaining attributes.
+        - There are no more instances.
+    """)
+
+    st.image("Decision Tree Algorithm.webp")
+
+    # Attribute Selection Measures
+    st.header("Attribute Selection Measures")
+    st.markdown("""
+    Attribute selection measure is a heuristic for selecting the splitting criterion that partitions data in the best possible manner. It is also known as splitting rules because it helps us to determine breakpoints for tuples on a given node. ASM provides a rank to each feature (or attribute) by explaining the given dataset. The best score attribute will be selected as a splitting attribute. In the case of a continuous-valued attribute, split points for branches also need to define. The most popular selection measures are Information Gain, Gain Ratio, and Gini Index.
+    
+    **Gini index**
+    
+    Another decision tree algorithm CART (Classification and Regression Tree) uses the Gini method to create split points.
+    """)
+
+    st.image("Gini method.webp")
+
+    st.markdown("""
+    The Gini Index considers a binary split for each attribute. You can compute a weighted sum of the impurity of each partition. If a binary split on attribute A partitions data D into D1 and D2, the Gini index of D is calculated, and the attribute with the minimum Gini index is chosen as the splitting attribute.
+    """)
+
+    st.image("The Gini Index.webp")
+
+    st.image("smaller gini index.webp")
+
+    # YouTube Video for additional content
+    st.header("Learn More Through This Video")
+    st.video("https://www.youtube.com/watch?v=_L39rN6gz7Y")
+
+    # Add a footer
+    st.markdown("---")
+    st.write("Made with ❤️ by Viga, Hanum, & Robit")
+
+if __name__ == "__main__":
+    main()

pages/5_Heart_Disease_Prediction.py

@@ -0,0 +1,57 @@
+import streamlit as st
+import joblib
+
+# Set page configuration
+st.set_page_config(page_title="Heart Disease Prediction", layout="wide")
+
+# Load the trained model
+model = joblib.load("./model-3.joblib")
+
+# Define function to predict heart disease
+def predict_heart_disease(sex, exang, cp_1, cp_2, cp_4, slope_1, slope_2, thal_3, thal_7):
+    print([[sex, exang, cp_1, cp_2, cp_4, slope_1, slope_2, thal_3, thal_7]])
+    prediction = model.predict([[sex, exang, cp_1, cp_2, cp_4, slope_1, slope_2, thal_3, thal_7]])
+    return prediction
+
+def run():
+    st.title("Heart Disease Prediction")
+    st.write("Please provide the following information to predict heart disease:")
+
+    # Design user interface
+    col1, col2 = st.columns([2, 1])
+
+    with col1:
+        sex = st.selectbox("Sex", ["Female", "Male"])
+        exang = st.selectbox("Exercise Induced Angina", ["No", "Yes"])
+        cp = st.selectbox("Chest Pain Type", ["Typical Angina", "Atypical Angina", "Non-Anginal Pain", "Asymptomatic"])
+        slope = st.selectbox("Slope of Peak Exercise ST Segment", ["Upsloping", "Flat", "Downsloping"])
+        thal = st.selectbox("Thal", ["Normal", "Fixed Defect", "Reversible Defect"])
+    
+    with col2:
+        st.image("https://images.unsplash.com/photo-1618939304347-e91b1f33d2ab?q=80&w=1974&auto=format&fit=crop&ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D", width=275)
+
+    # Map selected options to numerical values
+    sex_mapping = {"Female": 0, "Male": 1}
+    exang_mapping = {"No": 0, "Yes": 1}
+    cp_1_mapping = {"Typical Angina": 1, "Atypical Angina": 0, "Non-Anginal Pain": 0, "Asymptomatic": 0}
+    cp_2_mapping = {"Typical Angina": 0, "Atypical Angina": 1, "Non-Anginal Pain": 0, "Asymptomatic": 0}
+    cp_4_mapping = {"Typical Angina": 0, "Atypical Angina": 0, "Non-Anginal Pain": 0, "Asymptomatic": 1}
+    slope_1_mapping = {"Upsloping": 1, "Flat": 0, "Downsloping": 0}
+    slope_2_mapping = {"Upsloping": 0, "Flat": 1, "Downsloping": 0}
+    thal_3_mapping = {"Normal": 1, "Fixed Defect": 0, "Reversible Defect": 0}
+    thal_7_mapping = {"Normal": 0, "Fixed Defect": 0, "Reversible Defect": 1}
+
+    # Predict button
+    if st.button("Predict", key="predict_button"):
+        result = predict_heart_disease(sex_mapping[sex], exang_mapping[exang], cp_1_mapping[cp], cp_2_mapping[cp], cp_4_mapping[cp], slope_1_mapping[slope], slope_2_mapping[slope], thal_3_mapping[thal], thal_7_mapping[thal])
+        if result == 1:
+            st.error("The model predicts that the patient has heart disease.")
+        else:
+            st.success("The model predicts that the patient does not have heart disease.")
+
+    # Add a footer
+    st.markdown("---")
+    st.write("Made with ❤️ by Viga, Hanum, & Robit")
+
+if __name__ == "__main__":
+    run()