setup

2Tutor.py

@@ -0,0 +1,168 @@
+import streamlit as st
+import importlib
+import os
+import json
+from datetime import datetime
+from dotenv import load_dotenv
+from openai import OpenAI
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Set page title and layout
+st.set_page_config(page_title="Data Science Tutor", layout="wide")
+
+# Hide Streamlit's default page navigation menu
+st.markdown("""
+<style>
+/* Hide the default "Pages" menu in the top-left sidebar */
+[data-testid="stSidebarNav"] {
+    display: none;
+}
+</style>
+""", unsafe_allow_html=True)
+
+# Sidebar with image above the CRISP-DM Steps
+st.sidebar.image(
+    "data2.jpeg",  # Replace with your file path or URL
+    use_container_width=True
+)
+
+# Sidebar navigation
+st.sidebar.title("CRISP-DM Steps")
+sections = {
+    "Main Page": None,
+    "1. Business Understanding": "1_Business_understanding",
+    "2. Data understanding": "2_Data_understanding",
+    "3. Data Preparation": "3_Data_preparation",
+    "4. Feature Engineering": "4_Feature_engineering",
+    "5. Modeling": "5_Modeling",
+    "6. Evaluation": "6_Evaluation",
+    "7. Deployment & Testing": "7_Deployment",
+    "8. ML, Deep Learning & Transformers": "8_Models"
+}
+
+# By default, make the first item (Main Page) selected.
+selected_section = st.sidebar.radio("Select a topic:", list(sections.keys()), index=0)
+
+# If the user selects “Main Page,” just show your introduction content.
+if sections[selected_section] is None:
+    st.title("🚀 Welcome to the Data Science Tutor!")
+    st.markdown(
+        """
+        <div style="color: #2FA4E7; margin-top: 1rem;">
+            <h2>About This App</h2>
+            <p>
+                This application is designed to guide you through the CRISP-DM process
+                for data science projects. Each section in the sidebar highlights a
+                different step in the process, providing structured lessons, best
+                practices, and hands-on examples.
+            </p>
+            <h3>App Sections</h3>
+            <ul>
+                <li><strong>1. Business Understanding</strong> – Clarify project objectives, requirements, and success criteria.</li>
+                <li><strong>2. Data Understanding</strong> – Explore data sources, structures, and initial insights.</li>
+                <li><strong>3. Data Preparation</strong> – Clean, integrate, and transform the data for modeling.</li>
+                <li><strong>4. Feature Engineering</strong> – Engineer and select relevant features for better models.</li>
+                <li><strong>5. Modeling</strong> – Develop, train, and tune predictive models.</li>
+                <li><strong>6. Evaluation</strong> – Assess performance metrics and refine models.</li>
+                <li><strong>7. Deployment & Testing</strong> – Deploy models into production environments and validate.</li>
+                <li><strong>8. ML, Deep Learning & Transformers</strong> – Delve deeper into advanced methods and architectures.</li>
+            </ul>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+else:
+    # Otherwise, load the selected module from the pages folder
+    module_name = f"pages.{sections[selected_section]}"
+    module = importlib.import_module(module_name)
+    module.run()
+
+# OpenAI API Section
+st.sidebar.title("Ask AI")
+api_key = os.getenv("OPENAI_API_KEY")
+if not api_key:
+    api_key = st.sidebar.text_input("Enter your OpenAI API Key", type="password")
+
+client = OpenAI()
+
+# Create side menus for toggles from the pages/ list
+st.sidebar.title("Focus Areas")
+focus_areas = [
+    "Data Cleaning & Wrangling", 
+    "Feature Engineering & Selection", 
+    "Model Selection & Tuning", 
+    "Interpretability & Explainability", 
+    "Model Deployment & Monitoring"
+]
+selected_focus_areas = [area for area in focus_areas if st.sidebar.checkbox(area)]
+
+# Main chat section
+st.title("Data Science Tutor Chat")
+st.image("https://miro.medium.com/v2/resize:fit:100/format:webp/1*NfE0G4nEj4xX7Z_8dSx83g.png")
+
+# Initialize conversation in the session state
+if "messages" not in st.session_state:
+    st.session_state["messages"] = [
+        {"role": "assistant", "content": "How can I assist you with Data Science today?"}
+    ]
+
+# Initialize context prompt added state
+if "context_prompt_added" not in st.session_state:
+    st.session_state["context_prompt_added"] = False
+
+st.write("---")
+st.subheader("Chat")
+
+for msg in st.session_state["messages"]:
+    st.chat_message(msg["role"]).write(msg["content"])
+
+if prompt := st.chat_input("Enter your question here:"):
+    # Add context to the messages if toggles are selected
+    focus_context = ""
+    if selected_focus_areas:
+        focus_context = f"Focus on {', '.join(selected_focus_areas)} in your response."
+
+    # Add context based on the selected section
+    section_context = f"The user is currently viewing the {selected_section} section. "
+
+    # If the context prompt hasn't been added yet, build & inject it once;
+    # otherwise, just add the user's raw question.
+    if not st.session_state["context_prompt_added"]:
+        st.session_state["messages"].append({"role": "user", "content": f"{section_context}{prompt}\n{focus_context}"})
+        st.session_state["context_prompt_added"] = True
+    else:
+        st.session_state["messages"].append({"role": "user", "content": f"{section_context}{prompt}"})
+
+    # Display the latest user message in the chat
+    st.chat_message("user").write(st.session_state["messages"][-1]["content"])
+
+    # Now call GPT-4 with the entire conversation
+    completion = client.chat.completions.create(
+            model="gpt-4",
+            messages=st.session_state["messages"]
+    )
+    response_text = completion.choices[0].message.content.strip()
+
+    st.session_state["messages"].append({"role": "assistant", "content": response_text})
+    st.chat_message("assistant").write(response_text)
+
+    # Log the conversation
+    log_entry = {
+        "timestamp": datetime.now().isoformat(),
+        "user_query": prompt,
+        "assistant_response": response_text,
+        "focus_areas": selected_focus_areas,
+        "selected_section": selected_section
+    }
+    log_file_path = os.path.join("logs", "conversation_logs.json")
+    os.makedirs(os.path.dirname(log_file_path), exist_ok=True)
+    if os.path.exists(log_file_path):
+        with open(log_file_path, "r") as log_file:
+            logs = json.load(log_file)
+    else:
+        logs = []
+    logs.append(log_entry)
+    with open(log_file_path, "w") as log_file:
+        json.dump(logs, log_file, indent=4)

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,6 +1,6 @@
 ---
 title: LLM Tutor
-emoji: 🐨
+emoji: 👨‍🎓
 colorFrom: indigo
 colorTo: indigo
 sdk: streamlit
@@ -11,4 +11,102 @@ license: mit
 short_description: Learn ML/LLM
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Data Science Tutor
+
+## Overview
+
+The **Data Science Tutor** application is designed to guide users through the CRISP-DM process for data science projects. Each section in the sidebar highlights a different step in the process, providing structured lessons, best practices, and hands-on examples. The application also includes an AI-powered chat feature to assist users with their data science queries.
+
+## Project Structure
+
+The project is organized into the following main components:
+
+### 1. Main Application (`Tutor.py`)
+
+The main application file that sets up the Streamlit interface, including the sidebar navigation, chat functionality, and dynamic content loading based on the selected section.
+
+### 2. Pages Directory (`pages/`)
+
+Contains individual Python scripts for each section of the CRISP-DM process. Each script includes detailed content, explanations, and quizzes related to its respective topic.
+
+- `1_Business_understanding.py`: Covers the Business Understanding phase.
+- `2_Data_understanding.py`: Covers the Data Understanding phase.
+- `3_Data_preparation.py`: Covers the Data Preparation phase.
+- `4_Feature_engineering.py`: Covers Feature Engineering.
+- `5_Modeling.py`: Covers the Modeling phase.
+- `6_Evaluation.py`: Covers the Evaluation phase.
+- `7_Deployment.py`: Covers Deployment and Testing.
+- `8_Models.py`: Covers ML, Deep Learning, and Transformers.
+
+### 3. Chat Functionality
+
+The application includes an AI-powered chat feature that allows users to ask questions related to data science. The chat model's responses are tailored based on the selected section to provide relevant and focused answers.
+
+### 4. Focus Areas
+
+Users can select specific focus areas from the sidebar to further refine the context of their queries. The focus areas include:
+- Data Cleaning & Wrangling
+- Feature Engineering & Selection
+- Model Selection & Tuning
+- Interpretability & Explainability
+- Model Deployment & Monitoring
+
+## Installation
+
+To run the application locally, follow these steps:
+
+1. Clone the repository:
+    ```sh
+    git clone https://github.com/your-username/LLM-Tutor.git
+    cd LLM-Tutor
+    ```
+
+2. Create a virtual environment and activate it:
+    ```sh
+    python -m venv venv
+    source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
+    ```
+
+3. Install the required dependencies:
+    ```sh
+    pip install -r requirements.txt
+    ```
+
+4. Set up your OpenAI API key:
+    - Create a [.env](http://_vscodecontentref_/1) file in the root directory of the project.
+    - Add your OpenAI API key to the [.env](http://_vscodecontentref_/2) file:
+        ```
+        OPENAI_API_KEY=your_openai_api_key
+        ```
+
+5. Run the application:
+    ```sh
+    streamlit run Tutor.py
+    ```
+
+## Usage
+
+- **Select a CRISP-DM Step**: Use the sidebar to navigate through different steps of the CRISP-DM process.
+- **Ask AI**: Enter your OpenAI API key in the sidebar and ask questions related to data science.
+- **Focus Areas**: Select specific focus areas to refine the context of your queries.
+- **Interactive Content**: Each section includes detailed explanations, key concepts, and quizzes to test your understanding.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](http://_vscodecontentref_/3) file for more details.
+
+## Contributing
+
+Contributions are welcome! Please read the CONTRIBUTING file for guidelines on how to contribute to this project.
+
+## Acknowledgements
+
+- [Streamlit](https://streamlit.io/)
+- [OpenAI](https://www.openai.com/)
+- [CRISP-DM](https://www.sv-europe.com/crisp-dm-methodology/)
+
+---
+
+pinned: false
+license: mit
+short_description: Learn ML/LLM

pages/1_Business_understanding.py

@@ -0,0 +1,67 @@
+import streamlit as st
+
+def run():
+    st.title("Business Understanding")
+    
+    st.write("## Overview")
+    st.write("""
+    The Business Understanding phase is the first step in the CRISP-DM process. It involves understanding the project objectives and requirements from a business perspective, and then converting this knowledge into a data mining problem definition and a preliminary plan.
+    """)
+
+    st.write("## Key Concepts & Explanations")
+    st.markdown("""
+    - **Business Goals**: Clearly define the problem (e.g., Predict customer churn).
+    - **Constraints**: Time, budget, available data, legal considerations.
+    - **Success Metrics**: Accuracy, revenue impact, efficiency gains.
+    """)
+
+    st.write("## Introduction")
+    st.write("""
+    Business Understanding is crucial for the success of any data science project. It ensures that the project is aligned with the business objectives and that the results will be actionable and valuable to the organization.
+    """)
+
+    st.header("Objectives")
+    st.write("""
+    - **Understand the Business Objectives**: Gain a clear understanding of the business goals and how they translate into data mining goals.
+    - **Assess the Situation**: Evaluate the current situation, including resources, constraints, and risks.
+    - **Determine Data Mining Goals**: Define specific data mining goals that align with the business objectives.
+    - **Produce a Project Plan**: Develop a detailed project plan that outlines the steps, resources, and timeline for the project.
+    """)
+
+    st.header("Key Activities")
+    st.write("""
+    - **Identify Business Objectives and Constraints**: Work with stakeholders to identify the key business objectives and any constraints that may impact the project.
+    - **Define Success Criteria**: Establish clear criteria for success, including key performance indicators (KPIs) and metrics.
+    - **Develop a Project Plan**: Create a comprehensive project plan that includes a timeline, resource allocation, and risk management strategy.
+    """)
+
+    st.write("## Detailed Steps")
+    st.write("""
+    1. **Determine Business Objectives**:
+        - Interview stakeholders to understand their goals and expectations.
+        - Identify the key business questions that need to be answered.
+    2. **Assess the Situation**:
+        - Conduct a SWOT analysis (Strengths, Weaknesses, Opportunities, Threats).
+        - Review existing resources, including data, tools, and expertise.
+    3. **Define Data Mining Goals**:
+        - Translate business objectives into specific data mining goals.
+        - Ensure that the goals are measurable and achievable.
+    4. **Produce a Project Plan**:
+        - Outline the project phases, tasks, and deliverables.
+        - Allocate resources and assign responsibilities.
+        - Develop a risk management plan to address potential challenges.
+    """)
+
+    st.write("## Quiz: Conceptual Questions")
+    q1 = st.radio("What is the main purpose of the Business Understanding phase?", ["Define project goals", "Collect data", "Build models"])
+    if q1 == "Define project goals":
+        st.success("✅ Correct!")
+    else:
+        st.error("❌ Incorrect. The main purpose is to define project goals.")
+
+    st.write("## Learning Resources")
+    st.markdown("""
+    - 📘 [CRISP-DM Guide](https://www.sv-europe.com/crisp-dm-methodology/)
+    - 🎓 [Understanding Business Objectives](https://www.datasciencecentral.com/profiles/blogs/understanding-business-objectives-in-data-science)
+    - 🔬 [Business Understanding in Data Science](https://towardsdatascience.com/business-understanding-in-data-science-1a1d5e8b1c3d)
+    """)

pages/2_Data_understanding.py

@@ -0,0 +1,70 @@
+import streamlit as st
+
+def run():
+    st.title("Data Understanding")
+    
+    st.write("## Overview")
+    st.write("""
+    Data Understanding is the second phase of the CRISP-DM process. It involves collecting initial data, describing the data, exploring the data, and verifying data quality.
+    """)
+
+    st.write("## Key Concepts & Explanations")
+    st.markdown("""
+    - **Data Collection**: Gathering data from various sources.
+    - **Data Description**: Summarizing the main characteristics of the data.
+    - **Data Exploration**: Using statistical and visualization techniques to understand the data.
+    - **Data Quality Verification**: Ensuring the data is accurate, complete, and reliable.
+    """)
+
+    st.write("## Introduction")
+    st.write("""
+    The Data Understanding phase is crucial for identifying potential issues with the data and gaining insights that will inform the subsequent phases of the CRISP-DM process.
+    """)
+
+    st.header("Objectives")
+    st.write("""
+    - **Collect Initial Data**: Gather data from various sources to get a comprehensive dataset.
+    - **Describe the Data**: Summarize the main characteristics of the data, including its structure and content.
+    - **Explore the Data**: Use statistical and visualization techniques to identify patterns, trends, and anomalies.
+    - **Verify Data Quality**: Assess the quality of the data to ensure it is suitable for analysis.
+    """)
+
+    st.header("Key Activities")
+    st.write("""
+    - **Data Collection**: Gather data from internal and external sources.
+    - **Data Description**: Generate summary statistics and visualizations to describe the data.
+    - **Data Exploration**: Perform exploratory data analysis (EDA) to uncover patterns and relationships.
+    - **Data Quality Verification**: Check for missing values, outliers, and inconsistencies in the data.
+    """)
+
+    st.write("## Detailed Steps")
+    st.write("""
+    1. **Collect Initial Data**:
+        - Identify relevant data sources.
+        - Extract data from various sources and consolidate it into a single dataset.
+    2. **Describe the Data**:
+        - Generate summary statistics (e.g., mean, median, standard deviation).
+        - Create visualizations (e.g., histograms, box plots) to describe the data distribution.
+    3. **Explore the Data**:
+        - Perform exploratory data analysis (EDA) to identify patterns, trends, and anomalies.
+        - Use visualization tools (e.g., scatter plots, heatmaps) to explore relationships between variables.
+    4. **Verify Data Quality**:
+        - Check for missing values and handle them appropriately.
+        - Identify and address outliers and inconsistencies in the data.
+        - Assess the overall quality of the data to ensure it is suitable for analysis.
+    """)
+
+    st.write("## Quiz: Conceptual Questions")
+    q1 = st.radio("What is the main purpose of the Data Understanding phase?", ["Collect data", "Describe data", "Explore data", "All of the above"])
+    if q1 == "All of the above":
+        st.success("✅ Correct!")
+    else:
+        st.error("❌ Incorrect. The main purpose is to collect, describe, and explore data.")
+
+    st.write("## Learning Resources")
+    st.markdown("""
+    - 📘 [CRISP-DM Guide](https://www.sv-europe.com/crisp-dm-methodology/)
+    - 🎓 [Data Understanding in Data Science](https://towardsdatascience.com/data-understanding-in-data-science-1a1d5e8b1c3d)
+    - 🔬 [Exploratory Data Analysis (EDA)](https://www.analyticsvidhya.com/blog/2021/06/exploratory-data-analysis-eda-a-step-by-step-guide/)
+    """)
+

pages/3_Data_preparation.py

@@ -0,0 +1,62 @@
+import streamlit as st
+
+def run():
+    st.title("Data Preparation")
+    st.header("Introduction")
+    st.write("""
+    Data Preparation involves cleaning and transforming raw data into a format suitable for analysis.
+    """)
+    st.header("Objectives")
+    st.write("""
+    - Clean the data.
+    - Transform the data.
+    - Integrate data from multiple sources.
+    """)
+    st.header("Key Activities")
+    st.write("""
+    - Data cleaning.
+    - Data transformation.
+    - Data integration.
+    """)
+    import pandas as pd
+
+    st.title("3. Data Preparation")
+    st.write("## Overview")
+    st.write("Cleaning and transforming data for better model performance.")
+
+    st.write("## Key Concepts & Explanations")
+    st.markdown("""
+    - red[**Handling Missing Values**]: Fill with mean/median or drop rows.  
+    - **Feature Engineering**: Creating new features for better modeling.  
+    - **Scaling**: Normalization and standardization for consistency.
+    """)
+
+    file = st.file_uploader("Upload a dataset", type=["csv"])
+    if file:
+        df = pd.read_csv(file)
+        option = st.radio("Choose a method to handle missing values", ["Fill with Mean", "Fill with Median", "Drop Rows"])
+        if option == "Fill with Mean":
+            df.fillna(df.mean(), inplace=True)
+        elif option == "Fill with Median":
+            df.fillna(df.median(), inplace=True)
+        elif option == "Drop Rows":
+            df.dropna(inplace=True)
+
+    st.write("## Quiz: Conceptual Questions")
+    q1 = st.radio("What is feature engineering?", ["Data visualization", "Creating new features", "Data storage"])
+    if q1 == "Creating new features":
+        st.success("✅ Correct!")
+    else:
+        st.error("❌ Incorrect.")
+
+    st.write("## Code-Based Quiz")
+    code_input = st.text_area("Write a function to normalize a column", value="def normalize(col):\n    return (col - col.min()) / (col.max() - col.min())")
+    if "col.max() - col.min()" in code_input:
+        st.success("✅ Correct!")
+    else:
+        st.error("❌ Try again.")
+
+    st.write("## Learning Resources")
+    st.markdown("""
+    - 📝 [Data Cleaning with Pandas](https://realpython.com/pandas-data-cleaning/)
+    """)

pages/4_Feature_engineering.py

@@ -0,0 +1,78 @@
+import streamlit as st
+from sklearn.preprocessing import MinMaxScaler
+import pandas as pd
+
+def run():
+    st.title("Feature Engineering")
+    
+    st.write("## Overview")
+    st.write("""
+    Feature Engineering is the process of using domain knowledge to create features (input variables) that make machine learning algorithms work better. It involves transforming raw data into meaningful features that improve the performance of machine learning models.
+    """)
+
+    st.write("## Key Concepts & Explanations")
+    st.markdown("""
+    - **Feature Creation**: Generating new features from existing data.
+    - **Feature Transformation**: Modifying features to make them more suitable for modeling.
+    - **Feature Selection**: Identifying the most relevant features for the model.
+    - **Feature Scaling**: Normalizing or standardizing features to ensure they are on a similar scale.
+    """)
+
+    st.write("## Introduction")
+    st.write("""
+    Feature Engineering is a crucial step in the data science process. It can significantly impact the performance of machine learning models by providing them with the right input variables. Effective feature engineering requires a deep understanding of the data and the problem domain.
+    """)
+
+    st.header("Objectives")
+    st.write("""
+    - **Create New Features**: Generate new features that capture important information from the data.
+    - **Transform Existing Features**: Modify existing features to make them more suitable for modeling.
+    - **Select Relevant Features**: Identify and select the most relevant features for the model.
+    - **Scale Features**: Normalize or standardize features to ensure they are on a similar scale.
+    """)
+
+    st.header("Key Activities")
+    st.write("""
+    - **Feature Creation**: Generate new features from existing data using domain knowledge.
+    - **Feature Transformation**: Apply mathematical transformations to features to improve their suitability for modeling.
+    - **Feature Selection**: Use statistical techniques to identify the most relevant features for the model.
+    - **Feature Scaling**: Normalize or standardize features to ensure they are on a similar scale.
+    """)
+
+    st.write("## Detailed Steps")
+    st.write("""
+    1. **Feature Creation**:
+        - Generate new features from existing data using domain knowledge.
+        - Combine multiple features to create new ones (e.g., ratios, differences).
+    2. **Feature Transformation**:
+        - Apply mathematical transformations (e.g., log, square root) to features.
+        - Encode categorical variables using techniques like one-hot encoding or label encoding.
+    3. **Feature Selection**:
+        - Use statistical techniques (e.g., correlation, mutual information) to identify relevant features.
+        - Apply dimensionality reduction techniques (e.g., PCA) to reduce the number of features.
+    4. **Feature Scaling**:
+        - Normalize features to a range (e.g., 0 to 1) using MinMaxScaler.
+        - Standardize features to have a mean of 0 and a standard deviation of 1 using StandardScaler.
+    """)
+
+    st.write("## Quiz: Conceptual Questions")
+    q1 = st.radio("What is the main purpose of feature engineering?", ["Improve model accuracy", "Reduce dataset size", "Make data harder to interpret"])
+    if q1 == "Improve model accuracy":
+        st.success("✅ Correct!")
+    else:
+        st.error("❌ Incorrect. The main purpose is to improve model accuracy.")
+
+    st.write("## Code-Based Quiz")
+    code_input = st.text_area("Write a function to normalize a dataset using MinMaxScaler", 
+                            value="from sklearn.preprocessing import MinMaxScaler\n\ndef normalize_data(df):\n    scaler = MinMaxScaler()\n    return pd.DataFrame(scaler.fit_transform(df), columns=df.columns)")
+    if "MinMaxScaler" in code_input:
+        st.success("✅ Correct!")
+    else:
+        st.error("❌ Try again.")
+
+    st.write("## Learning Resources")
+    st.markdown("""
+    - 📘 [Feature Engineering for Machine Learning](https://towardsdatascience.com/feature-engineering-for-machine-learning-3a5e293a5114)
+    - 🎓 [Scikit-learn Feature Engineering Guide](https://scikit-learn.org/stable/modules/feature_extraction.html)
+    - 🔬 [Feature Engineering Techniques](https://www.analyticsvidhya.com/blog/2021/10/a-comprehensive-guide-on-feature-engineering/)
+    """)

pages/5_Modeling.py

@@ -0,0 +1,54 @@
+import streamlit as st
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score
+
+def run():
+    st.title("4. Modeling")
+    st.write("## Overview")
+    st.write("Building and training machine learning models to make predictions.")
+
+    st.write("## Key Concepts & Explanations")
+    st.markdown("""
+    - **Model Selection**: Choose the model based on the problem (e.g., Classification, Regression).  
+    - **Training Data**: The subset used to train the model.  
+    - **Test Data**: The subset used to evaluate the model’s performance.
+    """)
+
+    file = st.file_uploader("Upload a dataset for modeling", type=["csv"])
+    if file:
+        df = pd.read_csv(file)
+        target = st.selectbox("Select the target variable", df.columns)
+        features = st.multiselect("Select the feature columns", df.columns)
+
+        if target and features:
+            X = df[features]
+            y = df[target]
+            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+            model = LogisticRegression()
+            model.fit(X_train, y_train)
+            y_pred = model.predict(X_test)
+            accuracy = accuracy_score(y_test, y_pred)
+
+            st.write(f"Accuracy: {accuracy * 100:.2f}%")
+
+    st.write("## Quiz: Conceptual Questions")
+    q1 = st.radio("What is overfitting?", ["Model too simple", "Model too complex", "Data too large"])
+    if q1 == "Model too complex":
+        st.success("✅ Correct!")
+    else:
+        st.error("❌ Incorrect.")
+
+    st.write("## Code-Based Quiz")
+    code_input = st.text_area("Write a function to split data into train and test sets", value="def split_data(df, target):\n    X = df.drop(columns=[target])\n    y = df[target]\n    return train_test_split(X, y, test_size=0.2, random_state=42)")
+    if "train_test_split" in code_input:
+        st.success("✅ Correct!")
+    else:
+        st.error("❌ Try again.")
+
+    st.write("## Learning Resources")
+    st.markdown("""
+    - 📖 [Introduction to Machine Learning with Python](https://www.oreilly.com/library/view/introduction-to-machine/9781449369880/)
+    """)

pages/6_Evaluation.py

@@ -0,0 +1,62 @@
+def run():
+    import streamlit as st
+    from sklearn.metrics import confusion_matrix, classification_report
+    import numpy as np
+    import pandas as pd
+    import matplotlib.pyplot as plt
+    st.title("5. Evaluation")
+    st.header("Introduction")
+    st.write("""
+    Model Evaluation is the process of assessing the performance of a machine learning model using various metrics.
+    """)
+    st.header("Objectives")
+    st.write("""
+    - Assess model performance.
+    - Compare different models.
+    - Select the best model.
+    """)
+    st.header("Key Activities")
+    st.write("""
+    - Model validation.
+    - Performance metrics calculation.
+    - Model comparison.
+    """)
+
+    st.write("## Overview")
+    st.write("Assessing model performance using appropriate evaluation metrics.")
+
+    st.write("## Key Concepts & Explanations")
+    st.markdown("### Confusion Matrix")
+    st.write("""
+    A confusion matrix is a table used to evaluate the performance of a classification model. It shows the number of true positives, true negatives, false positives, and false negatives. This helps in understanding how well the model is performing in terms of correctly and incorrectly classified instances.
+    """)
+
+    st.markdown("### Precision, Recall, F1-Score")
+    st.write("""
+    - **Precision**: This metric measures the accuracy of the positive predictions. It is the ratio of true positive predictions to the total predicted positives (true positives + false positives). High precision indicates a low false positive rate.
+    - **Recall**: Also known as sensitivity, this metric measures the ability of the model to identify all relevant instances. It is the ratio of true positive predictions to the total actual positives (true positives + false negatives). High recall indicates a low false negative rate.
+    - **F1-Score**: This is the harmonic mean of precision and recall. It provides a single metric that balances both precision and recall, especially useful when you need to balance the two.
+    """)
+
+    st.markdown("### ROC-AUC")
+    st.write("""
+    - **ROC (Receiver Operating Characteristic) Curve**: This is a graphical representation of the model's performance across different threshold values. It plots the true positive rate (recall) against the false positive rate.
+    - **AUC (Area Under the Curve)**: This metric summarizes the ROC curve into a single value. It represents the likelihood that the model will rank a randomly chosen positive instance higher than a randomly chosen negative one. An AUC of 1 indicates a perfect model, while an AUC of 0.5 indicates a model with no discriminative power.
+    """)
+    q1 = st.radio("Which metric is used for evaluating a classification model?", ["Accuracy", "Mean Squared Error", "All of the above"])
+    if q1 == "All of the above":
+        st.success("✅ Correct!")
+    else:
+        st.error("❌ Incorrect.")
+
+    st.write("## Code-Based Quiz")
+    code_input = st.text_area("Write a function to calculate the confusion matrix", value="def confusion_mat(y_true, y_pred):\n    return confusion_matrix(y_true, y_pred)")
+    if "confusion_matrix" in code_input:
+        st.success("✅ Correct!")
+    else:
+        st.error("❌ Try again.")
+
+    st.write("## Learning Resources")
+    st.markdown("""
+    - 🎓 [Evaluation Metrics in Machine Learning](https://scikit-learn.org/stable/modules/model_evaluation.html)
+    """)

pages/7_Deployment.py

@@ -0,0 +1,43 @@
+import streamlit as st
+
+def run():
+    st.title("6. Deployment & Testing")
+    st.header("Introduction")
+    st.write("""
+    Model Deployment is the process of integrating a machine learning model into a production environment where it can make predictions on new data.
+    """)
+    st.header("Objectives")
+    st.write("""
+    - Integrate the model into production.
+    - Monitor model performance.
+    - Update the model as needed.
+    """)
+
+    st.write("## Overview")
+    st.write("Deploying the model and testing its real-world performance.")
+
+    st.write("## Key Concepts & Explanations")
+    st.markdown("""
+    - **Deployment**: Making the model available for use (e.g., via an API).  
+    - **Testing**: Ensuring the model works in production environments.
+    - **Model Monitoring**: Continuously tracking model performance in real-time.
+    """)
+
+    st.write("## Quiz: Conceptual Questions")
+    q1 = st.radio("Which of the following is part of deployment?", ["Model Training", "Model Versioning", "Model Testing"])
+    if q1 == "Model Versioning":
+        st.success("✅ Correct!")
+    else:
+        st.error("❌ Incorrect.")
+
+    st.write("## Code-Based Quiz")
+    code_input = st.text_area("Write code to save a model using joblib", value="import joblib\njoblib.dump(model, 'model.pkl')")
+    if "joblib.dump" in code_input:
+        st.success("✅ Correct!")
+    else:
+        st.error("❌ Try again.")
+
+    st.write("## Learning Resources")
+    st.markdown("""
+    - 📘 [Machine Learning Model Deployment](https://towardsdatascience.com/deploying-machine-learning-models-using-flask-285dbddedbfa)
+    """)

pages/8_Models.py

@@ -0,0 +1,48 @@
+import streamlit as st
+from sklearn.linear_model import LogisticRegression
+import torch
+from transformers import pipeline
+
+
+def run():
+    st.title("7. Machine Learning, Deep Learning & Transformers")
+    st.write("## Overview")
+    st.write("Learn about different machine learning models, deep learning models, and transformers.")
+
+    st.write("## Key Concepts & Explanations")
+    st.markdown("""
+    - **Machine Learning Models**: Supervised, unsupervised, and reinforcement learning.  
+    - **Deep Learning**: Neural networks with many layers, used for complex tasks like image recognition.
+    - **Transformers**: A powerful model architecture used in natural language processing (NLP) tasks.
+    """)
+
+    # ML Example: Logistic Regression
+    st.write("### Example: Logistic Regression")
+    st.write("We'll use logistic regression to classify some sample data.")
+    model = LogisticRegression()
+    # (Insert a sample dataset and training procedure here)
+
+    # Deep Learning Example: Using Pretrained Transformers
+    st.write("### Example: Transformer Model")
+    nlp = pipeline("sentiment-analysis")
+    st.write(nlp("I love machine learning!"))
+
+    st.write("## Quiz: Conceptual Questions")
+    q1 = st.radio("What is a transformer model used for?", ["Text classification", "Image processing", "Time series analysis"])
+    if q1 == "Text classification":
+        st.success("✅ Correct!")
+    else:
+        st.error("❌ Incorrect.")
+
+    st.write("## Code-Based Quiz")
+    code_input = st.text_area("Write code to create a simple neural network using PyTorch", value="import torch\nimport torch.nn as nn\nclass SimpleNN(nn.Module):\n    def __init__(self):\n        super(SimpleNN, self).__init__()")
+    if "super(SimpleNN" in code_input:
+        st.success("✅ Correct!")
+    else:
+        st.error("❌ Try again.")
+
+    st.write("## Learning Resources")
+    st.markdown("""
+    - 📚 [Deep Learning with PyTorch](https://pytorch.org/tutorials/)
+    - 🌐 [Transformers Library Documentation](https://huggingface.co/docs/transformers/)
+    """)

pages/ML_Algorithms/decision_trees.py

@@ -0,0 +1,4 @@
+import streamlit as st
+
+def run():
+    st.title("TBD")

pages/ML_Algorithms/logistic_regression.py

@@ -0,0 +1,4 @@
+import streamlit as st
+
+def run():
+    st.title("TBD")

pages/ML_Algorithms/neural_networks.py

@@ -0,0 +1,4 @@
+import streamlit as st
+
+def run():
+    st.title("TBD")

pages/ML_Algorithms/random_forest.py

@@ -0,0 +1,4 @@
+import streamlit as st
+
+def run():
+    st.title("TBD")

pages/ML_Algorithms/svm.py

@@ -0,0 +1,4 @@
+import streamlit as st
+
+def run():
+    st.title("TBD")